MCP 커넥터

ant beta:messages create --beta mcp-client-2025-11-20 <<'YAML'
model: claude-opus-5-5
max_tokens: 1000
messages:
  - role: user
    content: What tools do you have available?
mcp_servers:
  - type: url
    url: https://example-server.modelcontextprotocol.io/sse
    name: example-mcp
    authorization_token: YOUR_TOKEN
tools:
  - type: mcp_toolset
    mcp_server_name: example-mcp
YAML

client = anthropic.Anthropic()

response = client.beta.messages.create(
    model="claude-opus-5-5",
    max_tokens=1000,
    messages=[{"role": "user", "content": "What tools do you have available?"}],
    mcp_servers=[
        {
            "type": "url",
            "url": "https://example-server.modelcontextprotocol.io/sse",
            "name": "example-mcp",
            "authorization_token": "YOUR_TOKEN",
        }
    ],
    tools=[{"type": "mcp_toolset", "mcp_server_name": "example-mcp"}],
    betas=["mcp-client-2025-11-20"],
)

print(response)

const anthropic = new Anthropic();

const response = await anthropic.beta.messages.create({
  model: "claude-opus-5-5",
  max_tokens: 1000,
  messages: [
    {
      role: "user",
      content: "What tools do you have available?"
    }
  ],
  mcp_servers: [
    {
      type: "url",
      url: "https://example-server.modelcontextprotocol.io/sse",
      name: "example-mcp",
      authorization_token: "YOUR_TOKEN"
    }
  ],
  tools: [
    {
      type: "mcp_toolset",
      mcp_server_name: "example-mcp"
    }
  ],
  betas: ["mcp-client-2025-11-20"]
});

console.log(response);

AnthropicClient client = new();

var parameters = new MessageCreateParams
{
    Model = Model.ClaudeOpus5_5,
    MaxTokens = 1000,
    Messages = new List<BetaMessageParam>
    {
        new() { Role = Role.User, Content = "What tools do you have available?" }
    },
    McpServers = new List<BetaRequestMcpServerUrlDefinition>
    {
        new()
        {
            Url = "https://example-server.modelcontextprotocol.io/sse",
            Name = "example-mcp",
            AuthorizationToken = "YOUR_TOKEN"
        }
    },
    Tools = new List<BetaToolUnion>
    {
        new BetaMcpToolset("example-mcp")
    },
    Betas = [AnthropicBeta.McpClient2025_11_20]
};

var message = await client.Beta.Messages.Create(parameters);
Console.WriteLine(message);

client := anthropic.NewClient()

response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
	Model:     anthropic.ModelClaudeOpus5_5,
	MaxTokens: 1000,
	Messages: []anthropic.BetaMessageParam{
		anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("What tools do you have available?")),
	},
	MCPServers: []anthropic.BetaRequestMCPServerURLDefinitionParam{
		{
			URL:                "https://example-server.modelcontextprotocol.io/sse",
			Name:               "example-mcp",
			AuthorizationToken: anthropic.String("YOUR_TOKEN"),
		},
	},
	Tools: []anthropic.BetaToolUnionParam{
		{OfMCPToolset: &anthropic.BetaMCPToolsetParam{
			MCPServerName: "example-mcp",
		}},
	},
	Betas: []anthropic.AnthropicBeta{
		anthropic.AnthropicBetaMCPClient2025_11_20,
	},
})
if err != nil {
	log.Fatal(err)
}
fmt.Println(response)

import com.anthropic.models.beta.messages.BetaMcpToolset;
// ...
import com.anthropic.models.beta.messages.BetaRequestMcpServerUrlDefinition;
// ...

void main() {
    AnthropicClient client = AnthropicOkHttpClient.fromEnv();

    MessageCreateParams params = MessageCreateParams.builder()
        .model(Model.CLAUDE_OPUS_5_5)
        .maxTokens(1000L)
        .addUserMessage("What tools do you have available?")
        .addMcpServer(BetaRequestMcpServerUrlDefinition.builder()
            .url("https://example-server.modelcontextprotocol.io/sse")
            .name("example-mcp")
            .authorizationToken("YOUR_TOKEN")
            .build())
        .addTool(BetaMcpToolset.builder()
            .mcpServerName("example-mcp")
            .build())
        .addBeta(AnthropicBeta.MCP_CLIENT_2025_11_20)
        .build();

    BetaMessage response = client.beta().messages().create(params);
    IO.println(response);
}

$client = new Client();

$message = $client->beta->messages->create(
    maxTokens: 1000,
    messages: [
        ['role' => 'user', 'content' => 'What tools do you have available?']
    ],
    model: 'claude-opus-5-5',
    mcpServers: [
        [
            'type' => 'url',
            'url' => 'https://example-server.modelcontextprotocol.io/sse',
            'name' => 'example-mcp',
            'authorization_token' => 'YOUR_TOKEN',
        ],
    ],
    tools: [
        [
            'type' => 'mcp_toolset',
            'mcp_server_name' => 'example-mcp',
        ],
    ],
    betas: ['mcp-client-2025-11-20'],
);

