# Roboflow (Official) MCP server

Roboflow computer vision for AI agents: datasets, annotation, versioning, workflows, inference.

## Links
- Registry page: https://www.getdrio.com/mcp/com-roboflow-roboflow-mcp
- Repository: https://github.com/roboflow/roboflow-mcp
- Website: https://mcp.roboflow.com

## Install
- Endpoint: https://mcp.roboflow.com/mcp
- Auth: Auth required by registry metadata

## Setup notes
- Remote header: x-api-key (required; secret)
- The upstream registry signals required auth or secrets.
- Remote endpoint: https://mcp.roboflow.com/mcp
- Header: x-api-key

## Tools
- agent_chat - Chat with the Roboflow AI agent.

Use this tool for:

- **Roboflow Q&A** — the agent has the full Roboflow
  documentation indexed (SDKs, REST API, deployment options,
  training, batch processing, Universe, blocks, pricing,
  etc.). Ask it anything about how Roboflow works.
- **Advanced workflow building** — workflows complex enough
  that direct block composition via ``workflow_blocks_*`` is
  impractical. The agent knows every block and connection
  pattern.
- **Solution planning** — pass ``mode="plan"`` and the user's
  problem; the agent uses a stronger planning model to scope
  a CV solution end-to-end before any building happens.

For straightforward workflows you can construct yourself, the
direct ``workflow_*`` tools are fine — you don't have to route
every workflow through the agent.

## Conversation flow

The agent runs a multi-step conversation. It may ask
clarifying questions, recommend a model, or (in plan mode)
produce a plan for confirmation. Pass the returned
``conversation_id`` back on follow-up calls to keep context.
Use ``agent_conversations_list`` and ``agent_conversation_get``
to find and resume past conversations.

## CRITICAL: the agent NEVER publishes workflows

Every workflow the agent creates or edits is saved as a
**draft**. The published version that callers using the
workflow by id will hit is unchanged until you explicitly
publish.

To make agent edits live, call ``agent_workflow_publish`` with
the workflow ``url`` returned in the chat response.

## Running an agent-built workflow

Two options:

1. **Run the draft directly without publishing** — pass the
   ``specification`` returned in the chat response to
   ``workflow_specs_run``. Best for testing the draft, or for
   one-off runs where you don't want to disturb the
   currently-published version.
2. **Publish, then run by id** — call
   ``agent_workflow_publish(workflow_url=...)`` then
   ``workflows_run(workflow_id=..., images=...)``. Use this
   when you want the change to go live for everyone using the
   workflow by id.

## Where to open a workflow in the Roboflow UI

The agent's ``text`` response may include URLs pointing at the
workflow in the Roboflow UI. **Ignore those URLs** — the agent
sometimes picks the wrong host or path. Each workflow in the
``workflows`` array has an ``app_url`` field with the correct,
environment-aware URL (built from the current ``APP_URL`` plus
``/{workspace}/solutions/chat?workflowUrl=...``) — show that
one to the user instead.

## Response shape

- ``text`` — the agent's reply.
- ``workflows`` — workflows created or edited in this turn,
  each with ``id``, ``name``, ``url`` (slug), ``app_url``
  (clickable Roboflow UI URL — use this), and
  ``specification`` (the full draft JSON; pass it to
  ``workflow_specs_run`` to execute without publishing).
- ``conversation_id`` — pass back to continue the conversation. Endpoint: https://mcp.roboflow.com/mcp
- agent_conversations_list - List Roboflow agent conversations in the workspace.

Returns conversation metadata (id, name, source, timestamps,
linked workflow ids). Use ``agent_conversation_get`` to load
the full message history for a single conversation, or pass
the conversation id back to ``agent_chat`` to resume it. Endpoint: https://mcp.roboflow.com/mcp
- agent_conversation_get - Get a single agent conversation with its full message
history.

Returns the conversation metadata and the ordered list of
messages (role + text parts). Pass the same ``conversation_id``
back to ``agent_chat`` to continue the conversation. Endpoint: https://mcp.roboflow.com/mcp
- agent_workflow_publish - Publish the latest agent-edited draft of a workflow.

