Claude Cookbooks 实战指南

我们要开始啦！这章的目标是让你拿到 Claude API 密钥，并且配置好开发环境，这样你就能动手试试那些炫酷的功能了。读完这一章，你会知道怎么注册账号、获取密钥，以及如何设置你的电脑让它准备好和 Claude 打交道。

首先，你需要有一个 Claude API 密钥。如果你还没注册过 Anthropic 的账户，赶紧去官网免费申请一个吧（点击这里）。注册过程挺简单的，就是填些基本信息就行。

拿到密钥之后，我们需要把它保存在一个安全的地方。通常我们会用环境变量来存储这些敏感信息。下面我们就来做这件事儿。

第一步：安装必要的软件

为了方便起见，我们假设你已经安装了 Python 和 pip。如果没有的话，可以去 Python 官网下载最新版并按照指示安装（Python 下载页面）。

接着，我们需要安装 requests 库，它是用来发送 HTTP 请求的常用工具。打开终端或者命令提示符，输入以下命令：

pip install requests

这个命令会自动帮你下载并安装 requests 及其依赖项。

第二步：设置环境变量

在不同的操作系统中设置环境变量的方法略有不同。这里分别介绍 Windows 和 macOS/Linux 的方法。

Windows 用户

1. 打开“系统属性”对话框（可以通过右键点击“此电脑”或“计算机”，选择“属性”，然后点击左侧的“高级系统设置”）。
2. 点击底部的“环境变量”按钮。
3. 在弹出的窗口中找到“用户变量”，点击“新建”。
4. 输入变量名 CLAUDE_API_KEY。
5. 输入你在 Anthropic 官网上获得的 API 密钥作为变量值。
6. 点击确定保存更改。

macOS/Linux 用户

1. 打开终端。

2. 编辑你的 shell 配置文件（通常是 .bashrc 或 .zshrc）。你可以用你喜欢的编辑器打开它，比如 nano 或 vim：

   nano ~/.bashrc

3. 在文件的最后一行添加以下内容（记得替换 <your-api-key> 为你的实际密钥）：

   export CLAUDE_API_KEY=<your-api-key>

4. 保存文件并退出编辑器。

5. 让更改生效：

   source ~/.bashrc

第三步：验证设置是否成功

我们可以写一小段代码来测试一下我们的设置是否正确。创建一个新的 Python 文件（例如 test_claude.py），并在其中写下以下代码：

import os
import requests

api_key = os.getenv('CLAUDE_API_KEY')
headers = {
    'Authorization': f'Bearer {api_key}',
    'Content-Type': 'application/json'
}

response = requests.get('https://api.anthropic.com/v1/models', headers=headers)

if response.status_code == 200:
    print("Success! You've successfully authenticated with the Claude API.")
else:
    print(f"Error: {response.status_code} - {response.text}")

这段代码做了几件事：

1. 从环境变量中获取你的 API 密钥。
2. 设置请求头以便发送带有认证信息的请求。
3. 发送 GET 请求到 Claude API 的模型列表接口。
4. 根据响应的状态码判断是否成功连接到 API。

运行这个脚本看看结果吧！

python test_claude.py

如果一切顺利，你应该能看到 "Success! You've successfully authenticated with the Claude API." 这样的消息。如果有错误提示，请检查一下你的 API 密钥是否正确无误，并确认环境变量已正确设置。

小贴士

• 保护你的密钥：永远不要把你的 API 密钥泄露给他人或硬编码在公共仓库里。
• 调试技巧：如果遇到问题，请仔细查看错误信息。常见的问题是拼写错误或是网络连接问题。

通过以上几步操作，你现在应该已经成功地拿到了 Claude API 密钥并且配置好了开发环境。接下来就可以愉快地探索更多功能啦！

本章小结

• 我们学会了如何注册 Anthropic 账号并获取 Claude API 密钥。
• 学习了如何在不同操作系统中设置环境变量以存储敏感信息。
• 写了一段简单的 Python 脚本来验证我们的设置是否正确。

这章我们要来搞点实际的！具体来说，我们要学会用 Claude API 来做文本分类和数据分类。学完了之后，你就能让你的应用根据输入的内容自动归类，比如区分新闻文章和评论，或者把用户反馈分成积极、消极两类。

在开始之前，你需要确保已经完成了上一章的操作——也就是说，你已经有了 Claude API 密钥，并且能够成功调用 Claude API 接口。如果你还没搞定这些，赶紧回头补补课吧。

第一步：安装必要的库

首先我们需要一些 Python 库来帮助我们处理 HTTP 请求和解析 JSON 数据。打开终端或命令行工具，输入以下命令来安装 requests 库：

pip install requests

第二步：准备分类任务的数据集

为了演示文本分类的效果，我们可以使用一个简单的小数据集。这里假设我们有一个 CSV 文件 data.csv，其中包含两列：text 和 label。你可以随便找一个类似的文件来测试。

第三步：编写代码进行文本分类

接下来我们写一段 Python 代码来实现基本的文本分类功能。我们会用 Claude 的模型对文本进行预测，并返回相应的类别标签。

import os
import requests
import pandas as pd

# 读取数据集
df = pd.read_csv('data.csv')

# 获取 API 密钥
api_key = os.getenv("ANTHROPIC_API_KEY")

# 设置请求头
headers = {
    "Content-Type": "application/json",
    "x-api-key": api_key,
}

def classify_text(text):
    # 定义请求 payload
    payload = {
        "prompt": f"Classify the following text into 'positive' or 'negative': {text}",
        "max_tokens_to_sample": 10,
        "temperature": 0.1,
    }

    # 发送 POST 请求到 Claude API 的 completion 接口
    response = requests.post(
        "https://api.anthropic.com/v1/complete",
        headers=headers,
        json=payload,
    )

    if response.status_code == 200:
        return response.json()['completion'].strip()
    else:
        print(f"Error: {response.status_code}, {response.text}")
        return None

# 对数据集中的每一行进行分类预测
for index, row in df.iterrows():
    text = row['text']
    label = classify_text(text)
    print(f"Text: {text}\nPredicted Label: {label}\n")

预期结果

这段代码会读取 data.csv 中的所有行，并对每条 text 进行情感分析（在这个例子中是简单的正面或负面分类）。然后打印出原始文本及其对应的预测标签。

常见问题及排查方法

• API 密钥错误：如果你看到类似“Unauthorized”的错误信息，请检查你的 API 密钥是否正确设置。
• CSV 文件路径错误：确保 data.csv 文件存在于当前工作目录下。
• 网络连接问题：如果无法访问 API，请检查你的网络连接是否正常。

示例应用场景

想象一下你正在做一个客户服务系统，希望根据用户的反馈自动标记为“满意”、“不满意”或其他类别。通过上述方法，你可以训练 Claude 模型来进行这样的分类任务，并将其集成到你的应用中。

小贴士

• 调整温度参数：在上面的例子中我们设置了 "temperature": 0.1 来减少随机性并获得更确定的结果。你可以尝试不同的值来看看效果如何变化。
• 批量处理：对于大量数据，考虑分批处理以避免一次性加载过多内存导致程序崩溃。

通过本章的学习，你应该掌握了如何使用 Claude API 进行基础的文本分类任务。虽然这只是冰山一角，但它为你打开了通往更多可能性的大门！

本章小结

• 学会了如何使用 requests 库与 Claude API 进行交互。
• 编写了 Python 脚本来读取本地 CSV 文件并对其中的文本进行分类预测。
• 理解了如何处理常见的 API 错误以及调试技巧。
• 掌握了调整模型参数的方法以优化预测结果的质量。

增强 Claude 回应的检索增强生成技术，简单来说就是让 Claude 不仅基于输入生成回答，还能结合外部知识库中的信息来提供更有深度的回答。这就好比给 Claude 一个“大脑”，让它能够查阅资料后给出更加准确和全面的答案。