echo $message;

client = Anthropic::Client.new

response = client.beta.messages.create(
  model: "claude-opus-5-5",
  max_tokens: 1000,
  messages: [
    { role: "user", content: "What tools do you have available?" }
  ],
  mcp_servers: [
    {
      type: "url",
      url: "https://example-server.modelcontextprotocol.io/sse",
      name: "example-mcp",
      authorization_token: "YOUR_TOKEN"
    }
  ],
  tools: [
    {
      type: "mcp_toolset",
      mcp_server_name: "example-mcp"
    }
  ],
  betas: ["mcp-client-2025-11-20"]
)

puts response

First request: the toolset isn't pinned, so the API asks the server for

its tools and the response starts with an mcp_tool_listing block.

tee shows the response on stderr while the variable captures it.

FIRST=$(curl -sS https://api.anthropic.com/v1/messages
-H "content-type: application/json"
-H "x-api-key: $ANTHR...KEY"
-H "anthropic-version: 2023-06-01"
-H "anthropic-beta: mcp-client-2026-09-15"
-d "$BODY" | tee /dev/stderr)

Pin the list: copy the block's tools into the toolset. The API uses

exactly these entries and doesn't ask the server again.

TOOLS=$(jq '.content[] | select(.type == "mcp_tool_listing") | .tools'
<<<"$FIRST") PINNED=$(jq --argjson tools "$TOOLS" '.tools[0].tools = $tools' <<<"$BODY")

With a pinned toolset, the response has no mcp_tool_listing block.

curl https://api.anthropic.com/v1/messages
-H "content-type: application/json"
-H "x-api-key: $ANTHR...KEY"
-H "anthropic-version: 2023-06-01"
-H "anthropic-beta: mcp-client-2026-09-15"
-d "$PINNED"