The agent never publishes on its own — every workflow it
creates or edits is saved as a draft. This tool promotes the
latest draft to a published version so it goes live for
callers using the workflow by id (``workflows_run``).

Errors with 400 if there is no draft to publish (i.e. the
published version already matches the latest draft).

Returns ``{ workflowId, workflowUrl, versionId, status }``. Endpoint: https://mcp.roboflow.com/mcp
- projects_list - List all projects in the workspace associated with the API key.

Returns a list of projects with id, name, type, image count, and more. Endpoint: https://mcp.roboflow.com/mcp
- projects_create - Create a new computer vision project.

Returns the created project's id, name, type, and url. Endpoint: https://mcp.roboflow.com/mcp
- projects_health - Get dataset health check for a project.

Running this for the first time or with regenerate=True might take up to a couple minutes.

Returns class balance, image quality issues, annotation statistics, and other dataset health metrics. Endpoint: https://mcp.roboflow.com/mcp
- projects_get - Get detailed info about a project including versions, classes, splits, and trained models.

Returns full project details with workspace, project info, versions, and classes. Endpoint: https://mcp.roboflow.com/mcp
- projects_fork - Enqueue an async fork of a public Universe project into your workspace.

Provide either a Universe `url` or `source_project`.
Returns the platform's 202 payload verbatim — at minimum
`{ taskId, url }`, where `url` points at the async-task polling
endpoint. Poll completion with `async_tasks_get(task_id=taskId)`
every 5 seconds until `status` is terminal (`completed` or `failed`).
Processing may take up to 30 seconds to start. Endpoint: https://mcp.roboflow.com/mcp
- images_prepare_upload - Get an upload URL to upload a single image to a project.

Returns a pre-built upload URL and instructions. The caller must
perform the actual upload using curl since the MCP server cannot
access local files.

This endpoint uploads images only. To add annotations, call
annotations_save with the image ID from the upload response.
For bulk uploads with annotations, use images_prepare_upload_zip. Endpoint: https://mcp.roboflow.com/mcp
- images_prepare_upload_zip - Prepare a zip upload of images and annotations to a project.

Supports zip archives containing images with COCO, YOLO, Pascal VOC,
or classification-by-folder annotations. Up to 2 GB / 10k files.

Returns a signed URL and task ID. The caller must:
1. PUT the zip file to the signed URL
2. Poll the task status until completed

The signed URL expires in 1 hour. Endpoint: https://mcp.roboflow.com/mcp
- images_upload_zip_status - Check the status of a zip upload task.

Returns status (created, running, completed, failed), progress,
and result when completed (uploaded count, duplicates, annotation
errors, etc.). Endpoint: https://mcp.roboflow.com/mcp
- images_search - Search for images inside a project. Endpoint: https://mcp.roboflow.com/mcp
- universe_dataset_images_search - Search images inside a public Universe dataset URL.

The MCP app runs inside a host iframe, so URL parsing belongs on the server.
This tool accepts the selected Universe result URL and derives the workspace
and project slugs before calling the same image-search backend. Endpoint: https://mcp.roboflow.com/mcp
- annotations_save - Save an annotation for an existing image. Endpoint: https://mcp.roboflow.com/mcp
- autolabel_start - Start a hosted auto-label job over a batch of images.

Returns ``{jobId, annotationJobId, message}``. Poll progress with
``autolabel_job_get`` using the returned ``jobId``. Endpoint: https://mcp.roboflow.com/mcp
- autolabel_job_get - Get per-subjob status and progress for an auto-label job.

Returns status, model/project type, image counts, subjob progress,
ontology, confidence thresholds, and the linked annotation job id. Endpoint: https://mcp.roboflow.com/mcp
- annotation_batches_list - List upload batches in a project.

Returns a list of batches with id, name, image count, and upload info. Endpoint: https://mcp.roboflow.com/mcp
- annotation_batches_get - Get details about a specific batch.

