NewAgent Observability — find failures before customers do.
Back to directory
Cursor logo

Cursor MCP server: how to add and configure servers

Cursor reads MCP servers from mcp.json. It also runs two servers of its own: Origin MCP for repositories on Origin, and Cursor Cloud MCP for cloud-agent diagnostics.

Connector
MCP client, plus Origin MCP
Coverage
Your servers; Origin repos and PRs
Tools
Depends on the servers you add
Working route
Add servers in .cursor/mcp.json

Checked 3 October 2026 · from Cursor's MCP, Origin MCP and Cloud Agents documentation, and Cursor's 30 June 2026 changelog

One of 91 guides to monitoring and developer tools. Each covers what an AI coding agent can get out of the tool through MCP, the protocol that lets the agent query the tool directly.

Summary

Cursor reads MCP servers from .cursor/mcp.json in a project, or ~/.cursor/mcp.json for every project. It supports stdio, SSE and Streamable HTTP, with OAuth on the two remote transports.

Cursor also runs its own Origin MCP server for repositories and pull requests hosted on Origin. Origin is early beta, and its MCP server currently works only in Cursor and Grok Bot.

Cloud Agents add a built-in Cursor Cloud MCP for run diagnostics: transcripts, run events, environment details and setup logs. See the Cloud Agents documentation.

How Cursor works with MCP

MCP connects an agent client to tools exposed by a server. In Cursor, you add the server for the system that holds the data, such as a database, issue tracker or monitoring product.

Cursor supports tools, prompts, resources, roots and elicitation. Roots tell a server which folders the client wants it to work in. They are a hint, not an access control. Elicitation lets a server ask the user a question mid-call.

Cursor also supports MCP Apps, a standard MCP extension that lets a tool return interactive UI. Hosts that cannot render that UI still get the normal tool response.

Origin MCP works in the opposite direction. Cursor is the server, and each tool acts as the authenticated caller, with the same permission checks as the Origin API.

Three surfaces with different setup and permissions

SurfacePurposeBoundary
Cursor MCP clientCalls tools from configured external serversThe external server owns its data and authentication
Origin MCPOrigin-hosted repositories and pull requestsEarly beta; currently Cursor and Grok Bot
Cursor Cloud MCPCloud-run transcripts, events and setup diagnosticsBuilt into Cloud Agent runs

Every vendor here gets the same four checks: official, maintained, distributed and usable. Cursor passes 2 of them.

CheckResultEvidence
OfficialPassCursor documents its own Origin MCP server.
MaintainedUnknownCursor labels Origin "in Early Beta and subject to change" and gives no release cadence for its MCP server.
DistributedPassOrigin documents hosted /mcp and /mcp/readonly endpoints. Availability is restricted to the supported harnesses.
UsableUnknownAs of 3 October 2026 Origin MCP works only in Cursor and Grok Bot, authenticated by a Cursor session or an Origin App token.
Part of the workWhat Cursor has hereCan an agent reach it
Code, tests & reviewEditor and Origin repository workflowsExternal servers or supported Origin integration
CI & releaseOrigin checks and repository stateOrigin-scoped; not a general CI connector
Agent observability & evalsCloud-agent diagnosticsBuilt-in Cloud MCP scope, not general telemetry

Most teams only need Cursor's client role: one server per system the agent should reach. Origin MCP and Cloud MCP matter when repositories live on Origin or agents run in Cursor's cloud.

What can an AI agent do with Cursor?

A configured server does not expose the data you expected

An MCP connection supplies only the tools on that server. Origin sees repositories hosted on Origin; an external monitoring server sees its own product data.

Guard: Check the server URL, supported client and authenticated repository scope before changing the prompt.

Do you need the MCP server at all?

Use a product's API or CLI when you need direct control over a supported operation. Use MCP when Cursor's agent should discover and invoke that product's tools.

In most clients each connected server's tool definitions take up context. Disable servers you are not using from Customize so their tools stay out of the session.

Cursor integration setup

Project servers go in .cursor/mcp.json and personal ones in ~/.cursor/mcp.json, both under the mcpServers key.

Remote server (HTTP or SSE)

Remote servers take a url. Cursor marks SSE and Streamable HTTP as multi-user transports with OAuth; a static token can go in headers instead.

Terminal
{"mcpServers":{"my-service":{
  "url":"https://api.example.com/mcp",
  "headers":{"Authorization":"Bearer ${env:MY_SERVICE_TOKEN}"}}}}

Local server (stdio)

stdio servers take type, command, args, env and an optional envFile. Cursor manages the process, and authentication is manual.

