Claude Platform Documentation

https://platform.claude.com/docs/ja
Admin
Claude Platform Documentation is the official guide for building with Claude, Anthropic's...
Tokens:762,538
Snippets:3,121
Trust Score:9.9
Update:7 months ago
Show doc for...
Tokens:
Raw
### Run Quickstart Example (TypeScript)

Source: https://platform.claude.com/docs/ja/get-started

Executes the TypeScript quickstart script to interact with the CLAude API. This script requires Node.js and the 'tsx' package to be installed. It sends a prompt to the API and prints the response.

```bash
npx tsx quickstart.ts
```

--------------------------------

### Run Quickstart Example (Java)

Source: https://platform.claude.com/docs/ja/get-started

Commands to compile and run the Java quickstart program. This involves using the Java compiler ('javac') to compile the source file and then executing the compiled bytecode using the 'java' command.

```bash
javac QuickStart.java
java QuickStart
```

--------------------------------

### Programmatic Tool Calls - Quickstart

Source: https://platform.claude.com/docs/ja/agents-and-tools/tool-use/programmatic-tool-calling

An example demonstrating how Claude can programmatically query a database multiple times and aggregate the results.

```APIDOC
## POST /v1/messages

### Description
This endpoint allows for programmatic tool calls within a code execution container. It enables Claude to execute code that invokes tools without requiring a model round trip for each call, reducing latency and token consumption.

### Method
POST

### Endpoint
/v1/messages

### Parameters
#### Query Parameters
None

#### Request Body
- **model** (string) - Required - The model to use for the request (e.g., `claude-opus-4-6`).
- **max_tokens** (integer) - Required - The maximum number of tokens to generate.
- **messages** (array) - Required - An array of message objects representing the conversation history.
  - **role** (string) - Required - The role of the message sender ('user' or 'assistant').
  - **content** (string) - Required - The content of the message.
- **tools** (array) - Required - An array of tool definitions.
  - **type** (string) - Required - The type of the tool (e.g., `code_execution_20250825`).
  - **name** (string) - Required - The name of the tool (e.g., `code_execution`, `query_database`).
  - **description** (string) - Optional - A description of what the tool does.
  - **input_schema** (object) - Optional - The schema for the tool's input.
    - **type** (string) - Required - The type of the input schema (e.g., `object`).
    - **properties** (object) - Required - An object defining the properties of the input.
      - **sql** (object) - Required - Defines the SQL query input.
        - **type** (string) - Required - The type of the property (e.g., `string`).
        - **description** (string) - Required - Description of the property.
    - **required** (array) - Required - An array of required fields.
  - **allowed_callers** (array) - Optional - A list of tool types that are allowed to call this tool.

### Request Example
```json
{
    "model": "claude-opus-4-6",
    "max_tokens": 4096,
    "messages": [
        {
            "role": "user",
            "content": "Query sales data for the West, East, and Central regions, then tell me which region had the highest revenue"
        }
    ],
    "tools": [
        {
            "type": "code_execution_20250825",
            "name": "code_execution"
        },
        {
            "name": "query_database",
            "description": "Execute a SQL query against the sales database. Returns a list of rows as JSON objects.",
            "input_schema": {
                "type": "object",
                "properties": {
                    "sql": {
                        "type": "string",
                        "description": "SQL query to execute"
                    }
                },
                "required": ["sql"]
            },
            "allowed_callers": ["code_execution_20250825"]
        }
    ]
}
```

### Response
#### Success Response (200)
- **content** (array) - The content of the response, which may include tool use or text.
- **role** (string) - The role of the sender ('assistant').

#### Response Example
```json
{
  "content": [
    {
      "type": "tool_use",
      "id": "toolu_0123456789abcdef",
      "name": "query_database",
      "input": {
        "sql": "SELECT region, SUM(revenue) as total_revenue FROM sales WHERE region IN ('West', 'East', 'Central') GROUP BY region"
      }
    }
  ],
  "role": "assistant"
}
```
```

--------------------------------

### Web Fetch API Request Examples

Source: https://platform.claude.com/docs/ja/agents-and-tools/tool-use/web-fetch-tool

Demonstrates how to make API requests using the Web Fetch tool. Includes examples for making requests via cURL, Python, and TypeScript. These examples show how to configure the tool with parameters like model, max_tokens, messages, and the web_fetch tool definition.