Returns batch details including image count and status. Endpoint: https://mcp.roboflow.com/mcp
- annotation_jobs_create - Create an annotation job to assign a batch of images to a labeler.

Returns the created job details including id, name, and status. Endpoint: https://mcp.roboflow.com/mcp
- versions_generate - Create a new dataset version with optional preprocessing and augmentation.

IMPORTANT: Before calling this tool, you MUST ask the user which
preprocessing and augmentation options they want to apply. Present them
with the available options listed below and let them choose. Do not
assume defaults — explicitly confirm their choices before generating.

IMPORTANT: This operation can take several minutes for large datasets.
You MUST spawn a sub-agent to run this tool in the background.

Returns the generated version number, image count, and split sizes. Endpoint: https://mcp.roboflow.com/mcp
- versions_get - Get info about a dataset version including splits and model metrics.

Returns version details with id, name, images, splits, preprocessing,
augmentation, and model info if trained. Endpoint: https://mcp.roboflow.com/mcp
- versions_export - Check or trigger a dataset export for a version. Endpoint: https://mcp.roboflow.com/mcp
- models_list - List trained models associated with a project.

Each row carries metrics and (for NAS children) `nasFamily`, `group`,
`train.results.{hardware,latency,map5095,paretoOptimalFor}`, plus a
derived `recommended` flag when the model is the recommended pick for
any (metric, hardware) bucket on its parent version.

Pass `group=<modelGroup>` to filter to a single NAS run — that is the
canonical "list NAS models per run" path. Endpoint: https://mcp.roboflow.com/mcp
- models_get - Get details for a trained model. Endpoint: https://mcp.roboflow.com/mcp
- models_infer - Run hosted inference on an image using a trained model.
Returns JSON predictions only. For visualized/annotated images,
use workflow_specs_run with a visualization block instead. Endpoint: https://mcp.roboflow.com/mcp
- models_train - Start training a model on a dataset version.

IMPORTANT: A dataset version must exist before training. Use the
versions_generate tool first to create one with the desired
preprocessing and augmentation settings.

IMPORTANT: Each version can only have ONE trained model. If this
version already has a model, you must generate a new version first
with versions_generate, then train on that new version.

This tool validates prerequisites before starting training:
it checks the version has no existing model and that the required
dataset export is ready. If the export is not ready, it will be
triggered automatically — wait ~30 seconds and retry.

Training runs in the background on Roboflow servers. Endpoint: https://mcp.roboflow.com/mcp
- models_get_training_status - Get the training progress and metrics for a dataset version.

Use this tool to check on a training job started with models_train.

Returns training status, progress (current/total epochs), latest
metrics (mAP, loss), and the URL to view training in the dashboard. Endpoint: https://mcp.roboflow.com/mcp
- trainings_get_results - Run-level training results bundle.

For NAS sweeps (one Training produces many child Models) returns:
``{ trainingId, status, modelGroup, modelCount,
    recommendedByHardware: {[hardware]: modelId},
    mining?: { mining: {progress, frontier, ...}, baseline? },
    models: [ { modelId, nasFamily, metrics, recommended }, ... ] }``.

For non-NAS trainings returns a minimal bundle with the produced model.

Use this for the run-level dashboard. For full per-model metadata,
call models_list with the returned modelGroup. Endpoint: https://mcp.roboflow.com/mcp
- trainings_cancel - Cancel an in-flight training run.

Works for any architecture. For NAS runs the underlying handler
accepts the ``mining`` status — same call cancels mining or training
phases. Endpoint: https://mcp.roboflow.com/mcp
- trainings_stop - Request an early stop on an in-flight training run.

Distinct from cancel: the run finishes the current phase gracefully
(mining or training) instead of terminating immediately. Endpoint: https://mcp.roboflow.com/mcp
- models_star_nas - Star or unstar a NAS-trained model.

