@ringdev/mcp

Give your AI coding agent a phone. When it gets stuck, it calls you.

@ringdev/mcp connects your IDE's coding agent to the RingDev backend and exposes:

• ring_developer — Place a phone call asking ONE specific question.
• notify_completion — Tell you a unit of work is done and ask "what's next?"
• check_inbound_requests — Pick up coding tasks you queued by phone.

The agent calls the tool, your phone rings, you answer, and your voice answer becomes the agent's next instruction.

Quickstart

Run the setup wizard and pick your IDE:

npx -y @ringdev/mcp@latest setup

For IDEs with a browser OAuth flow (Claude Code, Claude Desktop, Cursor, VS Code), the wizard sets up the OAuth connector — no API key to manage; you sign in from your browser on first connect. Target an IDE non-interactively, and optionally force the auth method:

npx -y @ringdev/mcp@latest setup --ide=cursor               # OAuth where supported
npx -y @ringdev/mcp@latest setup --ide=gemini-cli --api-key # force the API-key path
npx -y @ringdev/mcp@latest setup --ide=vscode --no-rules    # skip writing the rules file

The wizard also writes the RingDev usage prompt into your IDE's rules file (Claude Code CLAUDE.md, Antigravity AGENTS.md, VS Code .github/copilot-instructions.md, Cursor/Windsurf rules, Gemini CLI GEMINI.md) so the agent knows when to call the tools — not just that they exist. Pass --no-rules to skip it.

Recommended: connect by URL (OAuth, no key)

Add the RingDev remote MCP server and sign in with your browser — nothing to install locally, no secret to store:

https://mcp.ringdeveloper.com/mcp

In Claude Code:

claude mcp add --transport http ringdev https://mcp.ringdeveloper.com/mcp
# then run /mcp and click Connect to authorize

Or paste that URL into any client that supports remote MCP servers (Claude Desktop Connectors, Cursor, VS Code, Zed) and complete the in-app "Connect" / sign-in. The first connect runs an OAuth handshake (Dynamic Client Registration + PKCE); your client stores and refreshes the tokens.

API key (headless / CI fallback)

For headless or CI environments — or IDEs without a browser OAuth flow — the local stdio server reads an API key from the environment:

export RINGDEV_API_KEY=rdk_live_...      # create at https://app.ringdeveloper.com/api-keys
export RINGDEV_PHONE=+919876543210       # optional E.164 offline fallback; discovery resolves it otherwise

Most IDEs use the mcpServers schema:

{
  "mcpServers": {
    "ringdev": {
      "command": "npx",
      "args": ["-y", "@ringdev/mcp"],
      "env": { "RINGDEV_API_KEY": "rdk_live_...", "RINGDEV_PHONE": "+919876543210" }
    }
  }
}

VS Code (.vscode/mcp.json) uses the servers root with an explicit type:

{
  "servers": {
    "ringdev": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@ringdev/mcp"],
      "env": { "RINGDEV_API_KEY": "rdk_live_...", "RINGDEV_PHONE": "+919876543210" }
    }
  }
}

Config file locations: Claude Code .mcp.json (or ~/.claude.json) · Cursor .cursor/mcp.json (or ~/.cursor/mcp.json) · VS Code .vscode/mcp.json · Windsurf ~/.codeium/windsurf/mcp_config.json · Antigravity ~/.gemini/antigravity/mcp_config.json · Gemini CLI ~/.gemini/settings.json. The setup wizard writes the right one for you.

Tell your agent how to use it

The tools work as soon as they're connected, but the agent only calls them as well as its instructions tell it to. The setup wizard writes this into your IDE's rules file automatically; over the remote server you can also pull it any time with the /ringdev MCP prompt — or paste it yourself:

RingDev — you can phone the developer through the RingDev MCP tools. Never wait silently, and never guess on a decision that's the human's to make.

Tools:
- ring_developer(question, context, urgency) — ask ONE specific, blocking question or request an approval. The developer answers by voice; their reply is your next instruction.
- notify_completion(summary, next_step_options) — when a unit of work is done, report it and offer next steps; the spoken choice is your next instruction.
- check_inbound_requests() — pick up coding tasks the developer queued by phone.

Call ring_developer / notify_completion whenever you would otherwise pause for the human: an approval or permission prompt, a plan or "proceed?" sign-off, a "continue to iterate?" confirmation, a clarifying question, an ambiguous choice, a risky or irreversible action, a failing build you can't decide on, or handing control back at end of turn. Ask one clear question with enough context to answer without seeing your screen.

Call check_inbound_requests at the start of every session (launch, resume, or first message), at the start of each turn, and after finishing a task — then do whatever was queued.

If a RingDev tool errors or times out, use your best judgment and keep going — never block. Redact secrets (keys, tokens, passwords) to [redacted] before sending.

Where to paste it: Claude Code → ./CLAUDE.md · Cowork → project instructions · Antigravity → AGENTS.md or Rules · VS Code (Copilot) → .github/copilot-instructions.md · Cursor / Windsurf / other → rules file or system prompt. The same prompt and table live in src/prompts/ringdev-agent-prompt.md.

Prefer to have your agent set it up? That same file has an enable prompt — paste it into your coding agent and it will connect RingDev for your IDE (OAuth where supported, otherwise an API key) and install the usage prompt above.

Prompt coaching (Claude Code)

RingDev can also coach your prompts before you send them, in two surfaces:

• coach_prompt tool: ask your agent to coach a draft on demand. It redacts the draft locally, scores it with a fast local heuristic, and for a weak draft returns a sharper rewrite plus what changed. A clearly good prompt is left as-is with no network call.
• A passive Claude Code hook: a UserPromptSubmit hook that posts a one-line, non-blocking nudge when a prompt looks clearly underspecified. It never blocks or alters your prompt, runs entirely on your machine (nothing is sent anywhere), and stays silent on good prompts.

Install the hook:

npx @ringdev/mcp install claude-code

This copies a small self-contained script to ~/.ringdev/coach-hook.mjs and registers it in ~/.claude/settings.json (any existing hooks are preserved; re-running is safe and refreshes the script after an upgrade). Restart Claude Code to activate.

How it works

1. The tool handler authenticates to the RingDev backend (an OAuth bearer token on the remote connector, or an API key on the stdio path), then POSTs and gets back a session_id.
2. RingDev places an outbound call via ElevenLabs Conversational AI + Twilio.
3. The voice agent reads your question, listens to the answer, paraphrases it.
4. The answer is delivered back over the WebSocket relay inside this MCP server.
5. The tool returns the answer to your IDE's chat.

If the developer says "I don't know — get me a human," the agent escalates to a marketplace developer (Tier 2).

Roadmap

• [x] Tier 1 voice bridge
• [x] IDE-aware setup wizard (Claude Code, Claude Desktop, Cursor, VS Code, Windsurf, Antigravity, Gemini CLI)
• [x] Remote Streamable-HTTP transport — add RingDev by URL with OAuth, no local Node
• [x] In-IDE prompt coaching — coach_prompt tool + Claude Code UserPromptSubmit nudge (install claude-code)
• [ ] VS Code extension wrapper with one-click setup

See ringdeveloper.com for the full product.