---
title: Python SDK
url: https://platform.claude.com/docs/ja/cli-sdks-libraries/sdks/python
description: 同期および非同期クライアントをサポートするAnthropic Python SDKのインストールと設定
---

Anthropic Python SDKは、PythonアプリケーションからClaude APIへの便利なアクセスを提供します。同期および非同期の両方の操作、ストリーミング、そしてAmazon Bedrock、Claude Platform on AWS、Google Cloud、Microsoft Foundryとの統合をサポートしています。

<Info>
  コード例を含むAPI機能のドキュメントについては、[APIリファレンス](https://platform.claude.com/docs/ja/api/overview)を参照してください。このページでは、Python固有のSDK機能と設定について説明します。
</Info>

## インストール

```bash
pip install anthropic
```

プラットフォーム固有の統合や非同期パフォーマンスの向上のためには、extrasを指定してインストールします。

```bash
# Amazon Bedrockサポート用
pip install "anthropic[bedrock]"

# Google Cloudサポート用
pip install "anthropic[vertex]"

# Claude Platform on AWSサポート用
pip install "anthropic[aws]"

# Microsoft Foundryサポートは基本パッケージに含まれています

# aiohttpによる非同期パフォーマンス向上用
pip install "anthropic[aiohttp]"
```

## 要件

Python 3.10以降が必要です。SDKの0.xリリースからアップグレードする場合は、破壊的変更の一覧について[v1移行ガイド](https://github.com/anthropics/anthropic-sdk-python/blob/main/MIGRATION.md)を参照してください。

## 使用方法

```python
import os
from anthropic import Anthropic

client = Anthropic(
    # これはデフォルト値のため、省略できます
    api_key=os.environ.get("ANTHROPIC_API_KEY"),
)

message = client.messages.create(
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": "Hello, Claude",
        }
    ],
    model="claude-opus-5-5",
)

for block in message.content:
    if block.type == "text":
        print(block.text)
```

<Tip>
  APIキーがソース管理に保存されないように、[python-dotenv](https://pypi.org/project/python-dotenv/)を使用して`.env`ファイルに`ANTHROPIC_API_KEY="my-anthropic-api-key"`を追加することを検討してください。
</Tip>

Workload Identity Federationを含む認証オプションについては、[認証](https://platform.claude.com/docs/ja/manage-claude/authentication)を参照してください。お使いのAPIキーが複数のワークスペースにアクセスできる[個人キーまたはサービスアカウントキー](https://platform.claude.com/docs/ja/manage-claude/authentication#key-types)である場合は、`anthropic-workspace-id`リクエストヘッダーにワークスペースIDを設定してください。[ワークスペースを選択する](https://platform.claude.com/docs/ja/manage-claude/authentication#select-a-workspace)では、このSDKにおけるリクエストごとのオプションを示しています。

## 非同期での使用方法

```python
import os
import asyncio
from anthropic import AsyncAnthropic

client = AsyncAnthropic(
    api_key=os.environ.get("ANTHROPIC_API_KEY"),
)


async def main() -> None:
    message = await client.messages.create(
        max_tokens=1024,
        messages=[
            {
                "role": "user",
                "content": "Hello, Claude",
            }
        ],
        model="claude-opus-5-5",
    )
    print(message.content)


asyncio.run(main())
```

### 並行性向上のためのaiohttpの使用

非同期パフォーマンスを向上させるために、デフォルトの`httpx2`の代わりに`aiohttp` HTTPバックエンドを使用できます。

```python
import os
import asyncio
from anthropic import AsyncAnthropic, DefaultAioHttpClient


async def main() -> None:
    async with AsyncAnthropic(
        api_key=os.environ.get("ANTHROPIC_API_KEY"),
        http_client=DefaultAioHttpClient(),
    ) as client:
        message = await client.messages.create(
            max_tokens=1024,
            messages=[
                {
                    "role": "user",
                    "content": "Hello, Claude",
                }
            ],
            model="claude-opus-5-5",
        )
        print(message.content)


asyncio.run(main())
```

## ストリーミングレスポンス

SDKは、Server-Sent Events（SSE）を使用した「streaming」（ストリーミング）レスポンスをサポートしています。

```python
client = Anthropic()

stream = client.messages.create(
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": "Hello, Claude",
        }
    ],
    model="claude-opus-5-5",
    stream=True,
)
for event in stream:
    print(event.type)
```

非同期クライアントもまったく同じインターフェースを使用します。

```python
client = AsyncAnthropic()

stream = await client.messages.create(
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": "Hello, Claude",
        }
    ],
    model="claude-opus-5-5",
    stream=True,
)
async for event in stream:
    print(event.type)
```

### ストリーミングヘルパー

SDKは、コンテキストマネージャーを使用し、蓄積されたテキストと最終メッセージへのアクセスを提供するストリーミングヘルパーも提供しています。

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

        message = await stream.get_final_message()
        print(message.to_json())


asyncio.run(main())
```

`client.messages.stream(...)`によるストリーミングでは、蓄積やSDK固有のイベントを含むさまざまなヘルパーが利用できます。

あるいは、`client.messages.create(..., stream=True)`を使用することもできます。これはストリーム内のイベントのイテラブルのみを返し、メモリ使用量が少なくなります（最終的なメッセージオブジェクトを構築しません）。

## トークンカウント

`usage`レスポンスプロパティを通じて、特定のリクエストの正確な使用量を確認できます。

```python
message = client.messages.create(...)
print(message.usage)
# Usage(input_tokens=25, output_tokens=13)
```

リクエストを行う前にトークンをカウントすることもできます。

```python
count = client.messages.count_tokens(
    model="claude-opus-5-5",
    messages=[{"role": "user", "content": "Hello, world"}],
)
print(count.input_tokens)  # 10
```

## ツール使用

このSDKは、関数呼び出しとしても知られる「tool use」（ツール使用）をサポートしています。詳細については、[Claudeでのツール使用](https://platform.claude.com/docs/ja/agents-and-tools/tool-use/overview)を参照してください。

### ツールヘルパー

SDKは、ツールを純粋なPython関数として定義および実行するためのヘルパーを提供します。`@beta_tool`デコレーターは、関数のシグネチャとdocstringからツールスキーマを生成します。

```python
import json
from anthropic import Anthropic, beta_tool

client = Anthropic()


@beta_tool
def get_weather(location: str) -> str:
    """Get the weather for a given location.

    Args:
        location: The city and state, for example, San Francisco, CA
    Returns:
        A JSON-encoded string with the location, temperature, and weather condition.
    """
    return json.dumps(
        {
            "location": location,
            "temperature": "68°F",
            "condition": "Sunny",
        }
    )


# tool_runner を使用して、ツール呼び出しを自動的に処理します
runner = client.beta.messages.tool_runner(
    max_tokens=1024,
    model="claude-opus-5-5",
    tools=[get_weather],
    messages=[
        {"role": "user", "content": "What is the weather in SF?"},
    ],
)
for message in runner:
    print(message)
```

各イテレーションでAPIリクエストが行われます。レスポンスに指定されたツールのいずれかへの呼び出しが含まれている場合、そのツールは自動的に呼び出され、結果は次のイテレーションでモデルに直接返されます。

このSDKでブラウザ使用ツールまたはコンピュータ使用ツールを実行するには、[SDKツールセットによるブラウザ使用とコンピュータ使用](https://platform.claude.com/docs/ja/agents-and-tools/tool-use/browser-use-sdk)を参照してください。

## メッセージバッチ

このSDKは、`client.messages.batches`の下で[バッチ処理](https://platform.claude.com/docs/ja/build-with-claude/batch-processing)をサポートしています。

### バッチの作成

Message Batchesはリクエストの配列を受け取ります。各オブジェクトには`custom_id`識別子と、標準のMessages APIと同じリクエスト`params`が含まれます。

```python
client.messages.batches.create(
    requests=[
        {
            "custom_id": "my-first-request",
            "params": {
                "model": "claude-opus-5-5",
                "max_tokens": 1024,
                "messages": [{"role": "user", "content": "Hello, world"}],
            },
        },
        {
            "custom_id": "my-second-request",
            "params": {
                "model": "claude-opus-5-5",
                "max_tokens": 1024,
                "messages": [{"role": "user", "content": "Hi again, friend"}],
            },
        },
    ]
)
```

### バッチからの結果の取得

Message Batchの処理が完了すると（`.processing_status == 'ended'`で示されます）、`.batches.results()`で結果にアクセスできます。

```python
client = anthropic.Anthropic()
batch_id = "batch_abc123"
result_stream = client.messages.batches.results(batch_id)
for entry in result_stream:
    if entry.result.type == "succeeded":
        print(entry.result.message.content)
```

## ファイルアップロード

ファイルアップロードに対応するリクエストパラメータは、さまざまな形式で渡すことができます。

* `PathLike`オブジェクト（例：`pathlib.Path`）
* `(filename, content, content_type)`のタプル
* `BinaryIO`ファイルライクオブジェクト

```python
from pathlib import Path
from anthropic import Anthropic

client = Anthropic()

# ファイルパスを使用してアップロード
client.files.upload(
    file=Path("/path/to/file"),
)

# バイトを使用してアップロード
client.files.upload(
    file=("file.txt", b"my bytes", "text/plain"),
)
```

非同期クライアントもまったく同じインターフェースを使用します。`PathLike`インスタンスを渡すと、ファイルの内容は自動的に非同期で読み込まれます。

## エラー処理

ライブラリがAPIに接続できない場合、またはAPIが成功以外のステータスコード（つまり4xxまたは5xxレスポンス）を返した場合、`APIError`のサブクラスが送出されます。

```python
import anthropic
# ...
try:
    message = client.messages.create(
        max_tokens=1024,
        messages=[
            {
                "role": "user",
                "content": "Hello, Claude",
            }
        ],
        model="claude-opus-5-5",
    )
except anthropic.APIConnectionError as e:
    print("The server could not be reached")
    print(e.__cause__)  # an underlying Exception, likely raised within httpx2
except anthropic.RateLimitError as e:
    print("A 429 status code was received; we should back off a bit.")
except anthropic.APIStatusError as e:
    print("Another non-200-range status code was received")
    print(e.status_code)
    print(e.response)
```

エラーコードは以下のとおりです。

| ステータスコード | エラータイプ                     |
| -------- | -------------------------- |
| 400      | `BadRequestError`          |
| 401      | `AuthenticationError`      |
| 403      | `PermissionDeniedError`    |
| 404      | `NotFoundError`            |
| 409      | `ConflictError`            |
| 422      | `UnprocessableEntityError` |
| 429      | `RateLimitError`           |
| >=500    | `InternalServerError`      |
| N/A      | `APIConnectionError`       |

## リクエストID

> リクエストのデバッグの詳細については、[リクエストID](https://platform.claude.com/docs/ja/api/errors#request-id)を参照してください。

SDKのすべてのオブジェクトレスポンスは、`request-id`レスポンスヘッダーから追加される`_request_id`プロパティを提供します。これにより、失敗したリクエストをすばやくログに記録し、Anthropicに報告できます。

```python
message = client.messages.create(
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello, Claude"}],
    model="claude-opus-5-5",
)
print(message._request_id)  # e.g., req_018EeWyXxfu5pfWkrYcMdjWG
```

<Note>
  `_`プレフィックスを使用する他のプロパティとは異なり、`_request_id`プロパティはパブリックです。特に記載がない限り、その他すべての`_`プレフィックスのプロパティ、メソッド、モジュールはプライベートです。
</Note>

## リトライ

特定のエラーは、デフォルトで短い指数バックオフを伴って2回自動的にリトライされます。接続エラー（例：ネットワーク接続の問題による）、408 Request Timeout、409 Conflict、429 Rate Limit、および>=500の内部エラーはすべてデフォルトでリトライされます。

`max_retries`オプションを使用して、これを設定または無効化できます。

```python
# すべてのリクエストのデフォルトを設定します:
client = Anthropic(
    max_retries=0,  # default is 2
)

# または、リクエストごとに設定します:
client.with_options(max_retries=5).messages.create(
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello, Claude"}],
    model="claude-opus-5-5",
)
```

## タイムアウト

デフォルトでは、リクエストは10分後にタイムアウトします。これは`timeout`オプションで設定でき、floatまたは`httpx2.Timeout`オブジェクトを受け付けます。

```python
import httpx2
from anthropic import Anthropic

# すべてのリクエストのデフォルトを設定します:
client = Anthropic(
    timeout=20.0,  # 20 seconds (default is 10 minutes)
)

# より細かく制御する場合:
client = Anthropic(
    timeout=httpx2.Timeout(60.0, read=5.0, write=10.0, connect=2.0),
)

# リクエストごとに上書きします:
client.with_options(timeout=5.0).messages.create(
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello, Claude"}],
    model="claude-opus-5-5",
)
```

タイムアウト時、SDKは`APITimeoutError`をスローします。

タイムアウトしたリクエストは[デフォルトで2回リトライされる](https://platform.claude.com/docs/ja/cli-sdks-libraries/sdks/python#retries)ことに注意してください。

## 長時間のリクエスト

<Warning>
  長時間実行されるリクエストには、ストリーミング[Messages API](https://platform.claude.com/docs/ja/cli-sdks-libraries/sdks/python#streaming-responses)の使用を検討してください。
</Warning>

ストリーミングを使用せずに大きな`max_tokens`値を設定することは避けてください。一部のネットワークでは、一定時間後にアイドル状態の接続が切断される場合があり、その結果、Anthropicからレスポンスを受信せずにリクエストが失敗したり[タイムアウト](https://platform.claude.com/docs/ja/cli-sdks-libraries/sdks/python#timeouts)したりする可能性があります。

非ストリーミングリクエストが約10分以上かかると予想される場合、SDKは`ValueError`をスローします。`stream=True`を渡すか、クライアントまたはリクエストレベルで`timeout`オプションをオーバーライドすると、このエラーは無効になります。

非ストリーミングリクエストで予想されるリクエストの「latency」（レイテンシ）が[タイムアウト](https://platform.claude.com/docs/ja/cli-sdks-libraries/sdks/python#timeouts)より長い場合、クライアントはレスポンスを受信せずに接続を終了してリトライします。

SDKは、一部のネットワークにおけるアイドル接続タイムアウトの影響を軽減するために、[TCPソケットキープアライブ](https://tldp.org/HOWTO/TCP-Keepalive-HOWTO/overview.html)オプションを設定します。これは、カスタムの`http_client`オプションをクライアントに渡すことでオーバーライドできます。

## 自動ページネーション

Claude APIのリストメソッドはページネーションされています。`for`構文を使用して、すべてのページにわたってアイテムを反復処理できます。

```python
client = Anthropic()

all_batches = []
# 必要に応じて追加のページを自動的に取得します。
for batch in client.messages.batches.list(limit=20):
    all_batches.append(batch)
print(all_batches)
```

非同期での反復処理の場合：

```python
async def main() -> None:
    all_batches = []
    async for batch in client.messages.batches.list(limit=20):
        all_batches.append(batch)
    print(all_batches)


asyncio.run(main())
```

あるいは、`.has_next_page()`、`.next_page_info()`、または`.get_next_page()`メソッドを使用して、ページをより細かく制御することもできます。

```python
first_page = await client.messages.batches.list(limit=20)

if first_page.has_next_page():
    print(f"will fetch next page using these details: {first_page.next_page_info()}")
    next_page = await first_page.get_next_page()
    print(f"number of items we just fetched: {len(next_page.data)}")

# 非同期でない場合は `await` を削除してください。
```

または、返されたデータを直接操作します。

```python
first_page = await client.messages.batches.list(limit=20)

print(f"next page cursor: {first_page.last_id}")
for batch in first_page.data:
    print(batch.id)

# 非同期でない場合は `await` を削除してください。
```

## デフォルトヘッダー

SDKは、`2023-06-01`に設定された`anthropic-version`ヘッダーを自動的に送信します。

必要に応じて、クライアントオブジェクトまたはリクエストごとにデフォルトヘッダーを設定することでオーバーライドできます。

<Warning>
  デフォルトヘッダーをオーバーライドすると、SDKで不正な型やその他の予期しない、または未定義の動作が発生する可能性があります。
</Warning>

```python
# クライアントのすべてのリクエストに対してデフォルトのヘッダーを設定します
client = Anthropic(
    default_headers={"anthropic-version": "My-Custom-Value"},
)

# またはリクエストごとに上書きします
client.messages.with_raw_response.create(
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello, Claude"}],
    model="claude-opus-5-5",
    extra_headers={"anthropic-version": "My-Custom-Value"},
)
```

## 型システム

### リクエストパラメータ

ネストされたリクエストパラメータは[TypedDict](https://docs.python.org/3/library/typing.html#typing.TypedDict)です。レスポンスは[Pydanticモデル](https://docs.pydantic.dev)であり、JSONへのシリアライズなどのためのヘルパーメソッドも備えています（[`v1`](https://docs.pydantic.dev/1.10/usage/models/)、[`v2`](https://docs.pydantic.dev/latest/concepts/serialization/)）。

型付けされたリクエストとレスポンスにより、エディタ内でオートコンプリートとドキュメントが提供されます。バグを早期に発見するためにVS Codeで型エラーを表示したい場合は、`python.analysis.typeCheckingMode`を`basic`に設定してください。

### レスポンスモデル

Pydanticモデルを辞書に変換するには、ヘルパーメソッドを使用します。

```python
message = client.messages.create(...)

# JSON文字列に変換
json_str = message.to_json()

# 辞書に変換
data = message.to_dict()
```

### nullフィールドと欠落フィールドの処理

レスポンスでは、明示的に`null`であるフィールドと、返されなかった（欠落している）フィールドを区別できます。

```python
response = client.messages.create(
    model="claude-opus-5-5",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello"}],
)
if response.my_field is None:
    if "my_field" not in response.model_fields_set:
        print("field was not in the response")
    else:
        print("field was null")
```

## 高度な使用方法

### 生のレスポンスデータへのアクセス（例：ヘッダー）

`httpx2`が返す「生の」`Response`には、クライアントの`.with_raw_response`プロパティを通じてアクセスできます。これは、レスポンスヘッダーやその他のメタデータにアクセスする場合に便利です。

```python
client = Anthropic()

response = client.messages.with_raw_response.create(
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello, Claude"}],
    model="claude-opus-5-5",
)

print(response.headers.get("request-id"))
message = (
    response.parse()
)  # get the object that `messages.create()` would have returned
print(message.content)
```

これらのメソッドは`APIResponse`オブジェクトを返します。非同期クライアントでは`AsyncAPIResponse`を返し、`.parse()`、`.read()`、`.text()`、`.json()`はawaitする必要があります。

### レスポンスボディのストリーミング

`.with_raw_response`のアプローチでは、リクエストを行った時点でレスポンスボディ全体を即座に読み込みます。代わりにレスポンスボディをストリーミングするには、`.with_streaming_response`を使用します。これはコンテキストマネージャーを必要とし、`.read()`、`.text()`、`.json()`、`.iter_bytes()`、`.iter_text()`、`.iter_lines()`、または`.parse()`を呼び出したときにのみレスポンスボディを読み込みます。非同期クライアントでは、これらは非同期メソッドです。

```python
with client.messages.with_streaming_response.create(
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello, Claude"}],
    model="claude-opus-5-5",
) as response:
    print(response.headers.get("request-id"))

    for line in response.iter_lines():
        print(line)
```

レスポンスが確実にクローズされるように、コンテキストマネージャーが必要です。

### ロギング

SDKは標準ライブラリの`logging`モジュールを使用します。

環境変数`ANTHROPIC_LOG`を`debug`または`info`に設定することで、ロギングを有効にできます。

```bash
export ANTHROPIC_LOG=debug
```

### カスタム/ドキュメント化されていないリクエストの実行

このライブラリは、ドキュメント化されたAPIに便利にアクセスできるように型付けされています。ドキュメント化されていないエンドポイント、パラメータ、またはレスポンスプロパティにアクセスする必要がある場合でも、ライブラリを使用できます。

#### ドキュメント化されていないエンドポイント

ドキュメント化されていないエンドポイントにリクエストを行うには、`client.get`、`client.post`、およびその他のHTTP動詞を使用できます。これらのリクエストを行う際、リトライなどのクライアントのオプションは尊重されます。

```python
import httpx2

response = client.post(
    "/foo",
    cast_to=httpx2.Response,
    body={"my_param": True},
)

print(response.json())
```

#### ドキュメント化されていないリクエストパラメータ

追加のパラメータを明示的に送信したい場合は、`extra_query`、`extra_body`、および`extra_headers`リクエストオプションを使用できます。

<Warning>
  `extra_`パラメータは、同じ名前のドキュメント化されたパラメータをオーバーライドします。セキュリティ上の理由から、これらのメソッドは信頼できる入力データでのみ使用するようにしてください。
</Warning>

#### ドキュメント化されていないレスポンスプロパティ

ドキュメント化されていないレスポンスプロパティにアクセスするには、`response.unknown_prop`のように追加フィールドにアクセスできます。また、`response.model_extra`を使用して、Pydanticモデル上のすべての追加フィールドをdictとして取得することもできます。

### HTTPクライアントの設定

SDKは、`httpx`のAPI互換フォークである[httpx2](https://httpx2.pydantic.dev)を使用してリクエストを送信します。プロキシやトランスポートを含めてHTTPクライアントをカスタマイズするには、独自の[httpx2クライアント](https://httpx2.pydantic.dev/api/#client)を`http_client`として渡します。

```python
import httpx2
from anthropic import Anthropic, DefaultHttpxClient

client = Anthropic(
    # または環境変数 `ANTHROPIC_BASE_URL` を使用します
    base_url="http://my.test.server.example.com:8083",
    http_client=DefaultHttpxClient(
        proxy="http://my.test.proxy.example.com",
        transport=httpx2.HTTPTransport(local_address="0.0.0.0"),
    ),
)
```

`with_options()`を使用して、リクエストごとにクライアントをカスタマイズすることもできます。

```python
client.with_options(http_client=DefaultHttpxClient(...))
```

<Note>
  SDKのデフォルト設定（タイムアウトや接続制限など）が保持されるように、生の`httpx2.Client`および`httpx2.AsyncClient`の代わりに`DefaultHttpxClient`および`DefaultAsyncHttpxClient`を使用してください。`http_client`引数は`httpx2`クライアントである必要があります。別パッケージである`httpx`のクライアントを渡すと`TypeError`が送出されます。
</Note>

OpenTelemetryの`HTTPXClientInstrumentor`、Sentryの`httpx`統合、`respx`、`pytest-httpx`など、`httpx`自体にパッチを当てるトレーシングツールやモックツールは、デフォルトではSDKのリクエストを認識しません。これらを使用するには、何かが`httpx`をインポートする前に、起動時に一度`httpx2.alias_httpx()`を呼び出してください。これにより、プロセス全体で`import httpx`が`httpx2`に解決されるようになります。

### HTTPリソースの管理

デフォルトでは、ライブラリはクライアントが[ガベージコレクション](https://docs.python.org/3/reference/datamodel.html#object.__del__)されるたびに、基盤となるHTTP接続をクローズします。必要に応じて`.close()`メソッドを使用して手動でクライアントをクローズするか、終了時にクローズするコンテキストマネージャーを使用できます。

```python
with Anthropic() as client:
    message = client.messages.create(...)

# HTTPクライアントは自動的にクローズされます
```

## ベータ機能

ベータ機能は、早期のフィードバックを得て新機能をテストするために、正式リリース前に利用可能になります。Claudeのすべての機能とツールの利用可能状況は、[機能の概要](https://platform.claude.com/docs/ja/build-with-claude/overview)で確認できます。

ほとんどのベータAPI機能には、クライアントの`beta`プロパティを通じてアクセスできます。特定のベータ機能を有効にするには、メッセージ作成時に適切な[ベータヘッダー](https://platform.claude.com/docs/ja/api/beta-headers)を`betas`フィールドに追加する必要があります。

例えば、[コンテキスト編集](https://platform.claude.com/docs/ja/build-with-claude/context-editing)を有効にするには：

```python
client = Anthropic()

response = client.beta.messages.create(
    model="claude-opus-5-5",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello, Claude"}],
    betas=["context-management-2025-06-27"],
)
```

## プラットフォーム統合

<Note>
  コード例を含む詳細なプラットフォームセットアップガイドについては、以下を参照してください。

  * [Amazon Bedrock](https://platform.claude.com/docs/ja/build-with-claude/claude-in-amazon-bedrock)
  * [Amazon Bedrock（Opus 4.6以前）](https://platform.claude.com/docs/ja/build-with-claude/claude-on-amazon-bedrock-legacy)
  * [Claude Platform on AWS](https://platform.claude.com/docs/ja/build-with-claude/claude-platform-on-aws)
  * [Google Cloud](https://platform.claude.com/docs/ja/build-with-claude/claude-on-vertex-ai)
  * [Microsoft Foundry](https://platform.claude.com/docs/ja/build-with-claude/claude-in-microsoft-foundry)
</Note>

5つのクライアントクラスはすべて、ベースの`anthropic`パッケージに含まれています。

| プロバイダー                       | クライアント                                         | 追加の依存関係                            |
| ---------------------------- | ---------------------------------------------- | ---------------------------------- |
| Agent Platform               | `from anthropic import AnthropicVertex`        | `pip install "anthropic[vertex]"`  |
| Bedrock                      | `from anthropic import AnthropicBedrockMantle` | `pip install "anthropic[bedrock]"` |
| Bedrock（`bedrock-runtime`パス） | `from anthropic import AnthropicBedrock`       | `pip install "anthropic[bedrock]"` |
| Claude Platform on AWS       | `from anthropic import AnthropicAWS`           | `pip install "anthropic[aws]"`     |
| Foundry                      | `from anthropic import AnthropicFoundry`       | なし                                 |

`AnthropicAWS`クライアントはベータ版です。コンストラクタに`workspace_id`を渡すか、`ANTHROPIC_AWS_WORKSPACE_ID`環境変数を設定してください。

新規プロジェクトには`AnthropicBedrockMantle`を使用してください。`AnthropicBedrock`は、Bedrockの`InvokeModel` APIを使用する既存のアプリケーション向けに引き続き提供されます。

## セマンティックバージョニング

このパッケージは概ね[SemVer](https://semver.org/spec/v2.0.0.html)の規約に従っていますが、特定の後方互換性のない変更がマイナーバージョンとしてリリースされる場合があります。

1. 実行時の動作を壊すことなく、静的型にのみ影響する変更。
2. 技術的にはパブリックであるが、外部での使用を意図しておらず、ドキュメント化もされていないライブラリ内部への変更。
3. 実際には大多数のユーザーに影響を与えないと予想される変更。

### インストールされているバージョンの確認

最新バージョンにアップグレードしたにもかかわらず期待していた新機能が表示されない場合、Python環境がまだ古いバージョンを使用している可能性があります。実行時に使用されているバージョンは、以下で確認できます。

```python
print(anthropic.__version__)
```

## 追加リソース

* [GitHubリポジトリ](https://github.com/anthropics/anthropic-sdk-python)
* [APIリファレンス](https://platform.claude.com/docs/ja/api/overview)
* [メッセージのストリーミング](https://platform.claude.com/docs/ja/build-with-claude/streaming)
* [Claudeでのツール使用](https://platform.claude.com/docs/ja/agents-and-tools/tool-use/overview)