claude-agent-sdk-python实战指南：从入门到架构师的进阶之路

问题导入：AI应用开发的核心痛点

在构建AI应用时，你是否曾遇到这些挑战：如何安全地让AI访问系统资源？怎样处理实时响应流以提升用户体验？如何将自定义业务逻辑无缝集成到AI工作流中？claude-agent-sdk-python正是为解决这些问题而生，它提供了一套完整的工具链，让开发者能够轻松构建安全、高效且可扩展的AI应用。

想象一下，你需要开发一个能够分析服务器日志并自动生成报告的AI助手。这个助手需要读取日志文件、执行数据分析、生成可视化图表，甚至在发现异常时发送警报。使用传统方法，你需要处理文件权限、命令执行安全、异步响应处理等一系列复杂问题。而claude-agent-sdk-python通过提供统一的接口和安全机制，让这一切变得简单。

核心功能模块解析

1. 基础查询模块：如何与AI建立对话？

你是否想过，与AI的对话背后发生了什么？claude-agent-sdk-python的查询功能就像是你与AI之间的翻译官，负责将你的问题传递给AI，并将AI的回答以易于处理的方式返回给你。

核心API：query()函数

完整代码示例：

import anyio
from claude_agent_sdk import query, ClaudeAgentOptions

async def main():
    # 创建配置选项 - 就像给AI助手设定工作规则
    options = ClaudeAgentOptions(
        system_prompt="你是一位数据分析师，擅长解释复杂的技术概念",
        max_turns=3,  # 限制对话轮次，防止无限循环
        allowed_tools=["Read"]  # 只允许读取文件工具
    )
    
    # 发送查询 - 相当于向AI助手提出问题
    async for message in query(
        prompt="解释什么是异步编程，并举例说明其优势",
        options=options
    ):
        # 处理响应 - 实时获取AI的回答
        if message.type == "text":
            print(f"AI回复: {message.content[0].text}")
        elif message.type == "tool_use":
            print(f"AI请求使用工具: {message.content[0].name}")

# 运行异步函数
anyio.run(main)

效果验证：运行代码后，你将看到AI对异步编程的解释，整个过程中AI不会尝试使用未授权的工具。

💡 企业级扩展建议：在生产环境中，考虑添加日志记录和错误处理机制，以便跟踪对话过程和排查问题。你还可以实现对话历史存储，让AI能够记住之前的对话内容。

2. 客户端模块：如何构建持续对话？

如果说query()函数是一次性的问答，那么ClaudeSDKClient类就是持续对话的舞台。它允许你与AI进行多轮交互，就像在与真人对话一样自然。

核心API：ClaudeSDKClient类

完整代码示例：

import anyio
from claude_agent_sdk import ClaudeSDKClient, ClaudeAgentOptions

async def main():
    # 创建客户端配置
    options = ClaudeAgentOptions(
        system_prompt="你是一位Python专家，帮助用户解决编程问题",
        allowed_tools=["Bash"]
    )
    
    # 创建客户端实例 - 相当于创建一个持久的对话通道
    async with ClaudeSDKClient(options=options) as client:
        # 发送第一个查询
        client.query("如何用Python实现斐波那契数列？")
        
        # 接收并处理响应
        async for message in client.receive_response():
            if message.type == "text":
                print(f"AI: {message.content[0].text}")
                
                # 用户 follow-up 问题
                client.query("如何优化这个算法的性能？")
            
            # 处理工具使用请求
            elif message.type == "tool_use":
                print(f"AI想要执行命令: {message.content[0].input['command']}")
                # 在实际应用中，这里可以添加权限检查逻辑

anyio.run(main)

效果验证：运行代码后，你将看到AI先解释斐波那契数列的实现，然后在收到 follow-up 问题后，继续讨论性能优化方案。

💡 企业级扩展建议：实现对话状态管理，允许用户暂停、恢复或回滚对话。考虑添加用户认证和权限控制，确保不同用户只能访问其权限范围内的功能。

3. 工具系统：如何扩展AI的能力？

AI本身就像一个聪明的大脑，但它需要工具来与外部世界交互。claude-agent-sdk-python的工具系统允许你为AI添加各种能力，从文件操作到复杂的业务逻辑。

核心API：@tool装饰器和create_sdk_mcp_server函数

完整代码示例：

from claude_agent_sdk import tool, create_sdk_mcp_server, ClaudeAgentOptions, ClaudeSDKClient
from typing import Any