```bash
curl https://api.anthropic.com/v1/messages \
    --header "x-api-key: $ANTHROPIC_API_KEY" \
    --header "anthropic-version: 2023-06-01" \
    --header "content-type: application/json" \
    --data '{ \
        "model": "claude-opus-4-6", \
        "max_tokens": 1024, \
        "messages": [ \
            { \
                "role": "user", \
                "content": "Please analyze the content at https://example.com/article" \
            } \
        ], \
        "tools": [{ \
            "type": "web_fetch_20250910", \
            "name": "web_fetch", \
            "max_uses": 5 \
        }] \
    }'
```

```python
import anthropic

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-opus-4-6",
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": "Please analyze the content at https://example.com/article",
        }
    ],
    tools=[{"type": "web_fetch_20250910", "name": "web_fetch", "max_uses": 5}],
)
print(response)
```

```typescript
import { Anthropic } from "@anthropic-ai/sdk";

const anthropic = new Anthropic();

async function main() {
  const response = await anthropic.messages.create({
    model: "claude-opus-4-6",
    max_tokens: 1024,
    messages: [
      {
        role: "user",
        content: "Please analyze the content at https://example.com/article"
      }
    ],
    tools: [{
      type: "web_fetch_20250910",
      name: "web_fetch",
      max_uses: 5
    }]
  });

  console.log(response);
}

main().catch(console.error);
```

--------------------------------

### Java Quickstart Code

Source: https://platform.claude.com/docs/ja/get-started

A Java example demonstrating how to use the Anthropic client library to send a message to the CLAude API. It initializes the client using environment variables, creates message parameters, sends the request, and prints the content of the response.

```java
import com.anthropic.client.AnthropicClient;
import com.anthropic.client.okhttp.AnthropicOkHttpClient;
import com.anthropic.models.messages.Message;
import com.anthropic.models.messages.MessageCreateParams;

public class QuickStart {
    public static void main(String[] args) {
        AnthropicClient client = AnthropicOkHttpClient.fromEnv();

        MessageCreateParams params = MessageCreateParams.builder()
                .model("claude-opus-4-6")
                .maxTokens(1000)
                .addUserMessage("What should I search for to find the latest developments in renewable energy?")
                .build();

        Message message = client.messages().create(params);
        System.out.println(message.content());
    }
}
```

--------------------------------

### TypeScript Quickstart Code

Source: https://platform.claude.com/docs/ja/get-started

A TypeScript example demonstrating how to use the Anthropic client library to send a message to the CLAude API and process the response. It initializes the client, defines message parameters, sends the request, and logs the output.

```typescript
import Anthropic from "@anthropic-ai/sdk";

const main = async () => {
  const client = new Anthropic({
    apiKey: process.env.ANTHROPIC_API_KEY,
  });

  const msg = await client.messages.create({
    model: "claude-opus-4-6",
    maxTokens: 1000,
    messages: [
      {
        role: "user",
        content: "What should I search for to find the latest developments in renewable energy?",
      },
    ],
  });

  console.log(msg);
};

main().catch(console.error);
```

--------------------------------

### Sequential Tool Use Example

Source: https://platform.claude.com/docs/ja/agents-and-tools/tool-use/overview

Demonstrates how Claude can use tools sequentially, where the output of one tool is used as input for another. This example shows fetching location first, then weather.

```APIDOC
## POST /v1/messages

### Description
This endpoint allows for message-based interactions with Claude models, including the ability to define and utilize external tools.

### Method
POST

### Endpoint
/v1/messages

### Parameters
#### Request Body
- **model** (string) - Required - The model to use for the request (e.g., "claude-opus-4-6").
- **max_tokens** (integer) - Required - The maximum number of tokens to generate in the response.
- **tools** (array) - Required - A list of tool definitions available for the model to use.
  - **name** (string) - Required - The name of the tool.
  - **description** (string) - Required - A description of what the tool does.
  - **input_schema** (object) - Required - The JSON schema defining the tool's input parameters.
- **messages** (array) - Required - A list of message objects representing the conversation history.
  - **role** (string) - Required - The role of the message sender ('user' or 'assistant').
  - **content** (string) - Required - The content of the message.

### Request Example
```json
{
    "model": "claude-opus-4-6",
    "max_tokens": 1024,
    "tools": [
        {
            "name": "get_location",
            "description": "Get the current user location based on their IP address. This tool has no parameters or arguments.",
            "input_schema": {
                "type": "object",
                "properties": {}
            }
        },
        {
            "name": "get_weather",
            "description": "Get the current weather in a given location",
            "input_schema": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "The city and state, e.g. San Francisco, CA"
                    },
                    "unit": {
                        "type": "string",
                        "enum": ["celsius", "fahrenheit"],
                        "description": "The unit of temperature, either 'celsius' or 'fahrenheit'"
                    }
                },
                "required": ["location"]
            }
        }
    ],
    "messages": [
        {
            "role": "user",
            "content": "What is the weather like where I am?"
        }
    ]
}
```

### Response
#### Success Response (200)
- **content** (array) - The response content, which may include tool use blocks.
  - **type** (string) - The type of content block (e.g., 'tool_use').
  - **id** (string) - A unique identifier for the tool use.
  - **name** (string) - The name of the tool being called.
  - **input** (object) - The input arguments for the tool.

#### Response Example
```json
{
  "content": [
    {
      "type": "tool_use",
      "id": "toolu_01A09q90qw90lq917835lq9",
      "name": "get_location",
      "input": {}
    }
  ]
}
```
```