为了实现这个功能，你需要确保已经完成了以下准备工作：

• 已经获取了 Claude API 密钥并且配置好了环境。
• 对基本的 Python 编程有所了解，特别是如何使用 requests 库发送 HTTP 请求。

我们先来看一下如何设置一个简单的检索增强生成系统。假设我们有一个包含产品信息的知识库文件 products.json，我们要让 Claude 根据用户提问从中查找相关信息并生成回答。

第一步：准备知识库

首先，创建一个名为 products.json 的文件，并添加一些示例数据：

[
    {"id": "1", "name": "无线耳机", "description": "高品质蓝牙耳机"},
    {"id": "2", "name": "智能手表", "description": "健康监测智能手表"}
]

第二步：编写查询函数

接下来，我们需要编写一个函数来从这个 JSON 文件中搜索信息。这里我们使用 Python 的内置模块 json 来解析文件内容。

import json

def search_products(query):
    with open('products.json', 'r') as file:
        products = json.load(file)
    
    results = []
    for product in products:
        if query.lower() in product['name'].lower() or query.lower() in product['description'].lower():
            results.append(product)
    
    return results

第三步：构建请求并调用 API

现在我们可以构建一个请求，将用户的查询传递给 Claude，并结合之前找到的信息生成回应。我们会使用 requests 库来发送 POST 请求到 Claude API。

import requests

api_key = 'your_claude_api_key'
endpoint = 'https://api.claude.com/v1/completions'

def generate_response(prompt, context):
    headers = {
        'Content-Type': 'application/json',
        'Authorization': f'Bearer {api_key}'
    }
    
    data = {
        'prompt': prompt,
        'context': context,
        'max_tokens_to_sample': 150,
        'temperature': 0.2
    }
    
    response = requests.post(endpoint, headers=headers, json=data)
    return response.json()['completion']

# 示例查询
query = "我想买一款蓝牙耳机"
search_results = search_products(query)

if search_results:
    context = "\n".join([f"{product['name']}: {product['description']}" for product in search_results])
else:
    context = "没有找到相关的产品信息"

full_prompt = f"用户询问: {query}\n已知信息:\n{context}\n请根据以上信息生成回复:"
response_text = generate_response(full_prompt, context)

print(response_text)

预期结果

这段代码会输出类似如下的回应：

用户询问: 我想买一款蓝牙耳机
已知信息:
无线耳机: 高品质蓝牙耳机
请根据以上信息生成回复:
您可以考虑购买我们的无线耳机，这款产品具有高品质的音质和稳定的蓝牙连接性能。

易错提示与调试技巧

• API 密钥错误：如果你看到“Unauthorized”错误，请检查你的 API 密钥是否正确无误。
• JSON 解析错误：确保 products.json 文件格式正确且存在。
• 网络连接问题：如果无法访问 API，请确认你的网络连接正常。

实际场景举例

假设你在一家电子产品公司工作，并且想要开发一个客服机器人来帮助解答客户关于产品的疑问。通过上述方法，你可以让机器人不仅能够识别客户的意图，还能够根据产品数据库中的详细描述给出精确的回答。这样不仅能提高客户满意度，还能减轻客服团队的工作负担。

本章小结

• 学习了如何创建和管理知识库文件。
• 编写了 Python 函数用于从 JSON 文件中搜索相关信息。
• 掌握了如何构造带有上下文的请求以增强 Claude 的响应质量。
• 理解了在实际应用中如何整合检索技术和生成模型。

本章我们要搞定智能文本总结，也就是让你的程序自动提炼文章精华。学完这章后，你会知道怎么用 Claude 来压缩长篇大论，提取核心观点。

首先得确保你已经安装好了必要的库，并且有 Claude API 密钥。上一章我们已经在代码里用到了 anthropic 库，所以这里就不重复安装了。记得你的 API 密钥也准备好啦。

我们先来设置一下基本的环境变量和导入所需的库：

import os
from anthropic import Anthropic

os.environ["ANTHROPIC_API_KEY"] = "your-api-key-here"
client = Anthropic()

接着，我们定义一个函数来进行文本总结。假设你要总结一段很长的文章，可以按照下面的方式来做：

def summarize_text(text):
    prompt = f"Please summarize the following text:\n\n{text}\n\nSummary:"
    response = client.completions.create(
        model="claude-instant-v1",
        max_tokens_to_sample=150,
        prompt=prompt
    )
    return response.completion.strip()

article_text = """
人工智能（Artificial Intelligence, AI）是一门研究如何构建机器学习算法和技术的学科，
旨在使计算机系统能够执行通常需要人类智能的任务，如视觉感知、语音识别、决策制定和语言翻译。
近年来，随着计算能力的提升和大数据的发展，AI 技术取得了显著的进步。深度学习作为AI的一个分支，
通过模拟人脑神经元的工作方式来训练复杂的模式识别模型，在许多领域展现了卓越的能力。
"""

summary = summarize_text(article_text)
print(summary)

预期结果

这段代码会输出类似如下的摘要：

人工智能是一门研究如何构建机器学习算法和技术的学科，旨在使计算机系统执行人类智能任务。
近年来，随着计算能力和大数据的发展，AI 取得了显著进步。深度学习通过模拟人脑神经元的工作方式，
在许多领域展示了卓越的能力。

易错提示与调试技巧

• API 密钥错误：如果你看到“Unauthorized”错误，请检查你的 API 密钥是否正确无误。
• 输入文本过长：Claude 对每次请求的最大 token 数有限制。如果输入文本太长可能会导致错误或截断输出。可以尝试分段处理长文本。
• 模型选择：不同的模型有不同的特点和适用场景。claude-instant-v1 是一个通用的即时响应模型， 如果你需要更高质量的总结或者特定领域的知识支持，可以选择其他更适合的模型。

实际场景举例

想象一下你是一名记者或者编辑，每天都要处理大量的新闻稿件和报告。有了这个自动化的文本总结功能， 你可以快速抓住每篇文章的核心内容，节省大量时间用于分析和撰写评论文章。

本章小结

• 设置了基本的环境变量并导入所需库。
• 定义了一个函数 summarize_text 用于对给定文本进行总结。
• 学习了如何构造合适的提示（prompt）以引导 Claude 生成简洁明了的摘要。
• 注意了一些常见的问题及解决方案，比如 API 密钥错误、输入文本长度限制等。

集成外部工具可以让 Claude 更加灵活和强大，就像给你的瑞士军刀增加更多的刀片一样。通过本章的学习，你会知道怎么让 Claude 调用计算器、查询数据库甚至访问网页上的信息。这样，无论遇到什么问题，都能找到合适的方法来解决。

首先，确保你已经按照上一章的步骤设置了 Claude API 密钥并且安装了必要的库。我们会在 Python 中演示这些操作。

第一步：集成计算器功能

假设我们要让 Claude 帮助我们做一些简单的数学运算。我们可以编写一个函数来实现这一点。

import requests

def call_calculator(expression):
    # 这里简单地使用 eval 来计算表达式，实际应用中要注意安全性
    result = eval(expression)
    return f"The result of {expression} is {result}"

# 测试一下我们的计算器功能
print(call_calculator("2 + 2 * 3"))

预期结果：输出 The result of 2 + 2 * 3 is 8。

注意：在生产环境中使用 eval 函数时要非常小心，因为它会执行传入的字符串中的任何代码，可能存在安全风险。更好的做法是使用专门的安全解析库如 asteval 或者自定义解析逻辑。

第二步：连接 SQL 数据库

接下来，我们要教 Claude 如何查询 SQL 数据库。这里我们以 SQLite 为例。

pip install sqlite3 pandas sqlalchemy

然后编写如下代码：

from sqlalchemy import create_engine
import pandas as pd

def query_database(query):
    engine = create_engine('sqlite:///example.db')  # 替换为你的数据库路径
    df = pd.read_sql_query(query, engine)
    return df.to_string()

