Linear MCP Server
リニアMCPサーバー
この MCP サーバーは、Linear API と対話するためのツールを提供し、タスクとその関連詳細を取得できるようにします。
設定
依存関係をインストールします:
npm installサーバーを構築します。
npm run buildリニア API キーを設定します。
LinearからAPIキーを取得します(設定 > API > 個人APIキー)
API キーを使用して MCP 設定ファイルを更新します。
場所:
/Users/tiru5/Library/Application Support/Cursor/User/globalStorage/rooveterinaryinc.roo-cline/settings/mcp_settings.jsonYOUR_LINEAR_API_KEY_HERE実際のAPIキーに置き換えます
Related MCP server: Linear MCP Server
利用可能なツール
タスクを取得する
オプションのフィルタリングを使用して Linear からタスクを取得します。
パラメータ:
status(オプション):ステータスでフィルタリングします(例:「Todo」、「進行中」、「完了」)assignee(オプション): 担当者名またはIDでフィルタリングteam(オプション):チーム名またはIDでフィルタリングlimit(オプション): 返されるタスクの最大数 (デフォルト: 20、最大: 100)
例:
{
"status": "In Progress",
"assignee": "John",
"team": "Engineering",
"limit": 10
}タスクの詳細を取得する
特定のタスクに関する詳細情報を取得します。
パラメータ:
taskId(必須): 詳細を取得するタスクのID
例:
{
"taskId": "LIN-123"
}get_teams
リニアワークスペース内のチームのリストを取得します。
**パラメータ:**なし
get_users
リニアワークスペース内のユーザーのリストを取得します。
**パラメータ:**なし
使用例
特定のユーザーに割り当てられたタスクの取得
use_mcp_tool
server_name: linear
tool_name: get_tasks
arguments: {
"assignee": "John",
"status": "In Progress"
}特定のタスクの詳細を取得する
use_mcp_tool
server_name: linear
tool_name: get_task_details
arguments: {
"taskId": "LIN-123"
}すべてのチームを一覧表示する
use_mcp_tool
server_name: linear
tool_name: get_teams
arguments: {}すべてのユーザーを一覧表示する
use_mcp_tool
server_name: linear
tool_name: get_users
arguments: {}Available Tools
4 toolsget_task_detailsC
Get detailed information about a specific task
| Name | Required | Description | Default |
|---|---|---|---|
| taskId | Yes | The ID of the task to retrieve details for |
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 states it 'gets' information, implying a read-only operation, but doesn't clarify aspects like authentication requirements, rate limits, error handling, or what 'detailed information' includes (e.g., fields, format). This is a significant gap for a tool with zero annotation coverage.
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 with zero wasted words. It's front-loaded with the core action ('Get detailed information'), making it easy to parse. Every word earns its place, achieving ideal conciseness.
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, no output schema, and a single parameter with full schema coverage, the description is incomplete. It lacks behavioral context (e.g., safety, errors), doesn't explain return values, and provides minimal usage guidance. For a tool with no structured support, this leaves the agent under-informed.
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%, with the single parameter 'taskId' fully documented in the schema. The description adds no additional parameter semantics beyond implying retrieval for a 'specific task', which aligns with the schema. Baseline 3 is appropriate when the schema handles all 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 verb ('Get') and resource ('detailed information about a specific task'), making the purpose unambiguous. However, it doesn't explicitly differentiate from sibling tools like 'get_tasks' (which likely lists multiple tasks) or 'get_teams'/'get_users', leaving some room for sibling 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?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing a valid task ID), contrast with 'get_tasks' for listing tasks, or specify use cases like retrieving metadata for a single task. This leaves the agent without contextual usage cues.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_tasksC
Get tasks from Linear with optional filtering
| Name | Required | Description | Default |
|---|---|---|---|
| status | No | Filter by status (e.g., "Todo", "In Progress", "Done") | |
| assignee | No | Filter by assignee name or ID | |
| team | No | Filter by team name or ID | |
| limit | No | Maximum number of tasks to return (default: 20) |
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 states this is a 'get' operation which implies read-only, but doesn't mention authentication requirements, rate limits, pagination behavior (beyond the limit parameter), error conditions, or what happens when no filters are applied. For a tool with 4 parameters and no annotation coverage, this is insufficient.
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 just 6 words, front-loading the core purpose. Every word earns its place - 'Get tasks' (action), 'from Linear' (source), 'with optional filtering' (capability). No wasted words or unnecessary elaboration.
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, no annotations, and no output schema, the description is inadequate. It doesn't explain what 'tasks' means in the Linear context, what data is returned, how results are structured, or provide any behavioral context. The agent would need to guess about authentication, error handling, and result 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 description coverage is 100%, so all parameters are documented in the schema. The description adds minimal value beyond stating 'optional filtering' - it doesn't explain how filters combine, precedence, or provide examples beyond what the schema already contains. 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 action ('Get tasks') and resource ('from Linear'), making the purpose understandable. However, it doesn't differentiate this tool from its sibling 'get_task_details' - both involve retrieving task information, so the distinction isn't explicit.
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 'optional filtering' which implies some usage context, but provides no guidance on when to use this tool versus alternatives like 'get_task_details' for detailed task information or 'get_teams'/'get_users' for related data. No explicit when/when-not instructions are present.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_teamsB
Get a list of teams in the Linear workspace
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
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 states the tool retrieves a list but doesn't specify details like pagination, rate limits, authentication needs, or what 'list' entails (e.g., format, completeness). This leaves significant gaps for an agent to understand how to use it effectively.
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, clear sentence with no wasted words, effectively front-loading the purpose. It's appropriately sized for a simple tool with no parameters, making it easy to parse.
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 simplicity (0 parameters, no output schema, no annotations), the description is minimally adequate but lacks depth. It doesn't explain what the output looks like (e.g., list format, fields) or any behavioral traits, which could hinder an agent's ability to use it correctly 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?
The input schema has 0 parameters with 100% coverage, so there's no need for parameter details in the description. The description appropriately avoids discussing parameters, earning a high baseline score for not adding unnecessary information.
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 ('Get a list') and resource ('teams in the Linear workspace'), providing a specific purpose. However, it doesn't distinguish this from sibling tools like 'get_users' or 'get_tasks' beyond the resource type, 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 like 'get_users' or 'get_tasks', nor does it mention any context or prerequisites for usage. It merely states what the tool does without operational context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_usersB
Get a list of users in the Linear workspace
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
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 'Get a list' implies a read operation, it doesn't specify whether this requires authentication, returns paginated results, includes all users or filtered subsets, or has rate limits. The description is minimal and lacks important behavioral context.
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 states exactly what the tool does with zero wasted words. It's appropriately sized for a simple retrieval tool with no parameters and gets straight to the point.
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 zero-parameter list retrieval tool with no output schema, the description is adequate but minimal. It covers the basic purpose but lacks important context about authentication requirements, result format, pagination, or how it differs from sibling tools. The absence of annotations means more behavioral detail would be helpful.
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 tool has zero parameters with 100% schema description coverage, so the schema already fully documents the parameter situation. The description appropriately doesn't mention parameters since none exist, maintaining focus on the tool's purpose without unnecessary detail.
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 ('Get a list') and resource ('users in the Linear workspace'), providing specific verb+resource pairing. However, it doesn't distinguish this tool from potential sibling tools like get_tasks or get_teams, which would require mentioning what makes user retrieval unique.
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's no mention of prerequisites, context for user retrieval, or comparison to sibling tools like get_tasks or get_teams that might serve different purposes in the workspace.
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.
4 tool updates
- First observed
get_task_details - First observed
get_tasks - First observed
get_teams - First observed
get_users
TDQS
Scored across 4 tools
Each tool has a clearly distinct purpose targeting different resources: tasks (details vs. list), teams, and users. There is no overlap in functionality, making tool selection straightforward for an agent.
All tools follow a consistent verb_noun pattern with 'get_' prefix and plural/singular nouns as appropriate (e.g., get_task_details, get_tasks). The naming is predictable and uniform throughout the set.
With only 4 tools, the set feels thin for a project management domain like Linear, which typically involves CRUD operations on tasks, issues, or other entities. While the tools cover basic read operations, the count is borderline low for the apparent scope.
The toolset is severely incomplete, covering only read operations (get) with no ability to create, update, or delete tasks, teams, or users. This creates significant gaps that will cause agent failures in typical project management workflows, such as modifying task status or assigning users.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
Search, read and create Linear issues, projects, teams and cycles.
Linear MCP — wraps the Linear GraphQL API (OAuth)
MCP server for Linear project management and issue tracking
Read teams, spaces, lists and tasks; create, update and comment on tasks and track time.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceAllows LLMs to integrate with Linear's issue tracking system, enabling them to create, update, search, and comment on issues through the Linear API.1,186MIT
- AlicenseBqualityDmaintenanceEnables interaction with Linear's API to manage issues, projects, and teams. Supports creating, updating, searching, and deleting issues, along with project management and team operations through API key authentication.13457MIT
- AlicenseBqualityDmaintenanceEnables AI tools like Cline to manage Linear issues, projects, and teams via the Linear API.246362MIT
- AlicenseNot gradedqualityDmaintenanceEnables LLMs to interact with Linear's issue tracking system, including creating, updating, searching issues, adding comments, and accessing resources via the Linear API.1,186MIT