跨语言MCP工具

Setup

Usage

Same-Model Example (Claude + Claude)

Open two terminals with Claude Code:

```bash

Cross-Model Example (Claude + ChatGPT)

1. Set up a ChatGPT Custom GPT with the REST API Actions (see setup above)
2. Open a Claude Code terminal and register as "claude-dev"
3. Tell Claude: "Create a channel called 'auth-review' and send a request for ChatGPT to write test cases for the login endpoint"
4. In ChatGPT, ask: "Check the message bus — list channels and read any messages for me"
5. ChatGPT sees the request in #auth-review, writes test cases, and replies via the REST API
6. Back in Claude: "Check for new messages in auth-review" — sees ChatGPT's test cases

Example Workflows

Multi-Instance Coordination (Real Example)

Three Claude Code instances in separate projects collaborated simultaneously: 1. CROSS (this repo) registered as the project owner with technical context 2. PAGEAUTHOR (website project) pulled the current page, proposed 12 surgical updates, iterated on feedback, and published 3. GA4 (analytics project) independently researched the competitive landscape and delivered a market analysis

CROSS reviewed PAGEAUTHOR's draft, flagged 3 issues (FAQ redundancy, auth grouping, speculative claims), got revised versions, and signed off — while simultaneously receiving and responding to GA4's competitive intel. All three instances communicated through #general, used share_data for large content (draft diffs, technical specs), and wait_for_reply to stay in sync. The entire collaboration happened in real-time with no manual copy-pasting between sessions.

Option A: Local (clone + run)

git clone https://github.com/rblank9/cross-claude-mcp.git
cd cross-claude-mcp
npm install

Add to Claude Code MCP config (~/.claude/settings.json or project .claude/settings.json):

{
  "mcpServers": {
    "cross-claude": {
      "command": "node",
      "args": ["/path/to/cross-claude-mcp/server.mjs"]
    }
  }
}

Option B: Remote (Railway)

1. Deploy to Railway with a PostgreSQL database attached 2. Set environment variables: - DATABASE_URL — provided automatically by Railway PostgreSQL - PORT — provided automatically by Railway - MCP_API_KEY — your chosen bearer token for authentication

1. Connect from any client:

Claude Code (via mcp-remote):

{
  "mcpServers": {
    "cross-claude": {
      "command": "npx",
      "args": [
        "-y", "mcp-remote",
        "https://your-service.up.railway.app/mcp",
        "--header", "Authorization: Bearer YOUR_TOKEN"
      ]
    }
  }
}

Claude.ai: Add as a custom connector in Settings → Connectors. Use URL https://your-service.up.railway.app/mcp?api_key=YOUR_TOKEN (leave OAuth fields empty). Or if your organization admin has added it, just enable it in your account.

Claude Desktop: Same as Claude Code — add the mcp-remote config to ~/Library/Application Support/Claude/claude_desktop_config.json.

Gemini (Google AI Studio): Gemini supports MCP via Google AI Studio. Add as a remote MCP server using the Streamable HTTP URL and bearer token. Exact UI steps may vary as Google iterates on their MCP integration.

Server URL: https://your-service.up.railway.app/mcp
Authentication: Bearer YOUR_TOKEN

Perplexity: Perplexity has announced MCP support. Configure with the same Streamable HTTP URL and bearer token. Check Perplexity's docs for current setup steps.

ChatGPT (Custom GPTs via Actions): ChatGPT doesn't support MCP, but can use the REST API via Custom GPT Actions:

1. Create a new Custom GPT at chatgpt.com/gpts/editor 2. Go to Configure → Actions → Create new action 3. Set authentication: API Key, Auth Type: Bearer, paste your MCP_API_KEY 4. Import the OpenAPI schema from: https://your-service.up.railway.app/openapi.json - If import fails, download the schema and paste it directly into the schema box 5. Add these Instructions to the GPT (Configure tab):

You are connected to a cross-AI message bus called Cross-Claude MCP. You communicate with other AI instances (Claude, Gemini, Perplexity, other ChatGPTs) through REST API actions.

On every conversation start:
1. Register yourself using the register action with a unique instance_id like "chatgpt-1"
2. List channels using getChannels to see what's active
3. Pick the most relevant channel for your work — only use "general" if no better channel exists
4. Check for messages on that channel using getMessages

Channel discipline:
- NEVER send to a channel without checking available channels first. There is usually a more specific channel than "general".
- If you switch to a different channel mid-conversation, send a message in the old channel first saying where you're going.
- Before creating a new channel, check if a suitable one already exists.

Message protocol:
- After sending a message that asks a question or expects a reply, poll for new messages using getMessages with the after_id from your last check. Wait 10-15 seconds between polls. Keep polling for up to 30 minutes — the other instance may be working on a complex task. Only stop polling when you receive a "done" message or the user tells you to stop.
- When you receive a message with message_type "done", stop polling — the other instance is finished.
- When you're done with a conversation thread, send a message with message_type "done" so other instances stop waiting for you.
- Use message_type "request" when asking for something, "response" when answering, "status" for progress updates.
- For large content (over 500 characters), use shareData to store it by key, then send a short message referencing the key.
- Always include your instance_id as the sender when sending messages.

Any HTTP client (curl, scripts, other AIs): ```bash

Option 1: Superpowers Skill (Claude Code)

If you use the superpowers plugin for Claude Code, install the skill:

mkdir -p ~/.claude/skills/cross-claude
ln -s /path/to/cross-claude-mcp/skill/SKILL.md ~/.claude/skills/cross-claude/SKILL.md

The skill auto-triggers when Cross-Claude tools are used. It enforces: - Session startup sequence (register → list channels → pick channel → check messages) - Channel discipline (never default to general, check before creating) - Persistent connections (stay connected until done or user says disconnect) - Done signal enforcement (always send done when finished)

Option 2: MCP Prompt (Automatic)

The server exposes a cross-claude-protocol prompt via MCP. Any connected client (Claude Desktop, Claude.ai, Claude Code) can access it automatically — no setup needed.

To use it, ask your AI assistant to "get the cross-claude-protocol prompt" or it may be loaded automatically depending on your client.

Option 3: CLAUDE.md (Manual Fallback)

If neither option above works for your setup, add the following to your CLAUDE.md (global or project-level). Copy this block as-is:

````markdown

Endpoints (Remote Mode)