NAS-only by design — the server rejects non-NAS modelTypes with a
``MODEL_NOT_NAS`` error. Starring triggers TRT compilation for the
model's recommended hardware so the model becomes deployable as an
edge target. Endpoint: https://mcp.roboflow.com/mcp
- model_evals_list - List model evaluations in the current workspace.

Returns ``{evals: [...]}`` where each entry has evalId, status,
project (URL slug), versionId, modelId, and createdAt. Use
``model_evals_get`` for the headline ``summary`` (mAP/precision/recall)
on a specific eval.

At most one of ``project`` / ``version`` / ``model`` may be set per
call (most-specific wins). Combinations return 400. Endpoint: https://mcp.roboflow.com/mcp
- model_evals_get - Get the top-level summary for a single model evaluation.

Returns the eval metadata plus a ``summary`` of mAP / precision /
recall on done evals, and an ``app_url`` deep link into the UI panel. Endpoint: https://mcp.roboflow.com/mcp
- model_evals_get_map_results - Get per-split mAP results for an eval.

Returns ``{splits: {train, valid, test}}`` where each split has
overall ``map50`` / ``map50_95`` / ``map75``, ``byObjectSize``
(small/medium/large), and ``perClass`` breakdowns. Endpoint: https://mcp.roboflow.com/mcp
- model_evals_get_confidence_sweep - Get the precision/recall/F1 confidence sweep for an eval.

For each split returns ``perThreshold`` (metrics keyed by threshold
like ``"0.20"``), the ``optimalThreshold`` and ``optimalMetrics``,
and ``perClass`` sweeps. Endpoint: https://mcp.roboflow.com/mcp
- model_evals_get_performance_by_class - Get per-class performance metrics for a single split.

Returns ``{split, classes: [{className, map50, map50_95, map75,
precision, recall, f1, optimalThreshold}, ...]}``. Endpoint: https://mcp.roboflow.com/mcp
- model_evals_get_confusion_matrix - Get the confusion matrix for an eval.

Returns ``{split, confidenceThreshold, classes, matrix}`` where
``matrix[actual][predicted]`` is the count. Endpoint: https://mcp.roboflow.com/mcp
- model_evals_get_vector_analysis - Get UMAP + HDBSCAN clustering of image embeddings for an eval.

Returns ``{clustering, preprocessing, clusters: [...]}`` — useful
for finding pockets of poor-performing images. Each cluster carries
``numImages``, ``splitDistribution``, F1 stats, and sample image refs. Endpoint: https://mcp.roboflow.com/mcp
- model_evals_get_image_predictions - Get per-image prediction stats for an eval (paginated).

Returns ``{split, confidenceThreshold, totalImages, offset, limit,
images: [...]}``. Each image carries TP/FP/FN counts, precision,
recall, F1, the assigned cluster, and a per-class confusion list. Endpoint: https://mcp.roboflow.com/mcp
- model_evals_get_recommendations - Get the LLM-generated recommendations for an eval, if available.

Returns ``{generated: false}`` until the recommendations job has
run. When ready, returns ``{generated: true, generatedAt,
recommendations: {summary, items}}``. Endpoint: https://mcp.roboflow.com/mcp
- workflows_list - List saved workflows in the current workspace. Endpoint: https://mcp.roboflow.com/mcp
- workflows_get - Get details for a saved workflow. Endpoint: https://mcp.roboflow.com/mcp
- workflows_create - Create and save a new Workflow in the workspace.

IMPORTANT: Always validate the config with workflow_specs_validate
before creating the workflow.

The config is the same JSON format used by workflow_specs_run and
workflow_specs_validate. Once saved, the workflow can be executed
by ID via workflows_run.

Returns the created workflow including its document ID. Save
this ID — it is required for workflows_update. Endpoint: https://mcp.roboflow.com/mcp
- workflows_update - Update an existing saved Workflow's name and definition.

IMPORTANT: Always validate the config with workflow_specs_validate
before updating the workflow.

Use workflows_get to retrieve the current workflow first, then
modify the config as needed. Endpoint: https://mcp.roboflow.com/mcp
- workflow_blocks_list - List all available Workflow blocks with a short summary of each.

