Linear
MCP ServerFree** - Integrates with Linear project management systems.
Capabilities9 decomposed
mcp protocol translation to linear graphql
Medium confidenceTranslates Model Context Protocol (MCP) tool calls received over stdio into authenticated GraphQL requests against the Linear API. The MCP Server Layer (src/mcp-server.ts) receives CallTool requests, routes them through a type-guarded tool dispatch system (src/tools/type-guards.ts validates arguments against Zod schemas), and delegates to LinearService which wraps @linear/sdk's LinearClient. This three-layer architecture decouples protocol handling from Linear SDK details, enabling AI clients (Cursor, Claude Desktop, Claude VSCode, GoMCP) to interact with Linear without custom integration code.
Three-layer architecture (MCP → Tool Dispatch → Linear Service) with strict separation of concerns: MCP protocol handling is isolated in src/mcp-server.ts, tool schemas and handlers are separated in src/tools/, and all Linear SDK access is funneled through a single LinearService class. This design enables adding new tools without touching protocol code and makes the codebase testable at each layer.
Cleaner than custom REST API wrappers because it uses standard MCP protocol, reducing client-side integration work; more maintainable than monolithic Linear API clients because tool dispatch is schema-driven and handlers are decoupled from protocol details.
schema-driven tool registration and dispatch
Medium confidenceRegisters 42 Linear tools (organized by domain: Issues, Projects, Initiatives, Cycles, Teams, Users/Org) via Zod schemas defined in src/tools/definitions/. Each tool has a corresponding handler in src/tools/handlers/ that receives validated arguments. The dispatch system uses type guards (src/tools/type-guards.ts) to validate incoming arguments against schemas before routing to handlers. Tool names follow a consistent linear_* prefix convention. This schema-first approach enables runtime validation, auto-documentation, and safe argument passing without manual type coercion.
Uses Zod schemas as the single source of truth for tool contracts — schemas define both validation rules and MCP tool descriptions, eliminating duplication. Type guards in src/tools/type-guards.ts enforce schema compliance before handler execution, preventing invalid data from reaching the Linear SDK.
More robust than string-based argument parsing because Zod provides compile-time type safety and runtime validation; more maintainable than hand-written validators because schema changes automatically update both validation and documentation.
issue lifecycle management (create, read, update, delete, search)
Medium confidenceExposes 18 issue-related tools covering the full lifecycle: create_issue, update_issue, delete_issue, get_issue, list_issues, search_issues, add_issue_comment, update_issue_comment, delete_issue_comment, and others. Each tool translates to a GraphQL operation via LinearService, which calls @linear/sdk's LinearClient. Handlers support filtering by status, assignee, project, cycle, and custom fields. The search_issues tool enables semantic and keyword-based queries. Comment operations support markdown formatting and attachment handling.
Issue tools are organized by operation type (create, update, delete, search, comment) with separate handlers for each, enabling fine-grained permission control and error handling. The search_issues tool integrates Linear's native search API rather than implementing custom indexing, reducing maintenance burden.
More comprehensive than basic REST API wrappers because it exposes comment management and search alongside CRUD operations; more flexible than Linear's UI because it allows programmatic bulk operations and custom filtering.
project and initiative hierarchy navigation
Medium confidenceProvides 5 project tools (get_project, list_projects, create_project, update_project, delete_project) and 10 initiative tools (get_initiative, list_initiatives, create_initiative, update_initiative, delete_initiative, link_initiative_to_project, etc.) that enable navigation and management of Linear's organizational hierarchy. Projects group issues; initiatives group projects. Handlers support filtering by team, status, and custom fields. The link_initiative_to_project tool enables cross-linking between organizational levels.
Separates project and initiative tools into distinct handlers, allowing AI agents to reason about organizational structure at different levels. The link_initiative_to_project tool enables cross-level operations without requiring the agent to manage IDs manually.
More useful than flat issue lists because it exposes hierarchical structure, enabling agents to understand context before creating issues; more flexible than Linear's UI because it allows programmatic navigation and linking.
cycle and sprint management
Medium confidenceExposes 3 cycle tools (get_cycle, list_cycles, create_cycle) that manage Linear's sprint/cycle abstraction. Cycles group issues into time-boxed iterations with start/end dates and status (planned, active, completed). Handlers support filtering by team and status. The create_cycle tool enables programmatic sprint planning. Cycles are the primary unit for iteration planning in Linear.
Exposes cycles as a first-class entity separate from issues, enabling agents to reason about sprint structure independently. The create_cycle tool uses ISO date strings for start/end times, enabling precise sprint planning without timezone confusion.
More useful than issue-level cycle assignment because it enables agents to understand sprint structure upfront; simpler than custom sprint management tools because it leverages Linear's native cycle abstraction.
team and workflow configuration access
Medium confidenceProvides 2 team/workflow tools (get_team, list_teams) that expose team metadata, workflow states, and status definitions. Handlers return team names, descriptions, members, and available workflow states (e.g., Backlog, Todo, In Progress, Done). This enables AI agents to understand team structure and valid issue states before creating or updating issues.
Exposes workflow states as part of team metadata, enabling agents to discover valid status values dynamically rather than hard-coding them. This makes the agent adaptable to custom Linear workflows.
More flexible than hard-coded status lists because it discovers workflow states from the Linear API; more useful than team-only tools because it includes workflow configuration.
user and organization identity resolution
Medium confidenceProvides 4 user/organization tools (get_user, list_users, get_organization, get_viewer) that resolve user identities and organization metadata. The get_viewer tool returns the authenticated user's identity (useful for determining who is running the agent). Handlers support filtering users by team or status. This enables agents to map user names to IDs and understand organization context.
The get_viewer tool provides a way for agents to determine their own identity without requiring the user to pass it explicitly. This is useful for audit trails and permission checks.
More useful than static user lists because it discovers users dynamically from the Linear API; more secure than embedding user IDs because it resolves names at runtime.
stateless, token-based authentication with multiple deployment modes
Medium confidenceAuthenticates to Linear using Personal API Tokens supplied via environment variable (LINEAR_API_TOKEN) or CLI flag (--token), parsed by yargs in src/index.ts. The token is passed to @linear/sdk's LinearClient constructor and never stored by the server. Supports three deployment modes: npx (recommended), Docker, and Smithery. The runServer() function in src/index.ts bootstraps authentication before initializing the MCP server. No session management or token refresh logic is required because Linear tokens do not expire.
Supports three deployment modes (npx, Docker, Smithery) with consistent authentication logic, eliminating the need for environment-specific configuration. The token is resolved early in runServer() and never stored, reducing the attack surface.
More flexible than hardcoded tokens because it supports environment variables and CLI flags; more secure than session-based auth because tokens are stateless and never persisted; more portable than custom deployment scripts because it supports standard deployment platforms.
extensible tool handler architecture for adding new linear operations
Medium confidenceThe tool dispatch system is designed for extensibility: new tools are added by creating a Zod schema in src/tools/definitions/ and a corresponding handler in src/tools/handlers/. The handler receives validated arguments and calls LinearService methods. The MCP server automatically registers new tools without code changes. This pattern is documented in the 'Adding New Tools' section of the DeepWiki. The separation of schemas, handlers, and service layer makes it easy to add new Linear operations without understanding the full codebase.
The three-layer architecture (schemas → handlers → service) makes it easy to add new tools without touching protocol code. The separation of concerns means new tool developers only need to understand Zod and the Linear API, not MCP internals.
More maintainable than monolithic tool files because each tool is isolated; more accessible to contributors because the pattern is simple and documented; more testable because handlers can be tested independently of the MCP server.
Capabilities are decomposed by AI analysis. Each maps to specific user intents and improves with match feedback.
Related Artifactssharing capabilities
Artifacts that share capabilities with Linear, ranked by overlap. Discovered automatically through the match graph.
Subway MCP Server
Provide a scalable and efficient server-side application framework to implement the Model Context Protocol (MCP) using Node.js and NestJS. Enable seamless integration of LLMs with external data and tools through a robust and maintainable server architecture. Facilitate rapid development and deployme
mcp-graphql
Model Context Protocol server for GraphQL
@mseep/airylark-mcp-server
AiryLark的ModelContextProtocol(MCP)服务器，提供高精度翻译API
functional-models-orm-mcp
A functional-models-orm datastore provider that uses the @modelcontextprotocol/sdk. Great for using models on a frontend.
Text-To-GraphQL
** - MCP server for text-to-graphql, integrates with Claude Desktop and Cursor.
markdownify-mcp
A Model Context Protocol server for converting almost anything to Markdown
Best For
- ✓AI agent builders integrating Linear into multi-tool workflows
- ✓Teams using Claude Desktop or Cursor who want native Linear access
- ✓Developers building MCP-compatible clients that need project management capabilities
- ✓Teams building AI agents that need predictable, validated access to Linear operations
- ✓Developers extending mcp-linear with custom tools following the existing pattern
- ✓Organizations that want to audit which Linear operations are exposed to AI clients
- ✓AI agents that need to triage, create, or update issues based on user requests
- ✓Automated workflows that generate issues from external data sources
Known Limitations
- ⚠Requires Linear Personal API Token with appropriate scopes — no OAuth2 support
- ⚠All tool calls are synchronous; no built-in batching or transaction support across multiple operations
- ⚠MCP stdio transport adds latency for each tool invocation — not suitable for high-frequency polling scenarios
- ⚠No caching layer between MCP requests and Linear GraphQL — each call hits the API
- ⚠Tool schemas are static — no dynamic tool generation based on Linear workspace configuration
- ⚠Schema validation adds ~5-10ms per tool call; not suitable for ultra-low-latency scenarios
Requirements
Input / Output
UnfragileRank
UnfragileRank is computed from adoption signals, documentation quality, ecosystem connectivity, match graph feedback, and freshness. No artifact can pay for a higher rank.
About
** - Integrates with Linear project management systems.
Categories
Alternatives to Linear
Search the Supabase docs for up-to-date guidance and troubleshoot errors quickly. Manage organizations, projects, databases, and Edge Functions, including migrations, SQL, logs, advisors, keys, and type generation, in one flow. Create and manage development branches to iterate safely, confirm costs
Compare →Are you the builder of Linear?
Claim this artifact to get a verified badge, access match analytics, see which intents users search for, and manage your listing.
Get the weekly brief
New tools, rising stars, and what's actually worth your time. No spam.
Data Sources
Looking for something else?
Search →