Dooray MCP Server
The Dooray MCP Server integrates Dooray's project management API with Claude Code, enabling management of tasks, comments, tags, members, files, search, and workflows.
Tasks: List, get, create, update, delete tasks; change status; assign members.
Comments: List, create, update, delete comments on tasks; supports user mentions.
Tags: List/filter tags, create tags with custom colors, add/remove tags from tasks.
Search: Search tasks by text, assignee, status, tag, date range, or workflow; supports advanced multi-condition AND/OR logic.
Members: Search by email or ID, retrieve member details, list project members.
Files & Images: List task attachments, get file metadata, download file content, upload images to S3 for use in task/comment bodies, access files by content ID via Drive API.
Workflows: List, get, create, update, and delete project workflows.
Provides comprehensive file and image management capabilities including listing task files, retrieving file metadata, downloading file content in base64 encoding, and direct file access through Content IDs via Drive API.
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., "@Dooray MCP Servershow me all tasks assigned to me that are overdue"
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.
Dooray MCP Server
Dooray API를 Claude Code와 연동하기 위한 MCP (Model Context Protocol) 서버입니다.
기능
이 MCP 서버는 Dooray의 주요 기능을 6개의 통합 도구로 제공합니다:
dooray_tasks - 업무 관리 (목록 조회, 상세 조회, 생성, 수정, 삭제, 상태 변경, 담당자 지정)
dooray_comments - 댓글 관리 (목록 조회, 생성, 수정, 삭제, 멘션 지원)
dooray_tags - 태그 관리 (목록 조회, 생성, 업무에 태그 추가/제거)
dooray_search - 검색 기능 (업무 검색, 담당자별/상태별/태그별/기간별 검색)
dooray_members - 사용자 관리 (이메일/ID 검색, 사용자 정보 조회, 프로젝트 멤버 목록)
dooray_files - 파일 및 이미지 관리 (업무 파일 업로드/목록, S3 본문 이미지 업로드, 파일 메타데이터, 파일 콘텐츠 다운로드, Content ID로 직접 접근)
Related MCP server: ZenTao MCP Server
빠른 설치
GitHub에서 자동 설치
# 1. 저장소 클론
git clone https://github.com/tallpizza/dooray-mcp.git
cd dooray-mcp
# 2. 자동 설치 스크립트 실행
./install.sh
# 3. 환경 변수 설정 (.env 파일 수정)
# DOORAY_API_TOKEN과 DOORAY_DEFAULT_PROJECT_ID를 실제 값으로 변경
# 4. Claude Code에 추가
claude mcp add-json dooray "$(cat .mcp.json | jq -c .dooray)"상세 설치 및 설정
1. GitHub에서 설치
# GitHub에서 프로젝트 클론
git clone https://github.com/tallpizza/dooray-mcp.git
cd dooray-mcp
# 종속성 설치
uv sync2. 환경 변수 설정
.env 파일을 생성하고 다음 내용을 설정합니다:
# .env.example을 복사
cp .env.example .env
# .env 파일 내용
DOORAY_API_TOKEN=your-actual-dooray-api-token
DOORAY_BASE_URL=https://api.dooray.com
DOORAY_DEFAULT_PROJECT_ID=your-default-project-id
# 선택: Dooray 본문 이미지용 S3-compatible 스토리지 (upload_body_image 사용 시)
S3_BUCKET=your-public-image-bucket
S3_REGION=ap-northeast-2
S3_ACCESS_KEY_ID=your-s3-access-key
S3_SECRET_ACCESS_KEY=your-s3-secret-key
LOG_LEVEL=INFO3. Claude Code MCP 서버 추가
방법 1: JSON으로 추가 (권장)
# 환경 변수를 포함한 완전한 설정
claude mcp add-json dooray '{
"type": "stdio",
"command": "uv",
"args": ["run", "python", "-m", "dooray_mcp.server"],
"env": {
"DOORAY_API_TOKEN": "your-actual-dooray-api-token",
"DOORAY_BASE_URL": "https://api.dooray.com",
"DOORAY_DEFAULT_PROJECT_ID": "your-default-project-id",
"S3_BUCKET": "your-public-image-bucket",
"S3_REGION": "ap-northeast-2",
"S3_ACCESS_KEY_ID": "your-s3-access-key",
"S3_SECRET_ACCESS_KEY": "your-s3-secret-key"
}
}'방법 2: 설정 파일 사용
# .mcp.json 설정 파일 준비
cp .mcp.json.example .mcp.json
# 환경 변수를 실제 값으로 수정
# Claude Code에서 사용
claude --mcp-config .mcp.json4. 연결 확인
# MCP 서버 목록 확인
claude mcp list
# Dooray 서버가 ✓ Connected로 표시되는지 확인5. 도구 테스트
# 업무 목록 조회 테스트
claude --print "dooray_tasks를 사용해서 업무 목록을 조회해주세요."
# 댓글 생성 테스트
claude --print "dooray_comments를 사용해서 댓글을 생성해주세요."사용법
도구별 사용 예제
1. dooray_tasks (업무 관리)
// 업무 목록 조회
{
"action": "list",
"projectId": "project-123" // 선택사항 (환경 변수 사용 가능)
}
// 업무 생성
{
"action": "create",
"projectId": "project-123",
"title": "새 업무",
"description": "업무 설명",
"priority": "normal"
}2. dooray_comments (댓글 관리)
// 댓글 생성 (멘션 포함)
{
"action": "create",
"taskId": "task-456",
"content": "댓글 내용",
"mentions": ["user1", "user2"] // 선택사항
}3. dooray_tags (태그 관리)
// 새 태그 생성
{
"action": "create",
"projectId": "project-123",
"tagName": "긴급",
"tagColor": "#FF0000" // # 포함 가능, 자동으로 제거됨
}
// 업무에 태그 추가
{
"action": "add_to_task",
"taskId": "task-456",
"tagName": "긴급"
}4. dooray_search (검색 기능)
// 업무 텍스트 검색
{
"searchType": "tasks",
"projectId": "project-123",
"query": "버그 수정"
}
// 상태별 검색
{
"searchType": "by_status",
"projectId": "project-123",
"status": "완료"
}5. dooray_members (사용자 관리)
// 이메일로 사용자 검색
{
"action": "search_by_email",
"email": "user@company.com"
}
// 프로젝트 멤버 목록
{
"action": "list_project_members",
"projectId": "project-123"
}6. dooray_files (파일 및 이미지 관리)
// 업무 파일 업로드
{
"action": "upload_task_file",
"taskId": "task-456",
"filePath": "/path/to/image.png",
"filename": "image.png", // 선택사항
"mimeType": "image/png", // 선택사항 (미지정 시 확장자로 추정)
"projectId": "project-123" // 선택사항 (환경 변수 사용 가능)
}
// 응답에는 result.id와 함께 result.fileId, result.metadataApiUrl, result.downloadApiUrl이 포함됩니다.
// 주의: downloadApiUrl/rawUrl은 Authorization 헤더가 필요한 API URL입니다.
// Dooray 본문/댓글에 이미지 URL로 붙여 넣으면 표시되지 않습니다. 업로드만으로 업무 첨부파일에는 등록됩니다.
// Dooray 본문/댓글에 사용할 이미지 URL 생성 (S3 업로드)
{
"action": "upload_body_image",
"filePath": "/path/to/image.png",
"filename": "image.png", // 선택사항
"mimeType": "image/png", // 선택사항
"altText": "스크린샷", // 선택사항
"s3Key": "dooray/image.png" // 선택사항 (미지정 시 자동 생성)
}
// 응답의 markdown 값을 업무/댓글 본문에 넣으면 됩니다.
// 예: 
// S3 객체는 Dooray 사용자가 인증 없이 접근 가능해야 합니다.
// 업무 파일 목록 조회
{
"action": "list_task_files",
"taskId": "task-456",
"projectId": "project-123" // 선택사항 (환경 변수 사용 가능)
}
// 업무 파일 메타데이터 조회
{
"action": "get_task_file_metadata",
"taskId": "task-456",
"fileId": "file-789",
"projectId": "project-123"
}
// 업무 파일 콘텐츠 다운로드 (임시 파일로 저장)
{
"action": "get_task_file_content",
"taskId": "task-456",
"fileId": "file-789",
"projectId": "project-123"
}
// Content ID로 직접 파일 메타데이터 조회 (Drive API)
{
"action": "get_drive_file_metadata",
"fileId": "content-id-xyz"
}
// Content ID로 직접 파일 콘텐츠 다운로드 (Drive API, 임시 파일로 저장)
{
"action": "get_drive_file_content",
"fileId": "content-id-xyz"
}S3 이미지 URL 설정
upload_body_image에 필요한 최소 S3 환경변수는 아래 4개입니다.
S3_BUCKETS3_REGIONS3_ACCESS_KEY_IDS3_SECRET_ACCESS_KEY
나머지는 기본값을 사용합니다.
S3_PREFIX:dooray-imagesS3_ACL:public-read(S3_ACL=none이면 ACL 전송 안 함)S3_PUBLIC_BASE_URL: 미설정 시 S3 공개 URL 자동 생성S3_ENDPOINT_URL: 미설정 시 AWS S3 기본 endpoint 사용S3_FORCE_PATH_STYLE: endpoint URL을 쓰면 기본true, 아니면false
API 정보
Base URL:
https://api.dooray.com인증:
Authorization: dooray-api {TOKEN}업무 관리:
/project/v1/projects/{projectId}/posts댓글 관리:
/project/v1/projects/{projectId}/posts/{taskId}/logs태그 관리:
/project/v1/projects/{projectId}/tags사용자 관리:
/common/v1/members파일 관리:
/project/v1/projects/{projectId}/posts/{taskId}/filesDrive 파일:
/drive/v1/files/{fileId}
문제 해결
연결 문제
인증 오류:
DOORAY_API_TOKEN이 올바른지 확인프로젝트 ID 오류:
DOORAY_DEFAULT_PROJECT_ID가 존재하는 프로젝트인지 확인권한 오류: API 토큰이 해당 프로젝트에 대한 권한을 가지고 있는지 확인
MCP 연결 문제
서버 연결 실패:
claude mcp list에서 상태 확인도구 인식 실패: MCP 서버 재시작 또는 Claude Code 재시작
권한 문제:
--dangerously-skip-permissions플래그 사용 (개발 환경에서만)
개발 및 기여
이 프로젝트는 MIT 라이센스 하에 배포되며, 버그 리포트와 기능 요청을 환영합니다.
버전 정보
버전: 1.0.0
Python: 3.8+
MCP: 1.0.0+
HTTP 클라이언트: httpx 0.25.0+
Available Tools
7 toolsdooray_commentsC
Manage Dooray task comments - get list, create, update, delete comments with mention support
| Name | Required | Description | Default |
|---|---|---|---|
| action | Yes | Action to perform on comments | |
| taskId | Yes | Task ID (required) | |
| commentId | No | Comment ID (required for update/delete) | |
| content | No | Comment content (for create/update) | |
| mentions | No | User IDs to mention (optional) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. While it mentions 'mention support', it fails to describe critical behaviors: whether operations require specific permissions, if deletions are permanent, rate limits, or what the output looks like (especially since there's no output schema). For a multi-action tool with mutation capabilities, this is a significant gap.
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, efficient sentence that front-loads the core purpose ('Manage Dooray task comments') and succinctly lists key features ('get list, create, update, delete comments with mention support'). Every word earns its place, with no redundancy or fluff.
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 (5 parameters supporting multiple CRUD operations) and lack of annotations or output schema, the description is incomplete. It doesn't explain return values, error conditions, or behavioral nuances like authentication needs. For a tool that can delete data, this leaves critical gaps for safe and 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 100%, so the schema already documents all 5 parameters thoroughly. The description adds minimal value beyond the schema by implying that 'mentions' are for user IDs and actions include list/create/update/delete, but it doesn't provide additional context like format examples or dependencies between parameters. This meets the baseline for high 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's purpose: 'Manage Dooray task comments - get list, create, update, delete comments with mention support'. It specifies the verb ('manage') and resource ('Dooray task comments'), and lists the specific actions available. However, it doesn't explicitly differentiate this tool from its siblings (like dooray_tasks or dooray_search), which prevents a perfect score.
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. It doesn't mention prerequisites (e.g., needing a task ID), exclusions, or how it relates to sibling tools like dooray_tasks. The agent must infer usage from the action parameter alone, which is insufficient for optimal tool selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
dooray_filesC
Manage Dooray files and images - list task files, get file metadata, download file content from tasks or directly by content ID
| Name | Required | Description | Default |
|---|---|---|---|
| action | Yes | Action to perform on files | |
| taskId | No | Task ID (required for task file actions) | |
| fileId | No | File ID (required for file operations) | |
| projectId | No | Project ID (optional - uses default from environment if not provided, required for task file actions) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden but only lists actions without disclosing behavioral traits like permissions needed, rate limits, side effects, or response formats. It mentions downloading content but doesn't specify if it's read-only or has destructive potential, leaving key operational details unclear.
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 concise and front-loaded, stating the main purpose in the first clause and listing key actions efficiently. It avoids unnecessary words, though it could be slightly more structured by grouping related actions or adding brief context.
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 annotations and no output schema, the description is incomplete for a tool with 4 parameters and multiple actions. It lacks details on return values, error handling, or prerequisites, making it inadequate for safe and effective use by an AI agent without additional context.
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 100%, so the schema already documents all parameters well. The description adds minimal value by implying action types but doesn't explain parameter interactions or semantics beyond what the schema provides, meeting the baseline for high 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's purpose as managing Dooray files and images, listing specific actions like listing task files, getting metadata, and downloading content. It distinguishes from siblings by focusing on file operations rather than comments, members, tasks, etc., though it doesn't explicitly contrast with them.
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 when to choose task-based vs. drive-based actions, or how it differs from other file-related tools if any exist. It lacks context for selection among its own actions or compared to sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
dooray_membersC
Manage Dooray members - search by email/ID, get member details, check project membership
| Name | Required | Description | Default |
|---|---|---|---|
| action | Yes | Action to perform on members | |
| No | Email address (for search_by_email) | ||
| userId | No | User ID (for search_by_id/get_details) | |
| projectId | No | Project ID (optional - uses default from environment if not provided) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It lists actions but doesn't explain permissions needed, rate limits, whether operations are read-only or mutating, or what happens with errors. This is inadequate for a tool with multiple action types.
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 with a single sentence that efficiently lists the key capabilities. Every word earns its place with no wasted text, making it easy to parse quickly.
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 tool with 4 parameters, multiple action types, no annotations, and no output schema, the description is insufficient. It doesn't explain return values, error conditions, or behavioral nuances needed for proper tool selection and 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?
Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description mentions the action types but doesn't add meaningful context beyond what the schema provides about parameter usage or constraints.
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's purpose as managing Dooray members with specific actions (search by email/ID, get details, check project membership). It uses specific verbs and resources, but doesn't differentiate from sibling tools like dooray_search or dooray_tasks that might also involve member 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 provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, when not to use it, or how it relates to sibling tools like dooray_search that might overlap in functionality.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
dooray_searchC
Search Dooray content - tasks by various criteria including workflow, assignee, tags, status, date range with AND/OR logic
| Name | Required | Description | Default |
|---|---|---|---|
| searchType | Yes | Type of search to perform | |
| query | No | Search query text (for tasks search) | |
| assigneeId | No | Assignee ID (for by_assignee search) | |
| status | No | Task status (for by_status search) | |
| tagName | No | Tag name (for by_tag search) | |
| workflowId | No | Workflow ID (for by_workflow search) | |
| startDate | No | Start date (for by_date_range search) | |
| endDate | No | End date (for by_date_range search) | |
| conditions | No | Array of search conditions (for advanced search) | |
| logicOperator | No | Logic operator for combining conditions in advanced search (default: AND) | |
| limit | No | Maximum results to return (optional) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It states the tool searches but doesn't disclose behavioral traits such as whether it's read-only (implied by 'search'), rate limits, authentication needs, pagination behavior, or what the output looks like. For a search tool with 11 parameters and no annotation coverage, this is a significant gap in transparency.
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, efficient sentence that front-loads the purpose and key features. It avoids unnecessary words and directly communicates the tool's function, though it could be slightly more structured by separating criteria from logic for 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 complexity (11 parameters, no annotations, no output schema), the description is incomplete. It covers the basic purpose but lacks crucial context: no output details, no behavioral disclosures (e.g., safety, limits), and minimal guidance on usage. For a versatile search tool with many parameters, this leaves significant gaps for an AI agent.
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 100%, so the schema already documents all parameters thoroughly. The description adds marginal value by listing criteria types (e.g., workflow, assignee) and mentioning AND/OR logic, but it doesn't provide additional syntax, format details, or usage examples beyond what the schema provides. Baseline 3 is appropriate when schema does the heavy lifting.
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 searches Dooray content with a specific focus on tasks and lists various criteria (workflow, assignee, tags, status, date range) and logic (AND/OR). It distinguishes from siblings like dooray_comments or dooray_files by specifying task-focused search, though it doesn't explicitly contrast with dooray_tasks which might handle individual tasks rather than searches.
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 mentions search criteria but provides no guidance on when to use this tool versus alternatives like dooray_tasks or other siblings. It lacks explicit when/when-not instructions, prerequisites, or named alternatives, leaving usage context implied rather than clearly defined.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
dooray_tagsC
Manage Dooray tags - list available tags, create new tags, add/remove tags from tasks
| Name | Required | Description | Default |
|---|---|---|---|
| action | Yes | Action to perform on tags | |
| taskId | No | Task ID (required for add_to_task/remove_from_task) | |
| tagName | No | Tag name (for create/add_to_task/remove_from_task) | |
| tagColor | No | Tag color (for create action, optional) | |
| filter | No | Optional substring to filter tag list by name (list action) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions actions but doesn't describe permissions required, rate limits, whether changes are reversible, or what happens on success/failure. For a multi-action tool with mutation capabilities (create/add/remove), this leaves significant behavioral gaps unaddressed.
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, efficient sentence that covers the tool's scope without unnecessary words. It's appropriately front-loaded with the core purpose. While it could potentially be more structured for a multi-action tool, it earns its place as concise and clear.
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 tool with 5 parameters, multiple mutation actions, and no annotations or output schema, the description is insufficient. It doesn't explain return values, error conditions, or the relationships between actions and parameters. The complexity of the tool (with create/add/remove operations) demands more contextual information than provided.
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 100%, so the schema already documents all 5 parameters thoroughly. The description mentions actions that align with the 'action' enum but doesn't add meaningful semantic context beyond what's in the schema descriptions. Baseline 3 is appropriate when the schema does the heavy lifting.
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's purpose as managing Dooray tags with specific actions (list, create, add/remove from tasks). It distinguishes itself from siblings like dooray_tasks or dooray_comments by focusing on tag operations. However, it doesn't explicitly differentiate from potential tag-related functions in other tools, keeping it at 4 rather than 5.
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. With siblings like dooray_tasks and dooray_search available, there's no indication of whether tag operations should be performed through this tool or integrated elsewhere. No exclusions, prerequisites, or context for tool selection are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
dooray_tasksC
Manage Dooray tasks - list, get details, create, update, delete, change status, assign members
| Name | Required | Description | Default |
|---|---|---|---|
| action | Yes | Action to perform | |
| taskId | No | Task ID (required for get/update/delete/status/assign) | |
| title | No | Task title (for create/update) | |
| description | No | Task description (for create/update) | |
| status | No | Task status class or workflow name (for create/update/change_status) | |
| workflowId | No | Workflow ID (for change_status when you know the exact workflow) | |
| assigneeId | No | Assignee member ID (for assign action) | |
| priority | No | Task priority (for create/update) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. While it mentions actions like create, update, delete which imply mutations, it doesn't specify authentication requirements, rate limits, side effects, or what happens on deletion. For a multi-action tool with write operations, this is a significant gap in transparency.
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 - a single sentence listing all actions. It's front-loaded with the core purpose and wastes no words. Every element earns its place in this compact format.
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 complex multi-action tool with 8 parameters, no annotations, and no output schema, the description is inadequate. It doesn't explain return values, error conditions, or how different actions relate to each other. The agent would struggle to use this tool correctly without significant trial and error.
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 100%, so the schema already documents all 8 parameters thoroughly. The description doesn't add any meaningful parameter semantics beyond what's in the schema - it just lists action types without explaining parameter dependencies or usage patterns. Baseline 3 is appropriate when schema does the heavy lifting.
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's purpose as managing Dooray tasks with specific verbs (list, get, create, update, delete, change status, assign members). It distinguishes from siblings by focusing on tasks rather than comments, files, members, etc. However, it doesn't explicitly differentiate from dooray_search which might also involve tasks.
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 like dooray_search for task-related queries or dooray_workflows for status management. It simply lists capabilities without context about appropriate use cases or prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
dooray_workflowsC
Manage Dooray workflows - list project workflows, get workflow details, create, update, delete workflows
| Name | Required | Description | Default |
|---|---|---|---|
| action | Yes | Action to perform on workflows | |
| workflowId | No | Workflow ID (required for get/update/delete) | |
| name | No | Workflow name (for create/update) | |
| projectId | No | Project ID (optional - uses default from environment if not provided) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It mentions create/update/delete operations implying mutations, but doesn't specify permissions needed, whether deletions are permanent, rate limits, or what happens to associated data. For a multi-action tool with destructive operations, this is inadequate.
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 efficiently structured as a single sentence listing all actions. It's appropriately sized for a multi-action tool, though could be more front-loaded by emphasizing the primary purpose before listing actions.
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 tool with 4 parameters, multiple actions including destructive operations, no annotations, and no output schema, the description is incomplete. It should address behavioral aspects like permissions, side effects, and response formats given the complexity and lack of structured metadata.
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 100%, so the schema already documents all 4 parameters thoroughly. The description adds no additional parameter semantics beyond what's in the schema - it doesn't explain relationships between action and other parameters or provide usage examples. Baseline 3 is appropriate when schema does the heavy lifting.
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 manages Dooray workflows with specific verbs (list, get, create, update, delete) and identifies the resource (workflows). It distinguishes from siblings like dooray_comments or dooray_tasks by focusing on workflows, but doesn't explicitly differentiate within the workflow management domain since there are no sibling workflow 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?
The description provides no guidance on when to use this tool versus alternatives like dooray_tasks or dooray_search. It lists actions but offers no context about prerequisites, when to choose create vs update, or how this tool fits into broader workflow management scenarios.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
7 tool updates
v1.0.0- Added
dooray_comments - Added
dooray_files - Added
dooray_members - Added
dooray_search - Added
dooray_tags - Added
dooray_tasks - Added
dooray_workflows
TDQS
Scored across 7 tools
Each tool has a clearly distinct purpose targeting a specific Dooray resource: comments, files, members, search, tags, tasks, and workflows. There is no overlap in functionality, and an agent can easily distinguish between them based on their resource focus.
All tools follow a consistent 'dooray_' prefix with a descriptive noun (e.g., dooray_comments, dooray_tasks). This uniform snake_case naming pattern makes the tool set predictable and easy to navigate.
With 7 tools, the server is well-scoped for managing Dooray project resources. Each tool covers a distinct aspect of the platform (e.g., tasks, members, workflows), and none feel redundant or missing for the domain.
The tool set provides comprehensive coverage of Dooray's core project management features, including CRUD operations for tasks, workflows, tags, comments, and files, plus search and member management. There are no obvious gaps for the stated purpose.
Maintenance
Related MCP Connectors
Task management for people and AI agents, with scoped OAuth access to issues, projects, and docs.
Task management for people and AI agents, with scoped OAuth access to issues, projects, and docs.
Manage projects, tasks, time tracking, and team collaboration through natural language.
Task manager your agent can fully operate: boards, tasks, sprints, roles, worklogs, day planner.
Related MCP Servers
- AlicenseBqualityDmaintenanceEnables AI assistants to interact with ClickUp's task management API for core project workflows, supporting operations like task creation, updates, search, assignment, and team analytics through natural language.283MIT
- FlicenseNot gradedqualityFmaintenanceEnables LLMs to interact with ZenTao project management system, supporting project and task management operations including creating, querying, and updating projects and tasks through natural language.5-
- AlicenseAqualityDmaintenanceEnables integration with Dooray project management platform, allowing users to manage projects, tasks, comments, milestones, tags, and team members through natural language interactions.1784 npm5MIT
- FlicenseBqualityDmaintenanceEnables interaction with Dooray's task and calendar management system, allowing users to filter and list tasks, retrieve details, and manage task comments. It provides a set of tools for seamless integration with MCP-compatible clients like Claude Desktop and Cursor.6-