Returns a list of blocks, each with manifest (schema key), name,
block_type, and short_description. Use ``workflow_blocks_get_schema``
to get the full schema of a specific block. Endpoint: https://mcp.roboflow.com/mcp
- workflow_blocks_get_schema - Get the full schema of a specific Workflow block.

Returns all properties, required fields, and descriptions for a
block identified by its manifest name (as returned by
``workflow_blocks_list``). Endpoint: https://mcp.roboflow.com/mcp
- workflow_specs_validate - Validate a Workflow JSON definition without executing it.

Check whether a workflow definition is syntactically and
semantically correct before saving or running it.

Example workflow definition — detects objects, enlarges bounding
boxes, crops, runs a second detection filtering for dogs, and
classifies the breed only when exactly one dog is found:

.. code-block:: json

    {
        "version": "1.0",
        "inputs": [
            {"type": "WorkflowImage", "name": "image"}
        ],
        "steps": [
            {
                "type": "ObjectDetectionModel",
                "name": "first_detection",
                "image": "$inputs.image",
                "model_id": "yolov8n-640"
            },
            {
                "type": "DetectionsTransformation",
                "name": "enlarging_boxes",
                "predictions": "$steps.first_detection.predictions",
                "operations": [
                    {"type": "DetectionsOffset", "offset_x": 50, "offset_y": 50}
                ]
            },
            {
                "type": "Crop",
                "name": "first_crop",
                "image": "$inputs.image",
                "predictions": "$steps.enlarging_boxes.predictions"
            },
            {
                "type": "ObjectDetectionModel",
                "name": "second_detection",
                "image": "$steps.first_crop.crops",
                "model_id": "yolov8n-640",
                "class_filter": ["dog"]
            },
            {
                "type": "ContinueIf",
                "name": "continue_if",
                "condition_statement": {
                    "type": "StatementGroup",
                    "statements": [
                        {
                            "type": "BinaryStatement",
                            "left_operand": {
                                "type": "DynamicOperand",
                                "operand_name": "prediction",
                                "operations": [{"type": "SequenceLength"}]
                            },
                            "comparator": {"type": "(Number) =="},
                            "right_operand": {
                                "type": "StaticOperand",
                                "value": 1
                            }
                        }
                    ]
                },
                "evaluation_parameters": {
                    "prediction": "$steps.second_detection.predictions"
                },
                "next_steps": ["$steps.classification"]
            },
            {
                "type": "ClassificationModel",
                "name": "classification",
                "image": "$steps.first_crop.crops",
                "model_id": "dog-breed-xpaq6/1"
            }
        ],
        "outputs": [
            {
                "type": "JsonField",
                "name": "dog_classification",
                "selector": "$steps.classification.predictions"
            }
        ]
    }

Key patterns shown above:
  - ``$inputs.<name>`` references a workflow input.
  - ``$steps.<step_name>.<output>`` references another step's output.
  - ``ContinueIf`` enables conditional branching based on runtime
    values.
  - Steps can chain: detect → transform → crop → detect → classify.

Returns validation status. A valid workflow returns
``{"status": "ok"}``. An invalid one returns error details. Endpoint: https://mcp.roboflow.com/mcp
- workflows_run - Execute a saved Workflow on one or more images.

Runs a previously created Workflow against the provided images on
the Roboflow serverless infrastructure. This always hits the
latest **published** version of the workflow.

IMPORTANT: Workflows created or edited via ``agent_chat`` are
saved as drafts, not published. If you want to run an agent's
latest changes, either call ``agent_workflow_publish`` first,
or pass the ``specification`` returned by ``agent_chat`` to
``workflow_specs_run`` to execute the draft directly.

IMPORTANT: If processing more than 10 images, spawn a sub-agent to
run this tool in the background so the user is not blocked.

Returns workflow outputs as defined by the workflow's output blocks. Endpoint: https://mcp.roboflow.com/mcp
- workflow_specs_run - Execute a Workflow from an inline JSON definition.