# 创建一个测试数据库并插入一些数据
conn = sqlite3.connect('example.db')
c = conn.cursor()
c.execute('''CREATE TABLE stocks (date text, trans text, symbol text, qty real, price real)''')
c.execute("INSERT INTO stocks VALUES ('2023-01-05','BUY','RHAT',100,35.14)")
conn.commit()
conn.close()

# 查询数据
print(query_database("SELECT * FROM stocks"))

预期结果：输出包含刚才插入的数据的表格。

第三步：访问网页内容

最后，我们来看看如何让 Claude 访问网页内容。我们会使用 requests 库来获取网页 HTML 内容，并结合 BeautifulSoup 来解析它。

pip install requests beautifulsoup4

然后编写如下代码：

import requests
from bs4 import BeautifulSoup

def fetch_web_content(url):
    response = requests.get(url)
    soup = BeautifulSoup(response.text, 'html.parser')
    return soup.get_text(strip=True)[:500]  # 返回前500个字符作为示例

# 示例 URL（可以替换成任意你想抓取的页面）
url = "https://www.example.com"
content = fetch_web_content(url)
print(content)

预期结果：输出指定网址的前500个文本字符。

实际场景举例

想象一下你正在开发一个客户服务机器人。客户可能需要查询订单状态、进行账单支付甚至是获取产品推荐。通过上述方法，你可以让机器人调用内部数据库查询订单信息、调用支付接口完成交易以及利用 Claude 的自然语言能力提供个性化的商品建议。

本章小结

• 学习了如何在 Python 中调用外部工具（如计算器）。
• 掌握了如何连接和查询 SQL 数据库。
• 理解了如何抓取和解析网页内容。
• 注意到了在实际应用中的一些安全性和性能方面的考虑。

这章我们要搞定如何把 Claude 和 Vector 数据库（比如 Pinecone）结合在一起，这样 Claude 就能根据用户问题去查找相关的知识库信息，从而变得更聪明。学完了这章，你的应用就能更好地回答复杂的问题了。

首先得确保你已经有一个 Claude API 密钥，并且安装好了必要的 Python 库。我们需要 requests 来发送 HTTP 请求，还有 pinecone-client 来和 Pinecone 打交道。如果你还没装这些库，可以用 pip 安装：

pip install requests pinecone-client

接着我们来设置 Pinecone 的 API 密钥。假设你已经在 Pinecone 上注册了一个账户并且创建了一个索引。你需要知道你的 API 密钥、环境名称和索引名称。

import pinecone

# 替换为你的 Pinecone API 密钥、环境名称和索引名称
api_key = "your-pinecone-api-key"
environment = "your-environment-name"
index_name = "your-index-name"

pinecone.init(api_key=api_key, environment=environment)
index = pinecone.Index(index_name)

如果你遇到 Unauthorized 错误，检查一下你的 API 密钥是否正确输入。如果看到 Index not found，确认一下索引名称拼写无误或者你在正确的环境中。

现在我们准备一些数据放入 Pinecone 索引中。为了简单起见，假设我们有一些文本片段想要存储下来。

data_to_store = [
    ("id1", [0.1, 0.2, 0.3], {"text": "这是一个关于机器学习的介绍"}),
    ("id2", [0.4, 0.5, 0.6], {"text": "深度学习是一种强大的神经网络模型"}),
    ("id3", [0.7, 0.8, 0.9], {"text": "Python 是一种流行的编程语言"})
]

index.upsert(vectors=data_to_store)

这段代码会把三个文本片段插入到我们的索引里面。每个片段都有一个唯一的 ID、一个向量表示（这里随便写的数字）和一个元数据字典包含实际的文本内容。

接下来就是如何从 Claude 收到的问题出发，在 Pinecone 中找到最相关的答案。我们会用一个简单的句子作为例子：“什么是深度学习？”

首先需要将这个问题转换成向量形式，然后才能在 Pinecone 中搜索相似的向量。这个过程通常需要预训练的语言模型来完成，不过为了简化演示，我们就手动给定一个向量吧。

query_vector = [0.4, 0.5, 0.6]  # 这是我们手动构造的一个查询向量

results = index.query(queries=[query_vector], top_k=1)

for match in results.matches:
    print(f"ID: {match.id}, Score: {match.score}, Metadata: {match.metadata}")

这段代码会在我们的索引中寻找与查询向量最接近的那个条目，并打印出来。你应该能看到类似这样的输出：

ID: id2, Score: 1.0, Metadata: {'text': '深度学习是一种强大的神经网络模型'}

这意味着我们的查询成功地找到了最相关的文档！

实际场景举例

想象一下你在做一个医疗咨询系统。医生可能会问一些具体症状的问题，而你要根据已有的医学文献提供准确的答案。通过这种方式，你可以预先将大量的医学文章转换成向量存储在 Pinecone 中，当有新的问题进来时快速匹配并返回相关内容。

本章小结

• 学习了如何设置和初始化 Pinecone 环境。
• 掌握了如何将数据插入到 Pinecone 索引中。
• 理解了如何基于查询向量在 Pinecone 中进行搜索。
• 注意到了常见的错误及其排查方法。

本章我们要搞定怎么利用 Wikipedia 和网页内容来增强 Claude 的能力。这样，当你问 Claude 一个问题时，它不仅能依靠自己的训练数据回答，还能从这些外部资源获取最新信息。读完这章后，你会知道如何抓取和整合这些信息。

首先得确认你已经安装好了必要的工具和库。我们需要 requests 来抓取网页内容，beautifulsoup4 来解析 HTML，还有 wikipedia-api 库来访问 Wikipedia 内容。如果你还没装好这些库，可以先跑下面的命令：

pip install requests beautifulsoup4 wikipedia-api

我们先从抓取网页内容开始。假设你想从某个网页上获取一段文本，可以用 requests 和 beautifulsoup4 来实现。比如我们要抓取百度百科上的“人工智能”页面的内容：

import requests
from bs4 import BeautifulSoup

url = "https://baike.baidu.com/item/%E4%BA%A7%E8%83%BD%E5%BA%A6"
response = requests.get(url)
soup = BeautifulSoup(response.content, 'html.parser')

# 找到正文部分
content_div = soup.find('div', class_='main-content')
paragraphs = content_div.find_all('p')

text_content = "\n".join([para.text for para in paragraphs])
print(text_content[:500])  # 只打印前500字符看看效果

预期结果是你应该能看到一段关于人工智能的文字介绍。

如果你遇到乱码或者找不到内容的情况，可能是编码问题或者网站结构调整了HTML结构。这时候可以检查响应的编码格式，并尝试调整选择器来找到正确的元素。

接着我们来看看如何从 Wikipedia 抓取内容。这里我们会用到 wikipedia-api 库。下面的例子是从维基百科上获取“机器学习”的词条内容：

import wikipediaapi

wiki_wiki = wikipediaapi.Wikipedia('zh')  # 设置为中文维基百科

page_py = wiki_wiki.page('机器学习')
if page_py.exists():
    print("Page - Title: %s" % page_py.title)
    print("Summary: %s" % page_py.summary[0:600])  # 打印摘要的前600字符
else:
    print("Page does not exist")

预期结果是看到一篇关于机器学习的文章摘要。

注意：不同的语言版本可能有不同的命名空间，请确保选择了正确的语言代码（如 'zh' 表示中文）。

最后，我们可以把这些抓来的信息整合到 Claude 的请求中去。假设我们已经有了一个 Claude API 客户端实例 client，并且之前定义了一个函数 generate_response(prompt) 来调用 Claude API 返回答案。

def generate_response(prompt):
    response = client.completions.create(
        model="claude-v1",
        prompt=prompt,
        max_tokens=150
    )
    return response.choices[0].text.strip()

# 结合前面抓到的内容作为背景信息传递给 Claude
prompt_with_context = f"""
背景信息：
{text_content}

问题：
什么是深度学习？
"""

