Claude Code MCP for support conversations: read the ticket, ship the fix

Here is the loop most solo builders live in. A customer reports a bug in the chat widget. You read it in one tab, switch to your editor in another, dig through the repo, fix the thing, deploy, then switch back to copy-paste a reply. Half the effort is the context-switching, not the fix. Claude Code already lives in your terminal next to your code. The missing piece is letting it see the support conversation that started all of this.

That is exactly what the muro MCP server gives Claude Code. muro is customer-support live chat for people who run many projects, and it ships a hosted Model Context Protocol endpoint. Point Claude Code at it and the agent can list your open conversations, read the full thread, reply to the visitor, and triage the ticket, right alongside the code it is editing. The conversation goes in, the fix comes out, in a single session.

What Claude Code can actually do with the inbox

The muro MCP server exposes a tight set of tools, the same ones the REST API uses, so the agent gets a complete find, read, reply, close loop and nothing it does not need:

• →list_conversations to find open threads by status and full-text search, so the agent can pull up exactly the report it is working on.
• →get_conversation to read the whole thread with every message, so it has the full context, not a one-line summary.
• →send_reply to answer the visitor in the chat, or to drop an internal note for you.
• →update_conversation to triage: set status, add tags, assign the thread.
• →list_contacts and get_contact so it knows who it is talking to.

Tool access is governed by the API key scopes. A read key lets Claude Code look but not touch, which is the safe way to start. Add write when you want it to actually reply and resolve. The connection muro mints for you carries both, so the agent can close the loop end to end.

Add the muro MCP server to Claude Code

In your muro dashboard, open the AI Agent tab and create an MCP connection. muro mints a read and write API key (it looks like mr_live_… and is shown once, so copy it then) and hands you a ready-to-paste config. The fastest way to register it is the one-liner. Run this in your project directory and replace the token with your own:

bashclaude mcp add --transport http muro https://muro.chat/api/mcp \
  --header "Authorization: Bearer mr_live_…"

Prefer to keep it in the repo so the agent in that project always has it? Claude Code reads a .mcp.json from the project root. Drop this in, swapping in your own key, and commit it to share the connection with your team (or add it to .gitignore and keep the key local):

json{
  "mcpServers": {
    "muro": {
      "type": "http",
      "url": "https://muro.chat/api/mcp",
      "headers": {
        "Authorization": "Bearer mr_live_…"
      }
    }
  }
}

One key point for the multi-project crowd: drop a separate .mcp.json into each repo, each pointing at the right workspace. The agent in your billing app talks to your billing app's inbox, the agent in your side project talks to that one. Your code and your support sit in the same place, per project, which is the whole reason a flat price across unlimited projects makes sense for this workflow.

The loop: conversation in, fix out, one session

Once the server is connected, restart Claude Code so it picks up the tools, then just talk to it. A real session looks like this. You open Claude Code in the repo the customer is complaining about and type a prompt like: find the open conversation where a user says the export button does nothing, read it, then check our code for the bug.

1. 01Claude Code calls list_conversations with a search for the report and get_conversation to read the full thread, including the browser and page the visitor mentioned.
2. 02It greps your repo for the export handler, finds the broken event binding, and proposes a patch, all in the same terminal where it just read the ticket.
3. 03You review the diff, let it apply, run the tests, and ship. Standard Claude Code work, now informed by the actual customer report.
4. 04It calls send_reply to tell the visitor the fix is live, and update_conversation to tag the thread bug-fixed and mark it resolved.

No tab switching, no copy-paste, no re-describing the bug to the agent because it read the source of truth itself. The same MCP loop works for the boring half of support too: ask it to triage every open thread, tag the billing questions, and draft replies for the easy ones for you to approve. You stay in the terminal you were already in.

Pair it with BYOK so the AI is on your own Anthropic key

There are two AI bills hiding in this setup, and it is worth separating them. Claude Code itself runs on your Anthropic account, so the reasoning, code edits, and tool calls in your terminal are already on your own key, with no muro markup on top. That is the point of doing this work in the editor instead of a metered support bot.

The other half is the AI that answers customers in the widget when you are asleep. muro lets you bring your own LLM key there too. With BYOK you paste your Anthropic key and the in-widget agent runs unlimited at zero markup, with no per-resolution fee. Prefer not to manage a key? Managed AI runs on a monthly credit pool instead, so a busy month is a known number, not a surprise. Either way you are not paying a toll every single time the bot answers a question, which is the trap most AI support pricing falls into.

First, get the widget on the site

None of this works without conversations to read, and those come from the chat widget. It is a tiny script, one line per site, and it is the same install whether you run one project or twenty. Drop this before the closing body tag and replace YOUR_WIDGET_ID with the id from your muro dashboard:

html<script>
  (function(w,d,s,o){
    w.MuroChat=o;w[o]=w[o]||function(){(w[o].q=w[o].q||[]).push(arguments)};
    var j=d.createElement(s);j.async=1;j.src='https://muro.chat/widget.js';
    d.getElementsByTagName('head')[0].appendChild(j);
  })(window,document,'script','muro');
  muro('init',{widgetId:'YOUR_WIDGET_ID'});
</script>

Now real questions land in muro, the MCP server makes them visible to Claude Code, and your terminal becomes the place where a support report turns into a shipped fix. See it working in the live demo, or start free on the 14-day trial with no card and connect your own repo today.

MCP and the API are on every plan, not locked behind an enterprise tier. The whole idea is that one person, or one small team, can run support across many projects from the same place they write the code. Claude Code reading your support conversations is how that stops being a slogan and starts being a Tuesday.