How to Set Up MCP Servers in Cursor IDE: Complete Guide 2026

You've heard the buzz about MCP servers in Cursor, but every time you try to set one up, you hit a wall. Maybe the config file isn't being read. Maybe the server starts but Cursor can't see the tools. Or maybe you're just not sure where to begin — stdio, SSE, HTTP… what does any of it mean?

You're not alone. The Model Context Protocol (MCP) is one of the most powerful features in Cursor IDE, letting your AI assistant connect to external tools, databases, APIs, and data sources. But the documentation can feel scattered, and getting your first mcp server cursor setup working requires understanding a few key concepts.

This guide fixes that. By the end, you'll have MCP servers running in Cursor — whether you're a Node.js developer, a Python programmer, or someone deploying remote servers for a team. No guesswork, no frustration, just working configurations.

---

What You'll Learn

This comprehensive guide covers everything you need to set up and use MCP servers in Cursor IDE:

• What MCP is and why it matters for AI-assisted development
• Three transport methods — stdio, SSE, and Streamable HTTP — and when to use each
• Step-by-step setup for local stdio servers (Node.js and Python examples)
• Remote server configuration for HTTP and SSE endpoints
• Configuration locations — project-level vs. global config files
• Config interpolation — using environment variables and workspace paths
• OAuth and authentication for secure server connections
• Using MCP tools in Cursor's chat and agent modes
• Security best practices to keep your setup safe
• Troubleshooting tips for common issues

Let's dive in.

---

Prerequisites

Before you start configuring MCP servers in Cursor, make sure you have these basics in place:

Requirement	Details
Cursor IDE	Installed and running. MCP support is available on all Cursor plans (Free, Pro, Ultra, and Enterprise).
Node.js (for JS servers)	Version 18+ recommended. Needed for npx-based MCP servers.
Python (for Python servers)	Version 3.10+ recommended. Needed for Python-based MCP servers.
A terminal	You'll need basic command-line comfort for testing servers.
A text editor	For editing JSON config files (Cursor itself works great for this).

If you're only setting up remote MCP servers (HTTP/SSE), you don't need Node.js or Python installed locally — just the server URL.

---

What Is MCP? (Model Context Protocol Explained)

The Model Context Protocol (MCP) is an open standard that enables AI coding assistants like Cursor to connect to external tools and data sources. Think of it as a universal adapter between your AI and the outside world.

Without MCP, your AI assistant is limited to what it can see in your codebase and its training data. With MCP, it can:

• Query databases directly to understand your schema and data
• Call APIs — search the web, check deployment status, create tickets
• Access documentation from external sources in real time
• Interact with services like GitHub, Jira, Slack, or your own custom tools
• Read and write files beyond your workspace boundaries

MCP works by defining a standard JSON-RPC protocol between the AI client (Cursor) and external servers. You can write MCP servers in any language that can print to stdout or serve an HTTP endpoint — Python, JavaScript, Go, Rust, and more.

The Five Protocol Capabilities

MCP in Cursor supports five protocol capabilities, all of which are fully supported:

Capability	What It Does	Cursor Support
Tools	Functions for the AI model to execute (e.g., search a database, call an API)	✅
Prompts	Templated messages and workflows the server can expose	✅
Resources	Structured data sources the AI can query	✅
Roots	Server-initiated inquiries into URI or filesystem boundaries	✅
Elicitation	Server-initiated requests for additional information from the user	✅

This full protocol support means Cursor's MCP implementation is among the most complete available. Whether you need simple tool calls or advanced two-way communication between server and client, Cursor handles it.

---

How MCP Works in Cursor: Transport Methods

When setting up an MCP server in Cursor, the first decision you need to make is which transport method to use. Cursor supports three transport types, each suited to different use cases:

Transport	Execution	Deployment	Users	Input	Auth
stdio	Local	Cursor manages	Single user	Shell command	Manual
SSE	Local/Remote	Deploy as server	Multiple users	URL to SSE endpoint	OAuth
Streamable HTTP	Local/Remote	Deploy as server	Multiple users	URL to HTTP endpoint	OAuth

When to Use Each Transport

stdio (Standard I/O) is the most common choice for individual developers. Cursor launches the server process itself and communicates through stdin/stdout. It's the simplest to set up — you just point Cursor to a command, and it handles the rest. Use stdio when:

• You're a solo developer working on your own machine
• The MCP server needs access to local files or tools
• You want zero deployment overhead
• You're using community MCP packages via npx or pip

SSE (Server-Sent Events) is ideal for remote or shared servers. You deploy the MCP server somewhere (a cloud server, a container, your company's infrastructure), and Cursor connects to it via a URL. Use SSE when:

• Multiple team members need the same MCP server
• The server needs to run persistently (not just when Cursor is open)
• You're connecting to a hosted MCP service
• You need OAuth-based authentication

Streamable HTTP is the newest transport method and works similarly to SSE, but uses standard HTTP streaming instead of the SSE protocol. It's becoming the preferred method for new remote deployments. Use Streamable HTTP when:

• You're building a new remote MCP server from scratch
• You want better compatibility with standard HTTP infrastructure (load balancers, proxies)
• You need OAuth authentication
• Your infrastructure doesn't support SSE well

---

Step-by-Step: Setting Up stdio MCP Servers

The stdio transport is the fastest way to get an MCP server running in Cursor. Cursor manages the server process — starting it when needed and communicating through standard input/output. Let's walk through both Node.js and Python setups.

Understanding the Config File

Before we start, let's understand what goes into an MCP configuration. For stdio servers, you'll need these fields:

Field	Required	Description
type	Yes	Server connection type — set to "stdio"
command	Yes	Command to start the server (e.g., npx, node, python, docker)
args	No	Array of arguments passed to the command
env	No	Environment variables for the server process
envFile	No	Path to a .env file (stdio only, not available for remote servers)

Example 1: Node.js MCP Server via npx

This is the most common pattern. Many community MCP servers are published as npm packages that you can run directly with npx.

Step 1: Create the config file. In your project root, create a .cursor folder with an mcp.json file:

mkdir -p .cursor
touch .cursor/mcp.json

Step 2: Add your server configuration. Open .cursor/mcp.json and add:

{
  "mcpServers": {
    "server-name": {
      "command": "npx",
      "args": ["-y", "mcp-server"],
      "env": {
        "API_KEY": "your-api-key-here"
      }
    }
  }
}

Let's break down what's happening:

• "server-name" — A unique identifier for this server. Pick something descriptive like "github", "database", or "search".
• "command": "npx" — Tells Cursor to use npx to run the package.
• "args": ["-y", "mcp-server"] — The -y flag auto-confirms the npx install prompt. Replace "mcp-server" with the actual package name.
• "env" — Any environment variables the server needs (API keys, config values, etc.).

Step 3: Restart Cursor (or reload the window). Cursor reads the config on startup and launches the server process automatically.

Step 4: Verify it's working. Open the Cursor chat (Agent mode) and look for the server's tools listed under "Available Tools." If they appear, your MCP server is live.

Example 2: Python MCP Server

If you're building your own MCP server in Python, or using a Python-based community server, the setup is similar:

Step 1: Create or identify your Python MCP server script. Let's say it's called mcp-server.py in your project.

Step 2: Configure it in .cursor/mcp.json:

{
  "mcpServers": {
    "server-name": {
      "command": "python",
      "args": ["mcp-server.py"],
      "env": {
        "API_KEY": "your-api-key-here"
      }
    }
  }
}

Step 3: If your Python server has dependencies, make sure they're installed in the Python environment that Cursor will use. You may want to use a full path to your virtual environment's Python:

{
  "mcpServers": {
    "my-python-server": {
      "command": "${workspaceFolder}/.venv/bin/python",
      "args": ["${workspaceFolder}/mcp-server.py"],
      "env": {
        "API_KEY": "your-api-key-here"
      }
    }
  }
}

Notice the use of ${workspaceFolder} — we'll cover config interpolation variables in detail later in this guide.

Step 4: Restart Cursor and verify the tools appear in chat.

Running Multiple stdio Servers

You can configure as many MCP servers as you need. Just add them as separate entries in the mcpServers object:

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_TOKEN": "ghp_your_token_here"
      }
    },
    "database": {
      "command": "python",
      "args": ["db-mcp-server.py"],
      "env": {
        "DATABASE_URL": "postgresql://localhost:5432/mydb"
      }
    },
    "search": {
      "command": "npx",
      "args": ["-y", "mcp-server-brave-search"],
      "env": {
        "BRAVE_API_KEY": "your-brave-key"
      }
    }
  }
}