answer = generate_response(prompt_with_context)
print(answer)

在这个例子中，我们将之前从百度百科抓取的人工智能相关内容作为背景信息的一部分传递给了 Claude，并提出了具体的问题“什么是深度学习？”。这样 Claude 就能在回复中结合提供的背景信息给出更详细的回答。

实际场景举例

想象一下你在开发一个教育平台，在这个平台上用户可以提问各种学术问题。为了提高问答的质量和准确性，你可以定期从相关领域的权威网站和维基百科抓取最新的知识更新，并将其整合到你的系统中去。这样无论是学生还是老师都能获得及时且准确的信息支持。

希望你现在对如何利用 Wikipedia 和网页内容来增强 Claude 的能力有了基本的理解！接下来你可以试试自己动手做一些类似的实验，进一步探索更多的可能性。

本章小结

• 学会了如何使用 requests 和 beautifulsoup4 抓取网页内容。
• 掌握了如何使用 wikipedia-api 访问维基百科的数据。
• 知道了如何将抓取到的信息整合进 Claude 的请求中以丰富回答。
• 注意到了在抓取过程中可能出现的一些常见问题及解决方法。

创建嵌入向量以优化 Claude 性能

这章我们要聊聊怎么用嵌入向量来提升 Claude 的表现，特别是当你想让它更好地理解和处理大量文本数据时。读完这一章后，你应该能够理解嵌入向量的基本原理，并知道如何在自己的项目中生成和使用它们。

首先，你需要确保已经安装了必要的库，并且有一个 Claude API 密钥。如果你还没有 API 密钥，记得去 Anthropic 官网注册一个。然后我们需要安装一些 Python 库，比如 openai 和 numpy。你可以通过以下命令来安装这些库：

pip install openai numpy

接下来，我们先导入所需的库，并设置好 API 密钥：

import openai
import numpy as np

openai.api_key = 'your-claude-api-key'

替换 'your-claude-api-key' 为你的实际 API 密钥。

现在我们来看如何生成文本的嵌入向量。假设我们有一段简单的文本需要转换成嵌入向量：

text = "机器学习是一种人工智能技术，使计算机能够在没有明确编程的情况下学习和做出决策。"
response = openai.Embedding.create(
    input=text,
    model="text-embedding-ada-002"
)
embedding_vector = response['data'][0]['embedding']
print(embedding_vector)

这段代码会调用 OpenAI 的 Embedding API 来生成给定文本的嵌入向量，并打印出来。注意这里的模型名称 "text-embedding-ada-002" 是我们在调用嵌入服务时指定的。

如果你遇到错误提示 Invalid request error 或者类似的消息，请检查你的 API 密钥是否正确输入以及网络连接是否正常。

接下来我们看看如何批量生成多个文本的嵌入向量。假设我们有以下几句话：

texts = [
    "机器学习是一种人工智能技术。",
    "深度学习是机器学习的一个分支。",
    "神经网络是实现深度学习的一种方式。",
]
embeddings = []

for text in texts:
    response = openai.Embedding.create(
        input=text,
        model="text-embedding-ada-002"
    )
    embeddings.append(response['data'][0]['embedding'])

embeddings_array = np.array(embeddings)
print(embeddings_array)

这段代码会对每个句子分别生成嵌入向量，并将所有结果存储在一个 NumPy 数组中以便后续处理。

实际场景举例

想象一下你正在构建一个客服机器人，希望能够根据用户的查询快速找到相关的答案。这时你可以预先将所有的 FAQ 文档转换成嵌入向量并存储起来。当用户提出一个问题时，你可以将问题也转换成嵌入向量，然后计算它与其他所有 FAQ 文档之间的相似度（通常使用余弦相似度）。最后返回最匹配的答案给用户。

这样不仅提高了搜索的速度和准确性，还能让机器人更好地理解和回应复杂的查询。

本章小结

• 学习了如何使用 OpenAI 的 Embedding API 生成文本的嵌入向量。
• 掌握了如何批量处理多个文本并获取对应的嵌入向量。
• 理解了为什么使用嵌入向量可以帮助提高 Claude 处理大规模文本数据的能力。
• 注意了一些常见的错误及其解决方法。

这章我们要来聊聊怎么让 Claude 处理图片，也就是视觉处理的基础。学完了之后，你应该能够上传一张图片给 Claude，并让它描述图片的内容或者回答关于图片的问题。

首先，你需要确保已经有一个 Claude API 密钥，并且安装好了 requests 库来发送 HTTP 请求。如果你之前没有安装过这个库，可以运行下面的命令：

pip install requests

我们先从一个简单的例子开始：上传一张图片并获取 Claude 对这张图片的描述。

步骤 1: 准备你的图片

假设你有一张名为 example.jpg 的图片放在当前目录下。你可以用任何你喜欢的照片代替。

步骤 2: 发送请求到 Claude API

我们需要构造一个 POST 请求来上传图片并获得响应。以下是一个最小可用代码示例：

import requests

api_key = 'your-claude-api-key'
image_path = 'example.jpg'

url = "https://api.anthropic.com/v1/images/generate"

headers = {
    "Authorization": f"Bearer {api_key}",
    "Content-Type": "multipart/form-data"
}

with open(image_path, 'rb') as image_file:
    files = {'file': image_file}
    response = requests.post(url, headers=headers, files=files)

if response.status_code == 200:
    print("Response:", response.json())
else:
    print("Error:", response.text)

预期结果: 如果一切顺利，你会得到一个 JSON 响应，里面包含了对图片的描述或者其他相关信息。

注意: 如果你遇到 "Unauthorized" 错误，请检查你的 API 密钥是否正确输入并且有权限访问该功能。如果看到 "File too large" 或者类似错误，请确保你的文件大小符合要求（通常不超过几 MB）。

实际场景举例

想象一下你在开发一款旅游应用，用户可以上传他们旅行中的照片，并希望应用能自动为这些照片添加标签或者描述。通过调用 Claude 的视觉处理能力，你可以实现这样的功能。用户上传了一张巴黎埃菲尔铁塔的照片后，应用会返回一段详细的描述：“这张照片展示了著名的巴黎埃菲尔铁塔夜景，灯光璀璨……”

小贴士

• 调试技巧: 如果你遇到了奇怪的错误信息，尝试打印出完整的响应内容 (response.text) 来查看更多细节。
• 性能优化: 对于大量图片处理任务，请考虑分批发送请求或者使用异步编程来提高效率。

本章小结

• 学会了如何使用 Claude API 处理和分析图像。
• 掌握了基本的请求构造方法以及如何解析响应。
• 理解了视觉处理在实际应用场景中的价值和可能性。
• 注意了一些常见的错误及其解决方法。

这章我们要聊聊如何更好地用 Claude 处理视觉内容，特别是那些复杂的图表和图形。学完了之后，你应该能自信地让 Claude 解释各种图表，甚至还能从中提取有用的信息。

首先，你需要确保已经按照之前的章节设置了好 Claude API 密钥，并且熟悉如何上传和处理图像的基本操作。如果你还没做这些，最好先回头看看前面的内容。

我们先来看几个最佳实践：

最佳实践

1. 清晰度第一: 确保上传的图表足够清晰。模糊不清的图会让 Claude 很难理解其中的内容。
2. 简单背景: 图表背景越简洁越好。复杂的设计可能会干扰 Claude 的识别。
3. 标注完整: 尽可能提供完整的轴标签、图例和其他注释。这些信息有助于 Claude 更准确地解释图表。
4. 格式规范: 使用常见的格式如 PNG 或 JPEG 保存你的图表。避免使用过于特殊的格式。

接着，我们来具体看一个例子：假设你要让 Claude 解释一张股票市场的折线图。

import requests

api_key = "YOUR_API_KEY"
image_url = "https://example.com/path/to/your/chart.png"

headers = {
    "x-api-key": api_key,
    "Content-Type": "application/json"
}

