Supercharge your AI with Scale AI. Orchestrate Multi-Modal Data Labeling Workflows
Gemini Works with every AI agent you already use
…and any MCP-compatible client
Connect to your AI in seconds.
Scale AI connects your agent directly to industrial-grade data labeling and fine-tuning pipelines. It lets you manage massive annotation projects—for images, video, text, or entity recognition—using natural conversation.
You can create new projects, organize high-volume work into batches, submit tasks for multi-modal formats, and track progress without leaving your chat interface.
What your AI can do
Cancel task
Cancels a pending data labeling task, allowing you to reuse the unique task ID later.
Create batch
Groups multiple individual annotation tasks together into one large batch for processing.
Create image annotation task
Creates a specific task to annotate images, defining the required labeling type and source data.
You create and configure a new labeling project to define the scope (e.g., image annotation vs. text collection) and specific rules.
The agent submits tasks for different data types, including images, video clips, and raw text collections.
You group many individual tasks into a single batch and then finalize that batch to start the processing run.
The agent retrieves detailed status for any task ID, letting you check progress or cancel pending jobs.
You update project-level instructions on the fly to adjust labeling quality requirements without recreating the whole project.
Ask an AI about this
Compatible AI Apps
OAuth 2.0 Compatible Gemini Waiting for input…
Scale AI MCP Server: 11 Tools for Data Annotation
Use these tools to manage the entire data lifecycle—from setting up projects and submitting multi-modal tasks to finalizing batches in one place.
Make your AI actually useful.
Add this MCP to Claude, Cursor, or Windsurf and your AI stops guessing. It gets real tools to look things up, take action, and handle the stuff you keep doing by hand.
Start using Scale AI on VinkiusCancel Task
Cancels a pending data labeling task, allowing you to reuse the unique task ID later.
Create Batch
Groups multiple individual annotation tasks together into one large batch for...
Create Image Annotation Task
Creates a specific task to annotate images, defining the required labeling type and...
Create Named Entity Recognition Task
Submits a job for recognizing and tagging named entities within provided text...
Create Project
Sets up an entirely new project, defining the rules, scope, and type of annotation...
Create Segment Annotation Task
Creates a task requiring pixel-level segmentation annotation for images or videos.
Create Text Collection Task
Submits a job to gather and label collections of raw text data.
Create Video Playback Annotation Task
Creates an annotation task specifically for marking events or objects within video...
Finalize Batch
Marks a prepared batch as complete, triggering the official data labeling processing...
Get Task
Retrieves all current status details for any specific task ID you provide.
Update Project Params
Modifies the rules and parameters of an existing project to refine labeling quality...
Connect to your AI in seconds. Security and governance baked right in.
Pick your AI client below to get set up. Just create a Vinkius account, subscribe, and you're instantly up and running. We handle the entire backend infrastructure, delivering out-of-the-box support for HTTPS Streamable, SSE, and OAuth2—zero messy routing required.
Claude AI
Open Claude Settings
Go to claude.ai, click your profile icon, then navigate to Customize → Connectors.
Add Custom Connector
Click the "+" button and select Add custom connector. Paste your Vinkius endpoint URL:
https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp
Replace [YOUR_TOKEN_HERE] with your token from
cloud.vinkius.com. For OAuth-protected servers, expand Advanced
settings to add credentials.
Start a conversation
Open a new chat. The Scale AI integration is available immediately — no restart needed.
Choose How to Get Started
Build a custom MCP for your own tools, or connect a ready-made integration from our catalog.
Build Your Own
Turn any API into an MCP. Import a spec, define Agent Skills, or deploy with MCPFusion.
- Import from OpenAPI, Swagger, or YAML specs
- Create Agent Skills with progressive disclosure
- Deploy to edge with MCPFusion framework
- Built in DLP, auth, and compliance on every call
- Real time usage dashboard and cost metering
- Publish to catalog or keep private
Make Your AI Do More
Start with Scale AI, then connect any of our 5,000+ other servers whenever your AI needs more. One click, no limits.
- Use this MCP plus 5,000+ others, all in one place
- Add new capabilities to your AI anytime you want
- Every connection is secured and compliant automatically
- Track usage and costs across all your servers
- Works with Claude, ChatGPT, Cursor, and more
- New servers added to the catalog every week
Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by Scale AI. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.
VINKIUS INFRASTRUCTURE
Cloud Hosted
Managed infra
V8 Isolated
Sandboxed per request
Zero-Trust Proxy
No stored credentials
DLP Enforced
Policy on every call
GDPR Compliant
EU data residency
Token Compression
~60% cost reduction
Works with Claude, ChatGPT, Cursor, and more
The Model Context Protocol standardizes how applications expose capabilities to LLMs. Instead of operating in isolation, your AI gains direct access to external platforms, live data, and real-world actions through secure, standardized connections.
This connection provides 11 powerful capabilities that interface natively with Claude, ChatGPT, Cursor, and other compatible AI platforms. No middleware. No custom integration required.
Managing ML Data Labeling Feels Like a Juggling Act Today.
Right now, getting clean, labeled data means jumping between five different dashboards. You create the project in one tab, submit tasks via an API script in another, and then you have to manually monitor progress by refreshing a status page. If you change a rule mid-project, it's a whole new cycle of clicks and updates.
With this MCP server, that process collapses into conversation. You tell your agent what you need—like 'I need 10k images segmented.' The agent handles the `create_segment_annotation_task`, groups them with `create_batch`, and monitors everything for you. It's all one chat.
The Scale AI MCP Server: Streamlining Data Annotation.
Manual workflows require separate steps to define the project, then submit data type by data type (image vs. text), and finally call a status check tool for every single ID. You lose continuity and spend time managing the tools instead of the data.
Now, you use specialized tools like `create_video_playback_annotation_task` to handle complex inputs and manage them all in sequence. It’s about making the entire data lifecycle predictable and controllable from a single source.
What your AI can actually do with this
Look, if you’re dealing with massive data labeling projects—images, video feeds, text documents—you don't want to jump between ten different platforms. This server hooks your agent up directly to industrial-grade pipelines so you manage the whole process using nothing but natural conversation. You get total control over everything, from setting up a new annotation scope to triggering the final processing run, all inside your chat window.
To start, you gotta define what you're doing. You use create_project when you need to set up an entirely new labeling project. That call defines the whole scope and rules—whether you’re dealing with simple image annotations or complex text collection jobs. If you figure out halfway through that the quality requirements changed, don't worry; you just run update_project_params to modify the existing project parameters.
This lets you refine labeling instructions on the fly without having to recreate the whole thing.
Once the project is configured, you submit the actual work. The system supports every major data type. For images, you can kick off a standard job using create_image_annotation_task, which requires defining both the source data and the specific labeling type needed. If your image or video needs pixel-perfect detail, use create_segment_annotation_task for segmentation tasks; this handles both images and videos.
When you're working with motion capture, create_video_playback_annotation_task creates a task specifically for marking events or objects within continuous video footage. For text data, the options are broad: running create_named_entity_recognition_task tags specific entities in documents, while create_text_collection_task handles gathering and labeling large collections of raw text.
When it comes to volume, you don't submit tasks one by one. You use create_batch to group a whole bunch of individual annotation tasks into one massive batch ready for processing. Once that batch is prepped—meaning every task in the grouping is accounted for and structured correctly—you run finalize_batch. That call marks the batch as complete, which kicks off the official data labeling pipeline run by Scale AI.
Managing this scale requires constant oversight. If you need to know where a specific job stands, you use get_task with any task ID; it pulls all the current status details for that job. And if something went sideways, or you just changed your mind about a pending run, you can hit cancel_task.
This cancels a specific, pending data labeling task but keeps the unique task ID available so you don't lose your progress.
You use these tools to manage every stage: defining the project scope with create_project, making sure the rules are current via update_project_params, submitting diverse tasks using create_image_annotation_task for images, create_segment_annotation_task for pixel detail, create_video_playback_annotation_task for video events, create_named_entity_recognition_task for text tags, or create_text_collection_task for raw data; grouping them into large loads with create_batch, running the official processing cycle by calling finalize_batch, and maintaining total visibility over everything through get_task and cancel_task.
You've got end-to-end control, period.
019e38e8-61a9-7168-a995-6da9d22b3e9e 
Here's how it actually works
The bottom line is that you manage an entire data pipeline—from project definition to task completion—using only conversational commands.
First, subscribe to the server and provide your Scale AI Live API Key.
Next, use tools like create_project to set up the specific labeling job (e.g., NER or Image Annotation).
Finally, submit tasks using specialized tools (create_batch, etc.) and wrap up the process by calling finalize_batch.
Who is this actually for?
ML Engineers who are tired of jumping between API endpoints and notebooks. Data Operations Managers who need to monitor batch progress while talking to a team lead. AI Researchers needing to rapidly spin up complex RLHF or annotation datasets for validation.
They use the agent to automate submitting edge case images or texts directly from their training scripts without writing dedicated API wrappers.
They monitor batch progress and update labeling instructions mid-process, all within a single chat interface, keeping stakeholders informed.
They quickly spin up specialized annotation projects (like video or segmentation) to validate new model datasets for immediate testing.
What Changes When You Connect
Manage the entire data flow, from create_project setup to final processing, all through your chat interface. You don't leave your workflow.
Handle diverse data types using single commands: Image Annotation, Semantic Segmentation, and Video Playback tasks are all submitted via dedicated tools like create_image_annotation_task.
Never lose track of work again. Use get_task to pull up the current status on any task ID or cancel pending items immediately if needed.
Process large amounts of data efficiently by grouping individual jobs with create_batch, and then executing them all at once using finalize_batch.
Need to change the rules? You can update project parameters dynamically using update_project_params. This lets you refine quality without restarting the whole pipeline.
See it in action
Training a Model on Lidar Data
A self-driving car ML Engineer needs to label thousands of obstacle images. Instead of writing an API script, they ask their agent: 'Create a project for image annotation and submit 50 tasks using create_image_annotation_task.' The agent handles the setup, submission, and tracking until the data is ready.
Annotating Video Game Footage
An AI Researcher needs to tag specific actions in video. They tell their agent: 'Set up a video annotation project and submit 10 clips using create_video_playback_annotation_task.' The server handles the complex multi-modal task setup, allowing immediate review.
Massive Document Review
A Data Ops Manager needs to process 10,000 legal documents for named entity recognition. They use create_project first, then run create_text_collection_task followed by create_batch, ensuring the entire corpus gets processed and finalized.
Iterative Quality Improvement
The model is labeling poorly. Instead of restarting, a team member uses update_project_params to tighten the quality constraints on an existing project. Then they can monitor the fix using get_task before running another batch.
The honest tradeoffs
Trying to process everything without planning.
Just calling a task creation tool repeatedly in a row, hoping it magically works. This ignores the need for defined scope and grouping.
Always start by defining your job with create_project. Then, group all related tasks into one batch using create_batch before you run finalize_batch. This ensures data integrity.
Assuming a task is ready just because it was created.
Thinking that submitting the task means the work is done. You might waste time or budget waiting for nothing.
Always confirm status using get_task. This tool tells you if the job is pending, processing, or complete before you assume anything.
Updating rules manually in a separate dashboard.
Having to log into the Scale AI web portal just to change one parameter—this breaks flow and wastes time.
Use update_project_params directly through your agent. You can refine project instructions without leaving your chat window.
When It Fits, When It Doesn't
Use this server if your workflow requires structured, high-volume data labeling across multiple modalities (image, video, text). You need to manage the entire pipeline—setup, submission, monitoring, and finalization—from one place. This is ideal for ML engineers running continuous training loops or data operations teams managing ongoing annotation quality.
Don't use this if you only have a single, simple task (e.g., labeling 3 images). For that, manual API calls might be faster. Also, don't use it if your goal is just general data storage; you need the structure of project creation and batch finalization for this toolset to make sense.
Questions you might have
How do I start annotating images using `create_image_annotation_task`? +
You first need to use create_project to define the rules. Then, you can submit your data by calling create_image_annotation_task, which uses the project context to submit the actual job.
What's the difference between `create_batch` and `finalize_batch`? +
create_batch just organizes a list of tasks, preparing them for processing. You must call finalize_batch afterward to actually tell Scale AI to start running the labeling job.
Can I change my labeling rules after starting a project? Which tool handles that? +
Yes. Use update_project_params. This tool lets you modify instructions and parameters on an existing project without having to delete and rebuild the whole thing.
How do I check if a task was successful? Which tool should I use? +
Use get_task with the unique ID. This retrieves all current status details, letting you know exactly where that specific job stands in the queue.
Before I use `create_project`, what authentication credentials do I need to connect my agent? +
You must provide your Scale AI Live API Key. Your agent uses this key to authenticate all calls, ensuring it has the correct permissions and access limits for your specific account.
What happens if I submit a task using `create_image_annotation_task` but realize I need to stop it? +
You use the cancel_task tool. This immediately halts any pending annotation job and removes its status, allowing you to reuse that unique ID or correct the initial parameters.
When should I use `create_segment_annotation_task` instead of standard image annotation? +
Use create_segment_annotation_task when your data requires pixel-level precision. This tool handles semantic segmentation, enabling you to draw precise outlines around objects rather than just using bounding boxes.
What is the correct sequence for handling large volumes of data using `create_batch` and `finalize_batch`? +
First, use create_batch to group all related tasks. Next, you must call finalize_batch. This commits the entire batch to Scale's system and triggers the actual processing pipeline.
How do I start a high-volume labeling job using batches? +
First, use create_batch to initialize a group for your project. After submitting your tasks to this batch, call finalize_batch to signal Scale to begin the labeling process.
Can I check the status of a specific annotation task? +
Yes, use the get_task tool with the specific Task ID. It will return the full metadata, current status, and any available results for that unit of work.
What should I do if I submitted a task by mistake? +
You can use the cancel_task tool with the Task ID. If you need to reuse the unique identifier, you can also set the clear_unique_id parameter to true.
We've already built the connector for Scale AI. Just plug in your AI agents and start using Vinkius.
No hosting. No infrastructure. No complex setup.
All 11 tools are live and waiting.
You're up and running in seconds.
Gemini Vinkius gives your AI agents access to the full catalog of app connectors, all fully managed, secure, and enterprise-ready. One subscription, every tool you need.
Built, hosted, and secured by Vinkius. You just connect and go.