Why we open sourced our MCP server, and what it means for you

Imagine you’re coding in VS Code with Copilot agent mode. You ask it: “What’s the status of PR #72?” But instead of fetching the details from GitHub, the model hallucinates an answer based on outdated context or guessed semantics. It sounds convincing, but it’s just wrong. Models, after all, are only as good as the context given to them. If large language models (LLMs) don’t have the ability to connect to other apps and tools, they’re not as useful as they can be.

This is the core problem that Model Context Protocol (MCP) was built to solve.

MCP is an open protocol that standardizes how LLM apps connect to and work with your external tools and data sources. It is similar to the Language Server Protocol (LSP) in that both follow client-server architecture, they simplify interaction between systems, and they provide standardized communication patterns. In essence, MCP is the LSP of LLMs.

And now, GitHub has open-sourced its own MCP server. It acts as a source-of-truth interface between GitHub and any LLM, reducing hallucinations and unlocking new automation workflows.

We cover this (and more!) in our latest episode of the GitHub Podcast! Listen below 👇

Trying to catch up quickly on MCP?

We put together a guide on everything you need to know (but were too embarrassed to ask) about MCP. 

Get the guide >

MCP architecture

MCP is based on a client-server architecture where an MCP host  — an AI app like Copilot Chat — maintains a dedicated 1:1 connection with MCP servers. Some key concepts to understand:

• MCP host: an LLM app that wants to access data via MCP (eg. VS Code, Copilot Chat)
• MCP clients: maintain a 1:1 connection with MCP servers, inside the host app
• MCP servers: lightweight programs that expose specific capabilities through MCP 

GitHub’s MCP Server

The GitHub MCP Server connects AI tools directly to GitHub’s platform. Instead of performing REST or GraphQL API calls, you point your MCP-compatible client or agent to the server, and request exactly what you need. For example, you could ask it to:

• List all open issues in a repository
• Show pull requests waiting for review
• Fetch metadata about a repo or file
• Create or comment on issues

The magic is that you can now use natural language to make requests that are automagically converted into structured, semantically meaningful API calls. You’re no longer creating custom  API endpoints or parsing markdown descriptions. Ask for what you need in natural language to fetch real-time data from GitHub.

And because the server speaks MCP, it can work with any compatible host. Copilot Workspace, VS Code plugins, LLM-based products, custom chat UIs, and homegrown agents can all request context or trigger actions using the same standardized interface.

How it works

The architecture is conceptually simple, but powerful:

1. Server: GitHub’s MCP Server is a standalone service that listens for structured MCP requests.
2. Client: A connector between the host and server. It knows how to translate user intent into valid MCP requests.
3. Host: The AI front-end (like an IDE assistant or chat UI) that surfaces the conversation and sends structured prompts downstream.

When a user asks a question, the host translates the question into a semantic request, the client packages it as an MCP request, and the server fetches the real data from GitHub and returns it as structured JSON.

This creates a clean separation between the language model, the UX, and the data or tools it can access. Each layer is modular, testable, and swappable.

How to get started using the GitHub Remote MCP Server

The best part: You can start using GitHub’s MCP server today! Here’s what you need:

• MCP Host: VS Code or any other LLM application that supports MCP
• MCP Client: Copilot agent, LLM chat UI, or custom client that speaks MCP
• GitHub MCP Server: Available from the official GitHub MCP Server repo

To install the GitHub MCP Server in VS Code follow these steps:

1. Add the server configuration by copying this code snippet:

{
  "servers": {
    "github": {
      "type": "http",
      "url": "https://api.githubcopilot.com/mcp/"
    }
  }
}

{
  "servers": {
    "github": {
      "type": "http",
      "url": "https://api.githubcopilot.com/mcp/"
    }
  }
}

2. Create the configuration file:

• In your project root, create a directory named /vscode
• Inside that directory, create a file named mcp.json
• Paste the above code into the file

3. Complete setup:

• Click the start button that appears
• Complete the OAuth flow when prompted

You’re now ready to use the GitHub MCP server in VS Code!

Start automating with the GitHub MCP now

Watch this video where I installed the GitHub MCP Server and automagically created five issues with natural language!

Real-world use cases

Early adopters have used MCP servers to create useful tools.

• Markdown automation: One team used the MCP server to turn dozens of GitHub Issues into Markdown content files for a community microsite. The issues had been collected as part of a campaign. Previously, converting them into site-ready content required tedious and manual reformatting. With MCP, the team created a script that fetched all labeled issues, cleaned and formatted the text, and committed the files automatically. It turned the process into a quick, repeatable job.
• Weekly team digests: Another team built a lightweight bot that scans specific GitHub repos and compiles a weekly digest. It pulls recent pull requests, issues, and merged changes, and summarizes them in Markdown. The report is posted to Slack every Monday morning, keeping distributed teams aligned without needing a meeting. Because it uses MCP, the bot isn’t tied to hard-coded GitHub queries; the same code could run against any MCP-compliant server.
• Conversational project assistants: A small open source team built a chat-based interface where contributors could ask natural-language questions like “What issues are waiting on review?” or “What changed in the last release?” The agent uses MCP to translate those questions into structured GitHub queries, fetch real-time data, and return conversational summaries. 
• Personal LLM dashboards: One developer connected their own GitHub account to an MCP-aware agent running on a local dashboard. The assistant provides proactive prompts each morning: pull requests they need to review, stale issues in owned repos, and even draft release notes based on merged changes. It’s like a personalized Copilot that watches GitHub for them.

By providing real, structured context to AI models, MCP servers enable tools that are both smarter and safer.

Take this with you

Read our practical guide on how to use the MCP server for a detailed walkthrough. Want to dive deeper? See how to build a secure and scalable remote MCP server in this guide.

Catch the next episode of the GitHub Podcast by subscribing today >