Unified MCP Server

{ "results": [{ "id": "123", "name": "Jane Doe", "emails": [{ "email": "jane@example.com" }] }] }

{ "error": true, "status": 404, "message": "Contact not found" }

import Anthropic from '@anthropic-ai/sdk';
import { Client } from '@modelcontextprotocol/sdk/client/index.js';
import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
import type { CallToolResult, TextContent } from '@modelcontextprotocol/sdk/types.js';

const anthropic = new Anthropic();

// 1. Connect to the Unified MCP server for one connection, limited to the tools this task needs.
const mcp = new Client({ name: 'my-app', version: '1.0.0' });
await mcp.connect(
    new StreamableHTTPClientTransport(new URL('https://mcp-api.unified.to/mcp?connection=YYYYYYY&tools=list_*,get_*'), {
        requestInit: { headers: { Authorization: `Bearer ${process.env.UNIFIED_API_KEY}` } },
    })
);

// 2. Offer each MCP tool to Claude as a tool that its code can call.
const { tools } = await mcp.listTools();
const claudeTools = [
    { type: 'code_execution_20260120' as const, name: 'code_execution' as const },
    ...tools.map((tool) => ({
        name: tool.name,
        description: `${tool.description ?? ''}\nReturns JSON. A list returns {"results": [...]}; a failure returns {"error": true, "status": ..., "message": ...}.`,
        input_schema: tool.inputSchema,
        allowed_callers: ['code_execution_20260120' as const],
    })),
];

// 3. Run the conversation, forwarding every tool call to the MCP server.
const messages: Anthropic.MessageParam[] = [
    { role: 'user', content: 'Which open deals over $50,000 have had no activity in the last 30 days?' },
];
let container: string | undefined;

while (true) {
    const response = await anthropic.messages.create({
        model: 'claude-opus-5-5',
        max_tokens: 16000,
        tools: claudeTools,
        messages,
        ...(container ? { container } : {}),
    });
    // A paused code execution run must continue in the same container.
    container = response.container?.id ?? container;
    messages.push({ role: 'assistant', content: response.content });

    if (response.stop_reason === 'pause_turn') {
        continue;
    }
    if (response.stop_reason !== 'tool_use') {
        for (const block of response.content) {
            if (block.type === 'text') {
                console.log(block.text);
            }
        }
        break;
    }

    // Answer every pending call in one user message that holds only tool_result blocks.
    const results = await Promise.all(
        response.content
            .filter((block) => block.type === 'tool_use')
            .map(async (block) => {
                const result = (await mcp.callTool({ name: block.name, arguments: block.input as Record<string, unknown> })) as CallToolResult;
                const text = result.content
                    .filter((part): part is TextContent => part.type === 'text')
                    .map((part) => part.text)
                    .join('');
                return {
                    type: 'tool_result' as const,
                    tool_use_id: block.id,
                    // structuredContent has the same shape as the text, without the text's size cap.
                    content: !result.isError && result.structuredContent ? JSON.stringify(result.structuredContent) : text,
                    ...(result.isError ? { is_error: true } : {}),
                };
            })
    );
    messages.push({ role: 'user', content: results });
}

await mcp.close();

deals = json.loads(await list_crm_deals({"limit": 100}))["results"]