---
title: カスタマーサポートエージェント
url: https://platform.claude.com/docs/ja/about-claude/use-case-guides/customer-support-chat
description: 製品に関する質問に答え、話題から逸れず、ツール使用を通じて見積もりを生成するカスタマーサポートチャットボットをClaudeで構築します。
---
## 前提条件
このガイドに従うには、以下が必要です。
* Claude APIキー（`ANTHROPIC_API_KEY` 環境変数として設定）
* Python 3.10以降
必要なパッケージをインストールします。
```bash
pip install anthropic streamlit python-dotenv
```
## Claudeで構築する前に
### サポートチャットにClaudeを使用するかどうかを決定する
カスタマーサポートプロセスの一部を自動化するために、Claudeのような「large language model」（大規模言語モデル）、すなわちLLMを採用すべきであることを示す主な指標は次のとおりです：
Claudeは多数の類似した質問を効率的に処理することに優れており、人間のエージェントをより複雑な問題に専念させることができます。
Claudeは膨大なナレッジベースから情報を迅速に取得、処理、統合できますが、人間のエージェントは調査や複数の情報源の参照に時間がかかる場合があります。
Claudeは疲労することなく終日サポートを提供できますが、継続的な対応のために人間のエージェントを配置するのはコストがかかり困難な場合があります。
Claudeは、追加のスタッフを雇用してトレーニングする必要なく、問い合わせ量の急増に対応できます。
Claudeに対して、ブランドのトーンと価値観を一貫して表現するよう指示できますが、人間のエージェントはコミュニケーションスタイルにばらつきが出る場合があります。
他のLLMではなくClaudeを選択する際の考慮事項をいくつか示します。
* 自然でニュアンスのある会話を優先する場合：Claudeの高度な言語理解により、他のLLMとのチャットよりも人間らしく感じられる、より自然でコンテキストを意識した会話が可能になります。
* 複雑で自由形式の問い合わせを頻繁に受ける場合：Claudeは、定型的な応答を生成したり、ユーザー発話の組み合わせを大量にプログラミングしたりすることなく、幅広いトピックや問い合わせに対応できます。
* スケーラブルな多言語サポートが必要な場合：Claudeの多言語機能により、サポート対象の言語ごとに個別のチャットボットや大規模な翻訳プロセスを用意する必要なく、200以上の言語で会話を行うことができます。
### 理想的なチャットインタラクションを定義する
顧客がいつどのようにClaudeとやり取りすることを期待するかを定義するために、理想的な顧客インタラクションの概要を作成します。この概要は、ソリューションの技術要件を決定するのに役立ちます。
自動車保険のカスタマーサポートにおけるチャットインタラクションの例を以下に示します。
* **顧客：** サポートチャットを開始する
* **Claude：** 顧客に温かく挨拶し、会話を開始する
* **顧客：** 新しい電気自動車の保険について質問する
* **Claude：** 電気自動車の補償に関する関連情報を提供する
* **顧客：** 電気自動車保険特有のニーズに関する質問をする
* **Claude：** 正確で有益な回答を返し、情報源へのリンクを提供する
* **顧客：** 保険や自動車とは無関係な話題外の質問をする
* **Claude：** 無関係なトピックについては話さないことを明確にし、ユーザーを自動車保険の話題に戻す
* **顧客：** 保険の見積もりに関心を示す
* **Claude：** 適切な見積もりを決定するための一連の質問を、顧客の回答に応じて調整しながら行う
* **Claude：** ユーザーから収集した必要な情報とともに、見積もり生成APIツールを使用するリクエストを送信する
* **Claude：** APIツール使用からの応答情報を受け取り、その情報を自然な応答に統合して、提供された見積もりをユーザーに提示する
* **顧客：** フォローアップの質問をする
* **Claude：** 必要に応じてフォローアップの質問に回答する
* **Claude：** 保険手続きの次のステップへ顧客を案内し、会話を締めくくる
自身のユースケース向けに作成する実際の例では、このやり取りの実際の文言を書き出すと、Claudeに求める理想的なトーン、応答の長さ、詳細さのレベルも把握できるため便利な場合があります。
### インタラクションを個別のタスクに分解する
カスタマーサポートチャットは、質問への回答から情報検索、リクエストに対するアクションの実行まで、複数の異なるタスクが単一の顧客インタラクションにまとめられたものです。構築を始める前に、理想的な顧客インタラクションを、Claudeに実行させたいすべてのタスクに分解してください。これにより、すべてのタスクについてClaudeにプロンプトを与えて評価できるようになり、テストケースを作成する際に考慮すべきインタラクションの範囲を十分に把握できます。
お客様によっては、ユーザーのリクエストに応じて会話が分岐しうるポイントを示すインタラクションフローチャートとして視覚化すると役立つと感じる場合があります。
保険のインタラクション例に関連する主なタスクを以下に示します。
1. 挨拶と一般的な案内
* 顧客に温かく挨拶し、会話を開始する
* 会社とインタラクションに関する一般的な情報を提供する
2. 製品情報
* 電気自動車の補償に関する情報を提供する
これにはClaudeがコンテキスト内に必要な情報を持っている必要があり、
[RAG統合](https://platform.claude.com/cookbook/capabilities-retrieval-augmented-generation-guide)
が必要になる可能性があります。
* 電気自動車保険特有のニーズに関する質問に答える
* 見積もりや保険の詳細に関するフォローアップの質問に答える
* 適切な場合に情報源へのリンクを提供する
3. 会話管理
* 話題（自動車保険）から逸れない
* 話題外の質問を関連するテーマに戻す
4. 見積もり生成
* 見積もりの適格性を判断するための適切な質問をする
* 顧客の回答に基づいて質問を適応させる
* 収集した情報を見積もり生成APIに送信する
* 提供された見積もりを顧客に提示する
### 成功基準を確立する
サポートチームと協力して、測定可能なベンチマークと目標を備えた[成功基準を定義し、詳細な評価を作成](https://platform.claude.com/docs/ja/test-and-evaluate/develop-tests)してください。
定義されたタスクをClaudeがどの程度うまく実行するかを評価するために使用できる基準とベンチマークを以下に示します。
この指標は、さまざまなトピックにわたる顧客の問い合わせをClaudeがどれだけ正確に解釈しているかを評価します。会話のサンプルをレビューし、Claudeが顧客の意図、重要な次のステップ、解決に成功した状態がどのようなものかなどを正しく解釈しているかを評価することで測定します。理解の正確性95パーセント以上を目指してください。
これは、Claudeの応答が顧客の具体的な質問や問題にどれだけ適切に対処しているかを評価します。一連の会話を評価し、各応答の関連性を採点します（大規模に行う場合はLLMベースの採点を使用）。関連性スコア90パーセント以上を目標にしてください。
コンテキスト内でClaudeに提供された情報に基づき、ユーザーに提供された会社や製品の一般的な情報の正確性を評価します。この基本的な情報については100パーセントの正確性を目標にしてください。
提示されたリンクや情報源の頻度と関連性を追跡します。追加情報が有益となり得るやり取りの80パーセントで、関連する情報源を提供することを目標にしてください。
実装例における自動車保険というトピックのように、Claudeがどれだけトピックから逸れずにいるかを測定します。応答の95パーセントが、自動車保険または顧客の具体的な問い合わせに直接関連していることを目指してください。
情報コンテンツを生成すべきタイミングをClaudeがどれだけうまく判断できるか、またそのコンテンツがどれだけ関連性があるかを測定します。たとえば、この実装では、Claudeが見積もりを生成すべきタイミングをどれだけうまく識別し、その見積もりがどれだけ正確であるかを判断します。これは顧客とのやり取りを成功させるために不可欠な情報であるため、100パーセントの正確性を目標にしてください。
これは、問い合わせに人間の介入が必要なタイミングを認識し、適切にエスカレーションするClaudeの能力を測定します。正しくエスカレーションされた会話の割合と、エスカレーションされるべきだったのにされなかった会話の割合を追跡します。エスカレーションの正確性95パーセント以上を目指してください。
サポートにClaudeを採用することによるビジネスへの影響を評価するために使用できる基準とベンチマークを以下に示します。
これは、会話全体を通じて顧客の感情を維持または改善するClaudeの能力を評価します。感情分析ツールを使用して、各会話の開始時と終了時の感情を測定します。やり取りの90パーセントで感情が維持または改善されることを目指してください。
人間の介入なしにチャットボットによって正常に処理された顧客の問い合わせの割合です。問い合わせの複雑さにもよりますが、通常は70～80パーセントの自己解決率を目指します。
チャットボットとのインタラクションに顧客がどれだけ満足しているかの指標です。通常はインタラクション後のアンケートを通じて測定します。5点満点中4点以上のCSATスコアを目指してください。
チャットボットが問い合わせを解決するのにかかる平均時間です。これは問題の複雑さによって大きく異なりますが、一般的には人間のエージェントと比較してより低いAHTを目指してください。
## Claudeをカスタマーサービスエージェントとして実装する方法
### 適切なClaudeモデルを選択する
モデルの選択は、コスト、正確性、応答時間のトレードオフによって決まります。
カスタマーサポートチャットには、Claude Opus 5.5が知能、「latency」（レイテンシ）、コストのバランスをとるのに適しており、長く複数ステップにわたる会話全体で深い推論を必要とする最も複雑なサポートシナリオにも対応できます。ただし、RAG、ツール使用、または長いコンテキストのプロンプトを含む複数のプロンプトからなる会話フローがある場合は、レイテンシを最適化するためにClaude Haiku 5.5の方が適している場合があります。[エフォート](https://platform.claude.com/docs/ja/build-with-claude/effort)は速度を制御する主な手段であり、`low`は最も高速なレベルで、チャットや短いツールタスクに適しています。
### 強力なプロンプトを構築する
カスタマーサポートにClaudeを使用するには、Claudeが適切に応答するための十分な指示とコンテキストを持ちつつ、幅広い顧客の問い合わせに対応できる十分な柔軟性を持っている必要があります。
まず、「system prompt」（システムプロンプト）から始めて、強力なプロンプトの要素を書いていきます。`config.py` というファイルを作成し、以下の各ブロックを追加してください。
```python
IDENTITY = """You are Eva, a friendly and knowledgeable AI assistant for Acme Insurance
Company. Your role is to warmly welcome customers and provide information on
Acme's insurance offerings, which include car insurance and electric car
insurance. You can also help customers get quotes for their insurance needs."""
```
指示とユーザーとの会話を分離する方法として、すべての情報をシステムプロンプト内に入れたくなるかもしれませんが、実際にはClaudeは、プロンプトの内容の大部分を最初の
`User`
ターン内に記述した場合に最も良く機能します（唯一の例外はロールプロンプティングです）。詳しくは
[システムプロンプトでClaudeに役割を与える](https://platform.claude.com/docs/ja/build-with-claude/prompt-engineering/claude-prompting-best-practices#give-claude-a-role)
をご覧ください。
複雑なプロンプトはサブセクションに分解し、一度に一部分ずつ書くのが最善です。各タスクについて、Claudeがそのタスクをうまく実行するために必要なプロンプトの各部分を定義するステップバイステップのプロセスに従うことで、より大きな成功が得られる場合があります。この自動車保険カスタマーサポートの例では、「挨拶と一般的な案内」タスクから始めて、プロンプトのすべての部分を少しずつ書いていきます。これにより、プロンプト全体の個々の部分をより迅速に調整できるため、プロンプトのデバッグも容易になります。
```python
STATIC_GREETINGS_AND_GENERAL = """
Acme Auto Insurance: Your Trusted Companion on the Road
About:
At Acme Insurance, we understand that your vehicle is more than just a mode of transportation—it's your ticket to life's adventures.
Since 1985, we've been crafting auto insurance policies that give drivers the confidence to explore, commute, and travel with peace of mind.
Whether you're navigating city streets or embarking on cross-country road trips, Acme is there to protect you and your vehicle.
Our innovative auto insurance policies are designed to adapt to your unique needs, covering everything from fender benders to major collisions.
With Acme's award-winning customer service and swift claim resolution, you can focus on the joy of driving while we handle the rest.
We're not just an insurance provider—we're your co-pilot in life's journeys.
Choose Acme Auto Insurance and experience the assurance that comes with superior coverage and genuine care. Because at Acme, we don't just
insure your car—we fuel your adventures on the open road.
Note: We also offer specialized coverage for electric vehicles, ensuring that drivers of all car types can benefit from our protection.
Acme Insurance offers the following products:
- Car insurance
- Electric car insurance
- Two-wheeler insurance
Business hours: Monday-Friday, 9 AM - 5 PM EST
Customer service number: 1-800-123-4567
"""
```
次に、自動車保険と電気自動車保険の情報についても同様に行います。
```python
STATIC_CAR_INSURANCE = """
Car Insurance Coverage:
Acme's car insurance policies typically cover:
1. Liability coverage: Pays for bodily injury and property damage you cause to others.
2. Collision coverage: Pays for damage to your car in an accident.
3. Comprehensive coverage: Pays for damage to your car from non-collision incidents.
4. Medical payments coverage: Pays for medical expenses after an accident.
5. Uninsured/underinsured motorist coverage: Protects you if you're hit by a driver with insufficient insurance.
Optional coverages include:
- Rental car reimbursement
- Roadside assistance
- New car replacement
"""
STATIC_ELECTRIC_CAR_INSURANCE = """
Electric Car Insurance:
Our specialized electric car insurance goes beyond traditional auto coverage,
offering tailored protection for your high-tech investment. In addition to standard coverages, we offer:
- Safeguarding expensive battery systems
- Covering home charging equipment
- Adapting to the rapidly evolving world of electric vehicles
Whether you're driving a Rivian, Nissan Leaf, Chevrolet Bolt,
or any other electric vehicle, our knowledgeable agents are ready to craft a policy
that gives you the confidence to enjoy every electron-powered mile.
"""
```
静的なコンテンツが揃ったら、Claudeの応答を導くために、少なくとも4～5個の「良い」やり取りのサンプルを追加します。これらの例は理想的な顧客とのやり取りを代表するものであるべきで、ガードレールやツール呼び出しなどの要素を含めることができます。
```python
EXAMPLES = """
Here are a few examples of how you can interact with customers:
H: Hi, do you offer commercial insurance for small businesses?
A: Ah! Unfortunately, we don't offer commercial insurance at this time.
However, we do provide a range of personal insurance products including car insurance and electric car insurance.
Would you like to know more about these offerings?
H: Hi, what are your business hours?
A: Our business hours are Monday to Friday, 9 AM to 5 PM EST.
If you have any questions or need assistance, feel free to reach out during those times.
How else can I assist you today?
H: I'm shopping for car insurance. What does Acme offer?
A: Great choice! Acme's car insurance policies typically include:
- Liability coverage: Protects you if you're at fault in an accident
- Collision coverage: Pays for damage to your car in an accident
- Comprehensive coverage: Covers non-collision incidents like theft or vandalism
- Medical payments coverage: Pays for medical expenses after an accident
- Uninsured/underinsured motorist coverage: Protects you from drivers with insufficient insurance
We also offer optional coverages like rental car reimbursement, roadside assistance, and new car replacement.
Would you like more details on any of these coverages, or do you have specific questions about insuring your vehicle?
H: I'd like to hear about your electric car insurance.
A: Certainly! Our electric car insurance is specially designed to meet the unique needs of electric vehicle owners.
In addition to all the standard coverages we offer for regular cars, our electric car policies include:
- Battery coverage: Protection against damage or degradation of your vehicle's expensive battery system
- Tech package: Covers repairs or replacement of advanced electronics and onboard computer systems
- Charging station coverage: Protects both home and portable charging equipment
- Cybersecurity protection: Coverage against hacking or digital threats
- Specialized roadside assistance: Includes flatbed towing to protect the vehicle's undercarriage
We cover a wide range of electric vehicles, including popular models from Tesla, Rivian, Nissan, Chevrolet, and more.
Is there a specific electric vehicle you're looking to insure, or would you like more details on any of these coverages?
H: I'd like to get a quote for my car insurance.
A: Certainly! I'd be happy to help you get a quote for your car insurance.
To provide you with an accurate quote, I'll need to collect some information about your vehicle and the primary driver.
Let's start with the basics:
1. What is the make and model of your vehicle?
2. What year was it manufactured?
3. Approximately how many miles have you driven?
4. What is the age of the primary driver?
Once you provide this information, I'll use our quoting tool to generate a personalized insurance quote for you.
"""
```
また、Claudeが顧客とどのようにやり取りすべきかについて、すべきこととすべきでないことを概説する重要な指示も含めてください。 これはブランドのガードレールやサポートポリシーから引用できます。
```python
ADDITIONAL_GUARDRAILS = """Please adhere to the following guardrails:
1. Only provide information about insurance types listed in our offerings.
2. If asked about an insurance type we don't offer, politely state
that we don't provide that service.
3. Do not speculate about future product offerings or company plans.
4. Don't make promises or enter into agreements it's not authorized to make.
You only provide information and guidance.
5. Do not mention any competitor's products or services.
"""
```
次に、これらすべてのセクションを1つの文字列に結合して、プロンプトとして使用します。
```python
TASK_SPECIFIC_INSTRUCTIONS = " ".join(
[
STATIC_GREETINGS_AND_GENERAL,
STATIC_CAR_INSURANCE,
STATIC_ELECTRIC_CAR_INSURANCE,
EXAMPLES,
ADDITIONAL_GUARDRAILS,
]
)
```
### ツール使用で動的かつエージェント的な機能を追加する
Claudeは、クライアント側のツール使用機能を使って、アクションを実行したり情報を動的に取得したりすることができます。まず、プロンプトが使用すべき外部ツールやAPIをリストアップします。
この例では、見積もりを計算するための1つのツールから始めます。
念のため補足すると、このツールは実際の計算を行いません。Claudeが指定した引数でツールを使用すべきであることをアプリケーションに伝えるだけです。
モデル名、ツール定義、およびスタブ実装を `config.py` に追加します。
```python
import time
MODEL = "claude-opus-5-5"
TOOLS = [
{
"name": "get_quote",
"description": "Calculate the insurance quote based on user input. Returned value is per month premium.",
"input_schema": {
"type": "object",
"properties": {
"make": {"type": "string", "description": "The make of the vehicle."},
"model": {"type": "string", "description": "The model of the vehicle."},
"year": {
"type": "integer",
"description": "The year the vehicle was manufactured.",
},
"mileage": {
"type": "integer",
"description": "The mileage on the vehicle.",
},
"driver_age": {
"type": "integer",
"description": "The age of the primary driver.",
},
},
"required": ["make", "model", "year", "mileage", "driver_age"],
},
}
]
def get_quote(make, model, year, mileage, driver_age):
"""Returns the premium per month in USD"""
# 見積もりを取得するには、HTTPエンドポイントやデータベースを呼び出すことができます。
# この例では1秒の遅延をシミュレートし、固定の見積もり値100を返します。
time.sleep(1)
return 100
```
### プロンプトをデプロイする
テスト用の本番環境にデプロイして[評価を実行](https://platform.claude.com/docs/ja/test-and-evaluate/develop-tests)しなければ、プロンプトがどれだけうまく機能するかを知ることは困難です。プロンプト、Anthropic SDK、およびユーザーインターフェース用のStreamlitを使用して小さなアプリケーションを構築します。
`chatbot.py` というファイル（またはお使いの言語における同等のモジュール）で、Anthropic SDKとのやり取りをカプセル化するChatBotクラスをセットアップします。
このクラスには2つの主要なメソッドが必要です。1つはAPIを呼び出してメッセージを生成するメソッド、もう1つは受信した各ユーザー入力を処理するメソッドです。
```python Python
# chatbot.py では、先ほど作成した config.py から以下をインポートします：
# from config import IDENTITY, TOOLS, MODEL, get_quote
from anthropic import Anthropic
from dotenv import load_dotenv
load_dotenv()
class ChatBot:
def __init__(self, session_state):
self.anthropic = Anthropic()
self.session_state = session_state
def generate_message(
self,
messages,
max_tokens,
):
try:
response = self.anthropic.messages.create(
model=MODEL,
system=IDENTITY,
max_tokens=max_tokens,
messages=messages,
tools=TOOLS,
)
return response
except Exception as e:
return {"error": str(e)}
def process_user_input(self, user_input):
self.session_state.messages.append({"role": "user", "content": user_input})
response_message = self.generate_message(
messages=self.session_state.messages,
max_tokens=2048,
)
if "error" in response_message:
return f"An error occurred: {response_message['error']}"
if response_message.content[-1].type == "tool_use":
tool_use = response_message.content[-1]
func_name = tool_use.name
func_params = tool_use.input
tool_use_id = tool_use.id
result = self.handle_tool_use(func_name, func_params)
self.session_state.messages.append(
{"role": "assistant", "content": response_message.content}
)
self.session_state.messages.append(
{
"role": "user",
"content": [
{
"type": "tool_result",
"tool_use_id": tool_use_id,
"content": f"{result}",
}
],
}
)
follow_up_response = self.generate_message(
messages=self.session_state.messages,
max_tokens=2048,
)
if "error" in follow_up_response:
return f"An error occurred: {follow_up_response['error']}"
response_text = next(
(
block.text
for block in follow_up_response.content
if block.type == "text"
),
None,
)
if response_text is None:
raise Exception("An error occurred: Unexpected response type")
self.session_state.messages.append(
{"role": "assistant", "content": response_text}
)
return response_text
text_block = next(
(block for block in response_message.content if block.type == "text"), None
)
if text_block is not None:
response_text = text_block.text
self.session_state.messages.append(
{"role": "assistant", "content": response_text}
)
return response_text
raise Exception("An error occurred: Unexpected response type")
def handle_tool_use(self, func_name, func_params):
if func_name == "get_quote":
premium = get_quote(**func_params)
return f"Quote generated: ${premium:.2f} per month"
raise Exception("An unexpected tool was used")
```
```typescript TypeScript
import Anthropic from "@anthropic-ai/sdk";
class ChatBot {
// IDENTITY、MODEL、TOOLS、getQuoteは、このガイドで先に（Pythonで）
// 定義されたconfig.pyの値を反映しています。
readonly anthropic = new Anthropic();
readonly messages: Anthropic.MessageParam[] = [];
async generateMessage(
messages: Anthropic.MessageParam[],
maxTokens: number
): Promise {
return this.anthropic.messages.create({
model: MODEL,
system: IDENTITY,
max_tokens: maxTokens,
messages,
tools: TOOLS
});
}
async processUserInput(userInput: string): Promise {
this.messages.push({ role: "user", content: userInput });
const responseMessage = await this.generateMessage(this.messages, 2048);
const lastBlock = responseMessage.content.at(-1);
if (lastBlock?.type === "tool_use") {
const toolResult = this.handleToolUse(lastBlock.name, lastBlock.input);
this.messages.push({ role: "assistant", content: responseMessage.content });
this.messages.push({
role: "user",
content: [{ type: "tool_result", tool_use_id: lastBlock.id, content: toolResult }]
});
const followUpResponse = await this.generateMessage(this.messages, 2048);
const followUpBlock = followUpResponse.content.find((block) => block.type === "text");
if (!followUpBlock) {
throw new Error("An error occurred: Unexpected response type");
}
this.messages.push({ role: "assistant", content: followUpBlock.text });
return followUpBlock.text;
}
const firstBlock = responseMessage.content.find((block) => block.type === "text");
if (firstBlock) {
this.messages.push({ role: "assistant", content: firstBlock.text });
return firstBlock.text;
}
throw new Error("An error occurred: Unexpected response type");
}
handleToolUse(toolName: string, toolInput: unknown): string {
if (toolName === "get_quote") {
// SDKはtool_use.inputをunknownとして型付けするため、get_quoteスキーマに絞り込みます。
if (
toolInput === null ||
typeof toolInput !== "object" ||
!("make" in toolInput) ||
typeof toolInput.make !== "string" ||
!("model" in toolInput) ||
typeof toolInput.model !== "string" ||
!("year" in toolInput) ||
typeof toolInput.year !== "number" ||
!("mileage" in toolInput) ||
typeof toolInput.mileage !== "number" ||
!("driver_age" in toolInput) ||
typeof toolInput.driver_age !== "number"
) {
throw new Error("An error occurred: Unexpected tool input");
}
const { make, model: vehicleModel, year, mileage, driver_age: driverAge } = toolInput;
const premium = getQuote(make, vehicleModel, year, mileage, driverAge);
return `Quote generated: $${premium.toFixed(2)} per month`;
}
throw new Error("An unexpected tool was used");
}
}
```
```csharp C#
using System.Text.Json;
using Anthropic;
using Anthropic.Models.Messages;
// Config.Model、Config.Identity、Config.Tools、Config.GetQuoteは、このガイドで
// 先に定義したconfig.pyの値（Pythonで示されています）を反映しています。
public class ChatBot
{
private readonly AnthropicClient _anthropic = new();
public List Messages { get; } = [];
public async Task GenerateMessage(List messages, long maxTokens) =>
await _anthropic.Messages.Create(
new MessageCreateParams
{
Model = Config.Model,
System = Config.Identity,
MaxTokens = maxTokens,
Messages = messages,
Tools = Config.Tools,
}
);
public async Task ProcessUserInput(string userInput)
{
Messages.Add(new UserMessageParam { Content = userInput });
var responseMessage = await GenerateMessage(Messages, maxTokens: 2048);
if (responseMessage.Content[^1].TryPickToolUse(out var toolUse))
{
var toolResult = HandleToolUse(toolUse.Name, toolUse.Input);
Messages.Add(new AssistantMessageParam
{
Content = responseMessage.Content
.Select(contentBlock => new ContentBlockParam(contentBlock.Json))
.ToList(),
});
Messages.Add(new UserMessageParam
{
Content = new List
{
new ToolResultBlockParam { ToolUseID = toolUse.ID, Content = toolResult },
},
});
var followUpResponse = await GenerateMessage(Messages, maxTokens: 2048);
foreach (var block in followUpResponse.Content)
{
if (block.TryPickText(out var followUpText))
{
Messages.Add(new AssistantMessageParam { Content = followUpText.Text });
return followUpText.Text;
}
}
throw new InvalidOperationException("An error occurred: Unexpected response type");
}
foreach (var block in responseMessage.Content)
{
if (block.TryPickText(out var textBlock))
{
Messages.Add(new AssistantMessageParam { Content = textBlock.Text });
return textBlock.Text;
}
}
throw new InvalidOperationException("An error occurred: Unexpected response type");
}
public string HandleToolUse(string funcName, IReadOnlyDictionary funcParams)
{
if (funcName == "get_quote")
{
var premium = Config.GetQuote(
funcParams["make"].GetString()!,
funcParams["model"].GetString()!,
funcParams["year"].GetInt64(),
funcParams["mileage"].GetInt64(),
funcParams["driver_age"].GetInt64()
);
return $"Quote generated: ${premium:F2} per month";
}
throw new ArgumentException("An unexpected tool was used");
}
}
```
```go Go
import (
"context"
"encoding/json"
"fmt"
"github.com/anthropics/anthropic-sdk-go/v2"
)
// ChatBotはAnthropicクライアントと会話履歴をラップします。使用される
// identity、model、tools、getQuoteの値は、このガイドの前半で（Pythonで）
// 示したconfig.pyの定義を反映しています。
type ChatBot struct {
client anthropic.Client
messages []anthropic.MessageParam
}
func NewChatBot() *ChatBot {
return &ChatBot{client: anthropic.NewClient()}
}
func (bot *ChatBot) GenerateMessage(ctx context.Context, messages []anthropic.MessageParam, maxTokens int64) (*anthropic.Message, error) {
return bot.client.Messages.New(ctx, anthropic.MessageNewParams{
Model: model,
System: []anthropic.TextBlockParam{{Text: identity}},
MaxTokens: maxTokens,
Messages: messages,
Tools: tools,
})
}
func (bot *ChatBot) ProcessUserInput(ctx context.Context, userInput string) (string, error) {
bot.messages = append(bot.messages, anthropic.NewUserMessage(anthropic.NewTextBlock(userInput)))
response, err := bot.GenerateMessage(ctx, bot.messages, 2048)
if err != nil {
return "", err
}
lastBlock := response.Content[len(response.Content)-1]
if toolUse, ok := lastBlock.AsAny().(anthropic.ToolUseBlock); ok {
result, err := bot.HandleToolUse(toolUse.Name, toolUse.Input)
if err != nil {
return "", err
}
bot.messages = append(bot.messages,
response.ToParam(),
anthropic.NewUserMessage(anthropic.NewToolResultBlock(toolUse.ID, result, false)),
)
followUp, err := bot.GenerateMessage(ctx, bot.messages, 2048)
if err != nil {
return "", err
}
for _, block := range followUp.Content {
if textBlock, ok := block.AsAny().(anthropic.TextBlock); ok {
bot.messages = append(bot.messages, anthropic.NewAssistantMessage(anthropic.NewTextBlock(textBlock.Text)))
return textBlock.Text, nil
}
}
return "", fmt.Errorf("an error occurred: unexpected response type")
}
for _, block := range response.Content {
if textBlock, ok := block.AsAny().(anthropic.TextBlock); ok {
bot.messages = append(bot.messages, anthropic.NewAssistantMessage(anthropic.NewTextBlock(textBlock.Text)))
return textBlock.Text, nil
}
}
return "", fmt.Errorf("an error occurred: unexpected response type")
}
func (bot *ChatBot) HandleToolUse(toolName string, toolInput json.RawMessage) (string, error) {
if toolName != "get_quote" {
return "", fmt.Errorf("an unexpected tool was used: %s", toolName)
}
var input struct {
Make string `json:"make"`
Model string `json:"model"`
Year int `json:"year"`
Mileage int `json:"mileage"`
DriverAge int `json:"driver_age"`
}
if err := json.Unmarshal(toolInput, &input); err != nil {
return "", err
}
premium := getQuote(input.Make, input.Model, input.Year, input.Mileage, input.DriverAge)
return fmt.Sprintf("Quote generated: $%.2f per month", premium), nil
}
```
```java Java
import com.anthropic.client.AnthropicClient;
import com.anthropic.client.okhttp.AnthropicOkHttpClient;
import com.anthropic.core.JsonValue;
import com.anthropic.models.messages.ContentBlock;
import com.anthropic.models.messages.ContentBlockParam;
import com.anthropic.models.messages.Message;
import com.anthropic.models.messages.MessageCreateParams;
import com.anthropic.models.messages.MessageParam;
import com.anthropic.models.messages.ToolResultBlockParam;
import com.anthropic.models.messages.ToolUseBlock;
// IDENTITY、MODEL、TOOLS、getQuote は、このガイドで先に（Python で）定義した
// config.py の値を反映しています。
class ChatBot {
final AnthropicClient anthropic;
final List messages;
ChatBot() {
// ANTHROPIC_API_KEY 環境変数から APIキーを読み取ります
this.anthropic = AnthropicOkHttpClient.fromEnv();
this.messages = new ArrayList<>();
}
Message generateMessage(List messages, long maxTokens) {
return anthropic.messages().create(MessageCreateParams.builder()
.model(MODEL)
.system(IDENTITY)
.maxTokens(maxTokens)
.messages(messages)
.tools(TOOLS)
.build());
}
String processUserInput(String userInput) {
messages.add(MessageParam.ofUser(userInput));
Message responseMessage = generateMessage(messages, 2048);
List content = responseMessage.content();
ContentBlock lastBlock = content.getLast();
if (lastBlock.isToolUse()) {
ToolUseBlock toolUse = lastBlock.asToolUse();
Map toolInput =
(Map) toolUse._input().asObject().orElseThrow();
String result = handleToolUse(toolUse.name(), toolInput);
messages.add(MessageParam.ofAssistantOfContentBlockParams(
content.stream().map(ContentBlock::toParam).toList()));
messages.add(MessageParam.ofUserOfContentBlockParams(List.of(ContentBlockParam.ofToolResult(
ToolResultBlockParam.builder()
.toolUseId(toolUse.id())
.content(result)
.build()))));
Message followUpResponse = generateMessage(messages, 2048);
ContentBlock followUpBlock = followUpResponse.content().stream()
.filter(ContentBlock::isText)
.findFirst()
.orElseThrow(() -> new IllegalStateException("An error occurred: Unexpected response type"));
String responseText = followUpBlock.asText().text();
messages.add(MessageParam.ofAssistant(responseText));
return responseText;
} else {
ContentBlock textBlock = content.stream()
.filter(ContentBlock::isText)
.findFirst()
.orElseThrow(() -> new IllegalStateException("An error occurred: Unexpected response type"));
String responseText = textBlock.asText().text();
messages.add(MessageParam.ofAssistant(responseText));
return responseText;
}
}
String handleToolUse(String funcName, Map funcParams) {
return switch (funcName) {
case "get_quote" -> {
double premium = getQuote(
funcParams.get("make").asStringOrThrow(),
funcParams.get("model").asStringOrThrow(),
((Number) funcParams.get("year").asNumber().orElseThrow()).longValue(),
((Number) funcParams.get("mileage").asNumber().orElseThrow()).longValue(),
((Number) funcParams.get("driver_age").asNumber().orElseThrow()).longValue());
yield "Quote generated: $%.2f per month".formatted(premium);
}
default -> throw new IllegalArgumentException("An unexpected tool was used");
};
}
}
```
```php PHP
use Anthropic\Client;
use Anthropic\Messages\AssistantMessageParam;
use Anthropic\Messages\Message;
use Anthropic\Messages\TextBlock;
use Anthropic\Messages\ToolResultBlockParam;
use Anthropic\Messages\ToolUseBlock;
use Anthropic\Messages\UserMessageParam;
class ChatBot
{
// MODEL、IDENTITY、TOOLS、get_quote()は、このガイドで先に定義した
// config.pyの値（Pythonで示したもの）を反映しています。
/** @var list */
public private(set) array $messages = [];
public function __construct(
private readonly Client $anthropic = new Client(),
) {}
/**
* @param list $messages
*/
public function generateMessage(array $messages, int $maxTokens): Message
{
return $this->anthropic->messages->create(
model: MODEL,
system: IDENTITY,
maxTokens: $maxTokens,
messages: $messages,
tools: TOOLS,
);
}
public function processUserInput(string $userInput): string
{
$this->messages[] = UserMessageParam::with(content: $userInput);
$responseMessage = $this->generateMessage($this->messages, maxTokens: 2048);
$content = $responseMessage->content;
$lastBlock = array_last($content);
if ($lastBlock instanceof ToolUseBlock) {
$toolResult = $this->handleToolUse($lastBlock->name, $lastBlock->input);
$this->messages[] = AssistantMessageParam::with(content: $content);
$this->messages[] = UserMessageParam::with(
content: [
ToolResultBlockParam::with(toolUseID: $lastBlock->id, content: $toolResult),
],
);
$followUpResponse = $this->generateMessage($this->messages, maxTokens: 2048);
$firstBlock = array_find(
$followUpResponse->content,
static fn ($block): bool => $block instanceof TextBlock,
);
if (!$firstBlock instanceof TextBlock) {
throw new \RuntimeException('An error occurred: Unexpected response type');
}
$this->messages[] = AssistantMessageParam::with(content: $firstBlock->text);
return $firstBlock->text;
}
$firstBlock = array_find($content, static fn ($block): bool => $block instanceof TextBlock);
if ($firstBlock instanceof TextBlock) {
$this->messages[] = AssistantMessageParam::with(content: $firstBlock->text);
return $firstBlock->text;
}
throw new \RuntimeException('An error occurred: Unexpected response type');
}
/**
* @param array $funcParams
*/
private function handleToolUse(string $funcName, array $funcParams): string
{
if ($funcName === 'get_quote') {
$premium = get_quote(...$funcParams);
return sprintf('Quote generated: $%.2f per month', $premium);
}
throw new \RuntimeException('An unexpected tool was used');
}
}
```
```ruby Ruby
# IDENTITY、MODEL、TOOLS、get_quoteは、このガイドの前半で（Pythonで）定義された
# config.pyの値を反映しています。
require "anthropic"
class ChatBot
attr_reader :messages
def initialize
@anthropic = Anthropic::Client.new
@messages = []
end
def generate_message(messages, max_tokens)
@anthropic.messages.create(
model: MODEL,
system_: IDENTITY,
max_tokens:,
messages:,
tools: TOOLS
)
end
def process_user_input(user_input)
@messages << {role: "user", content: user_input}
response_message = generate_message(@messages, 2048)
case response_message.content
in [*, Anthropic::ToolUseBlock => tool_use]
result = handle_tool_use(tool_use.name, tool_use.input)
@messages << {role: "assistant", content: response_message.content}
@messages << {
role: "user",
content: [{type: "tool_result", tool_use_id: tool_use.id, content: result}]
}
follow_up_response = generate_message(@messages, 2048)
case follow_up_response.content
in [*, Anthropic::TextBlock => text_block, *]
@messages << {role: "assistant", content: text_block.text}
text_block.text
else
raise "An error occurred: Unexpected response type"
end
in [*, Anthropic::TextBlock => text_block, *]
@messages << {role: "assistant", content: text_block.text}
text_block.text
else
raise "An error occurred: Unexpected response type"
end
end
def handle_tool_use(tool_name, tool_input)
raise "An unexpected tool was used" unless tool_name == "get_quote"
premium = get_quote(**tool_input)
format("Quote generated: $%.2f per month", premium)
end
end
```
### ユーザーインターフェースを構築する
main関数を使用して、このコードをStreamlitでデプロイしてテストします。この`main()`関数は、Streamlitベースのチャットインターフェースを設定します。StreamlitはPythonフレームワークであるため、このウォークスルーのこの部分はPythonでのみ示しています。前述のChatBotクラスは、任意の言語に移植できる部分です。
これを`app.py`というファイルで行います：
```python
import streamlit as st
from chatbot import ChatBot
from config import TASK_SPECIFIC_INSTRUCTIONS
def main():
st.title("Chat with Eva, Acme Insurance Company's Assistant🤖")
if "messages" not in st.session_state:
st.session_state.messages = [
{"role": "user", "content": TASK_SPECIFIC_INSTRUCTIONS},
{"role": "assistant", "content": "Understood"},
]
chatbot = ChatBot(st.session_state)
# 最初の2つをスキップしてユーザーとアシスタントのメッセージを表示
for message in st.session_state.messages[2:]:
# ツール使用ブロックは無視
if isinstance(message["content"], str):
with st.chat_message(message["role"]):
st.markdown(message["content"])
if user_msg := st.chat_input("Type your message here..."):
st.chat_message("user").markdown(user_msg)
with st.chat_message("assistant"):
with st.spinner("Eva is thinking..."):
response_placeholder = st.empty()
full_response = chatbot.process_user_input(user_msg)
response_placeholder.markdown(full_response)
if __name__ == "__main__":
main()
```
次のコマンドでプログラムを実行します。
```bash
streamlit run app.py
```
### プロンプトを評価する
プロンプトを本番環境で使用できる状態にするには、多くの場合テストと最適化が必要です。ソリューションの準備状況を判断するために、定量的手法と定性的手法を組み合わせた体系的なプロセスを使用してチャットボットのパフォーマンスを評価します。定義した成功基準に基づいて[強力な実証的評価](https://platform.claude.com/docs/ja/test-and-evaluate/develop-tests#build-evaluations)を作成することで、プロンプトを最適化できるようになります。
### パフォーマンスを改善する
複雑なシナリオでは、標準的な[プロンプトエンジニアリング手法](https://platform.claude.com/docs/ja/build-with-claude/prompt-engineering/overview)や[ガードレール実装戦略](https://platform.claude.com/docs/ja/test-and-evaluate/strengthen-guardrails/reduce-hallucinations)に加えて、パフォーマンスを向上させるための追加の戦略を検討すると役立つ場合があります。以下は一般的なシナリオです：
#### RAGで長いコンテキストのレイテンシを削減する
大量の静的および動的コンテキストを扱う場合、すべての情報をプロンプトに含めると、コストの増大、応答時間の低下、「context window」（コンテキストウィンドウ）の上限到達につながる可能性があります。このシナリオでは、「Retrieval Augmented Generation」（検索拡張生成）、すなわちRAGの手法を実装することで、パフォーマンスと効率を改善できます。
Voyage AI by MongoDBのモデルなどの[埋め込みモデル](https://platform.claude.com/docs/ja/build-with-claude/embeddings)を使用して情報をベクトル表現に変換することで、よりスケーラブルで応答性の高いシステムを作成できます。このアプローチでは、考えられるすべてのコンテキストをすべてのプロンプトに含めるのではなく、現在の問い合わせに基づいて関連情報を動的に取得できます。
サポートのユースケースにRAGを実装すると、広範なコンテキスト要件を持つシステムにおいて、正確性の向上、応答時間の短縮、APIコストの削減が実現されることが示されています。実例については[RAGレシピ](https://platform.claude.com/cookbook/capabilities-retrieval-augmented-generation-guide)をご覧ください。
#### ツール使用でリアルタイムデータを統合する
口座残高や保険契約の詳細など、リアルタイムの情報を必要とする問い合わせを扱う場合、埋め込みベースのRAGアプローチでは不十分です。代わりに、ツール使用によって、正確でリアルタイムな応答を提供するチャットボットの能力を強化できます。たとえば、ツール使用を利用して顧客情報を検索したり、注文の詳細を取得したり、顧客に代わって注文をキャンセルしたりできます。
[ツール使用：カスタマーサービスエージェントのレシピ](https://platform.claude.com/cookbook/tool-use-customer-service-agent)で概説されているこのアプローチにより、ライブデータをClaudeの応答に統合し、よりパーソナライズされた効率的な顧客体験を提供できます。
#### 入力と出力のガードレールを強化する
チャットボットをデプロイする際、特にカスタマーサービスのシナリオでは、悪用、範囲外の問い合わせ、不適切な応答に関連するリスクを防ぐことが重要です。Claudeは本来このようなシナリオに対する耐性を備えていますが、チャットボットのガードレールを強化するための追加の手順は次のとおりです：
* [ハルシネーションを削減する](https://platform.claude.com/docs/ja/test-and-evaluate/strengthen-guardrails/reduce-hallucinations)：ファクトチェックの仕組みと[引用](https://platform.claude.com/cookbook/misc-using-citations)を実装して、提供された情報に基づいた応答にします。
* 情報をクロスチェックする：エージェントの応答が会社のポリシーや既知の事実と一致していることを確認します。
* 契約上のコミットメントを避ける：エージェントが権限のない約束をしたり契約を結んだりしないようにします。
* [ジェイルブレイクを軽減する](https://platform.claude.com/docs/ja/test-and-evaluate/strengthen-guardrails/mitigate-jailbreaks)：無害性スクリーニングや入力検証などの手法を使用して、ユーザーがモデルの脆弱性を悪用して不適切なコンテンツを生成することを防ぎます。
* 競合他社への言及を避ける：競合他社言及フィルターを実装してブランドへの集中を維持し、競合他社の製品やサービスに言及しないようにします。
* [出力の一貫性を高める](https://platform.claude.com/docs/ja/test-and-evaluate/strengthen-guardrails/increase-consistency)：長く複雑なインタラクションの間でも、Claudeがスタイルを変えたりキャラクターから外れたりしないようにします。
* 個人を特定できる情報（PII）を削除する：明示的に必要とされ、許可されている場合を除き、応答からPIIをすべて取り除きます。
#### ストリーミングで体感応答時間を短縮する
長くなる可能性のある応答を扱う場合、「streaming」（ストリーミング）を実装することでユーザーのエンゲージメントと満足度を向上させることができます。このシナリオでは、ユーザーは応答全体が生成されるのを待つのではなく、回答を段階的に受け取ります。
ストリーミングの実装方法は以下のとおりです。
1. [AnthropicストリーミングAPI](https://platform.claude.com/docs/ja/build-with-claude/streaming)を使用してストリーミング応答をサポートします。
2. 受信するテキストのチャンクを処理できるようにフロントエンドを設定します。
3. 各チャンクを到着するたびに表示し、リアルタイムのタイピングをシミュレートします。
4. 完全な応答を保存する仕組みを実装し、ユーザーがページを離れて戻ってきた場合でも閲覧できるようにします。
場合によっては、段階的な表示によって処理時間の長さの影響が軽減されるため、ストリーミングによって、ベースのレイテンシがより高い高度なモデルを使用できるようになります。
#### チャットボットをスケールする
チャットボットの複雑さが増すにつれて、アプリケーションアーキテクチャもそれに合わせて進化させることができます。アーキテクチャにさらなるレイヤーを追加する前に、以下のより負担の少ない選択肢を検討してください。
* プロンプトを最大限に活用し、プロンプトエンジニアリングを通じて最適化していることを確認します。最も効果的なプロンプトを書くには[プロンプトエンジニアリングガイド](https://platform.claude.com/docs/ja/build-with-claude/prompt-engineering/overview)を使用してください。
* プロンプトに追加の[ツール](https://platform.claude.com/docs/ja/agents-and-tools/tool-use/overview)（[プロンプトチェーン](https://platform.claude.com/docs/ja/build-with-claude/prompt-engineering/claude-prompting-best-practices#chain-complex-prompts)を含めることができます）を追加し、必要な機能を実現できるかどうかを確認します。
チャットボットが非常に多様なタスクを処理する場合は、顧客の最初の問い合わせをルーティングするための[個別の意図分類器](https://platform.claude.com/cookbook/capabilities-classification-guide)の追加を検討するとよいでしょう。既存のアプリケーションの場合、これには、顧客の問い合わせを分類器を経由して専門の会話（それぞれ独自のツールとシステムプロンプトのセットを持つ）へルーティングする決定木を作成することが含まれます。この方法ではClaudeへの追加の呼び出しが必要になり、レイテンシが増加する可能性があることに注意してください。
### Claudeをサポートワークフローに統合する
これらの例ではStreamlit環境内で呼び出し可能なPython関数に焦点を当ててきましたが、リアルタイムのサポートチャットボットとしてClaudeをデプロイするにはAPIサービスが必要です。
以下のようにアプローチできます。
1. APIラッパーを作成する：分類関数をラップするシンプルなAPIラッパーを開発します。たとえば、FlaskやFastAPIを使用して、コードをHTTPサービスとしてラップできます。HTTPサービスはユーザー入力を受け取り、Assistantの応答全体を返すことができます。したがって、サービスには次のような特性を持たせることができます：
* Server-Sent Events（SSE）：SSEにより、サーバーからクライアントへの応答のリアルタイムストリーミングが可能になります。これにより、LLMを扱う際にスムーズでインタラクティブな体験が提供されます。
* キャッシング：キャッシングを実装することで、応答時間を改善し、不要なAPI呼び出しを削減できます。
* コンテキストの保持：ユーザーがページを離れて戻ってきたときにコンテキストを維持することは、会話の継続性にとって重要です。
2. Webインターフェースを構築する：Claudeを活用したエージェントとやり取りするための、ユーザーフレンドリーなWeb UIを実装します。
## 次のステップ
ClaudeにAPIへのアクセスを与え、顧客に代わってアクションを実行できるようにします。
定義した成功基準に対してサポートエージェントを測定するための評価を構築します。
応答をストリーミングして、生成されるにつれて顧客が回答を確認できるようにします。
タスクのパフォーマンスを向上させるために、システムプロンプトと例を改良します。