Open-weight models.
Frontier answers.
30× cheaper.

$ pip install claude-agent-sdk

from claude_agent_sdk import query, ClaudeAgentOptions

options = ClaudeAgentOptions(
    mcp_servers={
        "bytebell": {"type": "http", "url": "http://127.0.0.1:5757/mcp"}
    },
)

async for msg in query(prompt="What repos are indexed?", options=options):
    print(msg)

$ npm i @anthropic-ai/claude-agent-sdk

import { query } from "@anthropic-ai/claude-agent-sdk";

for await (const msg of query({
  prompt: "What repos are indexed?",
  options: {
    mcpServers: {
      bytebell: { type: "http", url: "http://127.0.0.1:5757/mcp" },
    },
  },
})) {
  console.log(msg);
}

$ pip install openai-agents

from agents import Agent, Runner
from agents.mcp import MCPServerStreamableHttp

async with MCPServerStreamableHttp(
    name="bytebell",
    params={"url": "http://127.0.0.1:5757/mcp"},
) as server:
    agent = Agent(name="x", instructions="Use bytebell.", mcp_servers=[server])
    print((await Runner.run(agent, "What repos are indexed?")).final_output)

$ npm i @openai/agents

import { Agent, run } from "@openai/agents";
import { MCPServerStreamableHttp } from "@openai/agents/mcp";

const server = new MCPServerStreamableHttp({
  name: "bytebell",
  url: "http://127.0.0.1:5757/mcp",
});
await server.connect();

const agent = new Agent({
  name: "x",
  instructions: "Use bytebell.",
  mcpServers: [server],
});
console.log((await run(agent, "What repos are indexed?")).finalOutput);

$ pip install langchain-mcp-adapters langgraph langchain-anthropic

from langchain_mcp_adapters.client import MultiServerMCPClient
from langgraph.prebuilt import create_react_agent

client = MultiServerMCPClient({
    "bytebell": {"url": "http://127.0.0.1:5757/mcp", "transport": "streamable_http"}
})
tools = await client.get_tools()

agent = create_react_agent("anthropic:claude-sonnet-4-5", tools)
print(await agent.ainvoke({"messages": "What repos are indexed?"}))

$ npm i @langchain/mcp-adapters @langchain/langgraph @langchain/anthropic

import { MultiServerMCPClient } from "@langchain/mcp-adapters";
import { createReactAgent } from "@langchain/langgraph/prebuilt";
import { ChatAnthropic } from "@langchain/anthropic";

const client = new MultiServerMCPClient({
  mcpServers: {
    bytebell: { url: "http://127.0.0.1:5757/mcp", transport: "streamable_http" },
  },
});
const tools = await client.getTools();

const agent = createReactAgent({
  llm: new ChatAnthropic({ model: "claude-sonnet-4-5" }),
  tools,
});
console.log(await agent.invoke({ messages: "What repos are indexed?" }));

$ uv add deepagents langchain-mcp-adapters

from deepagents import create_deep_agent
from langchain_mcp_adapters.client import MultiServerMCPClient

client = MultiServerMCPClient({
    "bytebell": {"url": "http://127.0.0.1:5757/mcp", "transport": "streamable_http"}
})
agent = create_deep_agent(
    model="anthropic:claude-sonnet-4-5",
    tools=await client.get_tools(),
)

$ npm i deepagents @langchain/mcp-adapters @langchain/anthropic

import { createDeepAgent } from "deepagents";
import { MultiServerMCPClient } from "@langchain/mcp-adapters";
import { ChatAnthropic } from "@langchain/anthropic";

const client = new MultiServerMCPClient({
  mcpServers: {
    bytebell: { url: "http://127.0.0.1:5757/mcp", transport: "streamable_http" },
  },
});
const agent = createDeepAgent({
  model: new ChatAnthropic({ model: "claude-sonnet-4-5" }),
  tools: await client.getTools(),
});

$ npm i ai @ai-sdk/anthropic @modelcontextprotocol/sdk

import { experimental_createMCPClient, generateText } from "ai";
import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
import { anthropic } from "@ai-sdk/anthropic";

const mcp = await experimental_createMCPClient({
  transport: new StreamableHTTPClientTransport(new URL("http://127.0.0.1:5757/mcp")),
});

const { text } = await generateText({
  model: anthropic("claude-sonnet-4-5"),
  tools: await mcp.tools(),
  prompt: "What repos are indexed?",
});
console.log(text);

$ pip install pydantic-ai

from pydantic_ai import Agent
from pydantic_ai.mcp import MCPServerStreamableHTTP

bytebell = MCPServerStreamableHTTP("http://127.0.0.1:5757/mcp")
agent = Agent("claude-sonnet-4-5", toolsets=[bytebell])

async with agent:
    print((await agent.run("What repos are indexed?")).output)

$ npm i @mastra/core @mastra/mcp

import { Agent } from "@mastra/core/agent";
import { MCPClient } from "@mastra/mcp";
import { anthropic } from "@ai-sdk/anthropic";

const mcp = new MCPClient({
  servers: { bytebell: { url: new URL("http://127.0.0.1:5757/mcp") } },
});

const agent = new Agent({
  name: "x",
  instructions: "Use bytebell.",
  model: anthropic("claude-sonnet-4-5"),
  tools: await mcp.getTools(),
});