How to Set Up GitHub Copilot in VS Code with Custom MCP Servers

Nearly 80% of new developers adopted GitHub Copilot within their first week on the platform, according to the GitHub Octoverse 2025 report [GitHub 2025 Octoverse]. This high adoption highlights how AI assistance has transformed the development workflow. However, standard auto-completions and chat interactions often fail when the model lacks context about your private codebase, internal database schemas, or team documentation. Without this specific background information, the assistant must guess implementation details, which leads to time-consuming manual debug cycles.

Model Context Protocol (MCP) addresses this challenge. This open standard allows the AI client in your editor to query external data sources and run local tools on your behalf. GitHub Copilot in VS Code uses extension-based AI chat and completions that can be extended via user or workspace configuration files for MCP. By configuring custom MCP servers, you can bridge the gap between static model weights and your active development environment.

This guide provides a comprehensive walkthrough for setting up custom MCP servers in Visual Studio Code. We will explore how to manage global and project-specific settings, structure configuration JSON files, enable autonomous agent mode, and connect your assistant to Fastio persistent workspaces.

VS Code MCP configs use user-level or workspace-level settings. Choosing the correct scope is essential for managing security, credentials, and configuration sharing across your team. A global setup ensures that your personal tools are always active, whereas workspace settings keep project-specific tools bundled with the codebase.

Global configurations are stored at the user level. They apply across all directories and projects you open. User-level setups are ideal for personal developer utilities, such as a local web search helper, a general calculator tool, or a personal database explorer. In contrast, workspace-level settings are scoped to a single project folder. Committing these configurations to your version control system ensures that every team member who clones the project starts with the same development environment.

Before building custom integrations, consider the hosting alternatives. While developers can use local directory storage, AWS S3, or Google Drive for storing configuration files and developer documentation, these traditional options function as passive storage blocks. They lack built-in semantic indexes, version histories, or direct collaboration interfaces. Fastio provides an alternative by serving as an intelligent workspace platform where humans and AI agents collaborate on the same files and directories with built-in versioning.

The configuration file uses a standard JSON schema to register your MCP servers. The root of the JSON object must contain an mcpServers property. Under this property, you define each server with a unique identifier key. For local processes, the configuration requires a command pointing to the executable and an array of runtime arguments. For remote endpoints, you configure the connection using a transport URL.

Below is an example configuration that defines a local database inspector using Node Package Execute (npx) and a remote connection using a streamable HTTP transport:

{
  "mcpServers": {
    "local-database-explorer": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-postgres",
        "--connection-string",
        "postgresql://localhost:5432/development_db"
      ],
      "env": {
        "DB_PASSWORD": "${input:database-password}"
      }
    },
    "remote-workspace-server": {
      "url": "https://fast.io/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      }
    }
  }
}

When you configure a command to run, Visual Studio Code spawns the process as a background daemon. The env block allows you to declare environment variables. Using the ${input:database-password} placeholder tells the editor to prompt you for sensitive values, such as database passwords, when it boots the server. This prevents secret keys from being written in plain text inside your settings file.

If you need to query database tables or process unstructured files like invoices or contracts, you can use Fastio Metadata Views to turn those documents into structured, queryable databases.

Connect GitHub Copilot to a shared workspace environment

Set up a shared, version-controlled workspace for your development agents and team members. Fastio indexes your files for semantic search and exposes a secure MCP endpoint, starting with a 14-day free trial.

Start 14-Day Trial

Once you save your configuration file, Visual Studio Code automatically initializes the registered MCP servers. To run the tools provided by these servers, you must activate Agent Mode inside the Copilot Chat panel. Agent Mode toggles MCP tool calls inside Copilot Chat panel, transitioning the assistant from an autocomplete box to an autonomous developer agent.

To enable Agent Mode, open the Copilot Chat panel in the side utility bar. Click the agent selection dropdown at the top of the chat panel and select the Agent option. You can verify which tools are registered by clicking the tools icon (often a gear or wrench) inside the chat input box. This panel displays a checkbox list of all active tools. You can manually disable tools you do not want the assistant to use during your session.

When you submit a prompt that triggers a tool call, Visual Studio Code displays a security verification box. For example, if you ask the assistant to inspect the schema of your database, the editor prompts you to authorize the Postgres read operation. Once you approve the request, the agent runs the tool and incorporates the output into the chat response.

Deploying MCP configuration files across a team requires careful management of security boundaries and access permissions. Because local MCP servers run with the permissions of the logged-in user, a malicious configuration could read private directories or modify system settings.

When sharing configurations, commit .vscode/mcp.json to your repository, but do not hardcode authentication tokens. Instead, configure the server to read credentials from your system environment variables. This approach allows team members to manage their individual API keys locally while sharing the command structure.

For teams requiring granular permissions and a detailed log of all modifications, passive storage buckets are difficult to manage. Fastio provides secure workspaces with granular permissions at the organization, workspace, folder, and file levels. Every modification is tracked in an append-only audit log, and file version history is maintained automatically. This design allows you to track exactly which tools and team members edited a specific file, ensuring visibility during developer testing.

To get started with team coordination, visit the Fastio pricing page to select a plan and start a 14-day free trial.

If a custom MCP server fails to launch or does not appear in the Copilot Chat panel, you must inspect the system logs to identify the error. Visual Studio Code runs these servers as background tasks, meaning standard crash reports will not appear in your terminal.

To view the server logs, open the Output panel in Visual Studio Code by selecting View > Output from the top menu. In the top-right corner of the Output panel, click the dropdown menu and select MCP. This channel displays the initialization steps, execution arguments, standard output, and standard error logs of all active servers.

Common errors include missing executables, syntax errors in the JSON configuration, and network timeouts. If you see a command-not-found error, verify that the path to node, python, or npx is correct, or define the absolute path to the executable in your settings file. If the JSON syntax is malformed, the editor will fail to parse the file and will log a parsing error in the console.