Model Context Protocol (MCP)

import asyncio

from mcp import ClientSession
from mcp.client.sse import sse_client

from anthropic import Anthropic


ROLLOUT_SSE_URL = "https://api.rollout.dev/mcp/sse"
ROLLOUT_AUTH_TOKEN = "<Your token here>"
ANTHROPIC_API_KEY = "<Your API Key here>"

async def send_query_with_tools (session):
    """Process a query using Claude and Rollout's tools"""
    anthropic = Anthropic()
    messages = [
        {
            "role": "user",
            "content": "Which leads should I reach out to today?"
        }
    ]

    # Get the list of tools available from the MCP server
    tools_response = await session.list_tools()
    available_tools = [{
        "name": tool.name,
        "description": tool.description,
        "input_schema": tool.inputSchema
    } for tool in tools_response.tools]

    # Send user message to the model along with provided tools
    model_response = anthropic.messages.create(
        model="claude-3-5-sonnet-20241022",
        max_tokens=1000,
        messages=messages,
        tools=available_tools
    )

    for content in model_response.content:
        if content.type == "tool_use":
            # Make call to MCP server on the model's behalf
            result = await session.call_tool(content.name, content.input)

            # Provide prior conversation context and tool use result back to the model
            messages.append({
                "role": "assistant",
                "content": [content]
            })
            messages.append({
                "role": "user",
                "content": [{
                    "type": "tool_result",
                    "tool_use_id": content.id,
                    "content": result.content
                }]
            })

            # Get next response from the model after tool use
            model_response = await anthropic.messages.create(
                model="claude-3-5-sonnet-20241022",
                max_tokens=1000,
                messages=messages,
                tools=available_tools
            )

    # Print the final response text
    print(model_response.content[0].text)

async def main():
    headers = { 
        "Authorization": f"Bearer {ROLLOUT_AUTH_TOKEN}",
    }
    async with sse_client(ROLLOUT_SSE_URL, headers=headers) as (read_stream, write_stream):
        async with ClientSession(
            read_stream,
            write_stream,
            message_handler=message_handler
        ) as session:
            await send_query_with_tools(session)

if __name__ == "__main__":
    asyncio.run(main()) 

import Anthropic from "@anthropic-ai/sdk";
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";

const ROLLOUT_SSE_URL = new URL("https://crm.universal.rollout.com/mcp/sse");
const ROLLOUT_AUTH_TOKEN = "<YOUR ROLLOUT AUTH TOKEN HERE>";
const ANTHROPIC_API_KEY = "<YOUR ANTHROPIC API KEY HERE>";

async function sendQueryWithTools(client) {
  const anthropic = new Anthropic({
    apiKey: ANTHROPIC_API_KEY,
  });

  const messages = [
    {
      role: "user",
      content: "Which leads should I reach out to today?",
    },
  ];

  // Get the list of tools available from the MCP server
  const toolsResponse = await client.listTools();
  const availableTools = toolsResponse.tools.map((t) => ({
    name: t.name,
    description: t.description,
    input_schema: t.inputSchema,
  }));

  // Send user message to the model along with provided tools
  let modelResponse = await anthropic.messages.create({
    model: "claude-3-5-sonnet-20241022",
    max_tokens: 1000,
    messages,
    tools: availableTools,
  });

  for (const content of modelResponse.content) {
    if (content.type === "tool_use") {
      // Make call to MCP server on the model's behalf
      const result = await client.callTool({
        name: content.name,
        arguments: content.input,
      });

      // Provide prior conversation context and tool use result back to the model
      messages.push({
        role: "assistant",
        content: [content],
      });

      messages.push({
        role: "user",
        content: [
          {
            type: "tool_result",
            tool_use_id: content.id,
            content: result.content,
          },
        ],
      });

      // Get next response from the model after tool use
      modelResponse = await anthropic.messages.create({
        model: "claude-3-5-sonnet-20241022",
        max_tokens: 1000,
        messages,
        tools: availableTools,
      });
    }
  }

  // Print the final response text
  console.log(modelResponse.content[0].text);
}

async function withRolloutMcpClient(token, fn) {
  const client = await createRolloutMcpClient(token);
  try {
    await fn(client);
  } finally {
    client.close();
  }
}

async function createRolloutMcpClient(rolloutAuthJwt) {
  // Include an Authorization header on each request
  const rolloutRequestInit = {
    headers: { Authorization: `Bearer ${rolloutAuthJwt}` },
  };

  // Modify fetch to use the Rollout fetch init. MCP SDK for Typescript will only
  // pass headers to `POST` request and not the initial
  const rolloutFetch = (...args) => {
    const [input, init] = args;
    const modifiedInit = init
      ? { ...init, ...rolloutRequestInit }
      : rolloutRequestInit;
    return fetch(input, modifiedInit);
  };

  const transport = new SSEClientTransport(ROLLOUT_SSE_URL, {
    eventSourceInit: { fetch: rolloutFetch },
    // Use the Rollout request init on subsequent SSE requests
    requestInit: rolloutRequestInit,
  });

  const client = new Client({
    name: "rollout-client",
    version: "0.0.1",
  });

  await client.connect(transport);

  return client;
}

withRolloutMcpClient(ROLLOUT_AUTH_TOKEN, sendQueryWithTools);