--------------------------------

### POST /v1/messages - Pre-filling Claude's Response

Source: https://platform.claude.com/docs/ja/build-with-claude/working-with-messages

This endpoint allows you to pre-fill the assistant's response by including a partial message in the `messages` array. This can be used to guide Claude's output, such as in the example where `max_tokens` is set to 1 to get a single multiple-choice answer.

```APIDOC
## POST /v1/messages

### Description
Pre-fills the assistant's response by providing a partial message in the `messages` array to guide Claude's output. Useful for scenarios like single-choice answers.

### Method
POST

### Endpoint
/v1/messages

### Parameters
#### Query Parameters
None

#### Request Body
- **model** (string) - Required - The model to use for generation (e.g., "claude-opus-4-6").
- **max_tokens** (integer) - Required - The maximum number of tokens to generate.
- **messages** (array) - Required - A list of message objects representing the conversation history. Each object should have a `role` (user or assistant) and `content`.
  - **role** (string) - Required - The role of the message sender ('user' or 'assistant').
  - **content** (string) - Required - The content of the message.

### Request Example
```json
{
    "model": "claude-opus-4-6",
    "max_tokens": 1,
    "messages": [
        {"role": "user", "content": "What is latin for Ant? (A) Apoidea, (B) Rhopalocera, (C) Formicidae"},
        {"role": "assistant", "content": "The answer is ("}
    ]
}
```

### Response
#### Success Response (200)
- **id** (string) - The unique identifier for the message.
- **type** (string) - The type of the response object (e.g., "message").
- **role** (string) - The role of the sender of the message (e.g., "assistant").
- **content** (array) - The content of the message, which can include text, images, etc.
  - **type** (string) - The type of content (e.g., "text").
  - **text** (string) - The text content of the message.
- **model** (string) - The model used for generation.
- **stop_reason** (string) - The reason the model stopped generating text (e.g., "max_tokens").
- **stop_sequence** (null) - The stop sequence that was triggered, if any.
- **usage** (object) - An object containing token usage information.
  - **input_tokens** (integer) - The number of input tokens used.
  - **output_tokens** (integer) - The number of output tokens generated.

#### Response Example
```json
{
  "id": "msg_01Q8Faay6S7QPTvEUUQARt7h",
  "type": "message",
  "role": "assistant",
  "content": [
    {
      "type": "text",
      "text": "C"
    }
  ],
  "model": "claude-opus-4-6",
  "stop_reason": "max_tokens",
  "stop_sequence": null,
  "usage": {
    "input_tokens": 42,
    "output_tokens": 1
  }
}
```

### Warning
Pre-filling is deprecated and not supported in Claude Opus 4.6 and Claude Sonnet 4.5. Use [structured outputs](/docs/ja/build-with-claude/structured-outputs) or system prompt instructions instead.
```

--------------------------------

### Single Tool Example: Get Weather

Source: https://platform.claude.com/docs/ja/agents-and-tools/tool-use/overview

This section demonstrates how to configure and use a single tool, 'get_weather', to retrieve weather information for a specified location. The example includes the API request payload and corresponding client-side code in multiple languages.