data = {
    "prompt": f"Please describe the following stock market chart: {image_url}",
    "max_tokens_to_sample": 500
}

response = requests.post("https://api.anthropic.com/v1/images/analyze", headers=headers, json=data)

if response.status_code == 200:
    print(response.json())
else:
    print("Error:", response.text)

预期结果: 如果一切顺利，你会得到一个 JSON 响应，里面包含了对图表的详细描述。

如果你遇到 "Unauthorized" 错误，请检查你的 API 密钥是否正确输入并且有权限访问该功能。如果看到 "Invalid URL" 或者类似错误，请确保你的图片 URL 是有效的并且可以被访问。

实际场景举例

想象一下你在开发一款金融分析软件，用户可以上传他们的投资组合报告中的图表，并希望软件能够自动解析这些图表并给出建议。通过调用 Claude 的视觉处理能力，你可以实现这样的功能。用户上传了一份包含过去一年内某支股票价格走势的折线图后，应用会返回一段详细的分析：“根据提供的折线图可以看出，在过去的十二个月中，该股票的价格经历了显著波动……”

技巧分享

• 逐步细化问题: 如果一次性的请求没有达到理想的效果，试着将问题拆分成多个部分分别询问。
• 辅助信息: 提供一些额外的信息可以帮助 Claude 更好地理解图表的具体含义。
• 多次迭代: 不要怕失败，多试几次不同的提示和角度往往能得到更好的结果。

本章小结

• 学习了几种提高视觉处理效果的最佳实践。
• 掌握了如何让 Claude 描述和解释复杂的图表。
• 理解了在实际应用中如何利用这些技能提升用户体验。
• 注意了一些常见的错误及其解决方法。

这章我们要搞定从表单中提取内容的任务。想象一下，你有一个客户填写的表格，你想快速从中提取有用的信息，比如姓名、地址或者订单详情。通过 Claude 的帮助，我们可以自动化这个过程，大大提高效率。

首先得确认几个前提条件：你需要一个 Claude API 密钥，并且已经安装好了 Python 环境。如果你还没准备好这些，回头去第一章看看吧。

我们先来安装必要的库 requests 和 pytesseract。requests 用于发送 HTTP 请求，而 pytesseract 可以用来识别图像中的文字。打开终端或者命令提示符，运行以下命令：

pip install requests pytesseract

接着我们需要下载 Tesseract OCR 引擎。Tesseract 是一个开源的文字识别引擎，可以从图像文件中提取文本。你可以从 这里 下载适合你操作系统的版本，并按照官方文档进行安装。

假设我们已经有了一个包含用户信息的扫描版 PDF 文件或者图片文件。为了演示方便，我们用一张简单的图片作为例子。这张图片上有用户的姓名、邮箱和电话号码。

我们先来看如何从图片中提取文本。首先导入所需的库，并设置 Claude API 密钥：

import requests
from PIL import Image
import pytesseract

api_key = 'YOUR_CLAUDE_API_KEY'
image_path = 'path/to/your/image.png'  # 替换为你的图片路径

然后加载图片并使用 pytesseract 提取其中的文字：

image = Image.open(image_path)
text = pytesseract.image_to_string(image)
print(text)

如果你看到一大坨乱七八糟的文字出来，别担心，OCR 工具有时候不太准。这时候可以用 Claude 来进一步处理这些文字，提取我们需要的信息。下面是一个完整的代码示例：

def extract_info_from_image(api_key, image_path):
    # 加载图片并提取文字
    image = Image.open(image_path)
    raw_text = pytesseract.image_to_string(image)

    # 发送请求给 Claude API 进行进一步处理
    url = "https://api.claude.com/v1/engines/davinci-codex/completions"
    headers = {
        "Content-Type": "application/json",
        "Authorization": f"Bearer {api_key}"
    }
    payload = {
        "prompt": f"From the following text, extract the user's name, email, and phone number:\n{raw_text}",
        "max_tokens": 150,
        "temperature": 0.2
    }

    response = requests.post(url, json=payload, headers=headers)
    
    if response.status_code == 200:
        return response.json()['choices'][0]['text'].strip()
    else:
        print(f"Error: {response.status_code}")
        print(response.text)
        return None

# 示例调用函数
extracted_info = extract_info_from_image(api_key, image_path)
print(extracted_info)

这段代码做了几件事：

1. 使用 pytesseract 从图片中提取原始文本。
2. 将提取到的文本发送给 Claude API 处理。
3. 设置合适的参数（如最大 token 数和温度值）以获得最佳的结果。
4. 解析 API 返回的 JSON 响应并打印出所需的信息。

如果你遇到 "Unauthorized" 错误，请检查你的 API 密钥是否正确输入并且有权限访问该功能。如果看到 "Invalid request" 或者类似错误，请确保你的请求格式正确并且所有必填字段都已提供。

实际场景举例

假设你是一家酒店前台工作人员，每天都要处理大量的入住登记表单。手动录入每个客人的信息既耗时又容易出错。通过上述方法，你可以将扫描后的入住表单传给程序自动提取关键信息，并将其录入系统中。

技巧分享

• 预处理图像: 在使用 OCR 工具之前，尽量保证图像质量良好（例如清晰度高、背景简洁），这样可以提高识别准确率。
• 定制提示: 根据具体需求调整提示文案的内容和格式。
• 调试与验证: 对于初次尝试的新方法务必做好测试工作，在实际环境中部署前确保其稳定性和准确性。

本章小结

• 安装了必要的库并设置了 Claude API 密钥。
• 学习了如何使用 pytesseract 提取图像中的文字。
• 掌握了如何将 OCR 结果传递给 Claude 进一步处理以获取结构化的数据。
• 注意了一些常见的错误及其解决方法，并分享了一些实用技巧来提高工作效率。

本章我们要搞定的是用 Claude 生成图像。想象一下，你只需要输入一段描述性的文字，就能得到一幅精美的插图，是不是很酷？学完了这章，你也能做到这一点。

首先，你需要确保已经安装了必要的库，并且配置好了 Claude API 密钥。另外，我们会用到一个叫 Stable Diffusion 的模型来生成图像，所以也要准备好这个工具。

第一步：安装所需的库

我们先来安装一些必要的 Python 库。打开终端或者命令提示符，输入以下命令：

pip install anthropic openai pillow

这些库分别是用来调用 Claude API、处理图像以及与 OpenAI 的接口交互的。

第二步：设置 Claude API 密钥

接着，我们需要设置 Claude API 密钥。假设你已经在前面的章节中完成了这一步骤，如果没有的话，请记得去 Anthropic 的网站申请密钥，并按照之前的指导进行配置。

第三步：编写代码生成图像

我们现在来写一段代码，让 Claude 通过 Stable Diffusion 生成图像。这里有一个简单的示例：

import anthropic
import base64
from PIL import Image
from io import BytesIO

# 设置你的 Claude API 密钥
api_key = "your_claude_api_key"

client = anthropic.Client(api_key=api_key)

# 描述你想生成的图像
prompt = "A futuristic cityscape at sunset with flying cars and holographic advertisements."

response = client.completion(
    prompt=f"{anthropic.HUMAN_PROMPT} {prompt}{anthropic.AI_PROMPT}",
    model="claude-instant",
    max_tokens_to_sample=300,
)

# 解析响应中的图片数据（假设返回的数据是 Base64 编码）
image_data = response["completion"].split("base64,")[1]
image_bytes = base64.b64decode(image_data)

# 将字节流转换为 Pillow 图像对象并显示出来
image = Image.open(BytesIO(image_bytes))
image.show()

这段代码做了几件事：

1. 初始化 Claude 客户端。
2. 给定一个描述性提示。
3. 请求 Claude 生成相应的图像。
4. 处理返回的 Base64 编码图像数据并显示出来。

常见问题及解决办法

如果你遇到 "Unauthorized" 错误，请检查你的 API 密钥是否正确无误并且具有相应的权限。 如果收到 "Invalid request" 或类似的错误，请确认你的请求格式正确并且所有必需的字段都已填写完整。

