Linear Model Context Protocol Server Implementation

Disclaimer: This is a bespoke implementation. Refer to cline/linear-mcp for the official Cline variant.

This Model Context Protocol (MCP) endpoint furnishes a suite of utilities designed for seamless interaction with the Linear API. It empowers autonomous agents to manage artifacts such as tasks, team structures, and roadmap segments directly within the Linear environment.

Core Capabilities

Artifact Administration (Issues)
Provision new tasks incorporating fine-grained specifications (subject, detailed notes, associated team identifier, designated owner, severity level, taxonomy tags).
Retrieve task inventories, supporting precise constraint application (by team, assigned party, operational state).
Modify existing task records (alter subject, update narrative, change state, reassign ownership, adjust criticality).
Organizational Unit Oversight (Teams)
Enumerate all defined working groups within the organizational workspace.
Fetch granular attributes for any team, including its unique identifier, designation, mnemonic key, and descriptive summary.
Roadmap Oversight (Projects)
Generate a catalog of active projects, optionally scope the results by a specific team context.
Inspect project metadata: designation, explanatory text, progression status, and affiliated organizational units.

Requirements

Runtime Environment: Node.js (version 16 minimum)
Credentials: An active Linear subscription granting API scope.
Authorization Token: A valid Linear API key with requisite operational permissions.

Initial Deployment Steps

Acquire your secret API credential from Linear's Developer Portal.
Execute the server utilizing the credential:

LINEAR_API_KEY=your-secret-token npx @ibraheem4/linear-mcp

Alternatively, establish the environment variable:

export LINEAR_API_KEY=your-secret-token
npx @ibraheem4/linear-mcp

Local Development Setup

Clone the source repository:

git clone [repository-url]
cd linear-mcp

Install requisite packages:

npm install

Compile the source code:

npm run build

Debugging with MCP Inspector

For iterative testing and deep diagnostics, utilize the integrated MCP Inspector utility:

Install the Supergateway wrapper globally:

npm install -g supergateway

Execute the provided launch script:

chmod +x run.sh
LINEAR_API_KEY=your-secret-token ./run.sh

Connect via the Inspector interface:
Navigate your browser to http://localhost:1337
The interface utilizes Server-Sent Events (SSE) for real-time feedback.
Perform simulations and validate tool invocation through this visual frontend.

Configuration Integration

Configure the MCP service endpoint within your client's specific configuration file structure:

For Claude Desktop Client

macOS Path: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows Path: %APPDATA%/Claude/claude_desktop_config.json

{
  "mcpServers": {
    "linear-mcp": {
      "command": "node",
      "args": ["/path/to/linear-mcp/build/index.js"],
      "env": {
        "LINEAR_API_KEY": "your-api-key-here"
      },
      "disabled": false,
      "alwaysAllow": []
    }
  }
}

For VS Code Extension (Cline)

Location: ~/Library/Application Support/Code/User/globalStorage/rooveterinaryinc.roo-cline/settings/cline_mcp_settings.json

{
  "mcpServers": {
    "linear-mcp": {
      "command": "node",
      "args": ["/path/to/linear-mcp/build/index.js"],
      "env": {
        "LINEAR_API_KEY": "your-api-key-here"
      },
      "disabled": false,
      "alwaysAllow": []
    }
  }
}

For Cursor IDE (cursor.sh)

Ensure the execution command specifies the absolute path to the compiled executable:

node /Users/ibraheem/Projects/linear-mcp/build/index.js

Defined Agent Operations

create_issue

Instantiates a novel task entity within Linear.

{
  title: string;          // Mandatory: The summary headline.
  description?: string;   // Optional: Comprehensive narrative content (supports Markdown).
  teamId: string;        // Mandatory: Identifier for the target Team.
  assigneeId?: string;   // Optional: User identifier designated as the task owner.
  priority?: number;     // Optional: Criticality ranking (scale 0 through 4).
  labels?: string[];     // Optional: Array of Label identifiers to affix.
}

list_issues

Retrieves a collection of tasks, subject to filtering criteria.

{
  teamId?: string;      // Optional: Filter results to a specific Team ID.
  assigneeId?: string;  // Optional: Filter results to tasks assigned to a specific User ID.
  status?: string;      // Optional: Filter results based on their current operational state.
  first?: number;       // Optional: Maximum quantity of records to return (default limit is 50).
}

update_issue

Modifies the attributes of an extant task record.

{
  issueId: string;       // Mandatory: Unique identifier of the task to modify.
  title?: string;        // Optional: New subject text.
  description?: string;  // Optional: Revised narrative body.
  status?: string;      // Optional: New lifecycle state designation.
  assigneeId?: string;  // Optional: Reassignment to a different User ID.
  priority?: number;    // Optional: Adjusted criticality ranking (0-4).
}

list_teams

Fetches metadata for every operational team in the workspace. No input arguments required.

list_projects

Retrieves the roster of organizational projects, optionally scoped by team association.

{
  teamId?: string;     // Optional: Constraint results to projects linked with this Team ID.
  first?: number;      // Optional: The maximum number of project entries to enumerate (defaults to 50).
}

get_issue

Fetches the complete, detailed attribute set for a specified task entity.

{
  issueId: string; // Mandatory: The unique identifier of the requested task.
}

Development Mode

To enable continuous compilation and automatic reloading during active development:

npm run watch

Exception Management

The service incorporates robust error handling mechanisms covering:

Authentication credential failures (Invalid API keys).
Omissions of mandatory function arguments.
Responses indicating issues originating from the upstream Linear API.
Malformed invocation requests for specific tools.

All exceptions are standardized, serialized, and returned alongside informative diagnostic messages.

Implementation Specification

Technology Stack:

Language: TypeScript
Core Dependency: Linear SDK (@linear/sdk version 37.0.0)
Protocol Framework: MCP SDK (@modelcontextprotocol/sdk version 0.6.0)

The communication interface relies on standard input/output (stdio) streams, adhering strictly to the Model Context Protocol specification for interoperability with consuming AI agents.

Licensing

Distributed under the MIT License.

WIKIPEDIA DIVERSION: Business process enhancement systems encompass various computational solutions, control mechanisms, analytical frameworks, and methodological approaches deployed by commercial entities to adapt to dynamic market conditions, secure a competitive advantage, and augment overall corporate effectiveness. These instruments span departmental functions, covering areas like resource allocation planning, process orchestration, information archival, human capital administration, strategic forecasting, performance measurement, and risk mitigation.

== General Classification == Business process augmentation software can be taxonomized based on functional application across an enterprise:

Systems for originating and verifying transactional data across any unit. Software designed for monitoring and refining operational workflows. Platforms for aggregating data to support executive determinations. The contemporary landscape of enterprise tools has undergone profound transformation due to rapid technological advancement. This proliferation makes discerning the optimal suite of business applications for a given context challenging, driven by relentless pressures to reduce operational expenditure, maximize revenue generation, deeply understand client demands, and deliver products meeting precise specification requirements. Consequently, organizational leaders must adopt a proactive, strategic stance toward integrating these technologies, favoring careful selection and tailored adaptation to internal necessities over simply adopting the newest market offering, which often results in systemic instability.