Anthropic Python SDK

Install the anthropic package using pip to use the Anthropic Foundry client.

pip install anthropic

To use the Claude Platform on Google Cloud, you must install the anthropic package with the google_cloud optional dependency:

pip install "anthropic[google_cloud]"

The SDK provides helpers to convert Model Context Protocol (MCP) types to Anthropic API types. This is useful for local MCP servers.

Requirement: pip install anthropic[mcp] (Python 3.10+)

When to use MCP helpers vs mcp_servers parameter:

• Use mcp_servers for remote servers accessible via URL (tool support only).
• Use MCP helpers for local servers, or when you need access to MCP prompts, resources, or more granular connection control.

Use client.messages.stream() as an asynchronous context manager to receive a MessageStream. This stream allows you to iterate over events, use lenses like .text_stream for easy text access, and accumulate the final message object.

Note: The synchronous client provides the same interface without async/await. The stream is cancelled when the context manager exits, but you can call stream.close() to abort early.

async with client.messages.stream(
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": "Say hello there!",
        }
    ],
    model="claude-sonnet-5",
) as stream:
    async for text in stream.text_stream:
        print(text, end="", flush=True)
    print()

To use the SDK, import the Anthropic class and initialize a client. By default, the client looks for an API key in the ANTHROPIC_API_KEY environment variable, so you can omit the api_key argument if it is set. Use client.messages.create to send messages to Claude models.

import os
from anthropic import Anthropic

client = Anthropic(
    api_key=os.environ.get("ANTHROPIC_API_KEY"),  # This is the default and can be omitted
)

message = client.messages.create(
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": "Hello, Claude",
        }
    ],

    model="claude-opus-4-6",
)

print(message.content)

You can define tools for Claude by using the @beta_tool decorator on a Python function. The decorator automatically inspects the function's arguments and docstring to generate a JSON schema for the tool's input_schema.

If you are using an asynchronous client, use the @beta_async_tool decorator and define your function with async def instead.

from anthropic import beta_tool

@beta_tool
def sum(left: int, right: int) -> str:
    """Adds two integers together.
    Args:
        left (int): The first integer to add.
        right (int): The second integer to add.
    Returns:
        int: The sum of left and right integers.
    """
    return str(left + right)

The AnthropicGoogleCloud client authenticates using Google Cloud IAM credentials. It does not use ANTHROPIC_API_KEY, ANTHROPIC_AUTH_TOKEN, or ANTHROPIC_BASE_URL.

Authentication follows this precedence (first match wins, unless skip_auth=True):

1. token_provider: A callable returning a GCP access token (invoked on every request).
2. credentials: A google.auth.Credentials object.
3. Application Default Credentials (ADC): Discovered via google.auth.default() (e.g., via gcloud auth application-default login or GOOGLE_APPLICATION_CREDENTIALS).

A workspace_id is required unless skip_auth=True is used with an explicit base_url.

Install the anthropic package using pip to access the Claude API from your Python applications.

pip install anthropic

The following configuration options can be passed to the client constructor or set via environment variables:

Use AnthropicFoundry (synchronous) or AsyncAnthropicFoundry (asynchronous) to connect to the Claude Platform on Google Cloud/Azure.

Authentication can be provided via an api_key or an azure_ad_token_provider (a callable returning a string or an awaitable returning a string). These two methods are mutually exclusive.

If arguments are not provided, the client automatically infers them from the following environment variables:

• api_key from ANTHROPIC_FOUNDRY_API_KEY
• resource from ANTHROPIC_FOUNDRY_RESOURCE
• base_url from ANTHROPIC_FOUNDRY_BASE_URL

The bash tool executes an unrestricted /bin/bash directly on the host. Unlike the file tools (read, write, edit, glob, grep) which are confined to the workdir, bash is not sandboxed.

Best Practices:

• Run the worker inside a container or another isolation boundary.
• To control the subprocess environment for bash, pass an AgentToolContext(env=...).