```APIDOC
## POST /v1/messages

### Description
This endpoint allows you to send messages to the Claude API and configure tool use. This specific example shows how to define a 'get_weather' tool that accepts a location and an optional unit (celsius or fahrenheit).

### Method
POST

### Endpoint
/v1/messages

### Parameters
#### Headers
- **x-api-key** (string) - Required - Your Anthropic API key.
- **anthropic-version** (string) - Required - The API version to use (e.g., "2023-06-01").
- **content-type** (string) - Required - Set to "application/json".

#### Request Body
- **model** (string) - Required - The model to use (e.g., "claude-opus-4-6").
- **max_tokens** (integer) - Required - The maximum number of tokens to generate.
- **tools** (array) - Required - A list of tool definitions.
  - **name** (string) - Required - The name of the tool.
  - **description** (string) - Required - A description of what the tool does.
  - **input_schema** (object) - Required - The JSON schema for the tool's input.
    - **type** (string) - Required - Must be "object".
    - **properties** (object) - Required - Defines the input fields for the tool.
      - **location** (object) - Required - The location for the weather query.
        - **type** (string) - Required - Must be "string".
        - **description** (string) - Required - Description of the location field.
      - **unit** (object) - Optional - The unit for temperature measurement.
        - **type** (string) - Required - Must be "string".
        - **enum** (array) - Required - Allowed values: ["celsius", "fahrenheit"].
        - **description** (string) - Description of the unit field.
    - **required** (array) - Required - List of required properties (e.g., ["location"])
- **messages** (array) - Required - A list of message objects.
  - **role** (string) - Required - The role of the message sender (e.g., "user").
  - **content** (string) - Required - The content of the message.

### Request Example (Shell)
```bash
curl https://api.anthropic.com/v1/messages \
     --header "x-api-key: $ANTHROPIC_API_KEY" \
     --header "anthropic-version: 2023-06-01" \
     --header "content-type: application/json" \
     --data \
'{
    "model": "claude-opus-4-6",
    "max_tokens": 1024,
    "tools": [{
        "name": "get_weather",
        "description": "Get the current weather in a given location",
        "input_schema": {
            "type": "object",
            "properties": {
                "location": {
                    "type": "string",
                    "description": "The city and state, e.g. San Francisco, CA"
                },
                "unit": {
                    "type": "string",
                    "enum": ["celsius", "fahrenheit"],
                    "description": "The unit of temperature, either \"celsius\" or \"fahrenheit\""
                }
            },
            "required": ["location"]
        }
    }],
    "messages": [{"role": "user", "content": "What is the weather like in San Francisco?"}]
}'
```

### Request Example (Python)
```python
import anthropic
client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-opus-4-6",
    max_tokens=1024,
    tools=[
        {
            "name": "get_weather",
            "description": "Get the current weather in a given location",
            "input_schema": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "The city and state, e.g. San Francisco, CA"
                    },
                    "unit": {
                        "type": "string",
                        "enum": ["celsius", "fahrenheit"],
                        "description": "The unit of temperature, either \"celsius\" or \"fahrenheit\""
                    }
                },
                "required": ["location"]
            }
        }
    ],
    messages=[{"role": "user", "content": "What is the weather like in San Francisco?"}]
)

print(response)
```

### Request Example (Java)
```java
import java.util.List;
import java.util.Map;

import com.anthropic.client.AnthropicClient;
import com.anthropic.client.okhttp.AnthropicOkHttpClient;
import com.anthropic.core.JsonValue;
import com.anthropic.models.messages.Message;
import com.anthropic.models.messages.MessageCreateParams;
import com.anthropic.models.messages.Model;
import com.anthropic.models.messages.Tool;
import com.anthropic.models.messages.Tool.InputSchema;

public class WeatherToolExample {

    public static void main(String[] args) {
        AnthropicClient client = AnthropicOkHttpClient.fromEnv();

        InputSchema schema = InputSchema.builder()
                .properties(JsonValue.from(Map.of(
                        "location", Map.of(
                                "type", "string",
                                "description", "The city and state, e.g. San Francisco, CA"
                        ),
                        "unit", Map.of(
                                "type", "string",
                                "enum", List.of("celsius", "fahrenheit"),
                                "description", "The unit of temperature, either \"celsius\" or \"fahrenheit\""
                        )
                )))
                .putAdditionalProperty("required", JsonValue.from(List.of("location")))
                .build();

        MessageCreateParams params = MessageCreateParams.builder()
                .model(Model.CLAUDE_OPUS_4_0)
                .maxTokens(1024)
                .addTool(Tool.builder()
                        .name("get_weather")
                        .description("Get the current weather in a given location")
                        .inputSchema(schema)
                        .build())
                .addUserMessage("What is the weather like in San Francisco?")
                .build();

        Message message = client.messages().create(params);
        System.out.println(message);
    }
}
```

### Response
#### Success Response (200)
- **id** (string) - Unique identifier for the message.
- **model** (string) - The model used for the response.
- **stop_reason** (string) - The reason the model stopped generating text (e.g., "tool_use").
- **role** (string) - The role of the sender (e.g., "assistant").
- **content** (array) - The content of the message, which can include text and tool use objects.
  - **type** (string) - The type of content (e.g., "text" or "tool_use").
  - **text** (string) - The text content of the message.
  - **tool_use** (object) - Details about the tool use.
    - **id** (string) - Unique identifier for the tool use.

#### Response Example (JSON)
```json
{
  "id": "msg_01Aq9w938a90dw8q",
  "model": "claude-opus-4-6",
  "stop_reason": "tool_use",
  "role": "assistant",
  "content": [
    {
      "type": "text",
      "text": "I'll check the current weather in San Francisco for you."
    },
    {
      "type": "tool_use",
      "id": "toolu_01A09q90qw90lq917835lq9"
    }
  ]
}
```
```