Each server runs as its own process, managed independently by Cursor. You can toggle individual servers on and off from the chat interface.

---

Step-by-Step: Setting Up Remote MCP Servers (HTTP/SSE)

Remote MCP servers are perfect for team environments, hosted services, or any scenario where the server shouldn't run on your local machine. The configuration is actually simpler than stdio — you just need a URL.

Remote Server Configuration

For both SSE and Streamable HTTP servers, the config uses a url field instead of command:

{
  "mcpServers": {
    "server-name": {
      "url": "http://localhost:3000/mcp",
      "headers": {
        "API_KEY": "your-api-key-here"
      }
    }
  }
}

Here's what each field does:

• "url" — The endpoint URL of the MCP server. This can be localhost for local testing or a remote URL like https://mcp.yourcompany.com/endpoint.
• "headers" — Custom HTTP headers sent with every request. Useful for API keys, bearer tokens, or other authentication headers.

Setting Up a Local SSE/HTTP Server for Testing

Step 1: Start your MCP server. If you have an MCP server that exposes an HTTP or SSE endpoint, start it:

# Example: starting a Node.js MCP HTTP server
node my-mcp-server.js
# Server running at http://localhost:3000/mcp

Step 2: Add it to your .cursor/mcp.json:

{
  "mcpServers": {
    "my-remote-server": {
      "url": "http://localhost:3000/mcp"
    }
  }
}

Step 3: Restart Cursor and check for the server's tools in Agent chat.

Connecting to a Cloud-Hosted MCP Server

For production or team-shared servers, point the URL to your deployed server:

{
  "mcpServers": {
    "team-tools": {
      "url": "https://mcp.yourcompany.com/tools",
      "headers": {
        "Authorization": "Bearer your-team-token"
      }
    }
  }
}

The server handles authentication via the headers you provide. For more advanced OAuth flows, see the OAuth section below.

SSE vs. Streamable HTTP: Which Should You Choose?

Both work well, but here are some practical considerations:

• SSE — Well-established protocol. Works great for most deployments. Some older proxy servers and load balancers handle SSE connections without issues since they're essentially long-lived HTTP responses.
• Streamable HTTP — The newer standard. Better suited for serverless environments and modern HTTP infrastructure. Uses standard request/response patterns with streaming, so it works naturally with load balancers, CDNs, and API gateways.

If you're building a new remote MCP server from scratch, Streamable HTTP is the recommended choice. If you're connecting to an existing server, use whatever transport it supports.

---

Configuration Locations: Project vs. Global

Cursor reads MCP configuration from two locations, and understanding the difference is important for managing your setup effectively.

Config Location	Path	Scope	Best For
Project config	.cursor/mcp.json	Current project only	Project-specific tools, shared team config (committed to repo)
Global config	~/.cursor/mcp.json	All projects	Personal tools you want everywhere (search, general utilities)

Project-Level Configuration

The project config lives at .cursor/mcp.json in your project root. This is the ideal location for:

• Team-shared servers — Commit the file to version control so everyone on the team gets the same MCP servers.
• Project-specific tools — A database server that only makes sense for this particular project.
• Reproducible setups — New team members clone the repo and immediately have the right MCP servers configured.

Pro tip: If you commit .cursor/mcp.json to your repo, use config interpolation (covered next) for sensitive values like API keys. Never hardcode secrets in version-controlled files.

Global Configuration

The global config lives at ~/.cursor/mcp.json in your home directory. Servers configured here are available in every project you open. Use it for:

• Personal productivity tools — Web search, note-taking, general-purpose utilities.
• Frequently used services — GitHub, Jira, or other tools you use across all projects.
• Custom servers you've built for your own workflow.

How Cursor Merges Configs

When you open a project, Cursor loads both config files. If a server with the same name exists in both project and global configs, the project config takes precedence. This lets you override global defaults on a per-project basis.

---

Config Interpolation: Environment Variables and Workspace Paths

Hardcoding API keys and file paths in your MCP config is a bad idea — especially if you share the config with your team. Cursor supports config interpolation variables that let you reference dynamic values.

Available Interpolation Variables