```bash CLI
request=$(cat <<'YAML'
model: claude-opus-5-5
max_tokens: 1024
mcp_servers:
  - type: url
    url: https://example-server.modelcontextprotocol.io/sse
    name: example-mcp
    authorization_token: YOUR_TOKEN
tools:
  - type: mcp_toolset
    mcp_server_name: example-mcp
messages:
  - role: user
    content: What tools do you have available?
YAML
)

# First request: the toolset isn't pinned, so the API asks the server for
# its tools and the response starts with an mcp_tool_listing block.
# tee shows the response on stderr while the variable captures it.
first=$(ant beta:messages create --beta mcp-client-2026-09-15 --format json \
  <<<"$request" | tee /dev/stderr)
tools=$(jq -c '.content[] | select(.type == "mcp_tool_listing") | .tools' \
  <<<"$first")

# Pin the list: copy the block's tools into the toolset. The --tool flag
# replaces the body's tools array. The API uses exactly these entries and
# doesn't ask the server again, so the response has no mcp_tool_listing block.
ant beta:messages create --beta mcp-client-2026-09-15 \
  --tool "{type: mcp_toolset, mcp_server_name: example-mcp, tools: $tools}" \
  <<<"$request"

from anthropic.types.beta import (
    BetaMessageParam,
    BetaRequestMCPServerURLDefinitionParam,
)

client = anthropic.Anthropic()

mcp_servers: list[BetaRequestMCPServerURLDefinitionParam] = [
    {
        "type": "url",
        "url": "https://example-server.modelcontextprotocol.io/sse",
        "name": "example-mcp",
        "authorization_token": "YOUR_TOKEN",
    },
]
messages: list[BetaMessageParam] = [
    {"role": "user", "content": "What tools do you have available?"},
]

# First request: the toolset isn't pinned, so the API asks the server for
# its tools and the response starts with an mcp_tool_listing block.
first = client.beta.messages.create(
    model="claude-opus-5-5",
    max_tokens=1024,
    betas=["mcp-client-2026-09-15"],
    mcp_servers=mcp_servers,
    tools=[{"type": "mcp_toolset", "mcp_server_name": "example-mcp"}],
    messages=messages,
)

listing = next(block for block in first.content if block.type == "mcp_tool_listing")
print([tool.name for tool in listing.tools])

# Pin the list: copy the block's tools into the toolset. The API uses
# exactly these entries and doesn't ask the server again.
second = client.beta.messages.create(
    model="claude-opus-5-5",
    max_tokens=1024,
    betas=["mcp-client-2026-09-15"],
    mcp_servers=mcp_servers,
    tools=[
        {
            "type": "mcp_toolset",
            "mcp_server_name": "example-mcp",
            "tools": [
                {
                    "name": tool.name,
                    "description": tool.description,
                    "input_schema": tool.input_schema,
                }
                for tool in listing.tools
            ],
        },
    ],
    messages=messages,
)

# With a pinned toolset, the response has no mcp_tool_listing block.
print([block.type for block in second.content])

const client = new Anthropic();

const mcpServers: Anthropic.Beta.BetaRequestMCPServerURLDefinition[] = [
  {
    type: "url",
    url: "https://example-server.modelcontextprotocol.io/sse",
    name: "example-mcp",
    authorization_token: "YOUR_TOKEN"
  }
];
const messages: Anthropic.Beta.BetaMessageParam[] = [
  { role: "user", content: "What tools do you have available?" }
];

// First request: the toolset isn't pinned, so the API asks the server for
// its tools and the response starts with an mcp_tool_listing block.
const first = await client.beta.messages.create({
  model: "claude-opus-5-5",
  max_tokens: 1024,
  betas: ["mcp-client-2026-09-15"],
  mcp_servers: mcpServers,
  tools: [{ type: "mcp_toolset", mcp_server_name: "example-mcp" }],
  messages
});

const listing = first.content.find((block) => block.type === "mcp_tool_listing");
if (!listing) {
  throw new Error("The response has no mcp_tool_listing block.");
}
console.log(listing.tools.map((tool) => tool.name));

// Pin the list: copy the block's tools into the toolset. The API uses
// exactly these entries and doesn't ask the server again.
const second = await client.beta.messages.create({
  model: "claude-opus-5-5",
  max_tokens: 1024,
  betas: ["mcp-client-2026-09-15"],
  mcp_servers: mcpServers,
  tools: [
    {
      type: "mcp_toolset",
      mcp_server_name: "example-mcp",
      tools: listing.tools
    }
  ],
  messages
});

// With a pinned toolset, the response has no mcp_tool_listing block.
console.log(second.content.map((block) => block.type));

using Anthropic.Models.Beta;
using Anthropic.Models.Beta.Messages;
using Messages = Anthropic.Models.Messages;

AnthropicClient client = new();

List<BetaRequestMcpServerUrlDefinition> mcpServers =
[
    new()
    {
        Url = "https://example-server.modelcontextprotocol.io/sse",
        Name = "example-mcp",
        AuthorizationToken = "YOUR_TOKEN",
    },
];
List<BetaMessageParam> messages =
[
    new() { Role = Role.User, Content = "What tools do you have available?" },
];

// First request: the toolset isn't pinned, so the API asks the server for
// its tools and the response starts with an mcp_tool_listing block.
var first = await client.Beta.Messages.Create(new MessageCreateParams
{
    Model = Messages::Model.ClaudeOpus5_5,
    MaxTokens = 1024,
    Betas = [AnthropicBeta.McpClient2026_09_15],
    McpServers = mcpServers,
    Tools = [new BetaMcpToolset("example-mcp")],
    Messages = messages,
});

var listing = first.Content
    .Select(block => block.Value)
    .OfType<BetaMcpToolListingBlock>()
    .First();
Console.WriteLine(string.Join(", ", listing.Tools.Select(tool => tool.Name)));

// Pin the list: copy the block's tools into the toolset. The API uses
// exactly these entries and doesn't ask the server again.
var second = await client.Beta.Messages.Create(new MessageCreateParams
{
    Model = Messages::Model.ClaudeOpus5_5,
    MaxTokens = 1024,
    Betas = [AnthropicBeta.McpClient2026_09_15],
    McpServers = mcpServers,
    Tools =
    [
        new BetaMcpToolset("example-mcp")
        {
            Tools =
            [
                .. listing.Tools.Select(tool => new BetaMcpToolParam
                {
                    Name = tool.Name,
                    Description = tool.Description,
                    InputSchema = tool.InputSchema,
                }),
            ],
        },
    ],
    Messages = messages,
});

// With a pinned toolset, the response has no mcp_tool_listing block.
Console.WriteLine(string.Join(", ", second.Content.Select(block => block.Type)));

client := anthropic.NewClient()

mcpServers := []anthropic.BetaRequestMCPServerURLDefinitionParam{
	{
		URL:                "https://example-server.modelcontextprotocol.io/sse",
		Name:               "example-mcp",
		AuthorizationToken: anthropic.String("YOUR_TOKEN"),
	},
}
messages := []anthropic.BetaMessageParam{
	anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("What tools do you have available?")),
}

// First request: the toolset isn't pinned, so the API asks the server for
// its tools and the response starts with an mcp_tool_listing block.
first, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
	Model:      anthropic.ModelClaudeOpus5_5,
	MaxTokens:  1024,
	Betas:      []anthropic.AnthropicBeta{anthropic.AnthropicBetaMCPClient2026_09_15},
	MCPServers: mcpServers,
	Tools: []anthropic.BetaToolUnionParam{
		{OfMCPToolset: &anthropic.BetaMCPToolsetParam{MCPServerName: "example-mcp"}},
	},
	Messages: messages,
})
if err != nil {
	log.Fatal(err)
}

var listing anthropic.BetaMCPToolListingBlock
for _, block := range first.Content {
	if listingBlock, ok := block.AsAny().(anthropic.BetaMCPToolListingBlock); ok {
		listing = listingBlock
		break
	}
}

// Pin the list: copy the block's tools into the toolset. The API uses
// exactly these entries and doesn't ask the server again.
var toolNames []string
var pinnedTools []anthropic.BetaMCPToolParam
for _, tool := range listing.Tools {
	toolNames = append(toolNames, tool.Name)
	pinnedTools = append(pinnedTools, anthropic.BetaMCPToolParam{
		Name:        tool.Name,
		Description: anthropic.String(tool.Description),
		InputSchema: tool.InputSchema,
	})
}
fmt.Println(toolNames)

second, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
	Model:      anthropic.ModelClaudeOpus5_5,
	MaxTokens:  1024,
	Betas:      []anthropic.AnthropicBeta{anthropic.AnthropicBetaMCPClient2026_09_15},
	MCPServers: mcpServers,
	Tools: []anthropic.BetaToolUnionParam{
		{OfMCPToolset: &anthropic.BetaMCPToolsetParam{
			MCPServerName: "example-mcp",
			Tools:         pinnedTools,
		}},
	},
	Messages: messages,
})
if err != nil {
	log.Fatal(err)
}

// With a pinned toolset, the response has no mcp_tool_listing block.
var blockTypes []string
for _, block := range second.Content {
	blockTypes = append(blockTypes, block.Type)
}
fmt.Println(blockTypes)

import com.anthropic.models.beta.AnthropicBeta;
import com.anthropic.models.beta.messages.BetaMcpTool;
import com.anthropic.models.beta.messages.BetaMcpToolListingBlock;
import com.anthropic.models.beta.messages.BetaMcpToolset;
import com.anthropic.models.beta.messages.BetaMessage;
import com.anthropic.models.beta.messages.BetaRequestMcpServerUrlDefinition;
import com.anthropic.models.beta.messages.MessageCreateParams;
// ...

void main() {
    AnthropicClient client = AnthropicOkHttpClient.fromEnv();

    BetaRequestMcpServerUrlDefinition mcpServer = BetaRequestMcpServerUrlDefinition.builder()
        .url("https://example-server.modelcontextprotocol.io/sse")
        .name("example-mcp")
        .authorizationToken("YOUR_TOKEN")
        .build();

    // First request: the toolset isn't pinned, so the API asks the server for
    // its tools and the response starts with an mcp_tool_listing block.
    BetaMessage first = client.beta().messages().create(MessageCreateParams.builder()
        .model(Model.CLAUDE_OPUS_5_5)
        .maxTokens(1024)
        .addBeta(AnthropicBeta.MCP_CLIENT_2026_09_15)
        .addMcpServer(mcpServer)
        .addTool(BetaMcpToolset.builder()
            .mcpServerName("example-mcp")
            .build())
        .addUserMessage("What tools do you have available?")
        .build());

    BetaMcpToolListingBlock listing = first.content().stream()
        .flatMap(block -> block.mcpToolListing().stream())
        .findFirst()
        .orElseThrow();
    IO.println(listing.tools().stream().map(BetaMcpTool::name).toList());

    // Pin the list: copy the block's tools into the toolset. The API uses
    // exactly these entries and doesn't ask the server again.
    BetaMessage second = client.beta().messages().create(MessageCreateParams.builder()
        .model(Model.CLAUDE_OPUS_5_5)
        .maxTokens(1024)
        .addBeta(AnthropicBeta.MCP_CLIENT_2026_09_15)
        .addMcpServer(mcpServer)
        .addTool(BetaMcpToolset.builder()
            .mcpServerName("example-mcp")
            .tools(listing.tools().stream().map(BetaMcpTool::toParam).toList())
            .build())
        .addUserMessage("What tools do you have available?")
        .build());

    // With a pinned toolset, the response has no mcp_tool_listing block.
    IO.println(second.content().stream()
        .map(block -> block.type().asString())
        .toList());
}

use Anthropic\Beta\AnthropicBeta;
use Anthropic\Beta\Messages\BetaMCPTool;
use Anthropic\Beta\Messages\BetaMCPToolListingBlock;
// ...

$client = new Client();

$mcpServers = [
    [
        'type' => 'url',
        'url' => 'https://example-server.modelcontextprotocol.io/sse',
        'name' => 'example-mcp',
        'authorization_token' => 'YOUR_TOKEN',
    ],
];
$messages = [['role' => 'user', 'content' => 'What tools do you have available?']];

// First request: the toolset isn't pinned, so the API asks the server for
// its tools and the response starts with an mcp_tool_listing block.
$first = $client->beta->messages->create(
    model: Model::CLAUDE_OPUS_5_5,
    maxTokens: 1024,
    betas: [AnthropicBeta::MCP_CLIENT_2026_09_15],
    mcpServers: $mcpServers,
    tools: [['type' => 'mcp_toolset', 'mcp_server_name' => 'example-mcp']],
    messages: $messages,
);

$listing = array_find($first->content, fn ($block) => $block instanceof BetaMCPToolListingBlock);
echo json_encode(array_map(fn (BetaMCPTool $tool) => $tool->name, $listing->tools)), PHP_EOL;

// Pin the list: copy the block's tools into the toolset. The API uses
// exactly these entries and doesn't ask the server again.
$second = $client->beta->messages->create(
    model: Model::CLAUDE_OPUS_5_5,
    maxTokens: 1024,
    betas: [AnthropicBeta::MCP_CLIENT_2026_09_15],
    mcpServers: $mcpServers,
    tools: [
        [
            'type' => 'mcp_toolset',
            'mcp_server_name' => 'example-mcp',
            'tools' => array_map(
                fn (BetaMCPTool $tool) => [
                    'name' => $tool->name,
                    'description' => $tool->description,
                    'input_schema' => $tool->inputSchema,
                ],
                $listing->tools,
            ),
        ],
    ],
    messages: $messages,
);

// With a pinned toolset, the response has no mcp_tool_listing block.
echo json_encode(array_map(fn ($block) => $block->type, $second->content)), PHP_EOL;

client = Anthropic::Client.new

mcp_servers = [
  {
    type: "url",
    url: "https://example-server.modelcontextprotocol.io/sse",
    name: "example-mcp",
    authorization_token: "YOUR_TOKEN"
  }
]
messages = [{ role: "user", content: "What tools do you have available?" }]

# First request: the toolset isn't pinned, so the API asks the server for
# its tools and the response starts with an mcp_tool_listing block.
first = client.beta.messages.create(
  model: Anthropic::Model::CLAUDE_OPUS_5_5,
  max_tokens: 1024,
  betas: [Anthropic::AnthropicBeta::MCP_CLIENT_2026_09_15],
  mcp_servers:,
  tools: [{ type: "mcp_toolset", mcp_server_name: "example-mcp" }],
  messages:
)

listing = first.content.find { it.is_a?(Anthropic::Beta::BetaMCPToolListingBlock) }
puts listing.tools.map(&:name).inspect

# Pin the list: copy the block's tools into the toolset. The API uses
# exactly these entries and doesn't ask the server again.
second = client.beta.messages.create(
  model: Anthropic::Model::CLAUDE_OPUS_5_5,
  max_tokens: 1024,
  betas: [Anthropic::AnthropicBeta::MCP_CLIENT_2026_09_15],
  mcp_servers:,
  tools: [
    {
      type: "mcp_toolset",
      mcp_server_name: "example-mcp",
      tools: listing.tools.map(&:to_h)
    }
  ],
  messages:
)

# With a pinned toolset, the response has no mcp_tool_listing block.
puts second.content.map(&:type).inspect

import {
  mcpTools,
  mcpMessages,
  mcpResourceToContent,
  mcpResourceToFile
} from "@anthropic-ai/sdk/helpers/beta/mcp";

using Anthropic.Helpers.Beta;
using Anthropic.Helpers.Beta.Mcp;

import (
	"github.com/anthropics/anthropic-sdk-go/mcp"
)

import com.anthropic.helpers.McpBetaTool;
import com.anthropic.mcp.BetaMcp;

use Anthropic\Lib\Tools\BetaMcp;

require "anthropic"

# The helpers are exposed on the Anthropic::Mcp module

client = AsyncAnthropic()

async def main() -> None: # Connect to an MCP server server_params = StdioServerParameters(command="mcp-server") async with stdio_client(server_params) as (read, write): async with ClientSession(read, write) as mcp_client: await mcp_client.initialize()

          # List tools and convert them for the Claude API
          tools_result = await mcp_client.list_tools()
          runner = client.beta.messages.tool_runner(
              model="claude-opus-5-5",
              max_tokens=1024,
              messages=[
                  {"role": "user", "content": "What tools do you have available?"},
              ],
              tools=[async_mcp_tool(tool, mcp_client) for tool in tools_result.tools],
          )

          final_message = await runner.until_done()
          print(final_message)

asyncio.run(main())

```typescript TypeScript
import {
  mcpTools,
  type MCPCallToolResultLike,
  type MCPClientLike
} from "@anthropic-ai/sdk/helpers/beta/mcp";
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";