Terminal
{"mcpServers":{"local-tools":{
  "type":"stdio",
  "command":"python",
  "args":["${workspaceFolder}/tools/mcp_server.py"],
  "env":{"API_KEY":"${env:API_KEY}"}}}}

Origin

Use the supported Cursor or Grok Bot integration. Origin documents https://api.origin.cursor.com/mcp and a /mcp/readonly variant. It uses bearer authentication and enforces the caller's permissions.

Every other client

Each block below is the configuration for one client, with the file path and the key that client expects.

Static OAuth credentials

For providers without dynamic client registration, add an auth object with CLIENT_ID, an optional CLIENT_SECRET and optional scopes. Its values take the same interpolation as other fields.

Terminal
"auth":{
  "CLIENT_ID":"${env:MCP_CLIENT_ID}",
  "CLIENT_SECRET":"${env:MCP_CLIENT_SECRET}"}
Interpolation variables

Cursor resolves variables in command, args, env, url and headers, and in auth values. ${workspaceFolder} is the folder that contains .cursor/mcp.json.

envFile works only for stdio servers. Remote servers read secrets from shell variables through ${env:NAME}.

Terminal
${env:NAME}   ${userHome}   ${workspaceFolder}
${workspaceFolderBasename}   ${pathSeparator}  ${/}
Team distribution and the Enterprise allowlist

Team admins share servers under Dashboard > Plugins & MCPs and can add them to a team marketplace. Linking a server to a marketplace does not install it for everyone.

Enterprise admins set the MCP Allowlist under Team Settings > MCP Configuration. Allowlisting approves a configuration; it does not distribute or install the server.

Terminal
command entries  ->  approve local stdio servers
URL entries      ->  approve remote HTTP/SSE servers
tool allowlists  ->  empty means every tool runs automatically
Register from an extension

vscode.cursor.mcp.registerServer() adds a server without editing mcp.json. Cursor suggests it for enterprise environments and automated setup.

Terminal
vscode.cursor.mcp.registerServer()

Read-only access, permissions and security

  • For Origin investigation without writes, use the documented read-only route and retain repository permission boundaries.

  • For external servers, review the endpoint's authentication and tools. Store credentials through ${env:NAME} interpolation or envFile rather than literal values.

  • Cloud agents use MCP servers added through the MCP dropdown at cursor.com/agents, so a server in your local mcp.json may be missing there.

  • An empty tool allowlist lets every tool from that server run automatically. Name tools explicitly to narrow it.

Troubleshooting

Connected, but no relevant tools appear
Check that you selected the correct surface and account. A transport handshake succeeds before any permission check on the requested data.
Origin does not work in another MCP client
Origin MCP currently supports Cursor and Grok Bot only. Other harnesses are listed as coming soon.
A server works in one project but not another
Check which file defines it. .cursor/mcp.json applies to its project, while ~/.cursor/mcp.json applies everywhere.

What the vendor documents

Cursor's MCP documentation states that "Allowlisting approves an MCP configuration. It does not distribute or install the server." Its Origin page says that tools "act as the authenticated caller".

Should you connect an agent to Cursor?

Yes. Add each data source's own server to Cursor, and use Origin MCP if your repositories are on Origin. Best for teams connecting a specific data source to a supported Cursor workflow.

Strongest fit
Yes. Add each data source's own server to Cursor, and use Origin MCP if your repositories are on Origin.
Main advantage
The editor can consume external tools while Origin provides a separate repository surface.
Main weakness
Origin is early beta with a restricted supported-client list.
Operational risk
Selecting the wrong surface or scope produces incomplete answers.

From Oodle

One platform for agent traces and infrastructure

Agent traces usually sit in a different product from the rest of your telemetry, so when a slow database makes an agent slow the symptom is in one tool and the cause is in another. Oodle keeps both in one query surface.

See agent observability

Frequently asked questions

Does Cursor publish an MCP server?

Yes. Cursor documents Origin MCP, in addition to being an MCP client. Origin has its own availability and repository restrictions.

How do I add an MCP server to Cursor?

Add it under mcpServers in .cursor/mcp.json for one project or ~/.cursor/mcp.json for all of them. Official plugins also install from the Cursor Marketplace in Customize.

Can any MCP client use Origin?

No. As of 3 October 2026 the documentation limits Origin MCP to Cursor and Grok Bot, with other harnesses "coming soon".

Does allowlisting install a team server?

No. Allowlisting approves a configuration. Team admins distribute servers separately, through a team marketplace under Dashboard > Plugins & MCPs.