What is MCP and why does it matter for project management?
Model Context Protocol (MCP) is an open standard that lets AI tools read from and write to external services using a structured interface. Think of it as a USB-C port for AI integrations: one standard that works across Claude, Cursor, VS Code, Codex, Antigravity, and any other MCP-compatible tool.
For project management, MCP means your AI assistant can access your actual project data — open issues, sprint goals, backlog items — instead of relying on context you paste in manually. PlanIT ships with a native MCP server that exposes your team's project state to any connected AI tool.
This guide walks through the exact steps to connect PlanIT's MCP server and shows you what becomes possible once it's running. For background on why PlanIT was built around MCP from the start, see Why We Built PlanIT.
Prerequisites
Before starting, you need:
- A PlanIT account (free tier works; sign up here)
- One or more of: Claude Desktop, Claude Code, Cursor, VS Code, Codex, or Antigravity
- Your PlanIT Personal Access Token (found in Settings → Connections → Access Tokens)
- Node.js 18+ installed (
node --versionto check)
Step 1: Create a Personal Access Token
Log into PlanIT and navigate to Settings → Connections → Access Tokens. Click "Create Token", select the workspace your AI tool should act on, and enable the read, write, and profile scopes. Copy the token — you won't be able to see it again after closing the dialog.
Your token looks like: planit_pat_xxxxxxxxxxxxxxxxxxxx
You'll paste this token into each AI tool's config as the PLANIT_API_TOKEN environment variable.
Step 2: Connect Claude Desktop
Claude Desktop supports MCP servers through its configuration file. Open or create the config file at:
- macOS:
~/Library/Application Support/Claude/claude_desktop_config.json - Windows:
%APPDATA%\Claude\claude_desktop_config.json
Add the PlanIT server to the mcpServers object:
{
"mcpServers": {
"planit": {
"command": "npx",
"args": ["-y", "@plan-it/mcp-server"],
"env": {
"PLANIT_API_TOKEN": "your-token-here"
}
}
}
}Save the file and restart Claude Desktop. You'll see a hammer icon in the chat interface indicating MCP tools are available.
Step 3: Connect Claude Code
Claude Code (the CLI) makes setup even simpler. Run these two commands in your terminal:
claude mcp add planit -- npx -y @plan-it/mcp-server
export PLANIT_API_TOKEN="your-token-here"Add the export line to your ~/.zshrc or ~/.bashrc to persist the token across sessions. MCP tools are available immediately — no restart required.
Step 4: Connect Cursor
Cursor supports MCP through a JSON config file in your project root. Create or edit .cursor/mcp.json:
{
"mcpServers": {
"planit": {
"command": "npx",
"args": ["-y", "@plan-it/mcp-server"],
"env": {
"PLANIT_API_TOKEN": "your-token-here"
}
}
}
}Save and reload Cursor. PlanIT will appear as an available MCP server in your tool panel.
Step 5: Connect VS Code
VS Code MCP support depends on your AI extension. For extensions that support MCP (GitHub Copilot with MCP mode, Continue, and others), add to your user settings.json (Cmd+Shift+P → "Open User Settings JSON"):
{
"mcp.servers": {
"planit": {
"command": "npx",
"args": ["-y", "@plan-it/mcp-server"],
"env": {
"PLANIT_API_TOKEN": "your-token-here"
}
}
}
}Check your specific extension's documentation for the exact key names — they may vary between extensions.
Step 6: Connect Codex
Codex (OpenAI's CLI agent) uses a YAML config file at ~/.codex/config.yaml. Add the PlanIT server under mcpServers:
mcpServers:
planit:
command: npx
args:
- -y
- "@plan-it/mcp-server"
env:
PLANIT_API_TOKEN: "your-token-here"Save the file and start a new Codex session. Ask it What issues do I have in PlanIT? to verify the connection.
Step 7: Connect Antigravity
Antigravity reads MCP config from ~/.antigravity/mcp.json:
{
"mcpServers": {
"planit": {
"command": "npx",
"args": ["-y", "@plan-it/mcp-server"],
"env": {
"PLANIT_API_TOKEN": "your-token-here"
}
}
}
}Restart Antigravity after saving. PlanIT tools will be available in your next session.
What you can do once connected
With the MCP server running, your AI tool gains the following capabilities:
Query your backlog
What are the open issues in the current sprint?
Claude will call the PlanIT MCP server, fetch your active sprint issues, and summarize them. No copy-pasting required.
Create issues from conversation
Create an issue for the auth token refresh bug we just found.
Priority: high. Assign it to the backend project.
PlanIT creates the issue and returns the issue ID (e.g., PL-142) so you can reference it later.
Update issue status
Mark PL-138 as in progress — I'm starting work on it now.
The status updates in PlanIT in real time. Your teammates see the change immediately.
Log implementation details
Add a comment to PL-138: Implemented using exponential backoff,
max 3 retries. Edge case: tokens issued before 2026-01-01
need manual migration.
Implementation notes that would otherwise live only in your terminal or be forgotten entirely now exist in the project record.
Check project state before starting work
What's the highest-priority unassigned issue in the backend project?
This is particularly useful at the start of a work session. Instead of opening PlanIT in a browser tab, you ask Claude and get a direct answer.
A realistic workflow example
Here's what a typical development session looks like with MCP connected:
Start of session — in Claude:
What should I work on today? Check the current sprint in PlanIT
and give me the highest-priority item that's not yet in progress.
Claude queries PlanIT, identifies PL-151 (add rate limiting to the API), and summarizes the issue description and acceptance criteria.
During coding — in Cursor: As you work, you stay in Cursor. When you hit a question about the requirements, you ask directly:
What are the acceptance criteria for PL-151?
Cursor fetches the issue and displays the criteria in context.
After a commit — in Claude:
I've implemented the rate limiting middleware. Update PL-151 status
to "in review" and add a comment: middleware is at api/middleware/rate-limit.ts,
uses sliding window, 100 req/min per user.
The project record is updated without leaving the conversation.
End of session:
I finished PL-151 and started PL-152. Update both accordingly.
Done. No browser context-switching required.
Troubleshooting common issues
"MCP server not found" in Claude Desktop
Check that Node.js is installed (node --version). The npx command requires Node.js. If it's missing, install it from nodejs.org.
"Authentication failed" error
Verify your API key is correct. Keys can be regenerated in PlanIT Settings → Integrations → MCP. Make sure there are no trailing spaces in the environment variable value.
Tools appear but return empty results
Confirm you have at least one project in PlanIT with issues. The MCP server returns data for the workspace associated with your API key — if your workspace has no data, queries return empty.
Cursor shows MCP server as disconnected
Try reloading Cursor (Cmd+Shift+P → "Reload Window"). MCP server connections sometimes need a fresh window after configuration changes.
What's next
Once your MCP connection is working, explore the full list of available commands in your PlanIT dashboard under Settings → Integrations → MCP → Command Reference. The list grows with each PlanIT release.
The highest-leverage workflow change is forming the habit of starting each coding session with a project state query instead of a blank slate. Once that becomes automatic, you'll find the AI consistently gives better-targeted suggestions because it actually knows what you're trying to accomplish.
PlanIT's MCP integration is available on Pro plans and above. The integrations page has setup tabs for every supported AI tool — Claude Desktop, Claude Code, Cursor, VS Code, Codex, and Antigravity — plus a live config generator. See the pricing page for plan details.