# 定义一个天气查询工具 - 就像给AI配备了一个天气预报设备
@tool(
    name="weather",
    description="查询指定城市的天气情况",
    input_schema={"city": str}  # 定义输入参数 schema
)
async def get_weather(args: dict[str, Any]) -> dict[str, Any]:
    """获取指定城市的天气信息"""
    # 在实际应用中，这里会调用真实的天气API
    mock_weather_data = {
        "北京": {"temperature": 22, "condition": "晴朗", "humidity": 45},
        "上海": {"temperature": 25, "condition": "多云", "humidity": 60},
        "广州": {"temperature": 28, "condition": "小雨", "humidity": 75}
    }
    
    city = args.get("city", "北京")
    weather = mock_weather_data.get(city, {"temperature": "未知", "condition": "未知", "humidity": "未知"})
    
    return {
        "content": [
            {"type": "text", "text": f"{city}当前天气：{weather['condition']}，温度：{weather['temperature']}°C，湿度：{weather['humidity']}%"}
        ]
    }

# 创建MCP服务器 - MCP服务器就像餐厅的后厨，负责处理工具的实际"烹饪"过程
weather_server = create_sdk_mcp_server(
    name="weather-tools",
    version="1.0.0",
    tools=[get_weather]
)

# 使用自定义工具
async def main():
    options = ClaudeAgentOptions(
        mcp_servers={"weather": weather_server},  # 将工具服务器添加到配置
        allowed_tools=["mcp__weather__weather"],  # 允许使用天气工具
        system_prompt="你是一个天气助手，可以使用天气工具查询天气情况"
    )
    
    async with ClaudeSDKClient(options=options) as client:
        client.query("北京今天天气怎么样？")
        async for message in client.receive_response():
            if message.type == "text":
                print(f"AI: {message.content[0].text}")

import anyio
anyio.run(main)

效果验证：运行代码后，AI将使用我们定义的天气工具来回答北京的天气情况。

💡 企业级扩展建议：构建工具库系统，允许动态加载和卸载工具。实现工具使用审计日志，记录所有工具调用情况以满足合规要求。考虑添加工具权限管理，限制不同AI角色可以使用的工具。

技术原理图解

SDK工作流程图

图1：claude-agent-sdk-python工作流程图

SDK的工作流程可以分为以下几个关键步骤：

1. 用户交互层：提供query()函数和ClaudeSDKClient类，作为开发者与AI交互的入口。

2. 配置管理层：通过ClaudeAgentOptions类管理各种配置，包括系统提示、工具权限、模型选择等。

3. 通信层：负责与Claude Code CLI进行通信，处理输入输出流和错误信息。

4. 工具执行层：管理MCP服务器和工具调用，包括内置工具和自定义工具。

5. 响应处理层：解析AI返回的消息，将其转换为易于处理的格式，并触发相应的回调函数。

这个架构设计确保了SDK的灵活性和可扩展性，使开发者能够轻松添加新功能或集成到现有系统中。

进阶实战案例

案例1：智能日志分析助手

场景描述：开发一个能够分析服务器日志文件，识别异常并生成报告的AI助手。

核心API：ClaudeSDKClient、文件读取工具、自定义分析工具

完整代码示例：

import anyio
from claude_agent_sdk import tool, create_sdk_mcp_server, ClaudeAgentOptions, ClaudeSDKClient
from typing import Any
import re
from datetime import datetime

# 自定义日志分析工具
@tool(
    name="analyze_logs",
    description="分析日志内容，识别错误和异常模式",
    input_schema={"log_content": str}
)
async def analyze_logs(args: dict[str, Any]) -> dict[str, Any]:
    """分析日志内容，识别错误和异常"""
    log_content = args.get("log_content", "")
    
    # 查找错误行
    error_pattern = r"ERROR: (.*)"
    errors = re.findall(error_pattern, log_content)
    
    # 查找警告行
    warning_pattern = r"WARNING: (.*)"
    warnings = re.findall(warning_pattern, log_content)
    
    # 生成分析报告
    report = f"日志分析报告 ({datetime.now()}):\n"
    report += f"错误数量: {len(errors)}\n"
    report += f"警告数量: {len(warnings)}\n"
    
    if errors:
        report += "\n主要错误:\n"
        for i, error in enumerate(errors[:3], 1):
            report += f"{i}. {error[:100]}...\n"
    
    return {"content": [{"type": "text", "text": report}]}