const anthropic = new Anthropic();

// Connect to an MCP server
const transport = new StdioClientTransport({ command: "mcp-server", args: [] });
const mcpClient = new Client({ name: "my-client", version: "1.0.0" });
await mcpClient.connect(transport);

// List tools and convert them for the Claude API
const { tools } = await mcpClient.listTools();

// The MCP SDK's callTool return type still includes a legacy result shape that
// mcpTools does not accept; narrow it. Drop this once MCPClientLike widens.
const mcpClientForTools: MCPClientLike = {
  callTool: (params) => mcpClient.callTool(params) as Promise<MCPCallToolResultLike>
};

const finalMessage = await anthropic.beta.messages.toolRunner({
  model: "claude-opus-5-5",
  max_tokens: 1024,
  messages: [{ role: "user", content: "What tools do you have available?" }],
  tools: mcpTools(tools, mcpClientForTools)
});

console.log(finalMessage);

using Anthropic.Helpers.Beta;
using Anthropic.Helpers.Beta.Mcp;
using Anthropic.Models.Beta.Messages;
using ModelContextProtocol.Client;
using Messages = Anthropic.Models.Messages;

var anthropic = new AnthropicClient();

// Connect to an MCP server
await using var mcpClient = await McpClient.CreateAsync(
    new StdioClientTransport(new StdioClientTransportOptions { Command = "mcp-server" })
);

