StackMCP
Blog
·7 min read

How to Set Up MCP Servers in Continue.dev: Complete Guide

Step-by-step guide to configuring MCP servers in Continue.dev. Learn the YAML config format, where the file lives, and how to troubleshoot common issues.

mcpcontinuesetupguide

Continue.dev is an open-source AI code assistant that runs inside VS Code and JetBrains IDEs. It supports the Model Context Protocol (MCP), which means you can connect it to external tools like databases, browsers, GitHub, and more. But there is a catch that trips up most developers: Continue uses YAML for its configuration, not JSON.

If you have been copying MCP server configs from documentation written for Cursor or Claude Desktop, those JSON snippets will not work in Continue without conversion. This guide covers the full setup process: where the config file lives, the YAML format, example server configurations, and what to do when things break.

How Continue's Config Differs from Other Clients

Most AI coding tools -- Cursor, Claude Desktop, Windsurf -- use JSON for their MCP server configuration. Continue uses YAML. The structure is conceptually similar, but the syntax is different enough that copy-pasting between clients does not work.

Here is a quick comparison. The same GitHub MCP server configured in JSON (for Cursor) versus YAML (for Continue):

Cursor (JSON):

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

Continue (YAML):

mcpServers:
  - name: github
    command: npx
    args:
      - "-y"
      - "@modelcontextprotocol/server-github"
    env:
      GITHUB_PERSONAL_ACCESS_TOKEN: ghp_your_token

Two key differences to notice. First, mcpServers in Continue is an array (denoted by the - prefix on each server entry), not an object with named keys. Second, YAML does not use braces, brackets, or quotes around most values. The server name moves from being an object key to being a name field on the array element.

Getting these structural differences wrong is the number one reason MCP servers fail to load in Continue.

Where the Config File Lives

Continue stores its configuration in a file called config.yaml. The location depends on your operating system:

macOS:

~/.continue/config.yaml

Linux:

~/.continue/config.yaml

Windows:

%USERPROFILE%\.continue\config.yaml

If you have been using Continue for a while, you likely already have this file with model configurations and other settings. The mcpServers section is added at the top level, alongside your existing configuration.

Unlike Cursor, Continue does not currently support project-level MCP configuration files. All MCP servers are configured globally and apply to every project you open. This means you should be thoughtful about which servers you enable -- running a project-specific database server globally can cause confusion when you switch between projects.

The Config Format in Detail

Here is a complete config.yaml snippet with the mcpServers section:

mcpServers:
  - name: github
    command: npx
    args:
      - "-y"
      - "@modelcontextprotocol/server-github"
    env:
      GITHUB_PERSONAL_ACCESS_TOKEN: ghp_your_token

Required Fields

name: A string identifier for the server. This appears in Continue's UI and logs. Pick something descriptive.

command: The executable that starts the MCP server process. Common values are npx for npm-based servers, uvx or python for Python-based servers, and node or docker for other setups.

args: A list of command-line arguments passed to the command. Each argument is a separate list item. For npm-based servers, you typically use -y (auto-confirm install) followed by the package name.

Optional Fields

env: A mapping of environment variables passed to the server process. This is where API keys and tokens go.

Example Server Configurations

Here are four common MCP servers configured in Continue's YAML format.

GitHub MCP

The GitHub MCP server gives your assistant access to repositories, pull requests, issues, and code search.

mcpServers:
  - name: github
    command: npx
    args:
      - "-y"
      - "@modelcontextprotocol/server-github"
    env:
      GITHUB_PERSONAL_ACCESS_TOKEN: ghp_your_token_here

You need a GitHub personal access token with repo scope. Generate one at github.com/settings/tokens.

Supabase MCP

The Supabase MCP server provides direct access to your database, migrations, edge functions, and project management.

mcpServers:
  - name: github
    command: npx
    args:
      - "-y"
      - "@modelcontextprotocol/server-github"
    env:
      GITHUB_PERSONAL_ACCESS_TOKEN: ghp_your_token_here
  - name: supabase
    command: npx
    args:
      - "-y"
      - "@supabase/mcp-server-supabase@latest"
    env:
      SUPABASE_ACCESS_TOKEN: sbp_your_token_here

Notice how multiple servers are added as separate items in the same mcpServers list. Each one starts with a - followed by its name field.

Playwright MCP

Playwright MCP gives your assistant control over a real browser for testing and verification.

mcpServers:
  - name: playwright
    command: npx
    args:
      - "-y"
      - "@playwright/mcp"

No API key needed. This server runs entirely locally.

Context7 MCP

Context7 MCP pulls live documentation into your conversation so the assistant uses current APIs instead of stale training data.

mcpServers:
  - name: context7
    command: npx
    args:
      - "-y"
      - "@upstash/context7-mcp@latest"

No API key needed. Two tools, minimal token cost.

Full Multi-Server Configuration

Here is what a complete mcpServers section looks like with all four servers:

mcpServers:
  - name: github
    command: npx
    args:
      - "-y"
      - "@modelcontextprotocol/server-github"
    env:
      GITHUB_PERSONAL_ACCESS_TOKEN: ghp_your_token_here
  - name: supabase
    command: npx
    args:
      - "-y"
      - "@supabase/mcp-server-supabase@latest"
    env:
      SUPABASE_ACCESS_TOKEN: sbp_your_token_here
  - name: playwright
    command: npx
    args:
      - "-y"
      - "@playwright/mcp"
  - name: context7
    command: npx
    args:
      - "-y"
      - "@upstash/context7-mcp@latest"