# 创建日志分析工具服务器
log_analyzer_server = create_sdk_mcp_server(
    name="log-analyzer",
    version="1.0.0",
    tools=[analyze_logs]
)

async def main():
    options = ClaudeAgentOptions(
        system_prompt="你是一位系统管理员助手，擅长分析服务器日志并提供解决方案。"
                      "首先使用Read工具读取日志文件，然后使用analyze_logs工具分析内容，最后提供修复建议。",
        allowed_tools=["Read", "mcp__log-analyzer__analyze_logs"],
        mcp_servers={"log-analyzer": log_analyzer_server}
    )
    
    async with ClaudeSDKClient(options=options) as client:
        client.query("分析/var/log/app.log文件，找出所有错误并提供解决方案")
        async for message in client.receive_response():
            if message.type == "text":
                print(f"AI: {message.content[0].text}")
            elif message.type == "tool_use":
                tool_name = message.content[0].name
                tool_input = message.content[0].input
                print(f"AI正在使用工具: {tool_name}, 输入: {tool_input}")

anyio.run(main)

效果验证：运行代码后，AI将先使用Read工具读取日志文件，然后使用我们定义的analyze_logs工具分析内容，最后生成包含错误数量、警告数量和主要错误的报告。

⚠️ 注意：在实际部署时，需要确保AI只能访问授权的日志文件，避免敏感信息泄露。

案例2：自动化代码审查工具

场景描述：开发一个能够自动审查代码质量、识别潜在问题并提供改进建议的AI助手。

核心API：ClaudeSDKClient、文件读取工具、Bash工具

完整代码示例：

import anyio
from claude_agent_sdk import ClaudeAgentOptions, ClaudeSDKClient

async def main():
    # 定义代码审查规则
    code_review_guidelines = """进行代码审查时，请关注以下几点：
1. 代码风格是否符合PEP 8规范
2. 是否存在安全漏洞，特别是SQL注入和XSS攻击风险
3. 错误处理是否完善
4. 性能是否有优化空间
5. 注释是否清晰有用
6. 是否有重复代码可以抽象"""
    
    options = ClaudeAgentOptions(
        system_prompt=f"你是一位资深Python代码审查专家。{code_review_guidelines} "
                      "使用Read工具读取代码文件，使用Bash工具运行代码检查命令，然后提供详细的审查报告。",
        allowed_tools=["Read", "Bash"],
        permission_mode="auto_approve"  # 自动批准工具使用
    )
    
    async with ClaudeSDKClient(options=options) as client:
        client.query("审查项目中的src/claude_agent_sdk/client.py文件，包括运行pylint检查并提供改进建议")
        async for message in client.receive_response():
            if message.type == "text":
                print(f"AI: {message.content[0].text}")
            elif message.type == "tool_use":
                tool_name = message.content[0].name
                tool_input = message.content[0].input
                print(f"AI正在使用工具: {tool_name}, 输入: {tool_input}")

anyio.run(main)

效果验证：运行代码后，AI将读取指定的Python文件，运行pylint检查，并生成包含代码风格问题、潜在错误和改进建议的详细报告。

💡 技巧：可以将此工具集成到CI/CD流程中，实现代码提交时的自动审查。

案例3：企业级文档处理助手

场景描述：开发一个能够处理各种格式文档（PDF、Word、Markdown），提取关键信息并生成摘要的AI助手。

核心API：ClaudeSDKClient、文件读取工具、自定义文档处理工具

完整代码示例：

import anyio
from claude_agent_sdk import tool, create_sdk_mcp_server, ClaudeAgentOptions, ClaudeSDKClient
from typing import Any
import PyPDF2  # 需要安装: pip install PyPDF2

