Linear MCP with Cursor
To set up Linear MCP with Cursor, connect Cursor to a Linear MCP server, authenticate with Linear through OAuth or an API key, restart Cursor, and verify that tools/list exposes the Linear issue, project, and comment tools. If you are starting from scratch, follow the Linear MCP setup guide or use the Linear MCP server template as a production-ready starting point.
Modern AI-powered development environments are changing how engineers build software.
Instead of switching between an IDE, project management tools, documentation, and browser tabs, developers increasingly expect their coding assistant to understand the entire development workflow.
Connecting Cursor to Linear through the Model Context Protocol (MCP) makes that possible.
With a properly configured Linear MCP Server, Cursor can retrieve issues, search projects, create tasks, update tickets, assign work, and access project information without leaving the editor.
Rather than communicating directly with the Linear API, Cursor sends requests to an MCP server, which securely handles authentication, permissions, and API communication.
A production-ready integration allows Cursor to:
- Search for engineering issues
- Create new Linear tickets
- Update issue status
- Assign issues to teammates
- Retrieve project information
- Access team metadata
- Add comments
- Generate sprint summaries
- Assist with development planning
In this guide, you'll learn how Cursor works with a Linear MCP Server, how the integration is structured, common development workflows, and best practices for building a secure production deployment.
How to Connect Linear MCP to Cursor
Connecting Linear MCP to Cursor requires four main steps:
- Choose or deploy a Linear MCP server.
- Configure authentication for your Linear workspace.
- Add the MCP server configuration to Cursor.
- Restart Cursor and test the available Linear MCP tools.
The exact configuration depends on whether your Linear MCP server runs locally using stdio or remotely using Streamable HTTP.
Before starting, make sure you have:
- Cursor installed and updated.
- Access to a Linear workspace.
- A Linear API key or OAuth credentials required by your MCP server.
- A working Linear MCP server endpoint or local server command.
The following sections walk through the complete setup process.
Step 1: Choose a Linear MCP Server
Cursor needs an MCP server that exposes Linear operations as MCP tools.
Depending on the implementation, the server may provide tools for:
- Searching Linear issues.
- Creating new issues.
- Updating issue status.
- Listing projects and teams.
- Adding comments.
- Assigning issues to users.
You can run a Linear MCP server locally or connect Cursor to a remotely hosted server.
Before configuring Cursor, verify that the server starts correctly and that its authentication credentials are available.
If you are building your own implementation, see the Linear MCP Server guide, start from the Linear MCP server template, or adapt the Claude Code Linear MCP recipe for teams that use both Cursor and Claude Code.
Step 2: Configure Linear Authentication
The MCP server must authenticate with Linear before Cursor can access workspace data.
Depending on the server implementation, authentication may use:
- A Linear API key.
- OAuth 2.0.
- Environment variables containing credentials.
- A server-side secret manager in production deployments.
Never place Linear credentials directly inside prompts or expose them through MCP tool responses.
For local development, credentials are commonly stored in environment variables.
For production deployments, use a secure secret manager and restrict credentials to the MCP server process.
For a deeper explanation of the authentication flow, see the Linear MCP OAuth guide.
Want to analyze your API security?
Import your OpenAPI spec and generate a Security Report automatically.
Step 3: Add the Linear MCP Server to Cursor
Open Cursor MCP settings and add your Linear MCP server configuration.
For a locally running MCP server, the configuration may look similar to this:
{
"mcpServers": {
"linear": {
"command": "node",
"args": ["/path/to/linear-mcp-server/dist/server.js"],
"env": {
"LINEAR_API_KEY": "${LINEAR_API_KEY}"
}
}
}
}
The exact command and arguments depend on the Linear MCP server implementation you are using.
After saving the configuration, restart Cursor so the editor can initialize the MCP connection.
Do not commit API keys or access tokens directly to your repository.
Step 4: Verify the Linear MCP Connection
After restarting Cursor, confirm that the Linear MCP server is available and its tools were discovered correctly.
Test the integration with simple read-only requests such as:
- "List my Linear teams."
- "Find issues assigned to me."
- "Show open issues in the current project."
- "Get details for issue ENG-123."
Starting with read-only operations makes it easier to distinguish connection and authentication problems from permission errors affecting write operations.
If Cursor cannot discover the server or its tools, verify:
- The MCP server process starts successfully.
- The configured command and arguments are correct.
- Required environment variables are available.
- Linear credentials are valid.
- The server logs do not contain initialization errors.
Step 5: Test Write Operations
After read-only tools work correctly, test write operations such as creating or updating an issue.
For example:
- "Create a Linear issue titled Fix authentication timeout."
- "Move ENG-123 to In Progress."
- "Add a comment to ENG-123 summarizing the implementation."
Verify the result directly in Linear before relying on the integration for production workflows.
Write operations should use appropriate permissions, input validation, and approval controls when necessary.
Linear MCP Cursor Configuration Example
A typical local integration follows this flow:
Cursor │ │ MCP request ▼ Linear MCP Server │ │ authenticated API request ▼ Linear API │ ▼ Issues • Projects • Teams
Cursor discovers the tools exposed by the MCP server and decides when to call them based on the user's request.
The MCP server validates the request, applies authentication and permissions, calls the Linear API, and returns the result to Cursor.
Linear MCP Not Connecting to Cursor
If Linear MCP is not connecting to Cursor, check the configuration in this order:
- Confirm that the MCP server starts outside Cursor.
- Verify the server command and arguments.
- Check that required environment variables are available.
- Validate Linear credentials.
- Restart Cursor after changing the MCP configuration.
- Review MCP server logs for initialization or authentication errors.
- Test whether Cursor can discover the server's tools.
Connection failures are commonly caused by incorrect server commands, missing environment variables, invalid credentials, or MCP initialization errors.
For additional troubleshooting steps, see Cursor MCP Server Failed to Connect. For broader network or client-level failures, use the Cursor connection error guide.
Why Connect Cursor to Linear?
Most developers already spend the majority of their day inside their editor.
Switching repeatedly between Cursor and Linear interrupts focus and slows development.
Connecting the two systems allows Cursor to work directly with project data while you continue writing code.
Typical benefits include:
- Faster issue lookup
- Fewer context switches
- AI-assisted task management
- Better engineering productivity
- More accurate project context
- Streamlined development workflows
Instead of manually copying issue IDs or opening browser tabs, developers can ask Cursor to retrieve or update information using natural language.
How the Integration Works
Cursor does not communicate directly with the Linear API.
Instead, every request passes through an MCP server that exposes Linear as a collection of AI-accessible tools.
A typical architecture looks like this:
Cursor
│
▼
Linear MCP Server
│
▼
Authentication Layer
│
▼
Linear API
│
▼
Projects • Issues • Teams
The MCP server validates requests, applies permissions, communicates with the Linear API, and returns structured responses to Cursor.
This architecture keeps credentials secure while giving organizations complete control over the actions available to AI.
Typical Development Workflows
One of the biggest advantages of connecting Cursor to Linear is keeping the entire development workflow inside the editor.
Developers can ask Cursor to:
- Search for an issue before starting work.
- Retrieve implementation details for an assigned task.
- Create a new bug report while debugging.
- Update issue status after completing a feature.
- Add implementation notes directly to a ticket.
- Find related issues before modifying existing code.
- Generate a summary of completed work for a pull request.
Instead of treating project management as a separate activity, Cursor becomes an active participant in the software development lifecycle.
Choosing the Right MCP Tools
A good Cursor integration focuses on the tools developers use most frequently.
Common examples include:
- Search Issues
- Get Issue
- Create Issue
- Update Issue
- Assign Issue
- List Projects
- List Teams
- Add Comment
- Update Workflow Status
Keeping the toolset focused reduces complexity while improving the quality of AI-generated actions.
Explore a Verified Linear MCP Implementation
If you're planning to connect Cursor to Linear, reviewing an existing implementation is an excellent starting point.
The verified Linear MCP page in the MCPForge Directory showcases supported tools, implementation details, and production capabilities that can help you design your own integration.
https://www.mcpforge.tech/verified/linear-mcp-server
AI-Assisted Development with Cursor and Linear
The real value of connecting Cursor to Linear isn't simply reading project data—it's enabling an AI-assisted development workflow.
Instead of treating your IDE and project management platform as separate systems, Cursor can use information from Linear to make better coding decisions.
For example, before implementing a feature, Cursor can retrieve the associated issue, understand its description, acceptance criteria, and related tasks, then use that context while generating code.
During development, it can also help developers:
- Understand project requirements
- Reference existing issues
- Document implementation progress
- Prepare release notes
- Organize follow-up tasks
- Reduce repetitive project management work
This tighter feedback loop allows developers to spend more time writing code and less time navigating between tools.
Security and Permission Management
Connecting the Cursor to Linear does not mean granting unrestricted access to your workspace.
If you are comparing integrations across AI clients, see our guide to Linear MCP with Claude.
A production-ready Linear MCP Server should enforce the same security controls that exist throughout the rest of your engineering infrastructure.
Typical controls include:
- Authentication
- Role-based permissions
- Request validation
- Audit logging
- Read-only tools where appropriate
- Approval workflows for sensitive operations
- Secure credential storage
The MCP server acts as a policy enforcement layer, ensuring that Cursor can only perform actions explicitly allowed by your organization.
Common Integration Challenges
Most Cursor and Linear integrations encounter similar challenges during development.
Authentication Problems
Incorrect API credentials, expired OAuth tokens, or configuration mistakes can prevent Cursor from accessing Linear.
Authentication should always be validated before debugging higher-level functionality.
Poor Tool Definitions
Cursor relies on descriptive tool metadata to determine which MCP tool should be executed.
Incomplete descriptions or invalid input schemas may reduce the quality of AI-generated actions.
Permission Errors
Successful authentication does not guarantee authorization.
Developers should verify that the authenticated identity has permission to create issues, update projects, assign work, or perform other requested operations.
Missing Context
Providing too many tools without sufficient project context can make AI responses less reliable.
Many teams improve results by exposing useful resources alongside tools, such as project metadata, workflow documentation, and engineering guidelines.
Best Practices
Teams building production-ready Cursor integrations generally follow a consistent development approach.
Recommended practices include:
- Expose only frequently used Linear tools.
- Keep API credentials server-side.
- Validate every request before calling the Linear API.
- Implement structured logging.
- Review permissions regularly.
- Test new tools before deployment.
- Keep tool descriptions clear and consistent.
- Monitor authentication failures.
- Update MCP implementations alongside Linear API changes.
These practices improve both security and the overall developer experience.
Frequently Asked Questions
Can Cursor create Linear issues?
Yes.
If your MCP server exposes the appropriate tool and the authenticated user has permission, Cursor can create new Linear issues directly from the editor.
Can Cursor update existing tasks?
Yes.
Depending on the available MCP tools, Cursor can update issue status, assignments, labels, comments, priorities, and other supported fields.
Does Cursor connect directly to the Linear API?
No.
Cursor communicates exclusively with the MCP server.
The MCP server authenticates with the Linear API, executes requests, and returns structured responses to the editor.
Is the integration secure?
Yes.
When implemented correctly, the MCP server manages authentication, permissions, logging, and request validation while ensuring that API credentials remain hidden from Cursor.
Can an engineering team share one Linear MCP Server?
Yes.
Many organizations deploy a centralized MCP server that securely supports multiple developers, projects, and workspaces while maintaining individual authorization and auditability.
Final Thoughts
Integrating Cursor with Linear through the Model Context Protocol creates a more efficient and context-aware software development environment.
Rather than interrupting development to search for issues, update tasks, or review project information, developers can interact with their engineering workflow directly from the editor using natural language.
As AI-assisted development continues to evolve, a well-designed Linear MCP Server provides the secure integration layer that allows Cursor to work seamlessly with your project management system while maintaining authentication, permissions, and organizational governance.
Explore a Verified Linear MCP Integration
If you're building or evaluating a Cursor integration, reviewing a verified implementation is an excellent way to understand how a production-ready MCP server should be structured.
The Linear MCP page in the MCPForge Directory showcases supported tools, available capabilities, verification details, and implementation information that can serve as a practical reference during development.
Official Sources
- Linear MCP server documentation - official Linear MCP endpoint and Cursor setup entry point.
- MCP authorization specification - official OAuth authorization model for HTTP-based MCP transports.
- Cursor status - official Cursor service status page for outage checks.