What can you do with this server?

The Plane MCP Server enables LLMs to interact with Plane.so for project and issue management through its API. * List Projects: Retrieve all projects in your Plane workspace * Get Project Details: Fetch detailed information about specific projects using project IDs * Create Issues: Add new issues to projects with customizable properties including title, HTML description, priority levels (urgent/high/medium/low/none), state ID, and assignees * List & Filter Issues: View and filter issues from projects by state ID, priority, assignee ID, or limit results * Get Issue Details: Access detailed information about specific issues using project and issue IDs * Update Issues: Modify existing issues by updating their title, description, priority, state ID, or assignees All operations use your API key and workspace slug, with modifying operations requiring explicit user approval for security.

Which integrations are available for this server?

Enables LLMs to interact with Plane.so, allowing them to manage projects and issues. Provides tools for listing projects, getting project details, creating and updating issues, and managing issue properties like priority and assignees.

How do I use Plane MCP Server?

1. Click on "Deploy Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Plane MCP Server list all projects in my workspace" 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.

de en es ja ko ru zh

Plane MCP Server

by kelvin6365

Overview Schema Source Related Servers Discussions Admin

JavaScript

Remote

Plane MCP Server

Trust Score

A Model Context Protocol (MCP) server that enables LLMs to interact with Plane.so, allowing them to manage projects and issues through Plane's API. Using this server, LLMs like Claude can directly interact with your project management workflows while maintaining user control and security.

Features

List all projects in your Plane workspace
Get detailed information about specific projects
Create new issues with customizable properties
List and filter issues from projects
Get detailed information about specific issues
Update existing issues with new information

Related MCP server: Plane MCP Server

Prerequisites

Node.js 22.x or higher
A Plane.so API key
A Plane.so workspace

Installation

Option 1: Using Smithery

The quickest way to get started is to use Smithery to install the server directly:

# Install to Claude for Desktop
npx -y @smithery/cli install @kelvin6365/plane-mcp-server --client claude

This command will automatically set up the Plane MCP Server for use with Claude. After installation, you'll need to configure the server with your Plane API key and workspace slug through the Claude settings.

Valid client options are: claude, cline, windsurf, roo-cline, witsy, enconvo, cursor

Example for installing with Cursor:

npx -y @smithery/cli install @kelvin6365/plane-mcp-server --client cursor

Option 2: Manual Setup

If you prefer to set up the server manually, follow these steps:

Clone this repository:

git clone https://github.com/kelvin6365/plane-mcp-server.git
cd plane-mcp-server

Install dependencies:

npm install

Build the server:

npm run build

Usage with Claude for Desktop

Note: If you used Option 1 (Smithery) above, you can skip this section. Smithery automatically configures the MCP server for you.

Open your Claude for Desktop configuration file:
- macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
- Windows: %APPDATA%\Claude\claude_desktop_config.json
Add the Plane MCP server configuration:

{
  "mcpServers": {
    "plane": {
      "command": "node",
      "args": ["path/to/plane-mcp-server/build/index.js"],
      "env": {
        "PLANE_API_KEY": "your_plane_api_key_here",
        "PLANE_WORKSPACE_SLUG": "your_workspace_slug_here",
        "PLANE_HOST": "optional"
      }
    }
  }
}

Restart Claude for Desktop

Available Tools

Note: Tool names use hyphens (e.g., list-projects), not underscores. The server will automatically convert underscores to hyphens for compatibility.

list-projects

Lists all projects in your Plane workspace.

Parameters: None

Example:

{}

get-project

Gets detailed information about a specific project.

Parameters:

project_id: ID of the project to retrieve

Example:

{
  "project_id": "01abc123-4567-89de-0123-456789abcdef"
}

create-issue

Creates a new issue in a specified project.

Parameters:

project_id: ID of the project where the issue should be created
name: Title of the issue
description_html: HTML description of the issue (required by Plane API)
priority (optional): Priority of the issue ("urgent", "high", "medium", "low", "none")
state_id (optional): ID of the state for this issue
assignees (optional): Array of user IDs to assign to this issue