Variable	Resolves To	Example Use
${env:NAME}	Environment variable value	${env:GITHUB_TOKEN}
${userHome}	Path to home folder	${userHome}/.config/keys.json
${workspaceFolder}	Project root directory	${workspaceFolder}/scripts/server.py
${workspaceFolderBasename}	Project root folder name	Used for dynamic naming
${pathSeparator} or ${/}	OS path separator	/ on Mac/Linux, \ on Windows

Practical Example: Secure API Key Management

Instead of hardcoding your API key in the config file, reference an environment variable:

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_TOKEN": "${env:GITHUB_TOKEN}"
      }
    }
  }
}

Now set the environment variable in your shell profile (~/.bashrc, ~/.zshrc, etc.):

export GITHUB_TOKEN="ghp_your_actual_token_here"

This approach means you can safely commit .cursor/mcp.json to version control without exposing secrets.

Using envFile for Local Development

For stdio servers, you can also use the envFile field to load environment variables from a .env file:

{
  "mcpServers": {
    "my-server": {
      "command": "node",
      "args": ["server.js"],
      "envFile": "${workspaceFolder}/.env"
    }
  }
}

Make sure your .env file is in .gitignore so it doesn't get committed. Note that envFile is only available for stdio servers — remote servers don't support it.

Cross-Platform Paths with ${workspaceFolder}

If your team uses both Mac and Windows, use interpolation variables to keep paths portable:

{
  "mcpServers": {
    "custom-tools": {
      "command": "python",
      "args": ["${workspaceFolder}${/}tools${/}mcp_server.py"]
    }
  }
}

The ${/} resolves to / on Mac/Linux and \ on Windows, ensuring the path works on any OS.

---

OAuth and Authentication

For remote MCP servers that require secure authentication, Cursor supports OAuth flows. This is especially useful for enterprise environments and third-party MCP services.

Static OAuth Configuration

You can configure OAuth credentials directly in your MCP server config. Cursor supports static OAuth with the following parameters:

• CLIENT_ID — Your OAuth application's client ID
• CLIENT_SECRET — Your OAuth application's client secret
• scopes — The OAuth scopes your server needs

The OAuth callback URL for Cursor is:

cursor://anysphere.cursor-mcp/oauth/callback

When configuring your OAuth application (in GitHub, Google, or any provider), add this as an authorized redirect URI.

One-Click Installation from MCP Directory

Many MCP servers now support one-click installation from the MCP directory. When you find a server that supports this, clicking the install button will automatically configure the OAuth flow and add the server to your Cursor setup — no manual config editing required.

This is the easiest way to add remote, authenticated MCP servers, especially for popular services like GitHub, Linear, Notion, and others.

Extension API for Programmatic Registration

For enterprise or automated setups, Cursor exposes an Extension API for MCP server registration:

vscode.cursor.mcp.registerServer()

This API lets VS Code extensions (and Cursor extensions) register MCP servers programmatically. It's useful when:

• Your organization distributes a custom Cursor extension that auto-configures MCP servers
• You want to dynamically register servers based on project context
• You're building an onboarding tool that sets up a developer's environment automatically

---

Using MCP Tools in Cursor Chat

Once your MCP servers are configured and running, here's how to actually use them in your daily workflow.

How Cursor Discovers MCP Tools

When you open the Cursor Agent chat, all configured MCP servers are loaded automatically. The tools they expose appear under "Available Tools" in the chat interface. The agent knows about these tools and will use them when relevant to your request.

For example, if you have a GitHub MCP server configured and ask the agent to "check the latest PRs on our repo," it will automatically use the GitHub server's tools to fetch that information.

MCP in Plan Mode

MCP tools work in Plan Mode too — not just in Agent mode. This means you can use the planning step to outline what tools to use, then execute the plan with MCP tool calls. It's a powerful combination for complex, multi-step tasks.

Toggling Tools On and Off

You don't always want every MCP tool available. Maybe you have 10 servers configured but only need 2 for your current task. Cursor lets you toggle individual tools on and off from the chat interface.

This is useful for:

• Reducing noise — Fewer available tools means the AI makes better decisions about which to use.
• Security — Disable tools you don't need to minimize surface area.
• Performance — Fewer active servers means less overhead.

Tool Approval and Auto-Run

