Integrations10 min read

MCP Integration Guide: Continue.dev — Add MCP Tools to Your AI Coding Assistant

Complete guide to connecting MCP servers with Continue.dev, the open-source AI coding assistant. Configure MCP tools in Continue, use context providers, and build a custom AI coding workflow with your own tool ecosystem.

By MyMCPTools Team·

Continue.dev is an open-source AI coding assistant that runs inside VS Code and JetBrains IDEs. Unlike Copilot or Cursor, Continue gives you complete control over which models and tools your coding AI uses — including MCP servers. Connecting MCP servers to Continue lets your coding assistant query databases, read documentation, check GitHub issues, and run shell commands directly from your editor.

What Continue.dev's MCP Support Enables

Continue.dev added native MCP support as a first-class feature. MCP servers appear as context providers and tools in Continue's interface, which means you can:

  • Use @mcp-tool mentions to pull context from any MCP server into your chat
  • Let the AI call MCP tools autonomously during agentic coding sessions
  • Mix MCP-sourced context with file context (@file), codebase search (@codebase), and docs (@docs)

Step 1: Install Continue.dev

Install the Continue extension from the VS Code Marketplace or JetBrains Plugin Marketplace. The extension creates a ~/.continue/config.json file where all configuration lives.

Step 2: Configure MCP Servers in Continue

Open ~/.continue/config.json and add an mcpServers section:

{
  "models": [...],
  "mcpServers": [
    {
      "name": "GitHub",
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_your_token_here"
      }
    },
    {
      "name": "Postgres",
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres", "postgresql://localhost/mydb"]
    },
    {
      "name": "Filesystem",
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/Users/you/projects"
      ]
    },
    {
      "name": "Fetch",
      "command": "uvx",
      "args": ["mcp-server-fetch"]
    }
  ]
}

After saving, Continue automatically starts each MCP server as a subprocess. Tools from all configured servers are available in the chat interface.

Step 3: Use MCP Tools in Chat

Continue exposes MCP tools in two ways:

As context providers (@mentions): Type @ in the chat to see available context providers. MCP servers that expose resource-type tools appear here. For example, with the GitHub MCP server, you might see @GitHub Issues or @GitHub PR.

As tools (autonomous use): In agent mode, Continue's AI can call MCP tools automatically. When you ask "Fix the bug mentioned in GitHub issue #234," Continue can fetch the issue via the GitHub MCP server, read the relevant code, apply a fix, and run tests — all without leaving your editor.

Step 4: Configure Per-Project MCP Servers

For project-specific MCP servers (like a database or API specific to one project), use a local Continue config that extends your global one. Create .continue/config.json in your project root:

{
  "mcpServers": [
    {
      "name": "Project DB",
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-postgres",
        "postgresql://localhost/project_db"
      ]
    },
    {
      "name": "Project Docs",
      "command": "node",
      "args": ["./scripts/mcp-docs-server.js"]
    }
  ]
}

Continue merges the project config with your global config, so project-specific servers are available only when you're working in that directory.

Step 5: Build a Coding Workflow with MCP Context

Here's a practical workflow combining multiple MCP servers for a full-stack feature:

  1. Fetch requirements from GitHub — ask Continue to read the issue and linked PR comments via the GitHub MCP server
  2. Query the schema — "Show me the current users table structure" pulls from the Postgres MCP server
  3. Generate the migration — Continue writes the SQL migration based on the issue requirements and current schema
  4. Apply and verify — use a shell MCP server to run psql and verify the migration applied correctly
  5. Write the endpoint — Continue generates the API handler with full context of the schema change

Using HTTP-Based MCP Servers

For MCP servers running remotely (team-shared servers, cloud-deployed instances), Continue supports SSE transport:

{
  "mcpServers": [
    {
      "name": "Team Knowledge Base",
      "url": "https://mcp.yourteam.com/sse",
      "headers": {
        "Authorization": "Bearer your-token"
      }
    }
  ]
}

This is particularly useful for sharing a single MCP server instance (like an internal documentation server or a company-wide database proxy) across your entire engineering team.