Note: The assignees parameter must be an array of user ID strings. Common errors include providing a dictionary/object instead of an array, or accidentally nesting the entire issue data inside the assignees field. The server will attempt to handle these cases, but it's best to use the correct format.

Example:

{
  "project_id": "01abc123-4567-89de-0123-456789abcdef",
  "name": "Implement new feature",
  "description_html": "<p>We need to implement the new reporting feature</p>",
  "priority": "high",
  "assignees": ["user-id-1", "user-id-2"]
}

list-issues

Lists issues from a specified project with optional filtering.

Parameters:

project_id: ID of the project to get issues from
state_id (optional): Filter by state ID
priority (optional): Filter by priority
assignee_id (optional): Filter by assignee ID
limit (optional): Maximum number of issues to return (default: 50)

Example:

{
  "project_id": "01abc123-4567-89de-0123-456789abcdef",
  "priority": "high",
  "limit": 10
}

get-issue

Gets detailed information about a specific issue.

Parameters:

project_id: ID of the project containing the issue
issue_id: ID of the issue to retrieve

Example:

{
  "project_id": "01abc123-4567-89de-0123-456789abcdef",
  "issue_id": "01def456-7890-12gh-3456-789ijklmnopq"
}

update-issue

Updates an existing issue in a project.

Parameters:

project_id: ID of the project containing the issue
issue_id: ID of the issue to update
name (optional): Updated title of the issue
description_html (optional): HTML description of the issue (required by Plane API)
priority (optional): Updated priority of the issue
state_id (optional): Updated state ID of the issue
assignees (optional): Updated array of user IDs to assign to this issue

Note: The assignees parameter must be an array of user ID strings, following the same format guidelines as the create-issue tool.

Example:

{
  "project_id": "01abc123-4567-89de-0123-456789abcdef",
  "issue_id": "01def456-7890-12gh-3456-789ijklmnopq",
  "priority": "urgent",
  "description_html": "<p>Updated description with <strong>more details</strong></p>"
}

Development

Install development dependencies:

npm install --save-dev typescript @types/node

Start the server in development mode:

npm run dev

Testing

You can test the server using the MCP Inspector:

npx @modelcontextprotocol/inspector node dist/index.js

Examples

Here are some example interactions you can try with Claude after setting up the Plane MCP server:

"Can you list all the projects in my Plane workspace?"
"Please create a new high-priority issue in the Marketing project titled 'Update social media strategy'"
"What are all the high-priority issues in the Development project?"
"Update issue #123 in the QA project to change its priority to urgent"

Claude will use the appropriate tools to interact with Plane while asking for your approval before creating or modifying any issues.

Security Considerations

The API key requires proper Plane permissions to function
All operations that modify data require explicit user approval
Environment variables should be properly secured
API keys should never be committed to version control

Contributing

Fork the repository
Create your feature branch (git checkout -b feature/amazing-feature)
Commit your changes (git commit -m 'Add some amazing feature')
Push to the branch (git push origin feature/amazing-feature)
Open a Pull Request

License

This project is licensed under the MIT License - see the LICENSE file for details.

Support

If you encounter any issues or have questions:

Check the GitHub Issues section
Consult the MCP documentation at modelcontextprotocol.io
Open a new issue with detailed reproduction steps

Star History

Available Tools

6 tools

create-issueC

Create a new issue in a project

ParametersJSON Schema

Name	Required	Description
`project_id`	Yes	ID of the project where the issue should be created
`name`	Yes	Title of the issue
`description_html`	No	HTML description of the issue (required by Plane API)
`priority`	No	Priority of the issue (urgent, high, medium, low, none)
`state_id`	No	ID of the state for this issue (optional)
`assignees`	No	Array of user IDs to assign to this issue (optional)

TDQS

C2.9/5.0