By default, Cursor requires your approval before executing any MCP tool. When the agent wants to use a tool, you'll see a prompt asking you to confirm the action. This is a safety feature — it prevents the AI from making unintended API calls, database modifications, or other side effects.

If you trust a particular MCP server and want to skip the approval step, you can enable auto-run. With auto-run, the agent executes tool calls without asking for confirmation. Use this cautiously and only for servers you fully trust.

Image Responses

MCP servers can return images as base64-encoded data. This is useful for tools that generate charts, screenshots, diagrams, or other visual content. Cursor renders these images directly in the chat, making it easy to review visual output without leaving the IDE.

---

Security Best Practices

MCP servers are powerful, but power comes with responsibility. These servers can access APIs, databases, file systems, and more — so it's essential to configure them securely.

1. Verify the Source

Only install MCP servers from trusted developers and organizations. Before adding any community MCP server:

• Check the GitHub repository for the server's source code
• Look for a credible maintainer (established developer, known organization)
• Check for recent activity — abandoned repos may have unpatched vulnerabilities
• Read the README and documentation to understand what the server does

2. Review Permissions

Before connecting any MCP server, understand exactly what data and APIs it can access. Ask yourself:

• What APIs does this server call?
• What data does it read or write?
• Does it need access to my file system?
• Does it send data to any external service?

3. Limit API Keys

When providing API keys to MCP servers, follow the principle of least privilege:

• Create dedicated API keys for MCP servers — don't reuse your personal or admin keys.
• Use read-only access where possible. If the server only needs to read data, don't give it write permissions.
• Set scope restrictions to limit what the API key can access.
• Rotate keys regularly and revoke them when no longer needed.

4. Audit Code for Critical Integrations

For MCP servers that access sensitive systems (production databases, payment APIs, infrastructure), review the source code before installing. Even if it's from a trusted source, verify that:

• No data is logged or sent to unexpected endpoints
• Input validation is properly implemented
• Error handling doesn't expose sensitive information

5. Use Environment Variables for Secrets

Never hardcode API keys, tokens, or passwords in mcp.json. Always use config interpolation (${env:SECRET_NAME}) or envFile references. This is especially critical for project-level configs that get committed to version control.

6. Keep Tool Approval Enabled