// List tools and convert them for the Claude API
var tools = await BetaMcp.ListToolsAsync(mcpClient);
var runner = anthropic.Beta.Messages.ToolRunner(
    new MessageCreateParams
    {
        Model = Messages::Model.ClaudeOpus5_5,
        MaxTokens = 1024,
        Messages =
        [
            new BetaMessageParam
            {
                Role = Role.User,
                Content = "What tools do you have available?",
            },
        ],
    },
    tools
);

var finalMessage = await runner.RunUntilDoneAsync();
Console.WriteLine(finalMessage);

import (
// ...

// ...
	"github.com/anthropics/anthropic-sdk-go/mcp"
	mcpsdk "github.com/modelcontextprotocol/go-sdk/mcp"
)

func main() {
	client := anthropic.NewClient()
	ctx := context.Background()

	// Connect to an MCP server
	mcpClient := mcpsdk.NewClient(&mcpsdk.Implementation{Name: "my-client", Version: "1.0.0"}, nil)
	session, err := mcpClient.Connect(ctx, &mcpsdk.CommandTransport{Command: exec.Command("mcp-server")}, nil)
	if err != nil {
		log.Fatal(err)
	}
	defer session.Close()

	// List tools and convert them for the Claude API
	toolsResult, err := session.ListTools(ctx, nil)
	if err != nil {
		log.Fatal(err)
	}
	betaTools, err := mcp.NewBetaTools(toolsResult.Tools, session)
	if err != nil {
		log.Fatal(err)
	}

	runner := client.Beta.Messages.NewToolRunner(betaTools, anthropic.BetaToolRunnerParams{
		BetaMessageNewParams: anthropic.BetaMessageNewParams{
			Model:     anthropic.ModelClaudeOpus5_5,
			MaxTokens: 1024,
			Messages: []anthropic.BetaMessageParam{
				anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("What tools do you have available?")),
			},
		},
	})

	finalMessage, err := runner.RunToCompletion(ctx)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(finalMessage.RawJSON())
}