# 自定义PDF处理工具
@tool(
    name="process_pdf",
    description="提取PDF文件内容并进行分析",
    input_schema={"file_path": str, "task": str}
)
async def process_pdf(args: dict[str, Any]) -> dict[str, Any]:
    """处理PDF文件，提取内容并执行指定任务"""
    file_path = args.get("file_path", "")
    task = args.get("task", "summarize")
    
    try:
        # 提取PDF内容
        text = ""
        with open(file_path, "rb") as f:
            reader = PyPDF2.PdfReader(f)
            for page in reader.pages:
                text += page.extract_text()
        
        # 根据任务处理内容
        if task == "summarize":
            # 简单摘要 - 在实际应用中可以使用更复杂的NLP模型
            words = text.split()
            summary = " ".join(words[:100]) + "..." if len(words) > 100 else " ".join(words)
            result = f"PDF摘要 (共{len(reader.pages)}页):\n{summary}"
        elif task == "extract_keywords":
            # 简单关键词提取
            words = text.lower().split()
            stop_words = {"the", "and", "of", "to", "a", "in", "is", "it", "you", "that", "he", "she", "this"}
            filtered_words = [word for word in words if word.isalpha() and word not in stop_words]
            word_counts = {}
            for word in filtered_words:
                word_counts[word] = word_counts.get(word, 0) + 1
            top_keywords = sorted(word_counts.items(), key=lambda x: x[1], reverse=True)[:10]
            result = "关键词及其出现次数:\n" + "\n".join([f"- {word}: {count}" for word, count in top_keywords])
        else:
            result = f"已提取PDF内容，共{len(text)}字符。请提供具体分析任务。"
            
        return {"content": [{"type": "text", "text": result}]}
    except Exception as e:
        return {"content": [{"type": "text", "text": f"处理PDF时出错: {str(e)}"}]}

# 创建文档处理工具服务器
document_server = create_sdk_mcp_server(
    name="document-processor",
    version="1.0.0",
    tools=[process_pdf]
)

async def main():
    options = ClaudeAgentOptions(
        system_prompt="你是一位文档处理专家，能够分析各种格式的文档并提取关键信息。"
                      "使用Read工具验证文件存在，然后使用process_pdf工具处理PDF文件。",
        allowed_tools=["Read", "mcp__document-processor__process_pdf"],
        mcp_servers={"document-processor": document_server}
    )
    
    async with ClaudeSDKClient(options=options) as client:
        client.query("分析./docs/report.pdf文件，提取关键词并生成简要摘要")
        async for message in client.receive_response():
            if message.type == "text":
                print(f"AI: {message.content[0].text}")
            elif message.type == "tool_use":
                tool_name = message.content[0].name
                tool_input = message.content[0].input
                print(f"AI正在使用工具: {tool_name}, 输入: {tool_input}")

anyio.run(main)

效果验证：运行代码后，AI将先验证PDF文件是否存在，然后使用我们定义的process_pdf工具提取关键词并生成文档摘要。

📌 重点：这个案例展示了如何将第三方库（如PyPDF2）集成到自定义工具中，扩展AI的能力。在企业环境中，你可以根据需要集成更多专业文档处理库。

工具开发设计模式

在开发自定义工具时，有几种常见的设计模式可以帮助你构建灵活、可维护的工具系统：

1. 单一职责模式

每个工具只负责一项具体功能，如我们前面实现的天气查询工具和PDF处理工具。这种模式使工具易于理解、测试和维护。

示例：

@tool(name="weather", description="查询天气", input_schema={"city": str})
async def get_weather(args): ...

@tool(name="news", description="获取新闻", input_schema={"topic": str})
async def get_news(args): ...

2. 组合模式

将多个相关工具组合成一个工具集，通过一个统一的接口提供多种功能。这种模式适合处理复杂任务，如文档处理工具集可以包含PDF处理、Word处理、Markdown处理等子工具。

示例：

# 文档处理工具集
@tool(name="process_document", description="处理各种文档", 
      input_schema={"file_path": str, "task": str, "format": str})
async def process_document(args):
    format = args.get("format", "pdf")
    task = args.get("task", "summarize")
    
    if format == "pdf":
        return await process_pdf(args)
    elif format == "docx":
        return await process_word(args)
    # 其他格式...
    else:
        return {"content": [{"type": "text", "text": f"不支持的格式: {format}"}]}

3. 适配器模式

当需要集成现有系统或第三方API时，适配器模式非常有用。它可以将不兼容的接口转换为AI工具能够理解和使用的格式。

示例：

# 第三方天气API适配器
import requests

@tool(name="weather", description="查询天气", input_schema={"city": str})
async def weather_api_adapter(args):
    city = args.get("city", "北京")
    api_key = os.environ.get("WEATHER_API_KEY")
    
    # 调用第三方API
    response = requests.get(f"https://api.weather.com/weather?city={city}&appid={api_key}")
    data = response.json()
    
    # 转换为AI能够理解的格式
    return {
        "content": [{"type": "text", 
                    "text": f"{city}当前天气：{data['weather'][0]['description']}，"
                            f"温度：{data['main']['temp']}°C"}]
    }