Behavior2/5

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 'Create' which implies a write operation, but doesn't mention permissions, side effects, error handling, or response format. This is inadequate for a mutation 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.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence with no wasted words. It's appropriately sized and front-loaded with the core action, making it easy to parse quickly.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a creation tool with 6 parameters, no annotations, and no output schema, the description is insufficient. It doesn't explain what happens after creation, error conditions, or provide enough context for safe usage despite the comprehensive schema.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema fully documents all 6 parameters. The description adds no additional parameter information beyond what's in the schema, maintaining the baseline score for high schema coverage.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb ('Create') and resource ('new issue in a project'), making the purpose unambiguous. However, it doesn't differentiate from sibling tools like 'update-issue' or specify what distinguishes creation from other operations.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

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 'update-issue' or 'list-issues', nor does it mention prerequisites or context for creation. It's a basic statement without usage context.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get-issueC

Get detailed information about a specific issue

ParametersJSON Schema

Name	Required	Description	Default
`project_id`	Yes	ID of the project containing the issue
`issue_id`	Yes	ID of the issue to retrieve

TDQS

C2.9/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries full burden. It states 'Get detailed information,' implying a read-only operation, but does not disclose behavioral traits such as authentication needs, rate limits, error conditions, or what 'detailed information' includes (e.g., fields, format). This is inadequate for a tool with no 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.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence with no wasted words. It is front-loaded with the core purpose, making it easy to parse quickly, though it lacks depth due to its brevity.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given no annotations and no output schema, the description is incomplete. It does not explain what 'detailed information' entails, potential return values, or error handling. For a read operation with rich sibling tools, more context is needed to guide the agent effectively.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, with clear descriptions for 'project_id' and 'issue_id' in the input schema. The description adds no additional meaning beyond the schema, such as parameter interactions or examples. Baseline 3 is appropriate when the schema does the heavy lifting.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

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 issue'), making the purpose understandable. However, it does not explicitly differentiate from sibling tools like 'get-intake-issue' or 'get-issue-activity', which also retrieve issue-related information, leaving some ambiguity about scope.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

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. With many sibling tools like 'list-issues' for multiple issues or 'get-intake-issue' for specific types, there is no indication of context, prerequisites, or exclusions, leaving the agent to infer usage.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get-projectB

Get detailed information about a specific project

ParametersJSON Schema

Name	Required	Description	Default
`project_id`	Yes	ID of the project to retrieve

TDQS

B3.3/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations supplied, the description carries the full burden of behavioral disclosure. It only states 'Get detailed information,' omitting any details about authentication, rate limits, or what 'detailed' encompasses. For a read operation, it is minimally transparent.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, clear sentence with no extraneous words. It is front-loaded and efficient, earning its place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple get operation with one parameter and no output schema, the description is adequate but lacks context about the return format or any prerequisites. It does not fully compensate for the absence of annotations or additional behavioral notes.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, and the parameter 'project_id' is adequately described in the schema as 'ID of the project to retrieve.' The description adds no extra meaning beyond that, meeting the baseline for parameter semantics.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool retrieves detailed information about a specific project, using a specific verb+resource structure. It successfully distinguishes from sibling tools like create-project, delete-project, and get-issue.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is provided on when to use this tool versus alternatives such as list-projects or get-issue. There are no exclusions, prerequisites, or context for appropriate use.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

list-issuesC

List issues from a project

ParametersJSON Schema

Name	Required	Description
`project_id`	Yes	ID of the project to get issues from
`state_id`	No	Filter by state ID (optional)
`priority`	No	Filter by priority (optional)
`assignee_id`	No	Filter by assignee ID (optional)
`limit`	No	Maximum number of issues to return (default: 50)

TDQS

