Connect GitHub Copilot to your support inbox with MCP

You fix customer-reported bugs in VS Code. The reports themselves live in a support inbox in a browser tab, and the round trip between the two (read the complaint, find the code, ship the fix, go back and reply) costs more focus than most of the fixes do. Copilot Chat already edits your files and runs your tests in agent mode. It should be able to read the inbox too.

It can. GitHub Copilot in VS Code supports MCP (Model Context Protocol) servers in agent mode, and muro ships a hosted MCP server that exposes your support conversations and contacts as tools. This guide wires the two together: one API key, one small config file, and "what did customers hit this week?" becomes something you type into your editor instead of a reason to open five tabs.

What the setup actually does

MCP is a small protocol that lets an AI client call tools on a server. VS Code is the client here. muro's server lives at https://muro.chat/api/mcp and authenticates with a Bearer key. Once connected, Copilot's agent mode can:

• →List and search conversations, filtered by status, so "show me open conversations from this week" is a tool call, not a tab switch.
• →Read full message threads, including visitor messages, agent replies, and the AI auto-replies muro already sent.
• →Draft and send replies, so you can fix the bug and answer the customer without leaving the editor.
• →Triage the queue, closing, snoozing, tagging, or assigning conversations, and looking up the contact behind a thread.

The muro side of this is identical for every MCP client. The same URL and the same Bearer key work from Claude Desktop, Claude Code, Cursor, Windsurf, or a ChatGPT connector. Only the client-side config file changes shape. The muro-mcp repo collects ready-made configs for each client if you use more than one.

What you need

• →VS Code, reasonably current. MCP support in Copilot Chat rolled out during 2025, so anything recent is fine.
• →A GitHub Copilot subscription with Copilot Chat enabled.
• →Node.js 18 or newer if you use the mcp-remote bridge (option A below).
• →A muro workspace with a site set up. The 14-day trial needs no card and includes API and MCP access.

Step 1: create a scoped API key

In your muro dashboard, open the API keys section under workspace settings and create a new key. Two decisions to make:

• →Scope. muro keys can be scoped per site. If this VS Code workspace is the repo for one product, scope the key to that product's site. Copilot then physically cannot read another project's conversations, which matters a lot if you run an agency setup with one repo per client.
• →Permissions. Read-only is enough for triage and summaries. Add write access if you want Copilot to draft and send replies from the editor. Starting read-only for the first week is a reasonable way to build trust.

Copy the key (it looks like mr_live_...). You will paste it exactly once in the next step. The full key and scope reference lives in the API docs.

Step 2: add the server to VS Code

Copilot reads MCP servers from a config file. For a project-level setup, that file is .vscode/mcp.json in your repo. For a machine-wide setup, add the server to your user-level MCP configuration instead: the command palette has an "MCP: Add Server" command that scaffolds either location, and "MCP: Open User Configuration" jumps to the global file. There are two ways to declare muro.

Option A: via mcp-remote (stdio, works everywhere)

json{
  "servers": {
    "muro": {
      "type": "stdio",
      "command": "npx",
      "args": [
        "mcp-remote",
        "https://muro.chat/api/mcp",
        "--header",
        "Authorization: Bearer mr_live_YOUR_KEY"
      ]
    }
  }
}

mcp-remote is a tiny bridge process that speaks stdio to VS Code and HTTP to muro. It is the most portable option because the exact same command line works in every MCP client that can launch local servers.

Option B: native remote server (newer VS Code)

Recent VS Code versions can talk to remote MCP servers directly, with no bridge process:

json{
  "servers": {
    "muro": {
      "type": "http",
      "url": "https://muro.chat/api/mcp",
      "headers": {
        "Authorization": "Bearer mr_live_YOUR_KEY"
      }
    }
  }
}

The exact field names have shifted a little between VS Code releases (older builds used sse as the transport type, and the headers key has moved around), so if your version rejects the file, run "MCP: Add Server" and let VS Code scaffold the current shape. The muro side never changes: one URL, one Bearer header.