--------------------------------

### Define Tool with Input Examples (TypeScript)

Source: https://platform.claude.com/docs/ja/agents-and-tools/tool-use/implement-tool-use

Illustrates how to include `input_examples` in a tool definition using TypeScript. Similar to Python, these examples validate against the `input_schema` and guide Claude in generating correct tool invocations, especially for optional fields.

```typescript
import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();

const response = await client.messages.create({
  model: "claude-opus-4-6",
  max_tokens: 1024,
  tools: [
    {
      name: "get_weather",
      description: "Get the current weather in a given location",
      input_schema: {
        type: "object",
        properties: {
          location: {
            type: "string",
            description: "The city and state, e.g. San Francisco, CA"
          },
          unit: {
            type: "string",
            enum: ["celsius", "fahrenheit"],
            description: "The unit of temperature"
          }
        },
        required: ["location"]
      },
      input_examples: [
        {
          location: "San Francisco, CA",
          unit: "fahrenheit"
        },
        {
          location: "Tokyo, Japan",
          unit: "celsius"
        },
        {
          location: "New York, NY"
          // Demonstrates that 'unit' is optional
        }
      ]
    }
  ],
  messages: [{ role: "user", content: "What's the weather like in San Francisco?" }]
});

```

--------------------------------

### Configure Deferred Tool Loading

Source: https://platform.claude.com/docs/ja/agents-and-tools/tool-use/tool-search-tool

Example of a tool definition using the 'defer_loading' property. Setting this to true ensures the tool is only loaded into the context when discovered via a search, optimizing performance.

```json
{
  "name": "get_weather",
  "description": "Get current weather for a location",
  "input_schema": {
    "type": "object",
    "properties": {
      "location": { "type": "string" },
      "unit": { "type": "string", "enum": ["celsius", "fahrenheit"] }
    },
    "required": ["location"]
  },
  "defer_loading": true
}
```

--------------------------------

### Python: .envファイル変更をブロックするPreToolUseフック

Source: https://platform.claude.com/docs/ja/agent-sdk/hooks

このPythonコードスニペットは、ClaudeエージェントSDKを使用して、エージェントが`.env`ファイルを変更しようとするのを防ぐ方法を示しています。`PreToolUse`フックを使用してツール呼び出しをインターセプトし、ファイルパスをチェックして、`.env`ファイルへの変更が試みられた場合に操作を拒否します。このフックは、機密ファイルへの不正なアクセスを防ぐために使用できます。

```python
import asyncio
from claude_agent_sdk import query, ClaudeAgentOptions, HookMatcher

# ツール呼び出しの詳細を受け取るフックコールバックを定義
async def protect_env_files(input_data, tool_use_id, context):
    # ツールの入力引数からファイルパスを抽出
    file_path = input_data['tool_input'].get('file_path', '')
    file_name = file_path.split('/')[-1]

    # .envファイルを対象としている場合、操作をブロック
    if file_name == '.env':
        return {
            'hookSpecificOutput': {
                'hookEventName': input_data['hook_event_name'],
                'permissionDecision': 'deny',
                'permissionDecisionReason': 'Cannot modify .env files'
            }
        }

    # 空のオブジェクトを返して操作を許可
    return {}

async def main():
    async for message in query(
        prompt="Update the database configuration",
        options=ClaudeAgentOptions(
            hooks={
                # PreToolUseイベント用にフックを登録
                # マッチャーはWriteとEditのツール呼び出しのみにフィルタリング
                'PreToolUse': [HookMatcher(matcher='Write|Edit', hooks=[protect_env_files])]
            }
        )
    ):
        print(message)

asyncio.run(main())
```

--------------------------------

### TypeScript: Define Tools with Zod and Run

Source: https://platform.claude.com/docs/ja/agents-and-tools/tool-use/implement-tool-use

Shows how to define tools in TypeScript using the `betaZodTool` helper for type-safe definitions with Zod validation. It includes an example of getting weather information.

