Mushi Mushi
Mushi Mushi's MCP server lets a coding agent read bug reports, get fix-ready context, triage work, and update reports — all read-mostly with a few write actions.
Survey bugs:
get_recent_reportslists recent reports filtered by status, category, severity, or project;search_reportsfinds reports by meaning/keyword (pgvector similarity).Inspect a report:
get_report_detailreturns the full record — description, console/network logs, screenshot URL, classification, fix attempts, inventory action (includeRawfor every column).Build a fix:
get_fix_contextbundles a paste-ready fix prompt, root cause, repro steps, ontology tags, design tokens/recipe, schema and deploy context in one read-only call.Decide what's next:
triage_next_stepsranks blocked fixes, waiting reporters, in-flight PRs, and top bugs;use_mushiorients a new agent and recommends the first tool.File and move work:
file_reportcreates a hand-written bug/backlog item (rate-limited),transition_statusmoves a report through workflow states (with closed reasons and reporter messages).Talk to users:
reply_to_reporterposts a message that appears in the in-app widget with a notification badge.Health and docs:
diagnose_setupchecks SDK ingest and fix-dispatch readiness with a next action;search_mushi_docsandget_mushi_docsearch and read official Mushi documentation (no API key needed).Privacy guardrail: reporter identifiers (end-user id, token hash, session id, display name) are never returned, even with
includeRaw.
SDK for capturing errors and user reports from Angular applications.
Inbound adapter to forward Bugsnag alerts into Mushi.
Sandbox provider for running fix attempts in a sandbox environment.
Inbound adapter to forward Datadog alerts into Mushi.
Inbound adapter to forward Firebase alerts into Mushi.
Outbound integration to open draft pull requests with fixes.
Inbound adapter to forward Grafana Loki alerts into Mushi.
Sandbox provider for running fix attempts in a sandbox environment.
Inbound adapter to forward New Relic alerts into Mushi.
SDK for capturing errors and user reports from Next.js applications.
LLM provider supported as an alternative for the classification pipeline.
Inbound adapter to forward Opsgenie alerts into Mushi.
SDK for capturing errors and user reports from React applications.
Inbound adapter to forward Sentry alerts into Mushi for deeper fix context; outbound plugin to auto-resolve Sentry issues when Mushi merges a fix.
Outbound integration to dispatch fixes via Slack.
Backend database and edge functions platform used for self-hosting the Mushi stack.
SDK for capturing errors and user reports from Svelte applications.
This server has a remotely hosted endpoint. Open its connector listing for connection details, authentication requirements, and setup instructions:
Mushi Mushi
Your AI built it. Mushi Mushi makes it better.
Mushi Mushi checks your live site, shows where people get stuck, and reviews your code. Your users can tap a button to report a bug. Each problem comes with a plain-English explanation and a fix that Lovable, Cursor or Claude Code can apply.
Fix what breaks · Smooth the journeys people take · Clean up the code — one place, from your editor.
Check your live app free → No sign-up, nothing to install.
Add it to Lovable or Bolt with one prompt → No terminal, about five minutes, free for three apps.
Or, in your app's folder:
npx mushi-mushiBuilt for the vibe coder who ships fast with Cursor, Claude Code, Lovable or Bolt.
Quick start · How it works · Docs · Sample diagnosis · Why not Sentry? · Self-host · Vision
↑ What comes back when a user writes "Checkout button does nothing on my phone". Click for the whole sample, from their words to the fix prompt, without signing up.
How it works
↑ Short videos that show every click: a user reporting a bug, the diagnosis, connecting your editor, and the fix shipping. Watch them on How it works.
flowchart LR
U["Your users<br/>tap the bug widget"] --> M
S["Your monitoring<br/>Sentry, Crashlytics… (optional)"] -.-> M
M["Mushi Mushi<br/>one queue · diagnosis · fix"] --> E["Your editor or agent<br/>Cursor, Claude Code (MCP)"]
E --> P["Draft PR<br/>you review it"]
P --> R["Release<br/>report closes, user is told"]Capture. A user taps the widget. Mushi Mushi records a screenshot, the route, their note, and the last console and network events.
Diagnose. Mushi Mushi writes the root cause in plain English with a fix prompt. Twenty reports of the same broken button become one row.
Fix. Your editor reads the diagnosis over MCP and makes the fix with its own model. If you prefer, an agent opens a draft PR that you review like any other. On hosted Mushi Mushi the built-in fixer needs no key of your own; Cursor's agents need your Cursor key; or run fixes on your own computer with the Mushi Mushi worker. With your own Anthropic or OpenAI key, a second AI (Claude Opus, or GPT on an OpenAI key) reviews each agent PR first. Mushi Mushi will not merge a PR it says to hold unless you override it in the console and give a reason.
It catches the bugs that never throw an error: the pay button hidden under the keyboard, the Save button tapped twice because nothing happened, the dashboard that takes 12 seconds.
Beyond bugs. The same queue improves the rest of the app:
Journeys. The Journey optimizer maps how people move from page to page, from real visits, and flags dead ends, loops, pages people leave from, and orphan or duplicate pages. Each finding has a plain suggestion and a prompt your coding agent can run. The map from visits needs no key; the crawl of your live site needs a Firecrawl key. A first-time user test shows where a new user gets stuck (it runs on your own coding agent).
Code. Known security holes in your dependencies (once GitHub is connected), code audits run by your own agent, and clean-up of the branches and PRs Mushi Mushi made. Every change is a pull request you review.
Related MCP server: Playwright MCP
Page by page
Ten pages of the console, recorded on the maker's own apps (glot.it, tsumagoi, Help Her Take Photo, yen-yen and more). Real data, nothing staged; other people's emails and keys are masked. Each page has a longer write-up in the console guide.
Find out what broke
Home: the coffee-length check
Open it when you just woke up and want to know whether your app survived the night.
Is the site up, what broke, which pull requests wait for you and what ships next, on one screen per app.
Bugs: every report, already sorted
Open it when a user wrote “it's broken” and you need to know how bad, how many and where.
Reports from your users, Sentry and your own checks land in one list. “Fix first” ranks open bugs by severity and by how many people they reached.
Bug detail: the cause in plain English
Open it when you don't fully understand the code your AI wrote, and now you need to.
Each report gets a diagnosis: what the person saw, why it broke, the file at fault, and a fix prompt to paste into Claude Code, Cursor or any MCP client.
Apps: every app on one table
Open it when you run several apps and want the worst one first.
One row per app, one column per signal (open bugs, risks, SDK, release age, CI failures, last check-in), darker where it is worse. Problems open in several apps become one "Fix once" item.
Get it fixed
Fixes: what your agent tried
Open it when you sent a few bugs to an agent and want to know which fixes are safe to merge.
Every attempt with its pull request, review verdict and CI. A train of counts shows where fixes are, ready ones sit at the top, and the ones that stopped say why.
Pipeline: where fixes get stuck
Open it when bugs go in, but nothing seems to come out the other end.
Every stage from report to deploy, with the bottleneck in red, a bar of how long stuck work has waited, and the one action for each stuck group (re-run CI, re-run the review, close the PR) right beside it.
CI runners: why the merge is still waiting
Open it when a fix is done but its tests haven't run, or your Actions bill jumped.
Which jobs wait for which machine and for how long, what every machine is running, and how long each job usually takes. On a big screen it uses the whole width.
Keep it from coming back
Lessons: never the same bug a fourth time
Open it when you have fixed the same kind of bug twice and you're tired of it.
Bugs that keep coming back become rules, and your editor reads them over MCP before it writes the next fix.
Checks: is my app OK?
Open it when you want one answer before you ship.
Every automatic check in one grid (the full-stack audit, scheduled browser tests, triage grading and more), failing ones first.
Connect: Mushi Mushi inside your editor
Open it when you'd rather ask your editor than open another dashboard.
Pick your AI client and run one command; your editor can then ask what broke and pull the fix context. The SDK, GitHub and upgrade PRs live here too.
Quick start
npx mushi-mushiRun it in your app's folder. What happens next:
You sign in through your browser. Your free project and key are made for you. There is nothing to copy.
It installs Mushi Mushi and shows you a few lines of code. Add them to your app (or ask your AI editor to). They show a small report button.
Your users tap the button when something is wrong and write one sentence. Mushi Mushi adds a screenshot and what the app was doing.
You get the cause in plain English, and a fix your AI editor can apply.
Prefer to have your AI editor run it? Paste this into Cursor or Claude Code:
Add Mushi Mushi to this app. In the project folder, first run
`npx mushi-mushi --dry-run` and tell me what it will change. Then run
`npx mushi-mushi --yes`. It prints a sign-in link: show it to me and wait while
I approve it in my browser. It sends a test report at the end. If it prints
code and names a file, add the code there. Then run `npx mushi-mushi doctor`
and tell me which file you changed and what doctor says.Starting from nothing? npx mushi-mushi --template vue my-app (or svelte, node) makes a starter app with Mushi Mushi already in it. Want your linter to catch the buttons that do nothing and the fake data AI tools leave behind? Add mushi-mushi/eslint to eslint.config.js.
Then connect your editor so it can read diagnoses. You sign in once in your browser; there is no key to paste.
claude mcp add --transport http mushi https://kensaur.us/mushi-mushi/hosted-mcp/Other editors: the Connect page, or npx mushi-mushi setup --ide cursor (or --ide claude). Ask it: "Get the latest Mushi Mushi report and fix it."
No SDK for your stack? File a report with one curl (OpenAPI spec).
Building in Lovable, Bolt or Replit, with no terminal? Paste one script tag through your prompt instead: Mushi Mushi in Lovable or Bolt, in Replit.
The SDK needs two env vars (VITE_MUSHI_PROJECT_ID / VITE_MUSHI_API_KEY, or NEXT_PUBLIC_MUSHI_*; see examples/sdk.env.example). No Sentry, no LLM key, no monitoring stack.
Before you deploy. The wizard writes those two variables to .env.local, which never reaches your host. Add them where your site is built (Vercel: Project → Settings → Environment Variables, Production; Netlify: Project configuration → Environment variables), then redeploy. Without them the report button does not appear on the live site.
Want a real diagnosis of your own code right away? A test report is one made-up sentence, so its diagnosis is thin. Bring in a bug you already know about: npx mushi-mushi sentry import (your newest unresolved Sentry issues, once Sentry is connected under Integrations in the console) or npx mushi-mushi reports file --title "…" --description "…". Connect your GitHub repository so the diagnosis can name your files.
The hosted free plan covers three apps and 300 diagnoses a month, with no card and no AI key of your own (pricing). Or you can self-host.
Paste this into Cursor or Claude Code:
Install the Mushi Mushi skills from github.com/kensaurus/mushi-mushi (
npx skills add kensaurus/mushi-mushi), then run the mushi-setup skill to wire the Mushi Mushi SDK and MCP server into this app and send a test report to verify the connection.
The skills also add /mushi-triage (evidence, diagnosis, then fix here or dispatch), /mushi-debug (a pass/fail health check, then why ingest or MCP fails), /mushi-test (generated tests and an end-to-end smoke test), /mushi-sdk-upgrade and /mushi-check-live-app (a free check of a live site). /mushi-mushi routes to the right one.
npm install mushi-mushi # React Native: npm install @mushi-mushi/react-nativeimport { MushiProvider } from 'mushi-mushi/react';
export function App() {
return (
<MushiProvider config={{ projectId: 'proj_xxx', apiKey: 'mushi_xxx' }}>
<YourApp />
</MushiProvider>
);
}import { MushiPlugin } from 'mushi-mushi/vue'; // Vue 3 / Nuxt: app.use(MushiPlugin, { projectId, apiKey })
import { initMushi } from 'mushi-mushi/svelte'; // Svelte / SvelteKit: initMushi({ projectId, apiKey })
import { provideMushi } from 'mushi-mushi/angular'; // Angular 17+: providers: [provideMushi({ projectId, apiKey })]
import { MushiProvider } from '@mushi-mushi/react-native'; // React Native: its own package (native code)
import { Mushi } from 'mushi-mushi'; // any framework: Mushi.init({ projectId, apiKey })Native SDKs (iOS, Android, Flutter) are a preview and install from this repository: see packages/ios, packages/android and packages/flutter. A runnable demo lives in examples/react-demo.
Already on @mushi-mushi/react, @mushi-mushi/web or another @mushi-mushi/* SDK? It keeps working and keeps getting updates. mushi-mushi ships the same code; switch when you like by changing the import path.
Who it's for
You build apps with AI, mostly on your own. You use Lovable, Bolt, Cursor or Claude Code, your app has real users, and you didn't write most of the code by hand. When someone says "it's broken", Mushi Mushi tells you the likely cause in plain English and gives your editor a fix prompt.
You're a developer and you own your code. You read the diffs and may already run Sentry. User reports and Sentry errors land in one list with duplicates merged, and an agent's fix gets a second AI review before it can merge.
You run a team. Reports arrive from the app, Sentry, store reviews and Slack, and nobody sees all of them. Here they share one list, each with a diagnosis, and they can go on to Linear, Jira or GitHub Issues.
The pains each group has, and where each should start: who it's for.
What's inside
Package | For | What it does |
Your app | The one package: the setup wizard ( | |
| Your app | The same widget wired into your framework |
| Your server | Reports backend errors into the same queue |
Your mobile app | The widget for native and hybrid apps (they ship native code, so they stay separate installs) | |
Your editor | Gives Cursor and Claude Code the diagnosis and fix tools | |
Your terminal | Setup, reports, fixes and health checks | |
Your app's screens | Runs your coding agent over every screen and keeps only measured improvements | |
Backend | Supabase edge functions + Postgres. Hosted for you, or self-host |
Full list and maturity: SDK reference. Architecture: how the pipeline fits together.
What else it does
Most bugs never get reported. People just leave. So beyond the reports people send, Mushi Mushi can look for bugs itself and check the fixes. Each of these is off until you switch it on, and several need your own key.
Feature | What it does | Needs |
An AI that has never seen your app tries one goal, such as signing up, and files the places it got stuck, with screenshots | The Mushi Mushi worker on a computer of yours, or one run of | |
Reads each agent PR next to the original report and says merge, fix first or hold, with its reasons | Your GitHub repo and your own Anthropic or OpenAI key | |
Checks your live pages every hour. A broken page is filed only after a second check confirms it | Your own Firecrawl key | |
Reads every page once a week and files dead links, missing titles, text in the wrong language and images without a text description | Your own Firecrawl key | |
Checks your lockfiles daily against the public vulnerability database and says which package to update | Your GitHub repo | |
Shows which workflows cost the most and where minutes are wasted, and tells a code failure from a broken CI machine ( | Your GitHub repo. Reading the bill needs a token that can see billing | |
Runs a playbook such as "make it accessible" on part of your app, one fix PR per round, five rounds at most | Your own Cursor key, or the Mushi Mushi worker | |
Turns low-star App Store and Google Play reviews into bug reports | Your store accounts connected | |
Say or type a bug into Telegram, Slack or an iPhone shortcut | One of those connected from the console |
A "fix first" review can go back to the agent with its findings, at most twice per PR. That is off by default and uses your organization's Cursor key (agent PR review, CI runners). Every feature, with what it solves: what else it does.
Why not just Sentry?
Sentry is built around what the code threw, with a User Feedback widget and replay alongside. Mushi Mushi starts from what the user reported, ingests Sentry's errors too, explains each one in plain English, and hands your agent a fix prompt to start from. One queue, with or without Sentry.
Mushi Mushi | Sentry | |
Catches | Thrown errors and silent UX bugs (dead clicks, slow screens, broken layouts) | Thrown errors, performance traces |
You get | A plain-English root cause and a fix prompt, in your editor | A stack trace and breadcrumbs, in a dashboard |
Auto-fix | Optional: an agent opens a draft PR, with the built-in fixer, your Cursor key, or the worker on your computer | Seer add-on (paid) |
Setup | One command that signs you in through the browser; the sample diagnosis needs no account | SDK + DSN + dashboard |
It works with what you already run. Point a Sentry alert webhook at /v1/webhooks/sentry?projectId=<id> and errors land in the same queue. Once you add a Sentry auth token under Integrations → Sentry, merging a Mushi Mushi fix resolves the Sentry issue, and the reverse. Both work on every plan. Adapters also bring in Datadog, Bugsnag, Rollbar, Crashlytics and others. Plugins keep Linear, Jira, GitHub Issues, Slack, Discord, Teams and PagerDuty in sync. Nothing gets ripped out. Details: Sentry vs Mushi Mushi.
Self-host
On your own Supabase project (the free tier works):
git clone https://github.com/kensaurus/mushi-mushi.git && cd mushi-mushi
npx mushi-mushi@latest selfhost up --project-ref <your-supabase-ref>Or everything in Docker on one Linux or macOS server, no Supabase account:
curl -fsSL https://raw.githubusercontent.com/kensaurus/mushi-mushi/master/deploy/selfhost/install.sh -o install.sh
sh install.sh --email you@example.comThe installer runs Supabase's self-host kit plus Mushi's published images (amd64 and arm64), generates every secret, closes sign-up and keeps every port on 127.0.0.1. sh mushi.sh https your.domain adds HTTPS; backup, restore and update are one command each; your own model server (Ollama, vLLM) works too.
Guides: Self-hosting quickstart, Docker (one command) and every environment variable. Self-host turns every feature on, with no plan limits. Self-hosting is bring-your-own-key: you pay your LLM vendor at list price. The hosted service needs no key; it bills per diagnosis with a spend cap (pricing). Teams wiring Mushi Mushi into an existing stack (SSO, retention, region routing, Kubernetes) start at docs/operators/. Only the public api function should face the internet: see internal caller authentication.
Where it stops
Area | Still partial |
Track record | Mushi Mushi is young. Most of its use so far is on the maker's own apps. There, people reported only a small share of the bugs. The rest came from checks, Sentry errors and bugs the maker filed. The live numbers count the two separately |
Native SDKs | iOS, Android and Flutter are previews, not yet on CocoaPods, Maven Central or pub.dev |
Fine-tuning | OpenAI and Bedrock work. Anthropic fine-tuning is not self-service, so its adapter links to the access form |
Knowledge graph | SQL adjacency everywhere. Apache AGE only where the extension is installed (not managed Supabase) |
Inventory and QA gates | Behind the |
Multi-region | Region pinning works. Active/active write replication is not automated |
Repo at a glance (run pnpm docs-stats): ~670K TS lines · ~2,900 source files · 45 workspace / 37 npm packages · 78 edge functions · 580 SQL migrations · 19 pipeline agents. Full tour: docs/SCREENSHOTS.md.
Community and contributing
Questions and show-and-tell: GitHub Discussions. Bugs: Issues (first reply within 24 hours on weekdays). Security: .github/SECURITY.md. Anything else private: kensaurus@gmail.com.
git clone https://github.com/kensaurus/mushi-mushi.git && cd mushi-mushi
pnpm install && pnpm dev # Node ≥ 22, pnpm ≥ 10See .github/CONTRIBUTING.md and docs/stats.md.
License
Open core. Each package directory's own LICENSE governs that package; the root LICENSE states the split.
Part | License | In short |
SDKs, CLI, MCP, plugins, adapters | Use anywhere, including closed-source products | |
Server ( | Self-host and modify freely. Offer a modified server or console as a service: publish your changes or get a commercial license | |
Enterprise features ( | SSO, audit ingest, retention, region pinning. Paid for production use | |
Name, logo, icons, mascot | All rights reserved. Link to Mushi Mushi with the unmodified logo; forks must rename |
Self-hosting is free and complete: the repo has every feature and working default prompts. Mushi Mushi Cloud runs the same code and keeps its own tuning data (prompt wording, evaluation sets and scoring weights tuned on live traffic) as configuration. Contributions come in under a CLA. Why it is set up this way: ADR 0036. Third-party notices: NOTICE.
More apps from the same maker
App | What it is | |
Learn Thai — bite-size lessons, smart flashcards, and an AI tutor | ||
Where did the money go? Now you'll know. A kakeibo for households | ||
How the Battle Between Extraction and Generation Is Reshaping Our World — a 147,000-word interactive webbook with 268 concepts, 242 citations, and original illustrations | ||
Pair phones, direct the pose, nail the photo | ||
Practice hard conversations before you have them | ||
Bookkeeping and tax-filing co-pilot for one-person companies in Japan — Free tools | ||
A 24-hour mountain lounge at 1,444 m; guests sleep in their own car or tent — Book a stay · Instagram · Facebook · Maps | ||
Agent skills and slash commands for Claude Code, Cursor, Codex, and Gemini — Getting started | ||
Turns your own footage into reels and books the posts; you only approve. Open source — npm | ||
All apps from the same maker |
The list comes from https://kensaur.us/apps.json (kensaurus/kensaur.us src/data/family.json).
Available Tools
12 toolsdiagnose_setupUnified setup diagnoseARead-onlyIdempotentInspect
Diagnose Mushi setup health and return the single best next action. mode=full (default) runs both SDK-ingest and fix-dispatch preflight checks; mode=ingest runs ingest checks only (project exists, active API key, SDK heartbeat, at least one report); mode=dispatch runs dispatch readiness only (GitHub connected, codebase indexed, LLM key present, autofix enabled). Returns { ready, steps: [{ label, complete, required, hint }], nextAction }. Read-only. The one setup-diagnosis entry point — use this instead of separate connection/ingest checks.
Inputs: mode, projectId. Returns: mode, ready, health, ingest, +4 more
file_reportFile a reportAInspect
File a free-form report on a project by hand: a bug you found yourself, a backlog item, or work for an agent. Pass title (3-200 chars) and description (up to 10000 chars: what happens, steps, what you expected, how to check it is fixed); severity (critical | high | medium | low) and component are optional hints that triage may refine. The report is stored with status new and goes through the same triage as a user report (classification, diagnosis), so it can then be dispatched with dispatch_fix. Returns { reportId, projectId, title, status, severity, component }. Write; not idempotent (a retry files a second report); at most 30 filed reports per project an hour; viewers cannot file. Use for work no user reported; for issues already in Sentry use import_sentry_issues. Then call triage_issue on the new reportId.
Inputs: title (required), description (required), severity, component, +1 more. Returns: title, status, reportId, severity, +2 more
get_fix_contextFix context bundleARead-onlyIdempotentInspect
Bundle everything an agent needs to fix one bug in a single call: a paste-ready fixPrompt (plain-English diagnosis + reproduction + suggested fix + relevant code + blast radius), plus report detail, repro steps, component, root cause, ontology tags, and the inventory action (with its expected_outcome contract) the report is filed against, plus recipe: a ≤4 KB excerpt with the app's tokens (CSS var / TS names), the design deviance score and deviance findings in the files this fix touches, so the fix uses the app's tokens instead of literals, and recipe.context: the tables the stack trace names with their columns from the latest schema snapshot (and any it says do not exist), whether the last merged fix is live, and the open hole-check findings, each section with its own state and note. Returns { report, fixPrompt, reproductionSteps, component, rootCause, bugOntologyTags, inventoryAction, recipe }; recipe is always { state, note, … } with state ok | drift | unknown | not_connected | error, never null. Read-only; no second LLM key needed. Use before writing a fix; use triage_issue for a multi-report review packet, or suggest_fix for just the Stage-2 hint.
Inputs: reportId (required), projectId. Returns: recipe, report, component, fixPrompt, +4 more
get_mushi_docRead a Mushi docs pageARead-onlyIdempotentInspect
Fetch one official Mushi docs page as Markdown, by a url from search_mushi_docs or a route such as "/quickstart/mcp". Returns { title, url, markdown, truncated }; markdown is capped at 8,000 characters and says where to read the rest. Only indexed docs pages resolve. Read-only; works without an API key. Use after search_mushi_docs when an excerpt is not enough.
Inputs: page (required). Returns: url, title, markdown, truncated
get_recent_reportsRecent bug reportsARead-onlyIdempotentInspect
List recent bug reports for a project, newest first. Returns { reports: [{ id, status, category, severity, summary, component, created_at, processing_error }], total }; includeRaw=true returns every list column instead. Reporter identifiers (end-user id, reporter token hash, session id, display name) are never returned. Optional filters: status (new|classified|grouped|fixing|fixed|verified|reopened|dismissed|…), category (bug|slow|visual|confusing|other), severity (critical|high|medium|low), limit (default 20, max 100). Use to survey open reports; for one report use get_report_detail, to find a bug by text use search_reports.
Inputs: limit, status, category, severity, +2 more. Returns: total, reports
get_report_detailReport detailARead-onlyIdempotentInspect
Fetch the full record for one bug report by id: description, console logs, network requests, screenshot URL, classification (stage 1/2), fix history, the paste-ready fix packet and the inventory action it is filed against. Returns { report } with the documented fields; includeRaw=true returns every column the detail route has instead. Reporter identifiers (end-user id, reporter token hash, session id, display name) are never returned. Read-only. Use when you have a reportId and need everything about it; for evidence only use get_report_evidence, for the activity thread use get_report_timeline, for a one-call fix bundle use get_fix_context.
Inputs: reportId (required), projectId, includeRaw. Returns: report
reply_to_reporterReply to a reporterAInspect
Send a visible message to the end-user who filed a bug report. The reply appears in the in-app Mushi widget as an admin comment and creates an unread notification badge so the reporter sees it immediately. Use this to answer questions, request reproduction steps, or confirm a fix — without leaving the Cursor IDE.
Inputs: message (required), reportId (required), authorName.
search_mushi_docsSearch Mushi documentationARead-onlyIdempotentInspect
Search the official Mushi documentation (guides, MCP setup, inventory, QA, skills) by keyword — titles, section headings and summaries are indexed. Returns ranked { results: [{ title, url, excerpt, score }] }. Read-only; works without an API key. Use before guessing API shapes, tool names, or RPC names, then get_mushi_doc to read a page; use run_nl_query for questions about your own project data, not the docs.
Inputs: query (required), limit. Returns: query, results
search_reportsSearch reportsARead-onlyIdempotentInspect
Search reports by meaning and keyword (pgvector similarity server-side; falls back to summary/description substring if embeddings are unavailable). Returns ranked { results: [{ id, summary, similarity }] }. Read-only. Use to find reports by free text ("checkout flakiness"); use get_similar_bugs to dedupe a known component/bug, or get_recent_reports to list without a query.
Inputs: query (required), limit, threshold. Returns: results
transition_statusMove report between statesADestructiveIdempotentInspect
Move a report to a new workflow state, enforcing the same transition rules as the admin UI. Valid targets: classified, grouped, fixing, fixed, verified, reopened, dismissed. When dismissing, closedReason (duplicate, not_reproducible, wont_fix, working_as_intended, spam) sets what the reporter is told — spam closes silently, and duplicate needs the report grouped under another one first; reporterMessage posts your note to the reporter verbatim. Returns { ok }. Write; idempotent (setting the current status is a no-op); rejects illegal transitions. Use to dismiss a duplicate or mark fixed; use merge_fix to mark fixed via a merged PR, or reopen_report for the reopened path.
Inputs: status (required), reportId (required), reason, closedReason, +1 more.
triage_next_stepsWhat should I work on now?ARead-onlyIdempotentInspect
Prioritised "do this next" list for the project: blocked auto-fixes first (with the unblock action), then reporters waiting for an answer (they replied in the in-app thread since you last looked), then in-flight fixes to shepherd to merge, then user-felt classified reports by severity, with robot/cron chores (dependency bumps) last. Returns { steps: [{ priority, action, reason, tool, args }], summary }. Read-only. Call this first when the user asks "what needs my attention / what should I triage or fix".
Inputs: projectId. Returns: steps, summary
use_mushiMushi — where to startARead-onlyIdempotentInspect
CALL THIS FIRST if you are new to this Mushi project or unsure which tool to use. Pass your intent as a short natural-language phrase ("fix the top bug", "check what I should work on", "run QA tests", "set up Mushi", …). Returns: (1) a curated list of the 5–12 tool names most relevant to that intent, (2) a one-paragraph orientation to the Mushi project and dashboard state, and (3) the single recommended first tool to call. Only tools this connection exposes are recommended; relevant tools hidden by the active feature groups are named with how to enable them. Avoids loading the full tool catalog into context when only a small subset is needed. Read-only; does not call any downstream tools itself.
Inputs: intent.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 12 tools
Core read paths (get_recent_reports vs search_reports vs get_report_detail) are clearly separated, and descriptions explicitly route agents between them. However there are three overlapping 'start here' meta tools (use_mushi, triage_next_steps, diagnose_setup) and get_fix_context is essentially a superset of get_report_detail, so an agent may over-call the heavier bundles.
Nearly all tools follow a consistent snake_case verb_noun pattern (get_recent_reports, file_report, transition_status, reply_to_reporter, search_mushi_docs). The main deviation is use_mushi, which names a product rather than a resource+action, plus the mildly atypical triage_next_steps.
12 tools is squarely in the well-scoped range for a bug-triage/fix workflow covering listing, detail, search, filing, state transitions, reporter comms, setup checks, and docs. No obviously redundant or filler tools at the set level.
The read/create/transition/communicate loop is covered, but the fix lifecycle has holes: dispatch_fix, merge_fix, reopen_report, suggest_fix, get_report_evidence, get_report_timeline, get_similar_bugs, and import_sentry_issues are all referenced by descriptions yet not exposed, creating dead-end pointers. There is also no way to edit a report's content after filing.
Maintenance
Related MCP Connectors
Voice-powered bug reporting with 13 MCP tools. Record bugs by talking; let AI find and fix them.
AI-native git hosting — repos, PRs, issues, CI gates, and AI code review over MCP (60 tools).
MCP-native AI SRE: ask what's broken in production, get a reviewed GitHub fix PR.
GitHub Copilot MCP: code, repo, PR, workflow tools for AI assistants.
Related MCP Servers
AlicenseAqualityBmaintenanceA remote Model Context Protocol server acting as middleware to the Sentry API, allowing AI assistants like Claude to access Sentry data and functionality through natural language interfaces.74973Functional Source , Version 1.1, ALv2 Future- AlicenseAqualityNot gradedmaintenanceA server that enables LLMs to interact with web pages through structured accessibility snapshots without needing screenshots or visually-tuned models.2410,706,557 npm1-
- AlicenseBqualityBmaintenanceOpen source contribution manager — tracks PRs across repos, discovers contributable issues, diagnoses CI failures, and drafts maintainer responses. 21 MCP tools, 5 resources, 3 prompts. Ships as CLI, MCP server, and Claude Code plugin.2030MIT
- AlicenseNot gradedqualityAmaintenanceEquips MCP-compatible AI assistants with software development tools for deep research, codebase mapping across 35+ languages, context curation, and generating PRDs, user stories, task lists, and fullstack starter kits. Supports natural-language CLI and interactive REPL usage alongside multi-step workflow execution.42 npmMIT