Recommended MCP Servers for Coding Workflows

  • GitHub MCP server — issue context, PR reviews, code search
  • Filesystem MCP server — read/write project files outside the current editor view
  • Postgres/SQLite MCP server — live schema context for SQL generation
  • Fetch MCP server — pull documentation, API specs, or Stack Overflow answers
  • Git MCP server — commit history, diff context, branch information
  • Shell/Exec MCP server — run tests, linters, and build commands inline

Troubleshooting

Server not starting: Check Continue's output panel (View → Output → Continue) for MCP server startup errors. Common cause: missing environment variables or incorrect path to the MCP server binary.

Tools not appearing: MCP servers must be running and healthy for their tools to appear. Restart Continue after adding new servers. Check that npx or uvx can reach the package registry from your environment.

Rate limits: MCP servers calling external APIs can hit rate limits during intensive coding sessions. Add caching at the MCP server level or configure rate limits in the server's environment variables.

Explore the MCP server directory for tools to add to your Continue.dev setup, and check our Cursor MCP integration guide and VS Code MCP guide for comparison.

Recommended Tools

Better Stack

Free Plan

Get alerted when your APIs, browser tests, payment pipelines, or MCP server dependencies go down. Used by 100K+ developers.

Start monitoring free →

1Password

14-day Free Trial

Store and inject API keys, payment credentials, tokens, and file access secrets into your MCP server configs. Trusted by 150K+ developers.

Try 1Password free →

🔧 MCP Servers Mentioned in This Article

💻

GitHub MCP Server

The GitHub MCP server is GitHub's official Model Context Protocol integration, giving AI assistants like Claude and Cursor direct, authenticated access to the GitHub platform and its full developer surface. With this MCP server, you can ask your AI to read and write repository files, create and merge branches, open and review pull requests, comment on and close issues, trigger GitHub Actions workflows, search across code repositories with GitHub's code search, and inspect commit history — all through natural-language prompts in your AI interface. Developers use it to supercharge code review workflows, automate issue triage, generate PR descriptions from diffs, bulk-update repository settings, and wire AI agents into CI/CD pipelines. The GitHub MCP server connects via a GITHUB_PERSONAL_ACCESS_TOKEN environment variable with scopes for the operations you need, keeping authentication clean and auditable. Install with Docker: `docker run -e GITHUB_PERSONAL_ACCESS_TOKEN=<token> ghcr.io/github/github-mcp-server` — or configure it as a remote MCP server in Claude Desktop, Cursor, VS Code, Windsurf, and Cline. With over 8,000 GitHub stars, it is the most widely deployed official code-platform MCP server and the reference implementation for AI-native GitHub automation.

Auth required
🌐

Fetch

Web content fetching and conversion for efficient LLM usage. Extract readable content from any URL.

Local
📁

Filesystem

Secure file operations with configurable access controls. Read, write, and manage files safely.

Local
🔧

Docker MCP Server

The Docker MCP server connects your AI assistant directly to your local or remote Docker daemon, exposing container lifecycle management and image orchestration as Model Context Protocol tools. With this integration, developers can prompt Claude, Cursor, or Windsurf to inspect running containers, view real-time logs, build new images from Dockerfiles, start and stop services using Docker Compose, and prune unused system resources through natural language. Rather than switching to a terminal to type complex docker inspect commands, you can simply ask your AI to "find out why the postgres container keeps crashing" or "tail the last 100 lines of the frontend container logs and find the React error". This is a game-changer for DevOps engineers, backend developers, and system administrators who want to streamline container debugging, automate compose cluster orchestration, and troubleshoot networking issues faster. The server interacts securely with the Docker Engine API, meaning it can both read system state and execute commands like port binding or volume inspection. It works cross-platform wherever Docker Desktop or the Docker daemon is running. Docker's official implementation ships as the Docker MCP Gateway (docker/mcp-gateway), a `docker mcp` CLI plugin that acts as a single secure gateway in front of many containerized MCP servers from the Docker MCP Catalog — each downstream server runs in its own isolated container with resource limits and secret injection, so an assistant connects once to the gateway instead of wiring up dozens of individual servers. Start it with `docker mcp gateway run`, then point Claude Desktop, Cursor, or another client at the gateway; `docker mcp server enable <name>` toggles which catalog servers (including the Docker/container-management tools) are exposed. This container-per-server isolation is the key security benefit over running MCP servers directly on the host.

Local

📚 More from the Blog