```typescript
import { Anthropic } from "@anthropic-ai/sdk";
import { betaZodTool } from "@anthropic-ai/sdk/helpers/beta/zod";
import { z } from "zod";

const anthropic = new Anthropic();

const getWeatherTool = betaZodTool({
  name: "get_weather",
  description: "Get the current weather in a given location",
  inputSchema: z.object({
    location: z.string().describe("The city and state, e.g. San Francisco, CA"),
    unit: z.enum(["celsius", "fahrenheit"]).default("fahrenheit")
      .describe("Temperature unit")
  }),
  run: async (input) => {
    // In a full implementation, you'd call a weather API here
    return JSON.stringify({ temperature: "20°C", condition: "Sunny" });
  }
});

const runner = anthropic.beta.messages.toolRunner({
  model: "claude-opus-4-6",
  max_tokens: 1024,
  tools: [getWeatherTool],
  messages: [{ role: "user", content: "What's the weather like in Paris?" }]
});

for await (const message of runner) {
  console.log(message.content[0].text);
}
```

--------------------------------

### Create Command for Text Editor Tool (JSON)

Source: https://platform.claude.com/docs/ja/agents-and-tools/tool-use/text-editor-tool

This JSON example illustrates the 'create' command for the text editor tool. It shows how to create a new file named 'test_primes.py' with specified content, including Python unittest code. This command is used to generate new files with initial content.

```json
{
  "type": "tool_use",
  "id": "toolu_01A09q90qw90lq917835lq9",
  "name": "str_replace_editor",
  "input": {
    "command": "create",
    "path": "test_primes.py",
    "file_text": "import unittest\nimport primes\n\nclass TestPrimes(unittest.TestCase):\n    def test_is_prime(self):\n        self.assertTrue(primes.is_prime(2))\n        self.assertTrue(primes.is_prime(3))\n        self.assertFalse(primes.is_prime(4))\n\nif __name__ == '__main__':\n    unittest.main()"
  }
}
```

--------------------------------

### Few-Shot Prompting for Structured XML Output

Source: https://platform.claude.com/docs/ja/test-and-evaluate/strengthen-guardrails/increase-consistency

This snippet demonstrates how to guide Claude to produce structured XML output by providing a template and a corresponding example. It is useful for tasks requiring consistent data formatting, such as SWOT analysis or competitor intelligence.

```XML
<competitor>
  <name>AcmeGiant</name>
  <overview>Global tech leader with a vast ecosystem of consumer and enterprise products. Known for innovation, strong brand, and deep customer lock-in through integrated hardware, software, and services.</overview>
  <swot>
    <strengths>
      - Massive R&D budget fuels continuous innovation
      - Loyal customer base and powerful brand recognition
      - Synergistic product ecosystem increases switching costs
    </strengths>
    <weaknesses>
      - High prices may deter cost-sensitive customers
      - Slow to address enterprise-specific customization needs
      - Privacy concerns and regulatory scrutiny in multiple markets
    </weaknesses>
    <opportunities>
      - Growing demand for AI and ML capabilities
      - Expansion into emerging markets
      - Acquisitions to fill product or talent gaps
    </opportunities>
    <threats>
      - Rapid rise of cloud-native competitors
      - Antitrust lawsuits and regulatory actions
      - Talent poaching by startups and competitors
    </threats>
  </swot>
  <strategy>Focus on our agility and customization. Target TechGiant's slow enterprise response and privacy issues in our marketing.</strategy>
</competitor>
```

--------------------------------

### 会話履歴の圧縮 (/compact) (Python)

Source: https://platform.claude.com/docs/ja/agent-sdk/slash-commands

会話履歴を圧縮する '/compact' コマンドを実行します。このコードは、圧縮が完了した際にシステムメッセージからメタデータ（圧縮前のトークン数、トリガー）を取得し、コンソールに出力します。

```python
import asyncio
from claude_agent_sdk import query

async def main():
    async for message in query(
        prompt="/compact",
        options={"max_turns": 1}
    ):
        if (
            message.type == "system" and 
            message.subtype == "compact_boundary"
        ):
            print("Compaction completed")
            print("Pre-compaction tokens:", 
                  message.compact_metadata.pre_tokens)
            print("Trigger:", message.compact_metadata.trigger)

asyncio.run(main())
```

--------------------------------

### Custom Content Block Citation Example

Source: https://platform.claude.com/docs/ja/build-with-claude/citations

This Python code demonstrates how to cite a specific block of custom content. It specifies the citation type, the cited text, the document index, document title, and the start and end block indices.

```python
{
    "type": "content_block_location",
    "cited_text": "The exact text being cited", # 出力トークンにカウントされません
    "document_index": 0,
    "document_title": "Document Title",
    "start_block_index": 0,   # 0始まり
    "end_block_index": 1      # 排他的
}
```

--------------------------------

### コンパクションイベントのロギング (Python)

Source: https://platform.claude.com/docs/ja/build-with-claude/context-editing

