Linear MCP Server
The Linear MCP Server allows you to interact with the Linear API to manage tasks, teams, and users. With this server, you can:
Fetch tasks with optional filters like status, assignee, team, and limit
Retrieve detailed information about specific tasks using their IDs
Get a list of all teams in the Linear workspace
Get a list of all users in the Linear workspace
Provides tools for interacting with Linear's API, allowing users to fetch tasks with filtering options (by status, assignee, team), retrieve detailed task information, and list teams and users in a Linear workspace.
Click on "Install 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., "@Linear MCP Servershow me my in-progress tasks assigned to John"
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.
Linear MCP Server
This MCP server provides tools to interact with the Linear API, allowing you to fetch tasks and their associated details.
Setup
Install dependencies:
npm installBuild the server:
npm run buildConfigure your Linear API key:
Get your API key from Linear (Settings > API > Personal API Keys)
Update the MCP settings file with your API key:
Location:
/Users/tiru5/Library/Application Support/Cursor/User/globalStorage/rooveterinaryinc.roo-cline/settings/mcp_settings.jsonReplace
YOUR_LINEAR_API_KEY_HEREwith your actual API key
Related MCP server: Linear MCP Server
Available Tools
get_tasks
Get tasks from Linear with optional filtering.
Parameters:
status(optional): Filter by status (e.g., "Todo", "In Progress", "Done")assignee(optional): Filter by assignee name or IDteam(optional): Filter by team name or IDlimit(optional): Maximum number of tasks to return (default: 20, max: 100)
Example:
{
"status": "In Progress",
"assignee": "John",
"team": "Engineering",
"limit": 10
}get_task_details
Get detailed information about a specific task.
Parameters:
taskId(required): The ID of the task to retrieve details for
Example:
{
"taskId": "LIN-123"
}get_teams
Get a list of teams in the Linear workspace.
Parameters: None
get_users
Get a list of users in the Linear workspace.
Parameters: None
Usage Examples
Fetching tasks assigned to a specific user
use_mcp_tool
server_name: linear
tool_name: get_tasks
arguments: {
"assignee": "John",
"status": "In Progress"
}Getting details for a specific task
use_mcp_tool
server_name: linear
tool_name: get_task_details
arguments: {
"taskId": "LIN-123"
}Listing all teams
use_mcp_tool
server_name: linear
tool_name: get_teams
arguments: {}Listing all users
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. Dates show when Glama detected each change.
4 tool updates
- First observed
get_task_details - First observed
get_tasks - First observed
get_teams - First observed
get_users
TDQS
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.713MIT
- 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.13288MIT
- AlicenseBqualityDmaintenanceEnables AI tools like Cline to manage Linear issues, projects, and teams via the Linear API.242,4862MIT
- 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.713MIT
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/Tyru5/linear-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server