The crew can frame a house, but the wiring needs a licensed electrician. You don't retrain your framers — you bring in a subcontractor. They arrive with their own gear, you point them at the panel, and the site can suddenly do something it couldn't before. Job done, they pack up and leave; the site itself didn't change.
That's an MCP server. The agent has its built-in tools (2.1/2.2), but a task might need a capability it lacks — talk to Jira, drive a browser, query a database. Instead of rebuilding the agent, you plug in a specialist that exposes those extra tools. Some are on-site (a local process); some you phone (remote). And one specialist is already on the payroll: the GitHub MCP server.
The idea, in plain English
MCP (Model Context Protocol) is an open standard — a shared language — for letting an application give an LLM extra context and tools. (Open standard = a public spec anyone can implement, so the same server works across different AI clients.)
An MCP server is a program that exposes a set of tools to the agent. Add one and its tools join the agent's toolbox (still subject to the tools allow-listing from 2.2). The agent is the client/host; the server is the specialist it calls.
Add an MCP server as a tool, and configure the GitHub remote MCP server — both official GH-600 objectives.
Adding an MCP server (the mechanics)
Two ways:
- Interactive: type
/mcp addin the Copilot CLI — a form opens (Tab between fields),Ctrl+Ssaves. Live immediately — no restart. - Edit the config file directly:
~/.copilot/mcp-config.json.
Fields → JSON keys:
| Field | JSON key | Meaning |
|---|---|---|
| Server Name | (object key) | a unique id you pick |
| Server type | type | local (= STDIO) or http |
| Command (+ args) | command, args | for local/STDIO: the process to launch (e.g. npx @playwright/mcp@latest) |
| URL | url | for HTTP/SSE: the remote endpoint |
| Env | env | environment variables for the server |
| Headers | headers | HTTP headers (e.g. an API key) for a remote server |
| Tools | tools | which of the server's tools to expose — ["*"] = all |
The three transport types (a likely exam beat):
| Transport | What it is | Key fields |
|---|---|---|
| Local / STDIO | launches a local process, talks over stdin/stdout (STDIO = canonical name) | command, args |
| HTTP | Streamable HTTP to a remote server | url (+ headers) |
| SSE | legacy HTTP + Server-Sent Events — deprecated, still works | url |
When to use which: local/STDIO for a tool you run yourself (browser driver, local bridge); HTTP for a hosted remote service. Prefer HTTP over SSE for new servers (SSE is deprecated). Manage servers with /mcp subcommands: list, show, edit, remove, disable (session-scoped), enable. Copilot auto-selects MCP tools; force one by naming server/tool in the prompt.
The GitHub remote MCP server (know this cold)
The GitHub MCP server exposes GitHub itself — repos, issues, PRs — to AI clients. It is pre-installed in Copilot CLI (no setup). Key facts:
- Remote is recommended over local for most users. Remote URL:
https://api.githubcopilot.com/mcp/(HTTP). - Defaults (verified): all tools read-only by default, token scoped to the source repository. Reference tools as
github/<tool>orgithub/*. - Enterprise nuance: GitHub Enterprise Server = local only; GitHub Enterprise Cloud with data residency = both.
Worked example — a local + a remote server
// ~/.copilot/mcp-config.json
{
"mcpServers": {
"playwright": { // a LOCAL/STDIO specialist…
"type": "local",
"command": "npx",
"args": ["@playwright/mcp@latest"], // launched as a subprocess
"tools": ["*"]
},
"my-api": { // a REMOTE HTTP specialist…
"type": "http",
"url": "https://mcp.example.com/", // phoned, not launched
"headers": { "Authorization": "Bearer ..." }
}
}
}local/STDIO = command+args (you launch it); HTTP = url (you call it); the GitHub server = a remote HTTP server already provided at api.githubcopilot.com/mcp/. Type follows whether you launch or call.
- Config key is
mcp-serversin custom-agent YAML, butmcpServersin JSON — easy to mix up. - A URL inside
argsdoes not make it remote — with acommand+argsit's still a local process. - In the cloud agent, referenced secret names must start with
COPILOT_MCP_, and remote servers relying on OAuth aren't supported.
The cert-language version
MCP is an open standard for extending an agent with external tools and data. You add an MCP server via
/mcp addormcp-config.json, choosing a transport — STDIO/local (command+args), HTTP (url), or legacy SSE. The GitHub MCP server exposes repos/issues/PRs, is pre-installed, defaults to read-only, source-repo-scoped, and is recommended in its remote form athttps://api.githubcopilot.com/mcp/.Our summary · grounded in modelcontextprotocol.io + GitHub Docs (Copilot CLI MCP, GitHub MCP server, custom-agents config) + naim149 study gist · fetched 2026-05-30
Common confusions (read these or lose points)
- "MCP is a GitHub product." No — it's an open standard; the GitHub MCP server is one implementation.
- "You must install the GitHub MCP server." No — pre-installed in Copilot CLI; setup applies only to third-party servers.
- "A config with a URL is always remote." Not if there's a
command+args— that's a local process even with a URL in the args. (Study-guide trap.) - "SSE is the modern transport." No — SSE is legacy/deprecated; prefer HTTP.
- "The github MCP server can write to any repo." No — read-only by default, token scoped to the source repo.
Ticks this lesson done on the home roadmap. Saved in this browser.