Step 3: turn it on in Copilot Chat

1. 01Open the Copilot Chat panel and switch the mode dropdown to agent. MCP tools only run in agent mode.
2. 02Click the tools icon in the chat input. You should see the muro tools (conversations, messages, contacts) listed alongside Copilot's built-ins. Enable them.
3. 03Ask something that forces a tool call: "List my open muro conversations."
4. 04Approve the tool call when VS Code asks. First runs are gated behind a confirmation, which you can relax to always-allow per tool once you trust it.

If the server does not show up, check the servers list (the command palette has "MCP: List Servers") and read its output log. The usual culprits are a typo in the Bearer header or an old Node version failing to run npx mcp-remote.

Prompts that pull their weight

• →"Summarize the ten most recent conversations and flag anything that sounds angry."
• →"Which open conversations mention webhooks? Read them and tell me if it is the same root cause."
• →"Pull the full thread where the visitor mentions a 500 error and list reproduction steps."
• →"Draft a reply to the CSV export conversation explaining the fix, and leave an internal note with the commit link."

The actual workflow: triage, fix, reply

Here is the loop this replaces the browser tab with. Monday morning, editor open, coffee happening:

1. 01Triage. "What did customers hit this week? Group by theme and give me counts." Copilot pulls the recent conversations and summarizes: four people confused by webhook signatures, two hit a CSV export bug, one wants a refund (muro's own AI will have already handed the refund one to a human rather than improvising).
2. 02Prioritize with code context. "Show me the CSV export conversations in full." Copilot reads the threads, and because it is sitting in your repo you can follow up with "find where we generate that CSV and check the encoding". Same chat, same context.
3. 03Fix. Agent mode edits the file and runs your tests. This part you already know.
4. 04Reply. "Draft a reply to both CSV conversations: fixed, deploying today, apologize for the trouble." Review the draft, tell it to send, done.

The point is not that any single step gets faster. It is that the whole loop happens in one place, with the customer's exact words and your actual code in the same context window. Copilot's summary of a bug report is grounded in what the user typed, not in your memory of skimming it three days ago.

Per-repo scoping is the underrated part

Because muro keys are scoped per site, and because .vscode/mcp.json is per workspace, each repo can carry exactly the inbox it should see:

• →One product per repo. Each repo's config points at that product's key. Ask "what are customers saying?" inside the acme-app repo and you get acme-app conversations, nothing else.
• →Agency setup. Client repos each get a key scoped to that client's site. Whoever works in the repo can triage that client's support without ever holding a workspace-wide key.
• →Side projects. Two products, two keys, two repos. Solo at $19/mo covers up to 2 projects with unlimited agents; Fleet at $59/mo lifts the project cap when the portfolio grows.

Honest gotchas

• →Agent mode only. In plain ask mode Copilot will happily hallucinate an answer about your inbox without calling anything. If a response looks suspiciously generic, check the mode dropdown first.
• →Tool budget. VS Code caps how many tools it hands the model in a single request (128 at the time of writing). If you run several MCP servers at once, use the tools picker to disable the ones you do not need for the session.
• →Approval fatigue. Every new tool asks for confirmation at first. Approve read tools broadly, keep the reply-sending tool behind a manual confirm. A wrong file edit is reversible; a wrong customer reply is not.
• →mcp-remote needs Node. If npx is not on the PATH that VS Code uses, option A fails quietly in the server log. Option B avoids the dependency entirely.
• →Drafts beat auto-send. Have Copilot draft replies and read them before they go out. Grounded is not the same as finished.

If you already run muro, this is a fifteen-minute upgrade: create a scoped key, drop a dozen lines of JSON into .vscode/mcp.json, switch Copilot Chat to agent mode. If you do not, create a site, paste the widget snippet into your product, and point the AI at your docs by importing a URL. The trial runs 14 days with no card. Then connect Copilot and let the support inbox come to you, in the editor, where the fixes were going to happen anyway.