竞品技术选型对比

特性	claude-agent-sdk-python	OpenAI Python SDK	LangChain
核心定位	专注于Claude Agent开发的专业SDK	通用OpenAI服务SDK	通用LLM应用开发框架
工具系统	内置MCP服务器，支持进程内工具	需手动实现工具调用逻辑	提供工具抽象和调用链
安全机制	细粒度权限控制，钩子系统	基础API密钥控制	需自行实现安全控制
流处理	原生支持异步流处理	支持但需手动处理	提供流处理抽象
学习曲线	中等，专注于Claude生态	低，接口简单	高，概念较多
企业特性	内置审计、权限管理	基础功能，需扩展	可通过插件扩展

claude-agent-sdk-python的优势在于其专为Claude Agent设计，提供了完整的工具系统和安全机制，适合构建企业级AI应用。相比之下，OpenAI SDK更通用但需要更多定制开发，而LangChain提供了更广泛的LLM支持但学习曲线较陡峭。

性能优化指南

为了确保你的AI应用在生产环境中表现出色，考虑以下性能优化策略：

1. 连接池管理

对于需要频繁与外部服务交互的工具，使用连接池可以显著提高性能。

import aiohttp
from claude_agent_sdk import tool

# 创建全局连接池
session = aiohttp.ClientSession()

@tool(name="weather", description="查询天气", input_schema={"city": str})
async def get_weather(args):
    city = args.get("city", "北京")
    
    # 使用连接池中的连接
    async with session.get(f"https://api.weather.com/weather?city={city}") as response:
        data = await response.json()
        # 处理数据...

2. 结果缓存

对于相同输入的工具调用，缓存结果可以减少重复计算和外部API调用。

from functools import lru_cache
from claude_agent_sdk import tool

# 使用内存缓存
@lru_cache(maxsize=100)
async def cached_weather_query(city):
    # 实际的API调用...
    return weather_data

@tool(name="weather", description="查询天气", input_schema={"city": str})
async def get_weather(args):
    city = args.get("city", "北京")
    return await cached_weather_query(city)

3. 异步处理

充分利用Python的异步特性，并行处理多个工具调用。

from claude_agent_sdk import tool
import asyncio

@tool(name="multi_query", description="并行查询多个信息", 
      input_schema={"queries": list[str]})
async def multi_query(args):
    queries = args.get("queries", [])
    
    # 并行执行多个查询
    tasks = [process_single_query(q) for q in queries]
    results = await asyncio.gather(*tasks)
    
    return {"content": [{"type": "text", "text": "\n".join(results)}]}

4. 批处理优化

对于需要处理大量数据的工具，实现批处理功能可以减少通信开销。

from claude_agent_sdk import tool

@tool(name="batch_process", description="批处理数据", 
      input_schema={"items": list[dict], "batch_size": int})
async def batch_process(args):
    items = args.get("items", [])
    batch_size = args.get("batch_size", 10)
    
    results = []
    # 分批次处理
    for i in range(0, len(items), batch_size):
        batch = items[i:i+batch_size]
        batch_result = await process_batch(batch)
        results.extend(batch_result)
    
    return {"content": [{"type": "text", "text": str(results)}]}

避坑指南

常见错误与解决方案

1. 工具权限问题

错误表现：AI尝试使用未授权的工具，导致操作失败。

解决方案：

# 正确配置allowed_tools
options = ClaudeAgentOptions(
    allowed_tools=["Read", "mcp__weather__weather"],  # 明确指定允许的工具
    permission_mode="ask_user"  # 不确定时询问用户
)

2. 异步代码同步调用

错误表现：出现"coroutine was never awaited"错误。

解决方案：

# 错误示例
client.query("Hello")
for message in client.receive_response():  # 同步循环处理异步迭代器
    print(message)

# 正确示例
async def main():
    async with ClaudeSDKClient(options=options) as client:
        client.query("Hello")
        async for message in client.receive_response():  # 使用async for
            print(message)

anyio.run(main)

3. 工具输入输出格式错误

错误表现：工具调用返回的格式不符合预期，导致AI无法解析。

解决方案：

# 确保工具返回正确的格式
@tool(name="weather", description="查询天气", input_schema={"city": str})
async def get_weather(args):
    # 处理逻辑...
    
    # 正确的返回格式
    return {
        "content": [
            {"type": "text", "text": "天气信息..."},
            # 可以添加其他类型的内容，如图表
            # {"type": "image", "source": {"type": "base64", "media_type": "image/png", "data": "..."}}
        ]
    }