import com.anthropic.helpers.BetaToolRunner;
import com.anthropic.helpers.McpBetaTool;
import com.anthropic.mcp.BetaMcp;
import com.anthropic.models.beta.messages.BetaMessage;
import com.anthropic.models.beta.messages.MessageCreateParams;
import com.anthropic.models.messages.Model;
import io.modelcontextprotocol.client.McpClient;
import io.modelcontextprotocol.client.McpSyncClient;
import io.modelcontextprotocol.client.transport.ServerParameters;
import io.modelcontextprotocol.client.transport.StdioClientTransport;
import io.modelcontextprotocol.json.McpJsonDefaults;
import io.modelcontextprotocol.spec.McpSchema;
// ...

void main() throws Exception {
    AnthropicClient anthropic = AnthropicOkHttpClient.fromEnv();

    // Connect to an MCP server
    StdioClientTransport transport = new StdioClientTransport(
            ServerParameters.builder("mcp-server").build(), McpJsonDefaults.getMapper());

    try (McpSyncClient mcpClient = McpClient.sync(transport)
            .clientInfo(new McpSchema.Implementation("my-client", "1.0.0"))
            .build()) {

        mcpClient.initialize();

        // List tools and convert them for the Claude API
        List<McpBetaTool> betaTools = BetaMcp.mcpTools(mcpClient.listTools().tools(), mcpClient);

        MessageCreateParams params = MessageCreateParams.builder()
                .model(Model.CLAUDE_OPUS_5_5)
                .maxTokens(1024L)
                .addUserMessage("What tools do you have available?")
                .addTools(betaTools)
                .build();

        // The runner yields one message per assistant turn; the last is the final response
        BetaToolRunner runner = anthropic.beta().messages().toolRunner(params);
        BetaMessage finalMessage = null;
        for (BetaMessage message : runner) {
            finalMessage = message;
        }
        IO.println(finalMessage);
    }
}

use Anthropic\Lib\Tools\BetaMcp;
use Mcp\Client;
use Mcp\Client\Transport\HttpTransport;

$anthropic = new Anthropic();

// Connect to an MCP server. The PHP MCP client connects over HTTP; point this
// at your server's endpoint.
$mcp = Client::builder()->build();
$mcp->connect(new HttpTransport('http://localhost:8000/mcp'));

// List tools and convert them for the Claude API
$runner = $anthropic->beta->messages->toolRunner(
    maxTokens: 1024,
    messages: [['role' => 'user', 'content' => 'What tools do you have available?']],
    model: 'claude-opus-5-5',
    tools: BetaMcp::tools($mcp->listTools()->tools, $mcp),
);

echo $runner->runUntilDone(), "\n";

require "mcp"

anthropic = Anthropic::Client.new

# Connect to an MCP server
transport = MCP::Client::Stdio.new(command: "mcp-server")
mcp_client = MCP::Client.new(transport: transport)
mcp_client.connect