Unlike ``workflows_run`` which runs a saved workflow by ID,
this tool accepts a full workflow JSON spec and executes it
directly. Useful for testing workflows before saving them, or
for running an agent-built draft without publishing — pass
the ``specification`` returned by ``agent_chat``.

IMPORTANT: Always call ``workflow_specs_validate`` first to
check the definition is valid before running it.

IMPORTANT: Images must be public URLs or base64-encoded data.
Local file paths do NOT work — the API runs remotely and cannot
access your filesystem.

Returns workflow outputs as defined by the workflow's output blocks. Endpoint: https://mcp.roboflow.com/mcp
- devices_list - List devices registered in the workspace.

Returns a list of Device objects with id, name, status, last_heartbeat,
platform/hardware info, tags, and created_at. ``status`` is ``online``
if a heartbeat was received within the last 5 minutes, otherwise
``offline`` (or ``unknown`` for devices that have never reported).

Requires the ``device:read`` scope. Device-scoped api_keys cannot call
this endpoint and will receive 403. Endpoint: https://mcp.roboflow.com/mcp
- devices_create - Provision a new v2 device.

Requires the ``device:update`` scope. Returns
``{deviceId, installId, offlineProvisioningQrPayload?}``:
``installId`` is the short-lived token used by the device installer
(``GET /devices/v2/:installId/install.sh``).
``offlineProvisioningQrPayload`` is only present for AI1 devices
provisioned with ``offline_mode=true``. Endpoint: https://mcp.roboflow.com/mcp
- devices_get - Get a single device by id.

Returns the Device object. 404 if the device does not exist or belongs
to a different workspace.

When inspecting a device, also call ``devices_get_config`` for its
running services and ``devices_get_default_config`` for the
workspace's recommended versions — comparing the two ``services``
maps reveals whether the device is up to date or pinned to an
older build of any service. Endpoint: https://mcp.roboflow.com/mcp
- devices_get_config - Get the device's current runtime configuration.

Returns the full RFDM config JSON: ``device_id``, ``device_name``,
``workspace_id``, ``version``, ``last_updated``, ``config``,
``services``. The response passes through ``environment_variables``
and any embedded integration credentials, so treat the payload as
sensitive.

Tip: pair this with ``devices_get_default_config`` and diff the
``services`` map. The default config carries the workspace's
recommended version for each service, so comparing the two tells
you whether the device is up to date or pinned to an older build. Endpoint: https://mcp.roboflow.com/mcp
- devices_get_default_config - Get the workspace's default device configuration.

Returns ``{config, patch}``: ``config`` is the base default config
with the workspace's ``config_patch`` applied (the template used
when provisioning new devices, including default service versions),
and ``patch`` is the raw workspace-level patch object.

Useful for inspecting which service versions a fresh device would
be created with, or for seeding a payload to ``devices_update_config``.

Requires the ``device:read`` scope. Device-scoped api_keys are
rejected with 403 — this endpoint is workspace-wide. Endpoint: https://mcp.roboflow.com/mcp
- devices_update_config - Update the device's runtime configuration.

Requires the ``device:update`` scope. The merge is a Firestore
shallow update: omitted top-level fields stay as-is, but any
top-level field you supply replaces its entire nested object
wholesale. The payload is validated against the RFDM config
schema, and a new entry is appended to the config history. Endpoint: https://mcp.roboflow.com/mcp
- devices_get_config_history - List prior configuration revisions, newest first.

Returns ``{data: ConfigRevision[], pagination: {next_cursor,
has_more, limit}}``. Each ConfigRevision carries ``revision_id``,
``created_at``, and ``created_by``. Endpoint: https://mcp.roboflow.com/mcp
- devices_streams_list - List streams configured on the device.

Returns a list of Stream objects. Credential-bearing fields (URL
userinfo, ``password``, ``api_key``, etc.) are redacted from the
``source`` field. Endpoint: https://mcp.roboflow.com/mcp
- devices_streams_get - Get a single stream by id.

