This server enables natural language interaction with a CVAT (Computer Vision Annotation Tool) instance by exposing its REST API as MCP tools usable by AI assistants like Cline.
Server Info: Retrieve basic CVAT server information and inspect the full OpenAPI schema.
Task Management: List tasks with filters (search, status, project, assignee, pagination); get a specific task by ID; create new tasks with labels and configuration; attach media (local files, remote URLs, or server-side files).
Annotation Management: Retrieve annotations for a task; replace/overwrite task annotations (requires explicit confirmation).
Job Management: List jobs with filters (task, project, state, stage, assignee, pagination); get a specific job by ID.
Project Management: List projects with filters; create new projects with labels.
Label Management: List labels filtered by task, project, job, or name.
Background Request Tracking: Poll the status of async CVAT operations (imports, exports, uploads).
Generic API Access: Call any CVAT REST endpoint directly (GET, POST, PATCH, PUT, DELETE), with mutation operations requiring explicit confirmation.
Extended Tool Generation: Generate additional MCP tools from the CVAT OpenAPI schema to cover version-specific or less common endpoints.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@CVAT MCP List tasks with status 'annotation' and their assignees"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
CVAT MCP는 Cline에서 자연어로 CVAT 작업을 수행할 수 있게 하는 stdio MCP 서버입니다. CVAT의 공식 REST API만 호출하며, Node 내장 기능만 사용하므로 별도 런타임 의존성이 없습니다.
CVAT 공식 API를 MCP Tool로 노출한다.
Cline에서 "CVAT task 목록 보여줘", "새 task 만들고 이미지를 업로드해" 같은 텍스트 요청을 하면 적절한 CVAT API가 호출되도록 한다.
기존 CVAT 프로젝트에 어떻게 포함될지에 대한 단계별 계획을 문서로 남긴다.
Related MCP server: WorkItems DevOps MCP Server
src/index.js: Cline이 실행하는 MCP stdio 엔트리포인트
src/static-tools.js: 자주 쓰는 CVAT API를 고수준 MCP Tool로 정의
src/cvat-client.js: CVAT REST API 클라이언트
scripts/generate-tool-catalog.js: CVAT OpenAPI 스키마에서 추가 MCP Tool 카탈로그 생성
docs/integration-plan.md: 기존 CVAT에 포함시키는 계획
docs/cvat-api-tooling.md: CVAT API를 Tool로 확장하는 방식
Node.js 20 이상
접근 가능한 CVAT 서버
CVAT Personal Access Token 권장
CVAT 공식 문서는 서버 API가 HTTP REST API이며, API 스키마와 Swagger 문서를 서버에서 제공한다고 설명합니다. PAT 인증은 Authorization: Bearer <token> 헤더를 사용합니다.
npm test$env:CVAT_BASE_URL="http://localhost:8080"
$env:CVAT_AUTH_TOKEN="your_pat"
npm start서버는 MCP stdio 프로세스이므로 사람이 직접 대화형으로 쓰는 프로그램이 아닙니다. Cline이 프로세스를 실행하고 stdin/stdout으로 JSON-RPC 메시지를 주고받습니다.
Cline의 cline_mcp_settings.json에 아래 서버를 추가합니다. Windows 경로는 실제 저장소 경로로 바꿉니다.
{
"mcpServers": {
"cvat-mcp": {
"command": "node",
"args": ["C:\\Users\\준승\\Desktop\\Development\\CVAT-MCP\\src\\index.js"],
"env": {
"CVAT_BASE_URL": "http://localhost:8080",
"CVAT_AUTH_TOKEN": "your_pat",
"CVAT_AUTH_SCHEME": "Bearer"
},
"disabled": false,
"alwaysAllow": [
"cvat_server_about",
"cvat_list_tasks",
"cvat_get_task",
"cvat_list_projects",
"cvat_list_jobs"
]
}
}
}쓰기 작업을 자동 승인하려면 신중해야 합니다. cvat_api_request의 POST, PATCH, PUT, DELETE와 생성된 mutation 도구는 confirmMutation: true가 있어야 실행됩니다.
CVAT 서버 상태를 확인해줘.CVAT에서 "road"가 들어간 task를 찾아서 상태와 assignee를 요약해줘.CVAT에 "sample cars" task를 만들고 label은 car, person으로 설정해줘.task 12의 annotation JSON을 가져와서 현재 workspace에 요약해줘.cvat_server_about
cvat_get_api_schema
cvat_list_tasks
cvat_get_task
cvat_create_task
cvat_attach_task_data
cvat_get_task_annotations
cvat_replace_task_annotations
cvat_list_jobs
cvat_get_job
cvat_get_request
cvat_list_projects
cvat_create_project
cvat_list_labels
cvat_api_request
CVAT 서버에서 OpenAPI 스키마를 받아 추가 도구 카탈로그를 만들 수 있습니다.
node scripts/generate-tool-catalog.js http://localhost:8080/api/schema/ generated/cvat-tools.json인터넷 연결은 필수가 아닙니다. MCP 서버와 생성 스크립트는 CVAT_BASE_URL 또는 명령에 입력한 CVAT 주소로 직접 API를 호출합니다. 내부망 CVAT 서버를 쓰는 경우에도 MCP 서버가 그 서버의 /api/schema/에 접근할 수 있으면 Tool 카탈로그를 생성할 수 있습니다.
다만 CVAT 버전에 따라 OpenAPI 스키마와 엔드포인트가 다를 수 있습니다. https://app.cvat.ai/api/schema/처럼 외부 공개 서버 기준으로 생성한 Tool은 내부 CVAT 서버 버전과 맞지 않을 수 있으므로, 실사용 전에는 실제 사용할 CVAT 서버의 schema로 다시 생성하는 것을 권장합니다.
node scripts/generate-tool-catalog.js http://실제_CVAT_주소/api/schema/ generated/cvat-tools.json이후 Cline 설정에 아래 환경 변수를 추가합니다.
{
"CVAT_GENERATED_TOOLS_PATH": "generated/cvat-tools.json"
}생성 도구는 {path, query, body} 형태의 입력을 받고 실제 CVAT 엔드포인트로 전달됩니다. 자주 쓰는 작업은 정적 고수준 도구를 우선 사용하고, CVAT 버전별 새 엔드포인트는 생성 도구 또는 cvat_api_request로 처리합니다.
CVAT Server API: https://docs.cvat.ai/docs/api_sdk/api/
CVAT Access Tokens: https://docs.cvat.ai/docs/api_sdk/access_tokens/
Cline MCP 설정: https://docs.cline.bot/mcp/adding-and-configuring-servers
MCP stdio transport: https://modelcontextprotocol.io/specification/2025-06-18/basic/transports
Call any official CVAT REST endpoint under /api/. For POST, PATCH, PUT, or DELETE, confirmMutation must be true.
| Name | Required | Description | Default |
|---|---|---|---|
| method | Yes | ||
| path | Yes | CVAT API path, for example /api/tasks or /api/jobs/12/annotations/. | |
| query | No | ||
| body | No | ||
| outputPath | No | Workspace-relative path for binary downloads. | |
| confirmMutation | No | Required as true for non-GET methods. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden. It only mentions the confirmMutation requirement but does not disclose side effects (e.g., mutation, deletion), authentication needs, or rate limits. Behavioral traits are minimally conveyed.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is short (two sentences) and front-loaded, but it is under-specified. It efficiently conveys the core purpose but omits necessary usage details, making it not earn its place fully.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (generic API caller with 6 parameters, no output schema) and the existence of many sibling tools for specific operations, the description lacks completeness. It does not explain how to use parameters like query, body, or outputPath, nor does it cover return values or when to prefer this tool over siblings.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds semantics for confirmMutation by noting it must be true for non-GET methods. However, schema description coverage is 50%, and the description does not elaborate on query, body, or outputPath, relying on the schema's partial descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool calls any official CVAT REST endpoint under /api/, which distinguishes it from the specific sibling tools like cvat_create_project and cvat_get_task. The verb 'call' and resource 'CVAT REST endpoint' are specific.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides a condition for mutation methods (confirmMutation must be true) but offers no guidance on when to use this generic tool versus the specific sibling tools. No alternatives or exclusions are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Attach local, server, or remote media to a task using POST /api/tasks/{id}/data/ with CVAT upload headers.
| Name | Required | Description | Default |
|---|---|---|---|
| taskId | Yes | ||
| clientFiles | No | Local workspace file paths to upload as client_files. | |
| serverFiles | No | Files already available in the CVAT server share. | |
| remoteFiles | No | Remote URLs for CVAT to fetch. | |
| options | No | Additional DataRequest fields such as image_quality, sorting_method, use_cache, chunk_size, start_frame, stop_frame. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so description carries full burden. It mentions the HTTP method and headers but does not disclose authentication needs, error handling, data size limits, or side effects like overwriting existing data.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence that front-loads the key action and uses no filler. Every word adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Lacks context about return values, common use patterns, or error scenarios. With nested params and no output schema, more guidance is needed for an agent to invoke correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 80% (4 of 5 params have descriptions). The description adds no extra meaning beyond the schema; options field is vaguely described as 'additional DataRequest fields' without elaboration. Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action (attach), the resource (media to a task), and the endpoint (POST /api/tasks/{id}/data/). It distinguishes from sibling tools like cvat_create_task or cvat_get_task by specifying the attaching data function.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool vs. alternatives (e.g., after creating a task, for local vs. server files). No prerequisites or exclusions provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Create a CVAT project using POST /api/projects.
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | ||
| labels | Yes | ||
| bug_tracker | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, and the description only mentions creation without disclosing side effects, permissions, or error behavior. For a mutation tool, this lacks sufficient behavioral context beyond the obvious.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence with no extraneous words. It is concise, though it could benefit from additional structure to improve clarity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the lack of annotations, output schema, and parameter descriptions, the description is inadequate for an agent to fully understand the tool's purpose and usage constraints. It does not explain what a project or labels are, nor any restrictions.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description does not explain any parameters. It adds no meaning beyond what the schema itself provides, failing to compensate for the lack of parameter documentation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action (Create), the resource (CVAT project), and the HTTP method (POST). However, it does not differentiate from sibling tools like cvat_create_task, and does not clarify what a CVAT project encompasses.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool instead of alternatives such as cvat_create_task. Missing context on prerequisites or typical use cases.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Create a CVAT task using POST /api/tasks. Use cvat_attach_task_data afterward to upload images or videos.
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | ||
| labels | Yes | ||
| project_id | No | ||
| assignee_id | No | ||
| segment_size | No | ||
| overlap | No | ||
| subset | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must disclose behavioral traits. It only states the HTTP method and endpoint, omitting whether the tool is idempotent, requires authentication, or has side effects beyond creation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, no wasted words, but underspecified. Efficient in length but lacks necessary detail to be fully helpful.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 7 parameters, no annotations, and no output schema, the description fails to provide enough context for the agent to use the tool correctly. Missing details on required parameter formats (e.g., labels structure) and behavior.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema has 7 parameters with 0% description coverage. The description adds no meaning to any parameter, leaving the agent to infer from names alone.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states 'Create a CVAT task' and specifies the HTTP method and endpoint. Differentiates from sibling tool cvat_attach_task_data by directing to use it afterward.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly tells the agent to use cvat_attach_task_data after creation for data upload, providing clear context on workflow. Does not include exclusions or when not to use, but the guidance is helpful.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Fetch the CVAT OpenAPI schema from GET /api/schema/ so official API endpoints can be inspected or converted into MCP tools.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must carry the burden. It states the tool fetches a schema via a GET request, which implies a read-only operation. However, it does not disclose authentication requirements, rate limits, or the fact that the response is a JSON schema. For a simple tool, this is adequate but not thorough.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, well-structured sentence that includes the action, resource, endpoint, and purpose. No extraneous words; every part contributes value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has no parameters, no output schema, and no annotations, the description is complete enough. It clearly distinguishes the tool from siblings and provides the necessary information for an agent to decide when and how to invoke it.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema is empty with 100% coverage, so the schema already defines all parameters. The description adds no further parameter details. According to guidelines, high schema coverage yields baseline 3, which is appropriate here.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Fetch'), the exact resource ('CVAT OpenAPI schema'), and the specific endpoint ('GET /api/schema/'). It also explains the purpose ('inspected or converted into MCP tools'), which distinguishes it from siblings that focus on data operations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use the tool (when you need to inspect or convert API endpoints) but does not explicitly exclude contexts or name alternatives. Given the sibling tools cover concrete CVAT operations, the usage context is clear enough.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get one CVAT job by id from GET /api/jobs/{id}.
| Name | Required | Description | Default |
|---|---|---|---|
| jobId | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, and the description only references the API endpoint. It does not disclose potential side effects, authorization needs, response format, or error conditions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise at one sentence. However, it sacrifices informative value for brevity; front-loading is adequate but could be structured better.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema and no annotations, the description should explain return behavior or data format. It does not, leaving the agent with minimal context for a simple tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds no meaning beyond the schema. The single parameter 'jobId' is described only by its type and minimum, and schema coverage is 0%. No compensation for this gap.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Get', the resource 'one CVAT job', and the specific API endpoint. It distinguishes well from sibling tools like cvat_list_jobs.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance on when to use vs alternatives. The description implies usage for fetching a single job by ID but does not differentiate from similar tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get a CVAT background request by id from GET /api/requests/{id}; useful after imports, exports, or data upload.
| Name | Required | Description | Default |
|---|---|---|---|
| requestId | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided. Description implies read-only operation via 'Get', but lacks details on side effects, error handling, or auth requirements, which is acceptable for a simple GET with no annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence, front-loaded with action and purpose, no fluff, highly efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Covers purpose and usage context, but lacks description of return value or output structure; no output schema provided, so agent may need to infer response format.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema has zero description coverage; description adds endpoint context ('from GET /api/requests/{id}') but does not explain the nature or format of requestId beyond what schema provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Get', the resource 'CVAT background request', and the endpoint, while specifying useful contexts like imports/exports, distinguishing it from other get tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides clear usage context ('useful after imports, exports, or data upload'), but does not explicitly state when not to use or mention alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get one CVAT task by id from GET /api/tasks/{id}.
| Name | Required | Description | Default |
|---|---|---|---|
| taskId | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, and the description only mentions the HTTP endpoint. It does not disclose behavioral traits like read-only nature, side effects, or return format. For a get-by-id operation, more context would be helpful.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence with no wasted words, but it is overly minimal. It could be slightly longer to include useful details while remaining concise.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the low complexity (one param, no output schema, no annotations), the description is barely adequate. It includes the HTTP method but omits error handling, return structure, or usage hints.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds no extra meaning beyond the schema's param taskId. With 0% schema description coverage, the description fails to compensate by explaining parameter usage or format.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Get one CVAT task by id', specifying the verb 'Get', resource 'CVAT task', and identification method 'by id'. It distinguishes from sibling tools like cvat_list_tasks (list vs single) and cvat_get_task_annotations (task vs annotations).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives such as cvat_get_job or cvat_list_tasks. It lacks explicit context for selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get task annotations from GET /api/tasks/{id}/annotations/.
| Name | Required | Description | Default |
|---|---|---|---|
| taskId | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, and the description does not disclose behavioral details such as whether the operation is read-only, authentication requirements, or data format. The description merely restates the endpoint path, adding no behavioral insight beyond the name.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence of 9 words, which is concise but lacks structure and does not convey essential information beyond the name. It is under-specified rather than efficiently compact.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the absence of annotations, output schema, and parameter explanations, the description is insufficient for an agent to understand the tool's behavior, prerequisites, or return values. It fails to provide a complete context for reliable invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0% description coverage, and the description does not explain the 'taskId' parameter beyond its schema definition (integer, minimum 1). No context is provided about what identifiers are valid or how to obtain them.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states the action (get annotations) and references the specific API endpoint, which clarifies the resource. However, it does not differentiate from sibling tools like cvat_get_task (which gets task metadata) or cvat_replace_task_annotations, leaving ambiguity about scope.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives like cvat_get_task or cvat_list_tasks. There are no prerequisites or context for appropriate invocation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List CVAT jobs with official /api/jobs filters such as task_id, project_id, state, stage, assignee, sort, page, and page_size.
| Name | Required | Description | Default |
|---|---|---|---|
| task_id | No | ||
| project_id | No | ||
| state | No | ||
| stage | No | ||
| assignee | No | ||
| sort | No | ||
| page | No | CVAT page number. | |
| page_size | No | Number of results per page. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure. It only lists filter parameters and says 'list', but does not mention that the operation is read-only, safe, or any constraints like rate limits or data scope. The behavioral context is minimal.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence that is front-loaded with the verb and resource. It is concise but could be improved by structuring filter information more readably (e.g., bullet points). Still, it avoids unnecessary words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 8 optional parameters, no output schema, and no annotations, the description is too brief. It does not cover return type, pagination behavior, default values, or how filters combine. The tool is underspecified for effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is only 25% (only page and page_size have descriptions). The description merely lists parameter names without explaining their meaning, acceptable values, or how they interact. For low coverage, the description should add semantic detail but fails to do so.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states that the tool lists CVAT jobs and enumerates official filters, making the purpose specific. However, it does not explicitly differentiate from sibling list tools like cvat_list_tasks or cvat_get_job, which would clarify when to use this tool.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. There is no mention of prerequisites, typical use cases, or conditions that favor this tool over sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List labels with /api/labels filters such as task_id, project_id, job_id, name, search, and page_size.
| Name | Required | Description | Default |
|---|---|---|---|
| task_id | No | ||
| project_id | No | ||
| job_id | No | ||
| name | No | ||
| search | No | ||
| page | No | CVAT page number. | |
| page_size | No | Number of results per page. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations are absent, so the description must carry behavioral disclosure. It only says 'List labels', implying a read-only operation, but does not confirm safety, mention pagination behavior, or other traits. The description adds minimal value beyond what the schema already shows.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence with no wasted words. It is concise, though it could be slightly more structured by grouping filters. Still efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
No output schema exists, so the description should describe what the tool returns. It does not. The tool has no required parameters, but usage context (e.g., need for at least one filter) is unclear. The description feels incomplete for a tool with 7 optional parameters.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is only 29% (page and page_size have descriptions). The description lists parameter names but does not explain their meaning or effect beyond what the schema provides. It fails to compensate for the low coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'List labels' with a specific verb and resource. It mentions filters but does not differentiate from siblings like cvat_list_tasks or cvat_list_projects, which also list resources. The purpose is clear but lacks sibling context.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives. The description merely lists filter parameters without explaining context or prerequisites. No explicit when/when-not or alternative tools mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List CVAT projects with /api/projects filters such as search, owner, assignee, sort, page, and page_size.
| Name | Required | Description | Default |
|---|---|---|---|
| search | No | ||
| owner | No | ||
| assignee | No | ||
| sort | No | ||
| page | No | CVAT page number. | |
| page_size | No | Number of results per page. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so the description carries full burden. It only mentions 'list' and filters, but fails to disclose read-only nature, pagination behavior, authentication needs, or error handling.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence, front-loaded with verb and resource, no wasted words. However, it could include brief usage context without becoming too long.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
No output schema, low schema coverage, and no explanation of return structure or pagination details. The description is insufficient for an agent to fully understand the tool's behavior.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 33% (only page and page_size have descriptions). The description merely lists parameter names without adding meaning or format details, and does not compensate for the low coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'List' and the resource 'CVAT projects', and mentions specific filters. It distinguishes from sibling tools like cvat_list_tasks and cvat_list_jobs by focusing on projects.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance on when to use this tool versus alternatives. The description only lists filters without context or exclusions, leaving the agent to infer usage from the name and sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List CVAT tasks with official /api/tasks filters such as search, status, project_id, assignee, owner, sort, page, and page_size.
| Name | Required | Description | Default |
|---|---|---|---|
| search | No | ||
| status | No | ||
| project_id | No | ||
| assignee | No | ||
| owner | No | ||
| sort | No | ||
| page | No | CVAT page number. | |
| page_size | No | Number of results per page. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, and the description does not disclose key behavioral traits such as whether the operation is read-only, whether it returns a full list or paginated results, or if there are any side effects. The only implicit hint is the mention of page and page_size parameters.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence that efficiently conveys the purpose and key parameters. It is concise and front-loaded, though it could benefit from slight restructuring to separate purpose from parameter list.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the lack of output schema and annotations, the description should explain the return format (list of task objects) and default sorting/page behavior. It does not provide this context, making it incomplete for an agent to use correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is only 25% (only page and page_size have descriptions). The description merely lists parameter names without explaining their meanings, allowed values, or constraints, failing to compensate for the poor schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool lists CVAT tasks and enumerates specific filters. However, it does not explicitly distinguish this from sibling tools like cvat_get_task or cvat_list_projects, which could cause confusion.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. The description only lists filters but does not explain context (e.g., when to paginate, or when to use this instead of cvat_get_task for a single task).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Replace task annotations with PUT /api/tasks/{id}/annotations/. Requires confirmReplace=true.
| Name | Required | Description | Default |
|---|---|---|---|
| taskId | Yes | ||
| annotations | Yes | CVAT LabeledDataRequest JSON. | |
| confirmReplace | Yes | Must be true because this replaces current task annotations. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description indicates the HTTP method and the requirement for confirmReplace, which implies a destructive write. However, it lacks details on the full replacement behavior, idempotency, or return value. Without annotations, it partially addresses the behavioral burden.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences effectively communicate the core action and a key requirement. No wasted words, but it could include more essential details (e.g., what taskId refers to) without becoming verbose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple replacement tool with no output schema, the description misses critical context: it does not explain that this operation replaces all existing annotations, nor does it reference sibling tools like cvat_get_task_annotations. The agent may not understand the full impact.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema covers 67% of parameters with descriptions. The description adds minimal value: it restates the confirmReplace requirement and vaguely describes annotations as 'CVAT LabeledDataRequest JSON.' The taskId parameter lacks any description in both schema and description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Replace task annotations') and the HTTP method/PUT endpoint. However, it does not differentiate from sibling tools like cvat_attach_task_data, which might also modify annotations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It mentions the required parameter confirmReplace=true but provides no guidance on when to use this tool versus alternatives (e.g., when to replace all annotations vs. partial updates).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get basic CVAT server information from GET /api/server/about.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, and the description only mentions it's a GET request. It does not disclose authentication requirements, rate limits, or what 'basic' information entails (e.g., version, user info). This leaves the agent uncertain about side effects or prerequisites.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence that is front-loaded with the action and resource. No filler or redundant information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has no parameters and no output schema, the description is minimally complete. However, it lacks details about response structure or any behavioral notes (e.g., whether authentication is needed), which would be helpful for a simple info endpoint.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
There are no parameters, so schema coverage is 100%. The description adds the endpoint path, which provides context beyond the empty schema. Baseline for zero-param tools is 4.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool gets basic CVAT server information and specifies the endpoint. It uses a specific verb ('Get') and resource ('basic CVAT server information'), distinguishing it from sibling tools like cvat_create_task or cvat_list_projects.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives (e.g., cvat_get_api_schema or cvat_api_request). The description lacks context about prerequisites or scenarios where this is the appropriate choice.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v0.1.0cvat_api_requestcvat_attach_task_datacvat_create_projectcvat_create_taskcvat_get_api_schemacvat_get_jobcvat_get_requestcvat_get_taskcvat_get_task_annotationscvat_list_jobscvat_list_labelscvat_list_projectscvat_list_taskscvat_replace_task_annotationscvat_server_aboutScored across 15 tools
Each tool targets a distinct action and resource. The generic 'cvat_api_request' is clearly a fallback for uncovered endpoints, and all specific tools have unique purposes (create, list, get, attach, replace, etc.) without overlap.
All tools follow a consistent 'cvat_verb_noun' pattern (e.g., cvat_create_task, cvat_list_jobs). The convention is uniform across the entire set, with no mixing of styles.
15 tools is well within the ideal 3-15 range. The number is appropriate for a CVAT server covering projects, tasks, jobs, labels, annotations, and server introspection without being overwhelming.
The set covers core creation, listing, and annotation operations but lacks dedicated update and delete tools for projects and tasks. A generic API request tool exists but requires API knowledge, leaving notable gaps for typical agent workflows.
Manage projects, tasks, time tracking, and team collaboration through natural language.
Manage tasks, Focus Zone, notes, projects, and task history from compatible AI assistants.
Create and manage MeisterTask projects, tasks, and notes from your AI assistant.
Manage Superlist tasks and lists in plain language from any MCP-compatible AI agent.