# List tools and convert them for the Claude API
runner = anthropic.beta.messages.tool_runner(
  model: "claude-opus-5-5",
  max_tokens: 1024,
  messages: [{ role: "user", content: "What tools do you have available?" }],
  tools: Anthropic::Mcp.tools(mcp_client.tools, mcp_client)
)

final_message = runner.run_until_finished.last
puts final_message

prompt = await mcp_client.get_prompt(name="my-prompt") response = await client.beta.messages.create( model="claude-opus-5-5", max_tokens=1024, messages=[mcp_message(message) for message in prompt.messages], )

print(response)

```typescript TypeScript
import { mcpMessages } from "@anthropic-ai/sdk/helpers/beta/mcp";

const { messages } = await mcpClient.getPrompt({ name: "my-prompt" });
const response = await anthropic.beta.messages.create({
  model: "claude-opus-5-5",
  max_tokens: 1024,
  messages: mcpMessages(messages)
});

console.log(response);

var prompt = await mcpClient.GetPromptAsync("my-prompt");
var response = await anthropic.Beta.Messages.Create(
    new MessageCreateParams
    {
        Model = Messages::Model.ClaudeOpus5_5,
        MaxTokens = 1024,
        Messages = BetaMcp.Messages(prompt.Messages),
    }
);

Console.WriteLine(response);

prompt, err := session.GetPrompt(ctx, &mcpsdk.GetPromptParams{Name: "my-prompt"})
if err != nil {
	log.Fatal(err)
}

messages := make([]anthropic.BetaMessageParam, 0, len(prompt.Messages))
for _, promptMessage := range prompt.Messages {
	message, err := mcp.ToMessage(promptMessage)
	if err != nil {
		log.Fatal(err)
	}
	messages = append(messages, message)
}

response, err := client.Beta.Messages.New(ctx, anthropic.BetaMessageNewParams{
	Model:     anthropic.ModelClaudeOpus5_5,
	MaxTokens: 1024,
	Messages:  messages,
})
if err != nil {
	log.Fatal(err)
}
fmt.Println(response.RawJSON())

McpSchema.GetPromptResult prompt = mcpClient.getPrompt(
        new McpSchema.GetPromptRequest("my-prompt", Map.of()));

BetaMessage response = anthropic.beta().messages().create(MessageCreateParams.builder()
        .model(Model.CLAUDE_OPUS_5_5)
        .maxTokens(1024L)
        .messages(BetaMcp.mcpMessages(prompt.messages()))
        .build());

IO.println(response);

$prompt = $mcp->getPrompt('my-prompt');

$response = $anthropic->beta->messages->create(
    maxTokens: 1024,
    messages: array_map(BetaMcp::message(...), $prompt->messages),
    model: 'claude-opus-5-5',
);

echo $response, "\n";

prompt = mcp_client.get_prompt(name: "my-prompt")

response = anthropic.beta.messages.create(
  model: "claude-opus-5-5",
  max_tokens: 1024,
  messages: prompt["messages"].map { |message| Anthropic::Mcp.message(message) }
)

puts response

As a content block in a message

resource = await mcp_client.read_resource(uri="file:///path/to/doc.txt") response = await client.beta.messages.create( model="claude-opus-5-5", max_tokens=1024, messages=[ { "role": "user", "content": [ mcp_resource_to_content(resource), {"type": "text", "text": "Summarize this document"}, ], } ], ) print(response)

As a file upload

file_resource = await mcp_client.read_resource( uri="file:///path/to/data.json", ) uploaded = await client.files.upload( file=mcp_resource_to_file(file_resource), ) print(uploaded.id)

```typescript TypeScript
import { mcpResourceToContent, mcpResourceToFile } from "@anthropic-ai/sdk/helpers/beta/mcp";

// As a content block in a message
const resource = await mcpClient.readResource({ uri: "file:///path/to/doc.txt" });
const response = await anthropic.beta.messages.create({
  model: "claude-opus-5-5",
  max_tokens: 1024,
  messages: [
    {
      role: "user",
      content: [
        mcpResourceToContent(resource),
        { type: "text", text: "Summarize this document" }
      ]
    }
  ]
});
console.log(response);

// As a file upload
const fileResource = await mcpClient.readResource({ uri: "file:///path/to/data.json" });
const uploaded = await anthropic.files.upload({ file: mcpResourceToFile(fileResource) });
console.log(uploaded.id);

// As a content block in a message
var resource = await mcpClient.ReadResourceAsync("file:///path/to/doc.txt");
var response = await anthropic.Beta.Messages.Create(
    new MessageCreateParams
    {
        Model = Messages::Model.ClaudeOpus5_5,
        MaxTokens = 1024,
        Messages =
        [
            new BetaMessageParam
            {
                Role = Role.User,
                Content = new BetaMessageParamContent(
                    [
                        BetaMcp.ResourceToContent(resource),
                        new BetaTextBlockParam { Text = "Summarize this document" },
                    ]
                ),
            },
        ],
    }
);