Returns the Stream object. 404 if the stream does not exist on the
device. Endpoint: https://mcp.roboflow.com/mcp
- devices_get_logs - Fetch device logs from Elasticsearch.

Rate-limited at two tiers: 5 requests / minute per IP, and
50 requests / minute globally across all callers (Elasticsearch
protection).

Returns ``{data: LogEntry[], pagination: {next_cursor, has_more,
limit}}``. Endpoint: https://mcp.roboflow.com/mcp
- devices_get_telemetry - Get aggregated hardware metrics (cpu, memory, disk, gpu).

Rate-limited per-device: 60 requests / minute steady, plus a
burst limit of 10 requests / 10 seconds.

Returns ``{time_period, bucket_interval, fill_interval_seconds,
buckets: [...]}``. Endpoint: https://mcp.roboflow.com/mcp
- devices_get_events - List device and stream lifecycle events.

Returns ``{data: Event[], pagination: {next_cursor, prev_cursor,
has_more, limit}}``. Endpoint: https://mcp.roboflow.com/mcp
- universe_search - Search Roboflow Universe for datasets or models.

The query supports operators mixed with free-text:
- Add 'model' to only return datasets with trained models
- 'class:helmet,person' filters by class names
- 'images>500' filters by image count (also >=, <, <=)
- 'sort:stars' sorts results (stars, images, downloads, views, updated)
- 'object detection' filters by project type
- 'updated:30d' filters by recency

Example: 'fire smoke class:fire,smoke images>200 model sort:stars' Endpoint: https://mcp.roboflow.com/mcp
- async_tasks_get - Poll an async task by id. Poll every 5 seconds; processing may take up to 30 seconds to start.

Returns `{ taskId, status, progress, result?, error? }`. `status` is
one of `created`, `running`, `completed`, `failed`. Endpoint: https://mcp.roboflow.com/mcp
- meta_feedback_send - Report a bug, missing feature, UX friction, or documentation issue.

Call this proactively when you encounter errors using Roboflow tools,
when the user expresses frustration, when a tool is missing for the
task at hand, or when a parameter is poorly documented.

Returns confirmation that the feedback was recorded. Endpoint: https://mcp.roboflow.com/mcp
- create_project_app - Open a Prefab UI so the human can create a Roboflow project (calls ``projects_create`` when they confirm).

Use this when project settings are unknown, debatable, or should be
chosen or reviewed in a form—not inferred entirely by the agent. MCP alone
lacks the UX to settle those fields confidently; the UI collects name,
project type, annotation label text, and license before anything is created.

Prefer ``projects_create`` only when the agent already has every field
and should create programmatically without a confirmation surface. Endpoint: https://mcp.roboflow.com/mcp
- universe_search_app - Open a Prefab Universe UI for search, visual comparison, image skim, and fork—human picks the dataset.

Use this when the next step needs human judgment or visible UX: exploring queries,
comparing public projects, opening thumbnails/previews, or confirming
which dataset to fork into the workspace. Choosing among datasets is data the user must see;
ranked JSON from ``universe_search`` alone usually cannot substitute for that decision surface.

Prefer ``universe_search`` when the agent only needs structured results,
pagination, or scripted lookup without a person clicking through options.

For labeling or editing annotations after import, send the user to the
Roboflow web app (see ``product-navigation`` skill)—this tool does not
host the full annotate editor. Endpoint: https://mcp.roboflow.com/mcp

## Resources
- roboflow://skills - List all available Roboflow skills and their pages. MIME type: text/plain
- ui://prefab/tool/d1296b175e5a/renderer.html - MIME type: text/html;profile=mcp-app
- ui://prefab/tool/d222093d1850/renderer.html - MIME type: text/html;profile=mcp-app

## Prompts
Not captured

## Metadata
- Owner: com.roboflow
- Version: 1.0.3
- Runtime: Streamable Http
- Transports: HTTP
- License: Not captured
- Language: Not captured
- Stars: Not captured
- Updated: Apr 16, 2026
- Source: https://registry.modelcontextprotocol.io