HTTP and SSE Transport Servers

Some MCP servers run remotely and communicate over HTTP rather than as local processes. Continue supports these using a different configuration format:

mcpServers:
  - name: remote-server
    url: "https://mcp.example.com/sse"

If the remote server requires authentication, you can pass headers:

mcpServers:
  - name: remote-server
    url: "https://mcp.example.com/sse"
    headers:
      Authorization: "Bearer your_api_key"

When using a remote server, you do not need command or args -- just the url field (and optionally headers). Continue will connect to the server over HTTP/SSE instead of spawning a local process.

Step-by-Step Setup

1. Locate or create the config file

Check if ~/.continue/config.yaml already exists. If it does, you will be adding to it. If not, create the directory and file:

mkdir -p ~/.continue
touch ~/.continue/config.yaml

2. Add the mcpServers section

Open config.yaml in any editor and add your server configuration. If the file already has content (model settings, etc.), add the mcpServers section at the top level -- it should not be nested inside any other section.

Start with a single server to verify the setup works:

mcpServers:
  - name: context7
    command: npx
    args:
      - "-y"
      - "@upstash/context7-mcp@latest"

3. Reload Continue

After saving the file, reload Continue to pick up the changes. In VS Code, use the command palette (Cmd+Shift+P on macOS, Ctrl+Shift+P on Windows/Linux) and search for "Continue: Reload." In JetBrains IDEs, restart the Continue plugin.

4. Verify the connection

Open Continue's sidebar and check that the server appears in the MCP tools section. You can also test by asking Continue to use one of the server's tools. For Context7, try: "Look up the React documentation for useEffect." If Continue calls the Context7 tool and returns documentation, everything is connected.

Troubleshooting Common Issues

YAML syntax errors

YAML is whitespace-sensitive. The most common mistakes:

  • Inconsistent indentation: use exactly 2 spaces per level. Do not mix tabs and spaces.
  • Missing space after colons: name:github will break. It must be name: github with a space after the colon.
  • Unquoted special characters: if a value contains characters like @, #, {, }, or starts with *, wrap it in double quotes.

A quick way to validate your YAML: paste it into an online YAML validator before saving.

"Server failed to start"

This means the command could not be executed. Common causes:

  • Node.js not installed: npx requires Node.js. Run node --version in your terminal to verify.
  • Package name typo: double-check the package name in args. A single character off and npx will fail to find it.
  • Network issues: npx downloads packages on first run. If you are behind a corporate proxy or firewall, the download might fail.

Test by running the command manually in your terminal:

npx -y @upstash/context7-mcp@latest

If this fails, fix the underlying issue before going back to Continue.

Environment variables not working

  • Variable names are case-sensitive. github_personal_access_token is not the same as GITHUB_PERSONAL_ACCESS_TOKEN.
  • Make sure the token value does not have trailing whitespace or newline characters.
  • In YAML, you generally do not need quotes around environment variable values unless they contain special characters. But when in doubt, wrap the value in double quotes.

Servers connect but tools do not appear

Some MCP servers require specific environment variables before they expose their tools. If a server starts successfully but no tools show up, check the server's documentation for required configuration.

Also verify that Continue's agent mode is enabled. MCP tools are only available when Continue is running in agent mode, not in basic chat mode.

Converting JSON configs to YAML

If you find a server configuration written in JSON (from Cursor or Claude Desktop docs), here is how to convert it:

  1. Replace { and } with indentation
  2. Remove quotes from keys
  3. Replace "command": "npx" with command: npx
  4. Convert "args": ["-y", "@package/name"] to a YAML list with - prefixed items
  5. Convert "env": { "KEY": "value" } to a nested mapping
  6. Add name: your-server-name since YAML uses named array entries instead of object keys

Or use an online JSON-to-YAML converter -- just remember to restructure from object format (mcpServers.servername) to array format (mcpServers[].name).

Managing Secrets

Since Continue uses a global config file, your API tokens live in ~/.continue/config.yaml. Keep these security considerations in mind:

  • Do not commit ~/.continue/config.yaml to any repository. It is a user-level config, not a project file.
  • If you share your config with teammates, replace real tokens with placeholder values first.
  • Rotate tokens periodically, especially GitHub personal access tokens.

Next Steps

Once your MCP servers are running in Continue, explore these options:

  • Start with one or two servers and add more as you identify workflow gaps. Context7 and GitHub are a solid starting pair for most developers.
  • Monitor token usage: each server's tool definitions consume tokens from the context window. If Continue's responses start getting truncated, you might have too many servers active.
  • Check for updates: MCP servers are actively developed. Using @latest in your package versions (where supported) ensures you get the newest features and fixes.

For pre-built server stacks tailored to specific workflows -- frontend development, fullstack web, indie hacking, and more -- visit stackmcp.dev. Select your stack and your client, and get a configuration you can paste directly into your config.yaml.

Related Stacks

Indie Hacker StackFrontend Developer StackFull-Stack Web Dev Stack

Related Servers

GitHub MCPSupabase MCPPlaywright MCP