Console.WriteLine(response);

// As a file upload
var fileResource = await mcpClient.ReadResourceAsync("file:///path/to/data.json");
var (filename, data, mediaType) = BetaMcp.ResourceToFile(fileResource);

// Build the file part explicitly so the resource's filename and MIME type
// carry through to the upload.
var file = new BinaryContent { Stream = new MemoryStream(data), FileName = filename };
if (mediaType is not null)
{
    file.ContentType = new(mediaType);
}

var uploaded = await anthropic.Files.Upload(new FileUploadParams { File = file });
Console.WriteLine(uploaded.ID);

// As a content block in a message
resource, err := session.ReadResource(ctx, &mcpsdk.ReadResourceParams{URI: "file:///path/to/doc.txt"})
if err != nil {
	log.Fatal(err)
}
block, err := mcp.ResourceToBlock(resource)
if err != nil {
	log.Fatal(err)
}

response, err := client.Beta.Messages.New(ctx, anthropic.BetaMessageNewParams{
	Model:     anthropic.ModelClaudeOpus5_5,
	MaxTokens: 1024,
	Messages: []anthropic.BetaMessageParam{
		anthropic.NewBetaUserMessage(
			// ResourceToBlock returns the tool-result content union; message
			// content is a separate union type, so re-wrap the shared variants
			// (mcp.ToMessage does the same internally).
			anthropic.BetaContentBlockParamUnion{
				OfText:     block.OfText,
				OfImage:    block.OfImage,
				OfDocument: block.OfDocument,
			},
			anthropic.NewBetaTextBlock("Summarize this document"),
		),
	},
})
if err != nil {
	log.Fatal(err)
}
fmt.Println(response.RawJSON())

// As a file upload
fileResult, err := session.ReadResource(ctx, &mcpsdk.ReadResourceParams{URI: "file:///path/to/data.json"})
if err != nil {
	log.Fatal(err)
}
fileReader, err := mcp.ResourceToFile(fileResult)
if err != nil {
	log.Fatal(err)
}
uploaded, err := client.Files.Upload(ctx, anthropic.FileUploadParams{File: fileReader})
if err != nil {
	log.Fatal(err)
}
fmt.Println(uploaded.ID)

// As a content block in a message
McpSchema.ReadResourceResult resource = mcpClient.readResource(
        new McpSchema.ReadResourceRequest("file:///path/to/doc.txt"));

List<BetaContentBlockParam> content =
        new ArrayList<>(BetaMcp.mcpResourceContents(resource));
content.add(BetaContentBlockParam.ofText(
        BetaTextBlockParam.builder().text("Summarize this document").build()));

BetaMessage response = anthropic.beta().messages().create(MessageCreateParams.builder()
        .model(Model.CLAUDE_OPUS_5_5)
        .maxTokens(1024L)
        .addUserMessageOfBetaContentBlockParams(content)
        .build());

IO.println(response);

// As a file upload
McpSchema.ReadResourceResult fileResource = mcpClient.readResource(
        new McpSchema.ReadResourceRequest("file:///path/to/data.json"));

McpResourceFile resourceFile = BetaMcp.mcpResourceFiles(fileResource).getFirst();

// Build the file part explicitly so the resource's filename and MIME type
// carry through to the upload.
MultipartField.Builder<InputStream> fileField = MultipartField.<InputStream>builder()
        .value(new ByteArrayInputStream(resourceFile.content()))
        .filename(resourceFile.filename());
if (resourceFile.mimeType() != null) {
    fileField.contentType(resourceFile.mimeType());
}

var uploaded = anthropic.files().upload(FileUploadParams.builder()
        .file(fileField.build())
        .build());

IO.println(uploaded.id());

// As a content block in a message
$resource = $mcp->readResource('file:///path/to/doc.txt');

$response = $anthropic->beta->messages->create(
    maxTokens: 1024,
    messages: [
        [
            'role' => 'user',
            'content' => [
                BetaMcp::resourceToContent($resource),
                ['type' => 'text', 'text' => 'Summarize this document'],
            ],
        ],
    ],
    model: 'claude-opus-5-5',
);

echo $response, "\n";

// As a file upload
$fileResource = $mcp->readResource('file:///path/to/data.json');
$file = $anthropic->files->upload(file: BetaMcp::resourceToFile($fileResource));
echo $file->id, "\n";

# As a content block in a message
resource = mcp_client.read_resource(uri: "file:///path/to/doc.txt")

response = anthropic.beta.messages.create(
  model: "claude-opus-5-5",
  max_tokens: 1024,
  messages: [
    {
      role: "user",
      content: [
        *Anthropic::Mcp.resource_to_contents(resource),
        { type: "text", text: "Summarize this document" }
      ]
    }
  ]
)

puts response

# As a file upload
file_resource = mcp_client.read_resource(uri: "file:///path/to/data.json")
file = Anthropic::Mcp.resource_to_files(file_resource).first
uploaded_file = anthropic.files.upload(file: file)
puts uploaded_file.id