Python SDKを使用してコンパクションイベントをロギングする方法を示します。`anthropic.lib.tools`ロガーのレベルをINFOに設定することで、コンパクションの実行と完了に関するログメッセージが表示されます。

```python
import logging

logging.basicConfig(level=logging.INFO)
logging.getLogger("anthropic.lib.tools").setLevel(logging.INFO)

# ログには以下が表示されます：
# INFO: Token usage 105000 has exceeded the threshold of 100000. Performing compaction.
# INFO: Compaction complete. New token usage: 2500
```

--------------------------------

### SDKで利用可能なSkillsを確認する

Source: https://platform.claude.com/docs/ja/agent-sdk/skills

SDKアプリケーションで利用可能なSkillsを確認する方法を示します。setting_sources/settingSourcesでファイルシステムの設定ソースを指定し、allowed_tools/allowedToolsでSkillツールを有効化します。Claudeは現在の作業ディレクトリとインストールされたプラグインに基づいて利用可能なSkillsを一覧表示します。

```python
options = ClaudeAgentOptions(
    setting_sources=["user", "project"],  # ファイルシステムからSkillsを読み込み
    allowed_tools=["Skill"]
)

async for message in query(
    prompt="What Skills are available?",
    options=options
):
    print(message)
```

```typescript
for await (const message of query({
  prompt: "What Skills are available?",
  options: {
    settingSources: ["user", "project"],  // ファイルシステムからSkillsを読み込み
    allowedTools: ["Skill"]
  }
})) {
  console.log(message);
}
```

--------------------------------

### ファイルシステム上のSkills存在確認

Source: https://platform.claude.com/docs/ja/agent-sdk/skills

プロジェクトまたはユーザーディレクトリ内にSkillsファイルが存在するかを確認するためのシェルコマンドです。

```bash
# プロジェクトSkillsを確認
ls .claude/skills/*/SKILL.md

# 個人Skillsを確認
ls ~/.claude/skills/*/SKILL.md
```

--------------------------------

### Compare Multiple Images with Claude API

Source: https://platform.claude.com/docs/ja/build-with-claude/vision

Demonstrates sending multiple images to the Claude API to perform comparative analysis. The examples show how to structure the message content using either Base64 encoded data or public image URLs.

```python
message = client.messages.create(
    model="claude-opus-4-6",
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Image 1:"},
                {"type": "image", "source": {"type": "base64", "media_type": image1_media_type, "data": image1_data}},
                {"type": "text", "text": "Image 2:"},
                {"type": "image", "source": {"type": "base64", "media_type": image2_media_type, "data": image2_data}},
                {"type": "text", "text": "How are these images different?"}
            ],
        }
    ],
)
```

```python
message = client.messages.create(
    model="claude-opus-4-6",
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Image 1:"},
                {"type": "image", "source": {"type": "url", "url": "https://upload.wikimedia.org/wikipedia/commons/a/a7/Camponotus_flavomarginatus_ant.jpg"}},
                {"type": "text", "text": "Image 2:"},
                {"type": "image", "source": {"type": "url", "url": "https://upload.wikimedia.org/wikipedia/commons/b/b5/Iridescent.green.sweat.bee1.jpg"}},
                {"type": "text", "text": "How are these images different?"}
            ],
        }
    ],
)
```

--------------------------------

### Ruby: Define and Run Tools

Source: https://platform.claude.com/docs/ja/agents-and-tools/tool-use/implement-tool-use

Provides an example of defining tools in Ruby using `Anthropic::BaseTool` and `Anthropic::BaseModel` for input schemas. It demonstrates running both weather and calculation tools.

```ruby
require "anthropic"

# Initialize client
client = Anthropic::Client.new

# Define input schema
class GetWeatherInput < Anthropic::BaseModel
  required :location, String, doc: "The city and state, e.g. San Francisco, CA"
  optional :unit, Anthropic::InputSchema::EnumOf["celsius", "fahrenheit"],
           doc: "Temperature unit"
end

# Define tool
class GetWeather < Anthropic::BaseTool
  doc "Get the current weather in a given location"
  input_schema GetWeatherInput

  def call(input)
    # In a full implementation, you'd call a weather API here
    JSON.generate({temperature: "20°C", condition: "Sunny"})
  end
end

class CalculateSumInput < Anthropic::BaseModel
  required :a, Integer, doc: "First number"
  required :b, Integer, doc: "Second number"
end

class CalculateSum < Anthropic::BaseTool
  doc "Add two numbers together"
  input_schema CalculateSumInput

  def call(input)
    (input.a + input.b).to_s
  end
end

# Use the tool runner
runner = client.beta.messages.tool_runner(
  model: "claude-opus-4-6",
  max_tokens: 1024,
  tools: [GetWeather.new, CalculateSum.new],
  messages: [
    {role: "user", content: "What's the weather like in Paris? Also, what's 15 + 27?"}
  ]
)

runner.each_message do |message|
  message.content.each do |block|
    puts block.text if block.respond_to?(:text)
  end
end
```