实际场景举例

假设你现在是一个游戏设计师，想要快速创建一些概念艺术作品。你可以使用上面的方法，只需简单地描述你心中的画面，就可以得到初步的设计草图。这对于创意初期非常有用。

技巧分享

• 详细描述: 提供尽可能详细的描述可以帮助生成更符合预期的图像。
• 迭代优化: 如果第一次生成的结果不尽如人意，可以通过调整描述或增加更多的细节来进行优化。
• 保存成果: 记得保存每次生成的图像作为备选方案或进一步编辑的基础。

本章小结

• 我们学会了如何安装必要的库并设置 Claude API 密钥。
• 写了一段代码利用 Claude 和 Stable Diffusion 来根据文本描述生成图像。
• 学会了如何解析和展示生成的图像数据。
• 提到了几个常见的错误及其解决方法，并分享了一些实用技巧来提高创作效率。

我们要来聊聊怎么用子代理（sub-agents）提升 Claude 的功能。想象一下，Claude 不再孤军奋战，而是可以调用其他工具或模型来完成任务，这样不仅能提高效率，还能增强其能力。读完这章后，你就能学会如何设置和使用子代理。

首先，你需要确保已经完成了前面几章的内容，特别是初始化了 Claude 客户端并且熟悉基本的操作。另外，你需要有一个 Claude API 密钥，并且准备好 Python 环境。

我们先从安装必要的库开始：

pip install anthropic haiku opus

安装完成后，我们需要导入这些库并初始化客户端：

import anthropic
from haiku import HaikuClient
from opus import OpusClient

client = anthropic.Client(api_key="your_claude_api_key")
haiku_client = HaikuClient(api_key="your_haiku_api_key")
opus_client = OpusClient(api_key="your_opus_api_key")

接着，我们可以定义一个函数来调用子代理。这里我们假设你想让 Claude 在回答用户问题时使用 Haiku 来获取额外的信息：

def ask_with_subagent(prompt):
    # 先让 Claude 处理初始提示
    claude_response = client.completion(
        prompt=f"{anthropic.HUMAN_PROMPT} {prompt}{anthropic.AI_PROMPT}",
        max_tokens_to_sample=150,
        stop_sequences=[anthropic.HUMAN_PROMPT]
    )
    
    # 使用 Haiku 获取更多信息
    haiku_info = haiku_client.search(claude_response["completion"])
    
    # 将信息反馈给 Claude 以获得最终答案
    final_response = client.completion(
        prompt=(
            f"{anthropic.HUMAN_PROMPT} {prompt}\n"
            f"Additional info: {haiku_info}\n"
            f"{anthropic.AI_PROMPT}"
        ),
        max_tokens_to_sample=150,
        stop_sequences=[anthropic.HUMAN_PROMPT]
    )
    
    return final_response["completion"]

如果你遇到 ModuleNotFoundError 错误，请检查是否正确安装了所需的库。如果是 AttributeError 或类似的错误，请确认你使用的 API 方法和参数是否正确。

实际场景举例：假设你在开发一个客服机器人，希望它能够提供更准确的产品信息。你可以使用上述方法，在用户提问时调用产品数据库中的信息来辅助回复。

技巧分享：

• 选择合适的子代理：不同的任务可能需要不同类型的子代理。比如查询数据可以用数据库接口，生成文本可以用写作助手。
• 注意隐私和安全：确保在传递敏感信息时采取适当的安全措施。
• 调试和优化：通过不断测试和调整流程来优化性能。

本章小结：

• 我们学习了如何安装并初始化必要的库。
• 编写了代码实现 Claude 和子代理（Haiku）的协同工作。
• 探讨了一个实际应用场景，并分享了一些有用的技巧。

上传 PDF 并进行总结是个常见的需求，尤其是在需要处理大量文档的情况下。通过本章的学习，你不仅能学会如何上传 PDF 文件，还能让 Claude 自动生成这些文件的摘要，从而大大提高工作效率。

首先，你需要确保已经完成了前面几章的内容，特别是获取了 Claude API 密钥并配置好了环境。此外，还需要安装一些额外的库来处理 PDF 文件。

安装必要的库

我们需要 PyMuPDF 来读取 PDF 内容，并且之前提到的 anthropic 库也要准备好。我们可以使用以下命令安装这些库：

pip install PyMuPDF anthropic

读取 PDF 文件

接下来，我们编写一个函数来读取 PDF 文件的内容。这里我们用 fitz 库（即 PyMuPDF）来打开和解析 PDF 文档。

import fitz  # PyMuPDF

def read_pdf(file_path):
    document = fitz.open(file_path)
    text = ""
    for page_num in range(len(document)):
        page = document.load_page(page_num)
        text += page.get_text()
    return text

这个函数会返回整个 PDF 文档的文本内容。你可以试试看：

pdf_content = read_pdf("example.pdf")
print(pdf_content[:200])  # 打印前200个字符看看效果

将内容发送给 Claude 进行总结

有了 PDF 的文本内容后，我们可以将其发送给 Claude 进行总结。这里我们沿用上一章的方法来调用 Claude API。

from anthropic import Anthropic, HUMAN_PROMPT, AI_PROMPT

def summarize_with_claude(text):
    client = Anthropic(api_key="your-api-key-here")
    
    response = client.completion(
        prompt=(
            f"{HUMAN_PROMPT}请对以下文档进行简洁总结：\n{text}\n{AI_PROMPT}"
        ),
        max_tokens_to_sample=150,
        stop_sequences=[HUMAN_PROMPT]
    )
    
    return response["completion"]

summary = summarize_with_claude(pdf_content)
print(summary)

记得替换 "your-api-key-here" 为你的实际 API 密钥。

处理长文档的情况

如果文档很长，一次性的全部发送可能会导致超出 Claude 的输入限制。这时可以考虑分页或者分段发送，并合并多个摘要的结果。

def summarize_long_pdf(file_path):
    document = fitz.open(file_path)
    summaries = []
    
    for page_num in range(len(document)):
        page = document.load_page(page_num)
        page_text = page.get_text()
        
        summary_chunk = summarize_with_claude(page_text)
        summaries.append(summary_chunk)
    
    final_summary_prompt = (
        f"{HUMAN_PROMPT}请将以下各个部分的摘要合并成一个整体摘要：\n"
        + "\n".join(summaries) +
        f"\n{AI_PROMPT}"
    )
    
    final_response = client.completion(
        prompt=final_summary_prompt,
        max_tokens_to_sample=300,
        stop_sequences=[HUMAN_PROMPT]
    )
    
    return final_response["completion"]

long_doc_summary = summarize_long_pdf("long_example.pdf")
print(long_doc_summary)

这样就能更好地处理长文档了。

实际场景举例

假设你是一名研究员，每天都要阅读大量的学术论文。你可以使用上述方法自动提取每篇论文的核心观点，然后整理成笔记方便查阅。

技巧分享

• 优化输入长度：尽量控制每次发送给 Claude 的文本长度在合理范围内。
• 多次迭代：根据反馈不断调整和优化你的总结逻辑。
• 保存中间结果：在处理长文档时保存每个页面或段落的摘要结果，便于后续处理和调试。

通过本章的学习，你应该掌握了如何上传 PDF 并利用 Claude 进行总结的基本方法。无论是学术研究还是日常办公，这都能大大节省时间并提高效率。

本章小结

• 学习了如何使用 PyMuPDF 库读取 PDF 文件内容。
• 编写了代码将 PDF 内容分割并逐步发送给 Claude 进行总结。
• 探讨了一个实际应用场景，并分享了一些有用的技巧。

自动化提示评估流程可以大大提高你与 Claude 交互的质量和效率。通过编写脚本来自动测试和评估不同的提示，你可以快速找到最佳的提示设计，从而获得更好的响应效果。

