CallMe

Minimal plugin that lets Claude Code call you on the phone.

Start a task, walk away. Your phone/watch rings when Claude is done, stuck, or needs a decision.

• Minimal plugin - Does one thing: call you on the phone. No crazy setups.
• Multi-turn conversations - Talk through decisions naturally.
• Works anywhere - Smartphone, smartwatch, or even landline!
• Tool-use composable - Claude can e.g. do a web search while on a call with you.

Quick Start

1. Get Required Accounts

You'll need:

• Phone provider: Telnyx or Twilio
• OpenAI API key: For speech-to-text (and text-to-speech if not using Kokoro)
• ngrok account: Free at ngrok.com (for webhook tunneling)

2. Set Up Phone Provider

Choose one of the following:

CALLME_PHONE_PROVIDER=telnyx
CALLME_PHONE_ACCOUNT_SID=<Application ID>
CALLME_PHONE_AUTH_TOKEN=<API Key>
CALLME_TELNYX_PUBLIC_KEY=<Public Key>  # Optional: enables webhook security

CALLME_PHONE_PROVIDER=twilio
CALLME_PHONE_ACCOUNT_SID=<Account SID>
CALLME_PHONE_AUTH_TOKEN=<Auth Token>

3. Set Environment Variables

Add these to ~/.claude/settings.json (recommended) or export them in your shell:

{
  "env": {
    "CALLME_PHONE_PROVIDER": "telnyx",
    "CALLME_PHONE_ACCOUNT_SID": "your-connection-id-or-account-sid",
    "CALLME_PHONE_AUTH_TOKEN": "your-api-key-or-auth-token",
    "CALLME_PHONE_NUMBER": "+15551234567",
    "CALLME_USER_PHONE_NUMBER": "+15559876543",
    "CALLME_OPENAI_API_KEY": "sk-...",
    "CALLME_NGROK_AUTHTOKEN": "your-ngrok-token"
  }
}

Required Variables

Optional Variables

4. Install Plugin

/plugin marketplace add ZeframLou/call-me
/plugin install callme@callme

Restart Claude Code. Done!

How It Works

Claude Code                    CallMe MCP Server (local)
    │                                    │
    │  "I finished the feature..."       │
    ▼                                    ▼
Plugin ────stdio──────────────────► MCP Server
                                         │
                                         ├─► ngrok tunnel
                                         │
                                         ▼
                                   Phone Provider (Telnyx/Twilio)
                                         │
                                         ▼
                                   Your Phone rings
                                   You speak
                                   Text returns to Claude

The MCP server runs locally and automatically creates an ngrok tunnel for phone provider webhooks.

Tools

initiate_call

Start a phone call.

const { callId, response } = await initiate_call({
  message: "Hey! I finished the auth system. What should I work on next?"
});

continue_call

Continue with follow-up questions.

const response = await continue_call({
  call_id: callId,
  message: "Got it. Should I add rate limiting too?"
});

speak_to_user

Speak to the user without waiting for a response. Useful for acknowledging requests before time-consuming operations.

await speak_to_user({
  call_id: callId,
  message: "Let me search for that information. Give me a moment..."
});
// Continue with your long-running task
const results = await performSearch();
// Then continue the conversation
const response = await continue_call({
  call_id: callId,
  message: `I found ${results.length} results...`
});

end_call

End the call.

await end_call({
  call_id: callId,
  message: "Perfect, I'll get started. Talk soon!"
});

Costs

Plus API costs (same for both phone providers):

• Speech-to-text: ~$0.006/min (OpenAI gpt-4o-transcribe)
• Text-to-speech: ~$0.02/min (OpenAI TTS) or free with Kokoro

Total: ~$0.03-0.04/minute with OpenAI TTS, ~$0.01-0.02/minute with Kokoro

Kokoro TTS (Free, Local)

Kokoro is a free, local text-to-speech engine that runs via Docker. No TTS API key needed — just set one env var (note: CALLME_OPENAI_API_KEY is still required if you use the OpenAI API for speech-to-text):

CALLME_TTS_PROVIDER=kokoro

Auto-setup: If Docker is installed and port 8880 is free, the plugin automatically pulls and starts the Kokoro container on first use.

Existing instance: If you already have Kokoro running (or want a custom port), point to it:

CALLME_TTS_PROVIDER=kokoro
CALLME_KOKORO_URL=http://localhost:8880/v1

Voices: Kokoro has different voices than OpenAI. Query available voices at http://localhost:8880/v1/audio/voices. Popular choices: af_bella, af_sky, am_adam. Set with CALLME_TTS_VOICE.

Requirements: Docker (for auto-setup) or an existing Kokoro instance.

Troubleshooting

Claude doesn't use the tool

1. Check all required environment variables are set (ideally in ~/.claude/settings.json)
2. Restart Claude Code after installing the plugin
3. Try explicitly: "Call me to discuss the next steps when you're done."

Call doesn't connect

1. Check the MCP server logs (stderr) with claude --debug
2. Verify your phone provider credentials are correct
3. Make sure ngrok can create a tunnel

Audio issues

1. Ensure your phone number is verified with your provider
2. Check that the webhook URL in your provider dashboard matches your ngrok URL

ngrok errors

1. Verify your CALLME_NGROK_AUTHTOKEN is correct
2. Check if you've hit ngrok's free tier limits
3. Try a different port with CALLME_PORT=3334

Development

cd server
bun install
bun run dev

License

MIT

{
  "name": "callme",
  "owner": {
    "name": "ZeframLou"
  },
  "plugins": [
    {
      "name": "callme",
      "description": "Claude calls you on the phone when it needs your input or wants to report progress",
      "version": "1.0.3",
      "author": {
        "name": "ZeframLou",
        "url": "https://github.com/ZeframLou"
      },
      "source": "./"
    }
  ]
}