C2.7/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries full burden. It states 'List issues' but doesn't disclose behavioral traits like pagination (implied by 'limit'), default sorting, rate limits, authentication needs, or error handling. This leaves significant gaps for an agent to understand how the tool behaves.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence with zero waste. It's front-loaded and appropriately sized for a basic listing tool, making it easy to parse quickly.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given no annotations and no output schema, the description is incomplete. It doesn't explain return values (e.g., issue format), pagination behavior, or error cases. For a tool with 5 parameters and no structured behavioral hints, this leaves the agent under-informed about critical usage aspects.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema fully documents all 5 parameters. The description adds no meaning beyond the schema, such as explaining how filters combine or the format of returned issues. Baseline 3 is appropriate since the schema does the heavy lifting.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose3/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description 'List issues from a project' clearly states the verb ('List') and resource ('issues'), but it's vague about scope (e.g., all issues vs. filtered) and doesn't distinguish from siblings like 'get-issue' (single issue) or 'list-projects' (different resource). It's functional but lacks specificity.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is provided on when to use this tool versus alternatives. For example, it doesn't mention using 'get-issue' for a single issue or 'list-projects' to find project IDs first. The description implies usage for listing issues but offers no context on prerequisites or exclusions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

list-projectsA

List all projects in the workspace

ParametersJSON Schema

Name	Required	Description	Default
No parameters

TDQS

A3.8/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description should fully describe behavior. It is minimal, only stating a read operation. It lacks details on pagination, ordering, or whether results are comprehensive.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is extremely concise at 5 words, with no filler. Every word is informative and necessary.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a no-parameter list tool, the description is mostly complete. It specifies workspace scope, but could mention if results are limited or paginated. Still adequate for the simplicity.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has no parameters, so schema coverage is 100%. The description does not need to add parameter details, and it appropriately avoids extraneous information.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action (List), the resource (projects), and the scope (in the workspace). It effectively distinguishes from sibling tools like get-project (single project) and create-project.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No explicit guidance on when to use this tool versus alternatives like get-project. Usage is implied but not clarified with when-not or specific contexts.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

update-issueC

Update an existing issue in a project, delete just update the issue title with 'delete' or 'remove'

ParametersJSON Schema

Name	Required	Description
`project_id`	Yes	ID of the project containing the issue
`issue_id`	Yes	ID of the issue to update
`name`	No	Updated title of the issue (optional)
`description_html`	No	HTML description of the issue (required by Plane API)
`priority`	No	Updated priority of the issue (optional)
`state_id`	No	Updated state ID of the issue (optional)
`assignees`	No	Updated array of user IDs to assign to this issue (optional)

TDQS

C2.8/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries full burden but is inadequate. It mentions updating and a deletion method, but doesn't disclose critical behavioral traits like required permissions, whether updates are reversible, rate limits, or what happens to unspecified fields. The deletion note is vague and doesn't explain if it's a standard feature or workaround.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness3/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is concise with two clauses, but the second clause about deletion is poorly integrated and confusing, reducing clarity. It's front-loaded with the main purpose but the additional note doesn't earn its place effectively, making the structure somewhat disjointed.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the complexity of a mutation tool with 7 parameters, no annotations, and no output schema, the description is incomplete. It lacks details on behavior, error handling, return values, and how it differs from siblings. The deletion note adds confusion rather than completeness, failing to provide adequate context for safe and effective use.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema fully documents all 7 parameters. The description adds no meaningful parameter semantics beyond what's in the schema, such as explaining interactions between fields or special cases. It mentions 'delete' or 'remove' for the title but doesn't tie this to the 'name' parameter clearly.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb ('Update') and resource ('existing issue in a project'), making the purpose understandable. However, it doesn't explicitly differentiate from sibling tools like 'create-issue' or 'get-issue' beyond the update action, and the second part about deleting with 'delete' or 'remove' is confusing rather than clarifying.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

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 'create-issue' or 'get-issue'. It mentions a deletion method but doesn't clarify if this is the primary deletion mechanism or when to use it over other tools, offering minimal usage context.

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.

6 tool updatesOct 1, 2025
- First observedcreate-issue
- First observedget-issue
- First observedget-project
- First observedlist-issues
- First observedlist-projects
- First observedupdate-issue

Deploy Server

One endpoint for every MCP toolRayrun runs every MCP server behind one URL and holds the credentials. Each call is decided per client, tool, and argument, then recorded.ray.runAd

TDQS

B3.4/5.0

Scored 2026-04-18 11:00 across 6 tools

Disambiguation5/5