为了顺利进行本章的操作，你需要确保已经完成了以下准备工作：

• 已经获取了 Claude API 密钥，并且正确配置了环境变量。
• 对基本的 Python 编程有一定的了解。
• 上一章中提到的代码片段应该已经熟悉，特别是如何调用 Claude API 并处理返回的结果。

我们先来安装一些必要的库。首先，我们需要 requests 库来进行 HTTP 请求，以及 pandas 来处理评估结果的数据框。打开终端或者命令行工具，运行下面的命令：

pip install requests pandas

接着，我们来编写一个简单的函数来调用 Claude API 并接收回复。假设你已经有了一个基本的调用函数 call_claude(prompt)，我们可以在这个基础上构建我们的评估框架。

import os
import requests

def call_claude(prompt):
    api_key = os.getenv('ANTHROPIC_API_KEY')
    headers = {
        "x-api-key": api_key,
        "Content-Type": "application/json"
    }
    data = {
        "prompt": f"{prompt}",
        "max_tokens_to_sample": 150,
        "stop_sequences": ["\n"]
    }
    response = requests.post("https://api.anthropic.com/v1/complete", json=data, headers=headers)
    if response.status_code == 200:
        return response.json()["completion"].strip()
    else:
        raise Exception(f"Error calling Claude: {response.text}")

如果你遇到错误信息“Error calling Claude”，检查一下你的 API 密钥是否正确设置，并且网络连接正常。

接下来，我们要定义一组提示（prompts）来进行评估。这些提示应该是你在实际应用中可能会使用的不同版本或变体。这里举个例子：

prompts = [
    {"name": "short_prompt", "text": "告诉我今天天气怎么样？"},
    {"name": "detailed_prompt", "text": "请详细描述一下今天的天气情况，包括温度、湿度和风速。"}
]

然后我们需要定义一个评分标准来衡量每个提示的效果。这个评分标准可以根据你的具体需求来定制。比如我们可以简单地让人工评分员对每个回复打分：

def evaluate_response(response):
    # 这里可以是一个复杂的评分系统，但现在我们简化为手动评分
    score = int(input(f"请为以下回复打分（1-5）:\n{response}\n"))
    return score

最后，我们将所有部分整合在一起，创建一个完整的评估流程：

import pandas as pd

results = []

for prompt in prompts:
    print(f"正在评估提示: {prompt['name']}")
    response = call_claude(prompt['text'])
    score = evaluate_response(response)
    results.append({"prompt_name": prompt["name"], "score": score})

df_results = pd.DataFrame(results)
print(df_results)

这个脚本会依次对每一个提示进行评估，并记录下每个提示对应的得分。最终我们会得到一个包含所有结果的数据框。

实际场景举例

假设你是一名客服代表，在开发一个新的聊天机器人用于解答客户问题。你可以使用上述方法来比较不同版本的问候语的效果，并选择最有效的那个。

技巧分享

• 多样化提示：尝试多种不同的提示格式和内容组合。
• 批量处理：如果有很多提示需要评估，考虑使用批处理的方式来提高效率。
• 自动化评分：对于某些类型的任务，可以探索使用机器学习模型来自动生成评分。

通过本章的学习，你应该能够搭建起一个基础的自动化提示评估流程，并根据实际情况进行调整和优化。

本章小结

• 安装并导入所需的库 (requests, pandas)。
• 编写了一个通用的 call_claude 函数来调用 Claude API。
• 设计了一组待评估的不同版本的提示。
• 实现了一个简单的手动评分机制。
• 将所有部分整合在一起形成完整的自动化评估流程。

本章我们要搞定一件事：让 Claude 返回的响应变成标准的 JSON 格式。这样做的好处是你可以在后端轻松解析和处理这些数据，不用再担心格式不一致的问题。

前提是你已经有一个 Claude API 密钥并且知道怎么调用 Claude API。如果你还不熟悉这部分，建议先去上一章看看。

第一步操作

首先，我们需要设置请求头，告诉 Claude 我们希望得到 JSON 格式的回复。这很简单，只要在请求头中添加 Content-Type: application/json 即可。

import requests

api_key = 'your-claude-api-key'
headers = {
    'x-api-key': api_key,
    'Content-Type': 'application/json'
}

这里的 your-claude-api-key 是你的实际 API 密钥，请记得替换掉。

第二步发送请求

接下来，我们构造一个 POST 请求来调用 Claude API，并指定返回格式为 JSON。

url = 'https://api.anthropic.com/v1/complete'

data = {
    "prompt": "你好，Claude！你能告诉我今天的天气吗？",
    "max_tokens_to_sample": 150,
    "stop_sequences": ["\n\n"],
    "temperature": 0.7
}

response = requests.post(url, headers=headers, json=data)

这里的关键点是 json=data 参数，它会自动将我们的数据转换为 JSON 格式并发送给服务器。

第三步检查响应

最后，我们来查看一下 Claude 返回的结果是否符合预期。

if response.status_code == 200:
    result = response.json()
    print(result)
else:
    print("请求失败:", response.text)

如果一切顺利，你应该能看到类似这样的输出：

{
    "completion": "今天天气晴朗，气温适中。",
    "stop_reason": "stop_sequence"
}

注意看 "completion" 字段包含了 Claude 的回答。

易错提示

• 忘记设置 Content-Type: 如果你在请求头中没有设置 Content-Type: application/json，Claude 可能不会按照预期返回 JSON 格式的数据。

• 错误的状态码: 如果返回的状态码不是 200，请检查你的 API 密钥是否正确以及网络连接是否正常。

实际场景举例

想象一下你正在开发一个智能家居系统，用户可以通过语音助手询问各种信息。为了更好地处理这些信息，你需要从 Claude 获取标准化的 JSON 输出。比如用户问“家里的温度是多少”，你可以通过上面的方法获取到一个包含温度值的 JSON 对象，并据此控制空调系统的开关或者调整温度设定。

技巧分享

• 调试输出: 在开发过程中打印出完整的响应对象可以帮助你快速定位问题。

• 异常处理: 添加更多的错误处理逻辑可以让你的应用更加健壮。例如捕获特定类型的 HTTP 错误并提供友好的错误消息给用户。

通过本章的学习，你应该能够轻松地配置 Claude API 来获得标准的 JSON 格式输出，并将其集成到你的应用程序中。

本章小结

• 设置了正确的请求头以确保接收 JSON 格式的响应。
• 发送了一个 POST 请求到 Claude API 并指定了参数。
• 检查并解析了返回的 JSON 数据。
• 学习了一些常见的调试和错误处理技巧。

构建内容审核过滤器是个很重要的任务，尤其是在开发涉及到用户输入的应用程序时。通过本章的学习，你会学会如何使用 Claude API 来创建一个简单的内容审核过滤器，确保你的应用不会处理不当或有害的信息。

准备工作

首先，你需要有一个 Claude API 密钥。如果你还没有的话，可以在 Anthropic 官网 注册并获取。另外，我们假设你已经熟悉基本的 Python 编程，并且安装好了 requests 库来发送 HTTP 请求。

步骤一：定义敏感词列表

我们要做的第一件事就是定义一组敏感词。这些词是我们希望过滤掉的关键词或短语。

sensitive_words = ["badword1", "badword2", "offensivephrase"]

步骤二：编写审核函数

接下来，我们需要编写一个函数来检查用户输入的内容是否包含任何敏感词。

def contains_sensitive_word(text, sensitive_words):
    for word in sensitive_words:
        if word.lower() in text.lower():
            return True
    return False

这个函数会遍历敏感词列表，并检查每个词是否出现在用户输入的文本中（忽略大小写）。

步骤三：调用 Claude API 获取回复

假设我们已经有了一个用户输入的消息，我们可以先进行内容审核再决定是否将该消息发送给 Claude API 获取回复。

import requests

api_key = 'your_claude_api_key'
url = 'https://api.anthropic.com/v1/complete'