Unless you have a specific, well-justified reason, keep tool approval enabled (don't use auto-run). The extra confirmation step takes a second but can prevent expensive mistakes — like accidentally deleting a database or deploying to production.

---

Common Troubleshooting Tips

Even with the right configuration, things can go wrong. Here are the most common issues and how to fix them.

Problem: Server Doesn't Appear in Available Tools

Causes and fixes:

• Config file not in the right location. Make sure it's at .cursor/mcp.json (project) or ~/.cursor/mcp.json (global). Not .vscode/mcp.json, not mcp.json in the root.
• Invalid JSON. A single misplaced comma or missing bracket will break the entire config. Use a JSON validator or let Cursor highlight the syntax error.
• Cursor hasn't reloaded. After changing the config, restart Cursor or reload the window (Cmd/Ctrl + Shift + P → "Reload Window").

Problem: Server Starts But Tools Don't Work

Causes and fixes:

• Missing dependencies. If using npx, make sure Node.js is installed and on your PATH. For Python servers, ensure the right Python version and packages are available.
• Wrong command path. If using a virtual environment, specify the full path to the Python binary: "${workspaceFolder}/.venv/bin/python".
• Server crashes on startup. Run the command manually in your terminal to see error output. For example: npx -y mcp-server — if it crashes, you'll see the error message.

Problem: Environment Variables Not Resolving

Causes and fixes:

• Variable not set in the right shell. Environment variables set in .bashrc may not be available if Cursor was launched from a different shell or a desktop shortcut. Set them in a location that's loaded by all shells, or use envFile.
• Wrong interpolation syntax. Make sure you're using ${env:VARIABLE_NAME} — not $VARIABLE_NAME or ${VARIABLE_NAME}.

Problem: Remote Server Connection Fails

Causes and fixes:

• Server not running. Verify the remote server is actually online and accepting connections.
• Firewall or network issues. Make sure your machine can reach the server URL. Try curl http://your-server-url/mcp from the terminal.
• Authentication headers wrong. Double-check your headers configuration. Some servers expect "Authorization": "Bearer token" while others use custom header names.
• CORS issues. If the remote server has CORS restrictions, ensure it allows connections from Cursor's origin.

Problem: OAuth Flow Fails

Causes and fixes:

• Wrong redirect URI. Make sure the OAuth application's redirect URI is set to cursor://anysphere.cursor-mcp/oauth/callback.
• Expired tokens. Try disconnecting and reconnecting the OAuth flow.
• Scope mismatch. Verify the requested scopes match what your OAuth application is configured to allow.

---

How Serenities AI Integrates with MCP

If you're already using Serenities AI as your AI development platform, you'll be glad to know it supports MCP natively. Serenities AI's architecture is built around the same open standards, meaning you can connect the same MCP servers you configure in Cursor to Serenities AI's workflows.

This is particularly useful if you're working across multiple tools. Rather than maintaining separate integrations for each AI assistant, MCP gives you a single, standardized way to connect your tools. Configure an MCP server once, and it works with Cursor, Serenities AI, and any other MCP-compatible client.

Serenities AI also offers built-in MCP server support for common development tasks — meaning you can expose your Serenities AI workspace as an MCP server that Cursor connects to. This creates a powerful two-way bridge between your AI tools.

If you're exploring MCP for the first time, starting with Cursor's straightforward configuration and then expanding to platforms like Serenities AI is a solid approach. The protocol is the same everywhere — learn it once, use it everywhere.

---

Frequently Asked Questions

Is MCP available on Cursor's free plan?

Yes. MCP support is available across all Cursor plans, including the free tier. You don't need a paid plan to configure and use MCP servers. Whether you're on Free, Pro ($20/mo), Ultra ($60/mo), or Enterprise ($200/mo), you have full access to MCP functionality.

Can I use MCP servers written in languages other than Node.js and Python?

Absolutely. You can write MCP servers in any language that can print to stdout (for stdio transport) or serve an HTTP endpoint (for SSE/HTTP transport). Go, Rust, Java, Ruby, C# — if it can handle JSON-RPC communication, it works with Cursor's MCP implementation. The examples in this guide use Node.js and Python because they're the most common, but the protocol is language-agnostic.

What's the difference between project-level and global MCP configuration?

Project-level config (.cursor/mcp.json) only applies to the current project and is ideal for team-shared or project-specific servers. Global config (~/.cursor/mcp.json) applies to every project you open in Cursor, making it perfect for personal productivity tools you always want available. If both configs define a server with the same name, the project config takes precedence.

Is it safe to commit .cursor/mcp.json to version control?

Yes, as long as you don't hardcode secrets in it. Use config interpolation variables like ${env:API_KEY} to reference environment variables instead of putting actual keys in the file. This way, the config structure is shared with your team, but each developer provides their own credentials via their local environment.

Can MCP servers return images or other non-text data?

Yes. MCP servers can return images as base64-encoded data, and Cursor will render them directly in the chat interface. This is useful for servers that generate charts, screenshots, architecture diagrams, or any visual content. The protocol supports structured data responses, so servers can return complex data types beyond plain text.

---

Conclusion

Setting up MCP servers in Cursor transforms your AI coding assistant from a smart autocomplete tool into a connected, context-aware development partner. With MCP, Cursor can query your databases, check your CI/CD pipelines, search documentation, manage tickets, and interact with virtually any external service.

Here's a quick recap of what we covered:

• MCP is an open protocol that connects AI assistants to external tools and data
• Three transport methods — stdio for local servers, SSE and Streamable HTTP for remote
• Configuration goes in .cursor/mcp.json (project) or ~/.cursor/mcp.json (global)
• Config interpolation keeps your secrets safe with ${env:NAME} variables
• OAuth support enables secure authentication for remote servers
• Tool approval gives you control over what the AI executes
• Security best practices protect you from malicious or misconfigured servers

The MCP ecosystem is growing fast, with new servers being published every day for popular services. Start with one server that solves a real problem in your workflow — a GitHub server, a database connector, or a search tool — and expand from there.

If you're looking for an AI platform that supports MCP alongside powerful coding capabilities, check out Serenities AI. It supports the same MCP standard, so your server configurations work seamlessly across tools.

Now go configure your first MCP server. Your AI assistant is about to get a whole lot more useful.