Each tool has a clearly distinct purpose with no ambiguity: create-issue, get-issue, update-issue, and list-issues handle issues, while get-project and list-projects handle projects. The descriptions reinforce this separation, making misselection unlikely.

Naming Consistency5/5

All tools follow a consistent verb_noun pattern with hyphen separation (e.g., create-issue, list-projects). This predictable naming scheme enhances readability and usability across the tool set.

Tool Count5/5

With 6 tools, the server is well-scoped for managing issues and projects in a workspace. Each tool earns its place by covering essential CRUD operations without being overly sparse or bloated.

Completeness4/5

The tool set provides strong coverage for issues (create, get, list, update) and projects (get, list), but lacks explicit create-project, update-project, and delete operations. Agents can work around this with the update-issue workaround for deletion, but minor gaps exist.

Maintenance

ActivityInactive

ResponsivenessUnresponsive

Resources

GitHub Repository

Need Help?

Reddit Discussion

Related Servers

Related MCP Connectors

hithereiamaliff-mcp-nextcloudOAuth
ai.smithery
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to interact with yo…
Cloud Storage File Systems Workplace & Productivity
238
Mercado PagoOAuth
com.mercadopago.mcp
The Mercado Pago MCP Server implements the Model Context Protocol to provide AI agents and LLMs with access to Mercado Pago's APIs and tools within compatible development environments. It acts as an intermediary that translates Mercado Pago resources into executable functions (tools) that AI applications can invoke to perform actions and automate flows. The server simplifies integration, enables using documentation to implement or improve code, and optimizes operations through natural language interactions without manual implementations.
Finance E-commerce & Retail App Automation
2
Apideck MCP A
dev.apideck.mcp
Model Context Protocol server for the Apideck Unified API. Connect any MCP-compatible agent framework to 100+ accounting systems, HRIS platforms, file storage providers, and more through one integration. More information https://www.apideck.com/mcp-server
Developer Tools
42
Sentry AOAuth
dev.sentry.mcp
Enable secure connectivity between Sentry issues and debugging data, and LLM clients, using a Model Context Protocol (MCP) server.
Monitoring Developer Tools Observability
3

Related MCP Servers

Linear MCP Server
Project Management Developer Tools
magarcia
A
license
A
quality
C
maintenance
A Model Context Protocol server that enables large language models to interact with Linear's issue tracking system, allowing management of issues, projects, teams, and other Linear resources.
Updated a year ago (2025-03-24 09:18 UTC)
19
13 npm
1
MIT
Plane MCP Serverofficial
Project Management Developer Tools
makeplane
A
license
B
quality
A
maintenance
A Model Context Protocol server that enables AI interfaces to seamlessly interact with Plane's project management system, allowing management of projects, issues, states, and other work items through a standardized API.
Updated 3 days ago (2026-09-15 14:24 UTC)
46
121 npm
320
MIT
Plane MCP Server
Project Management Developer Tools
disrex-group
A
license
B
quality
C
maintenance
A Model Context Protocol (MCP) server that enables LLMs to interact with Plane.so, allowing them to manage projects and issues through Plane's API. Using this server, LLMs like Claude can directly interact with your project management workflows while maintaining user control and security.
Updated a year ago (2025-08-27 12:13 UTC)
76
13 npm
1
MIT
Plane MCP
Project Management Developer Tools
Rockysingh116
A
license
B
quality
D
maintenance
An MCP server that enables LLMs to fully manage a Plane workspace, including projects, work items, states, labels, cycles, modules, comments, and members.
Updated 3 months ago (2026-06-22 13:08 UTC)
38
MIT

Plane MCP Server

Features

Prerequisites

Installation

Option 1: Using Smithery

Option 2: Manual Setup

Usage with Claude for Desktop

Available Tools

list-projects

get-project

create-issue

list-issues

get-issue

update-issue

Development

Testing

Examples

Security Considerations

Contributing

License

Support

Star History

Available Tools

Tool Schema Changelog

Maintenance

Resources

Related MCP Connectors

Related MCP Servers

Plane MCP Serverofficial

Appeared in Searches