headers = {
    'Authorization': f'Bearer {api_key}',
    'Content-Type': 'application/json',
}

def get_claude_response(prompt):
    data = {
        "prompt": prompt,
        "max_tokens_to_sample": 100,
    }
    
    response = requests.post(url, headers=headers, json=data)
    
    if response.status_code == 200:
        return response.json()['completion']
    else:
        print(f"Error: {response.status_code}")
        return None

这里我们定义了一个简单的函数 get_claude_response 来发送请求并获取 Claude 的回复。

步骤四：结合审核和回应

现在我们可以将前面两部分结合起来，在发送请求之前先做一次内容审核。

user_input = "这是一个测试消息 badword1"

if contains_sensitive_word(user_input, sensitive_words):
    print("检测到敏感词汇，拒绝处理此消息")
else:
    claude_reply = get_claude_response(user_input)
    print("Claude 的回复:", claude_reply)

在这个例子中，如果用户输入包含任何敏感词，则直接拒绝处理该消息；否则则正常获取 Claude 的回复。

实际场景举例

想象一下你正在开发一款社交媒体应用，用户可以发布评论或帖子。为了避免恶意言论传播，你需要在后台对所有发布的文本进行实时审核。通过上述方法，你可以在用户的评论被公开前拦截并审查其中的内容。

常见问题与解决方案

• 性能考虑: 如果你的应用每天有大量的用户输入需要审核，可能需要考虑使用更高级别的搜索算法或专门的服务来提高效率。

• 误判率: 敏感词列表可能无法涵盖所有的不良内容。有时候即使某些词语不在列表内也可能有潜在的风险性含义。因此除了关键词匹配之外还可以引入机器学习模型来进行更复杂的分析。

• 更新维护: 敏感词列表需要定期更新以适应新的网络流行语和社会热点事件的变化。

技巧分享

• 日志记录: 记录每次触发过滤的情况有助于后续改进和审计。

• 反馈机制: 允许用户提供反馈机制以便于不断优化过滤规则。

• 透明度: 明确告知用户你的平台对于不当内容的态度和措施可以让社区更加信任和支持你的努力。

本章小结

• 创建了一个简单的敏感词列表用于内容审核。
• 编写了函数来检测文本中的敏感词汇。
• 结合了内容审核和 Claude API 请求的过程。
• 探讨了一些实际应用场景及常见问题的解决方案。

实现高效的提示缓存策略能大大减少对 Claude API 的调用次数，从而节省成本并加快响应速度。完成本章后，你不仅能学会如何设置和管理缓存，还能理解何时以及为何使用缓存。

为了顺利进行本章的学习，你需要确保已经安装了 requests 库，并且有一个有效的 Claude API 密钥。如果你还没有安装 requests，可以通过以下命令快速安装：

pip install requests

我们先从最基础的缓存实现开始。这里我们会使用 Python 内置的 functools.lru_cache 来创建一个简单的缓存系统。

首先，我们需要定义一个函数来发送请求到 Claude API：

import requests
from functools import lru_cache

def call_claude(prompt):
    api_key = "YOUR_CLAUDE_API_KEY"
    headers = {
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json",
    }
    data = {"prompt": prompt}
    response = requests.post("https://api.anthropic.com/v1/complete", json=data, headers=headers)
    return response.json()

这个函数会根据传入的 prompt 发送请求到 Claude API，并返回响应结果。注意替换 "YOUR_CLAUDE_API_KEY" 为你自己的 API 密钥。

接下来，我们给这个函数加上缓存功能：

@lru_cache(maxsize=128)
def cached_call_claude(prompt):
    return call_claude(prompt)

这里我们使用了 lru_cache 装饰器，并设置了最大缓存条目数为 128。这意味着最近使用的 128 个不同的提示会被缓存起来。

假设我们要测试一下这个缓存效果：

response1 = cached_call_claude("你好，Claude！")
print(response1)

response2 = cached_call_claude("你好，Claude！")
print(response2)

第一次调用 cached_call_claude 时，程序会向 Claude API 发送请求并得到响应；第二次调用相同的提示时，则直接从缓存中取出结果而不再发起网络请求。

如果你遇到类似 "LRUCache is not defined" 的错误，请检查是否正确导入了 functools.lru_cache。

需要注意的是，虽然 lru_cache 很方便，但它也有一些限制：

• 它只能缓存在内存中。
• 对于大量数据或者长时间运行的应用来说，可能需要更复杂的持久化存储方案。
• 缓存可能会占用较多内存资源，请根据实际情况调整大小。

实际场景举例

想象一下你正在开发一个客服机器人应用。每当用户输入同样的问题时，客服机器人应该能够迅速提供一致的答案而不需要每次都重新计算。这时就可以利用提示缓存来提升用户体验和效率。

技巧分享

• 选择合适的键值: 确保用于缓存的键足够唯一又能准确反映提示的内容。

• 定期清理: 如果你的应用持续运行很长时间或者处理的数据类型很多样化，记得定时清理旧的缓存项以释放空间。

• 监控命中率: 监控你的缓存命中率可以帮助你判断当前策略的有效性，并据此做出优化调整。

本章小结

• 学习了如何使用 Python 的 functools.lru_cache 来实现基本的提示缓存。
• 理解了如何在实际应用中利用缓存来提高性能和降低成本。
• 注意到了一些常见的陷阱和最佳实践建议。

安装报错：如何解决 ModuleNotFoundError: No module named 'requests'

在运行代码时遇到 ModuleNotFoundError: No module named 'requests' 错误，说明你的环境中缺少 requests 库。你可以通过以下命令安装该库：

pip install requests

确保你在一个激活的虚拟环境中执行此操作，以避免影响全局 Python 环境。

环境/依赖：如何设置 Python 虚拟环境？

为了更好地管理项目的依赖关系，建议创建一个 Python 虚拟环境。以下是步骤：

1. 创建虚拟环境：

   python -m venv myenv

2. 激活虚拟环境（Windows）:

   myenv\Scripts\activate

3. 激活虚拟环境（macOS/Linux）:

   source myenv/bin/activate

然后，在这个环境下安装所有必要的依赖包。

配置：如何正确配置 Claude API 密钥？

要使用 Claude API，你需要先获取 API 密钥并将其配置到你的项目中。通常可以通过设置环境变量来实现：

1. 获取 API 密钥后，在终端或命令提示符中设置环境变量：

   export CLAUDE_API_KEY='your-api-key-here'

   对于 Windows 用户，请使用：

   set CLAUDE_API_KEY=your-api-key-here

2. 在代码中读取该环境变量：

   import os
   
   api_key = os.getenv('CLAUDE_API_KEY')
   if not api_key:
       raise ValueError("Please set the CLAUDE_API_KEY environment variable.")

使用误区：为什么我的请求总是返回错误信息？

如果你的请求总是返回错误信息，请检查以下几个方面：

• API 密钥是否正确：确认你在代码中使用的密钥是正确的。
• URL 是否正确：检查请求 URL 是否指向正确的 Claude API 端点。
• 请求参数是否完整：确保所有的必填参数都已经提供，并且格式正确。
• 网络连接：验证是否有稳定的网络连接可以访问 Claude 的服务器。

与同类对比：Claude 和 OpenAI GPT 有什么区别？

Claude 和 OpenAI GPT 是由不同的公司开发的语言模型产品，各自有不同的特点和应用场景：

• 开发公司：Claude 由 Anthropic 公司开发，而 GPT 系列则由 OpenAI 开发。
• 训练数据来源：两者的训练数据集不同，这可能导致它们对相同输入产生不同的响应。
• 伦理考量：Anthropic 强调其产品的安全性、可靠性和有益性，致力于减少有害内容生成的风险。
• 功能特性：虽然两者都提供了强大的文本生成能力，但具体的功能接口和支持的服务可能有所不同。

选择哪个模型取决于你的具体需求以及对供应商的信任度等因素。