4. 资源泄漏

错误表现：长时间运行后出现连接耗尽或内存泄漏。

解决方案：

# 使用上下文管理器确保资源正确释放
async def main():
    async with ClaudeSDKClient(options=options) as client:  # 自动管理连接生命周期
        client.query("分析日志文件")
        async for message in client.receive_response():
            print(message)
    # 退出上下文后，客户端自动关闭连接

测试策略

单元测试

为工具和核心功能编写单元测试，确保每个组件独立工作正常。

# tests/test_tools.py
import pytest
from claude_agent_sdk import tool

@tool(name="add", description="加法", input_schema={"a": float, "b": float})
async def add(args):
    return {"content": [{"type": "text", "text": str(args["a"] + args["b"])}]}

@pytest.mark.asyncio
async def test_add_tool():
    result = await add({"a": 2, "b": 3})
    assert result["content"][0]["text"] == "5"

集成测试

测试不同组件之间的交互，确保整个系统协同工作。

# tests/test_integration.py
import anyio
import pytest
from claude_agent_sdk import ClaudeSDKClient, ClaudeAgentOptions, tool, create_sdk_mcp_server

@tool(name="echo", description="回声工具", input_schema={"message": str})
async def echo(args):
    return {"content": [{"type": "text", "text": args["message"]}]}

@pytest.mark.asyncio
async def test_client_with_custom_tool():
    server = create_sdk_mcp_server(name="test", tools=[echo])
    options = ClaudeAgentOptions(
        allowed_tools=["mcp__test__echo"],
        mcp_servers={"test": server},
        permission_mode="auto_approve"
    )
    
    async with ClaudeSDKClient(options=options) as client:
        client.query("使用echo工具回复'Hello World'")
        response = []
        async for message in client.receive_response():
            response.append(message)
        
        # 验证是否收到正确的回复
        assert any("Hello World" in msg.content[0].text for msg in response if msg.type == "text")

性能测试

测试系统在高负载下的表现，识别性能瓶颈。

# tests/test_performance.py
import anyio
import time
import pytest
from claude_agent_sdk import ClaudeSDKClient, ClaudeAgentOptions

@pytest.mark.asyncio
async def test_concurrent_queries():
    options = ClaudeAgentOptions(
        system_prompt="回复'OK'即可",
        max_turns=1
    )
    
    async def query_task():
        start_time = time.time()
        async with ClaudeSDKClient(options=options) as client:
            client.query("测试")
            async for _ in client.receive_response():
                pass
        return time.time() - start_time
    
    # 并发执行10个查询
    times = await anyio.gather(*[query_task() for _ in range(10)])
    
    # 验证性能指标
    avg_time = sum(times) / len(times)
    assert avg_time < 2.0  # 平均响应时间应小于2秒

附录

API速查表

核心类

类名	说明	主要方法
ClaudeAgentOptions	查询配置选项	__init__() - 初始化配置
ClaudeSDKClient	对话客户端	query(), receive_response(), interrupt()

工具相关

函数/装饰器	说明	参数
@tool	工具装饰器	name, description, input_schema
create_sdk_mcp_server	创建MCP服务器	name, version, tools

查询相关

函数	说明	参数
query()	发送查询	prompt, options, transport

常见问题诊断树

1. 无法连接到Claude

   • 检查Claude Code是否安装
   • 验证API密钥是否正确
   • 检查网络连接

2. 工具调用失败

   • 确认工具名称是否正确
   • 检查工具权限设置
   • 验证工具输入参数格式

3. 响应速度慢

   • 检查网络状况
   • 优化工具实现
   • 考虑使用缓存

4. 内存占用过高

   • 检查是否正确关闭客户端
   • 验证是否有内存泄漏
   • 考虑增加资源限制

资源推荐清单

1. 官方文档：README.md
2. 示例代码：examples/
3. 测试用例：tests/
4. 变更日志：CHANGELOG.md
5. 开发指南：CONTRIBUTING.md

通过本指南，你已经掌握了claude-agent-sdk-python的核心功能和高级用法。无论是构建简单的AI助手还是复杂的企业级应用，这些知识都将帮助你打造安全、高效且可扩展的AI解决方案。现在，是时候将这些知识应用到实际项目中，释放AI的全部潜力了！