--------------------------------

### PDF Page Citation Example

Source: https://platform.claude.com/docs/ja/build-with-claude/citations

This Python code illustrates how to create a citation for a specific page range within a PDF document. It includes the citation type, the exact text being cited, the document index, document title, and the start and end page numbers.

```python
{
    "type": "page_location",
    "cited_text": "The exact text being cited", # 出力トークンにカウントされません
    "document_index": 0,     
    "document_title": "Document Title", 
    "start_page_number": 1,  # 1始まり
    "end_page_number": 2     # 排他的
}
```

--------------------------------

### TypeScript: .envファイル変更をブロックするPreToolUseフック

Source: https://platform.claude.com/docs/ja/agent-sdk/hooks

このTypeScriptコードスニペットは、ClaudeエージェントSDKを使用して、エージェントが`.env`ファイルを変更しようとするのを防ぐ方法を示しています。`PreToolUse`フックを使用してツール呼び出しをインターセプトし、ファイルパスをチェックして、`.env`ファイルへの変更が試みられた場合に操作を拒否します。このフックは、機密ファイルへの不正なアクセスを防ぐために使用できます。

```typescript
import { query, HookCallback, PreToolUseHookInput } from "@anthropic-ai/claude-agent-sdk";

// HookCallback型でフックコールバックを定義
const protectEnvFiles: HookCallback = async (input, toolUseID, { signal }) => {
  // 型安全性のために入力を特定のフック型にキャスト
  const preInput = input as PreToolUseHookInput;

  // ツールの入力引数からファイルパスを抽出
  const filePath = preInput.tool_input?.file_path as string;
  const fileName = filePath?.split('/').pop();

  // .envファイルを対象としている場合、操作をブロック
  if (fileName === '.env') {
    return {
      hookSpecificOutput: {
        hookEventName: input.hook_event_name,
        permissionDecision: 'deny',
        permissionDecisionReason: 'Cannot modify .env files'
      }
    };
  }

  // 空のオブジェクトを返して操作を許可
  return {};
};

for await (const message of query({
  prompt: "Update the database configuration",
  options: {
    hooks: {
      // PreToolUseイベント用にフックを登録
      // マッチャーはWriteとEditのツール呼び出しのみにフィルタリング
      PreToolUse: [{ matcher: 'Write|Edit', hooks: [protectEnvFiles] }]
    }
  }
})) {
  console.log(message);
}
```

--------------------------------

### Send Image to Claude API (TypeScript)

Source: https://platform.claude.com/docs/ja/build-with-claude/working-with-messages

This TypeScript code demonstrates how to use the Anthropic SDK to send images to Claude. It covers both base64 encoded images and images referenced by URL, providing a clear example for Node.js environments. Ensure you have '@anthropic-ai/sdk' installed.

```typescript
import Anthropic from '@anthropic-ai/sdk';

const anthropic = new Anthropic();

// Option 1: Base64-encoded image
const image_url = "https://upload.wikimedia.org/wikipedia/commons/a/a7/Camponotus_flavomarginatus_ant.jpg"
const image_media_type = "image/jpeg"
const image_array_buffer = await ((await fetch(image_url)).arrayBuffer());
const image_data = Buffer.from(image_array_buffer).toString('base64');

const message = await anthropic.messages.create({
  model: 'claude-opus-4-6',
  max_tokens: 1024,
  messages: [
        {
            "role": "user",
            "content": [
                {
                    "type": "image",
                    "source": {
                        "type": "base64",
                        "media_type": image_media_type,
                        "data": image_data,
                    },
                },
                {
                    "type": "text",
                    "text": "What is in the above image?"
                }
            ],
        }
      ]
});
console.log(message);

// Option 2: URL-referenced image
const messageFromUrl = await anthropic.messages.create({
  model: 'claude-opus-4-6',
  max_tokens: 1024,
  messages: [
        {
            "role": "user",
            "content": [
                {
                    "type": "image",
                    "source": {
                        "type": "url",
                        "url": "https://upload.wikimedia.org/wikipedia/commons/a/a7/Camponotus_flavomarginatus_ant.jpg",
                    },
                },
                {
                    "type": "text",
                    "text": "What is in the above image?"
                }
            ],
        }
      ]
});
console.log(messageFromUrl);

```
Tokens:
Raw