# ❌ 错误示范 - 密钥暴露在代码中
client = Anthropic(api_key="勿硬编码")

# ✅ 正确做法 - 从环境变量读取
import os
from anthropic import Anthropic

api_key = os.environ.get("ANTHROPIC_API_KEY")
if not api_key:
    raise ValueError("ANTHROPIC_API_KEY环境变量未设置")

client = Anthropic(api_key=api_key)

export ANTHROPIC_API_KEY=<your-real-key>
python your_script.py

# .env文件（不要提交到Git！）
ANTHROPIC_API_KEY=<your-real-key>

# 使用python-dotenv加载
from dotenv import load_dotenv
import os

load_dotenv()  # 加载.env文件
api_key = os.environ.get("ANTHROPIC_API_KEY")

from anthropic import Anthropic
client = Anthropic(api_key=api_key)

# 安装dotenv
pip install python-dotenv

# ✅ 生产环境推荐
import boto3
import json
from anthropic import Anthropic

# 从AWS Secrets Manager获取密钥
secret_name = "anthropic-api-key"
region_name = "us-east-1"

session = boto3.session.Session()
client_secrets = session.client(
    service_name='secretsmanager',
    region_name=region_name
)

response = client_secrets.get_secret_value(SecretId=secret_name)
api_key = json.loads(response['SecretString'])['api_key']

anthropic_client = Anthropic(api_key=api_key)

from anthropic import Anthropic
import os

class AnthropicClient:
    """Anthropic API客户端封装"""
    
    _instance = None
    
    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
            cls._instance._client = Anthropic(
                api_key=os.environ.get("ANTHROPIC_API_KEY"),
                timeout=30,  # 请求超时30秒
                max_retries=3,  # 最多重试3次
            )
        return cls._instance
    
    @property
    def client(self):
        return self._client

# 使用单例模式
anthropic = AnthropicClient()
response = anthropic.client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello"}]
)

pip install anthropic

from anthropic import Anthropic
import os

# 初始化客户端
client = Anthropic(api_key=os.environ.get("ANTHROPIC_API_KEY"))

# 发送请求
message = client.messages.create(
    model="claude-sonnet-4-20250514",  # 使用的模型
    max_tokens=1024,  # 最大生成的token数
    messages=[
        {
            "role": "user",
            "content": "用一句话解释什么是量子计算"
        }
    ]
)

# 打印响应
print(message.content[0].text)

# 设置足够的max_tokens以获得完整响应
message = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=4096,  # 适合生成长文章
    messages=[{"role": "user", "content": "写一篇2000字的文章..."}]
)

messages=[
    {"role": "user", "content": "什么是Python？"},
    {"role": "assistant", "content": "Python是一种高级编程语言..."},
    {"role": "user", "content": "它适合做什么？"}
]

from anthropic import Anthropic
import os

client = Anthropic(api_key=os.environ.get("ANTHROPIC_API_KEY"))

with client.messages.stream(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    messages=[{"role": "user", "content": "讲一个关于程序员的笑话"}]
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)  # 实时打印
    print()  # 最后换行

message = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    messages=[{"role": "user", "content": "解释光合作用"}]
)

# message 是 Message 对象，完整属性：
print(message.id)          # msg_xxxxx - 消息唯一ID
print(message.type)        # "message" - 消息类型
print(message.role)        # "assistant" - 角色
print(message.content)      # [ContentBlock(text='...')] - 内容块列表
print(message.model)       # "claude-sonnet-4-20250514" - 使用的模型
print(message.stop_reason) # "end_turn" - 停止原因
print(message.stop_sequence) # None - 停止序列
print(message.usage)        # Usage(input_tokens=xx, output_tokens=xx) - token使用量

# ✅ 正确获取文本内容
if message.content and len(message.content) > 0:
    text = message.content[0].text
    print(text)

# ✅ 安全的方式
for block in message.content:
    if block.type == "text":
        print(block.text)

print(message.stop_reason)  # 可能的值：

# "end_turn" - 正常完成，Claude认为应该停止
# "max_tokens" - 达到max_tokens限制，可能被截断
# "stop_sequence" - 遇到指定的停止序列
# "only_stop_reason" - 仅当stop_reason是唯一有效停止信号时

if message.stop_reason == "max_tokens":
    print("⚠️ 警告：响应被截断，可能不完整")
    print("建议：增加max_tokens值或优化提示词")
elif message.stop_reason == "end_turn":
    print("✅ 响应正常完成")

print(f"输入token: {message.usage.input_tokens}")
print(f"输出token: {message.usage.output_tokens}")
print(f"总token: {message.usage.input_tokens + message.usage.output_tokens}")

# 计算成本（以 Sonnet 模型为例）
input_cost_per_1k = 0.003  # $0.003/1K输入tokens
output_cost_per_1k = 0.015  # $0.015/1K输出tokens

input_cost = (message.usage.input_tokens / 1000) * input_cost_per_1k
output_cost = (message.usage.output_tokens / 1000) * output_cost_per_1k
total_cost = input_cost + output_cost

print(f"本次请求成本: ${total_cost:.6f}")

from anthropic import Anthropic, RateLimitError, APIError
import os

client = Anthropic(api_key=os.environ.get("ANTHROPIC_API_KEY"))

try:
    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=1024,
        messages=[{"role": "user", "content": "Hello"}]
    )
except RateLimitError:
    print("速率限制：请求太频繁，等待后重试")
    import time
    time.sleep(5)
except APIError as e:
    print(f"API错误: {e}")
except Exception as e:
    print(f"未知错误: {e}")

# 每次请求都是独立的，没有上下文
response1 = client.messages.create(
    messages=[{"role": "user", "content": "我的狗叫豆豆"}]
)
print(response1.content[0].text)  # "真可爱的名字！"

response2 = client.messages.create(
    messages=[{"role": "user", "content": "它喜欢吃什么？"}]
)
print(response2.content[0].text)  # "对不起，我不知道你的狗是谁..."
# ❌ Claude不记得"豆豆"

# 维护消息历史
conversation_history = []

while True:
    user_input = input("你: ")
    
    # 添加用户消息
    conversation_history.append({
        "role": "user",
        "content": user_input
    })
    
    # 发送请求
    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=1024,
        messages=conversation_history
    )
    
    # 获取助手回复
    assistant_message = response.content[0].text
    
    # 添加助手回复到历史
    conversation_history.append({
        "role": "assistant",
        "content": assistant_message
    })
    
    print(f"Claude: {assistant_message}")

def trim_conversation(messages, max_turns=10):
    """只保留最近N轮对话"""
    # 保留系统消息（如果有）
    system_messages = [m for m in messages if m.get("role") == "system"]
    conversation = [m for m in messages if m.get("role") != "system"]
    
    # 只保留最近max_turns * 2条（每轮有user和assistant）
    trimmed = conversation[-(max_turns * 2):]
    
    return system_messages + trimmed

# 使用
messages = trim_conversation(conversation_history, max_turns=5)

def summarize_old_messages(messages, summary_turns=5):
    """将早期对话摘要，保留最近的消息"""
    if len(messages) <= summary_turns * 2 + 2:  # 留点余量
        return messages
    
    # 分离早期消息和最近消息
    early = messages[:-summary_turns * 2]
    recent = messages[-summary_turns * 2:]
    
    # 摘要早期对话
    early_text = "\n".join([f"{m['role']}: {m['content']}" for m in early])
    
    summary_prompt = f"""将以下对话摘要成一段话，保留关键信息：

{early_text}

摘要："""

    summary_response = client.messages.create(
        model="claude-haiku-3-20250514",  # 用便宜的模型做摘要
        max_tokens=500,
        messages=[{"role": "user", "content": summary_prompt}]
    )
    
    summary = summary_response.content[0].text
    
    # 返回摘要 + 最近对话
    return [
        {"role": "system", "content": f"对话摘要：{summary}"}
    ] + recent

class ConversationManager:
    """会话管理器：支持多话题"""
    
    def __init__(self):
        self.conversations = {}  # {conversation_id: [messages]}
        self.current_id = None
    
    def start_new(self, conversation_id):
        """开始新对话"""
        self.current_id = conversation_id
        self.conversations[conversation_id] = []
    
    def add_message(self, role, content):
        """添加消息"""
        if self.current_id is None:
            self.start_new("default")
        self.conversations[self.current_id].append({
            "role": role,
            "content": content
        })
    
    def get_messages(self, conversation_id=None):
        """获取对话历史"""
        cid = conversation_id or self.current_id
        return self.conversations.get(cid, [])
    
    def switch_conversation(self, conversation_id):
        """切换对话"""
        if conversation_id not in self.conversations:
            self.conversations[conversation_id] = []
        self.current_id = conversation_id

# 使用示例
manager = ConversationManager()
manager.start_new("技术支持")
manager.add_message("user", "我的代码报错了")
manager.add_message("assistant", "请告诉我错误信息")
manager.add_message("user", "NameError: name 'x' is not defined")

# 切换到另一个话题
manager.start_new("产品咨询")
manager.add_message("user", "你们的产品有什么特点")

# 回到技术支持
manager.switch_conversation("技术支持")
messages = manager.get_messages()

response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    system="你是一位专业的产品经理，用词简洁专业。",
    messages=[{"role": "user", "content": "我应该做什么产品？"}]
)

# 设定角色
system = """你是一位拥有20年经验的高级Python工程师。
你的特点：
- 代码风格遵循PEP 8
- 喜欢用类型提示
- 注重性能优化
- 说话直接，有话直说
"""

system = """你是一个数据分析师。

当回答问题时，必须使用以下格式：

## 主要发现
[最重要的1-2个发现]

## 详细分析
[详细的分析内容]

## 建议
[基于分析的 actionable 建议]

## 数据来源
[使用的数据]
"""

system = """你是一位财经记者。

约束条件：
- 不预测具体股价
- 引用数据时注明来源
- 风险提示必须清晰
- 不使用"一定"、"保证"等绝对词汇
"""

system = """你是一个翻译助手。

翻译示例：
- "Hello, how are you?" → "你好，你怎么样？"
- "The weather is nice today." → "今天天气很好。"
- "I can't understand." → "我无法理解。"

注意：
- 中文翻译用"你"而不是"您"
- 保持原文的语气和情感
"""

# 清晰具体
system = """你是一位医疗助手。

职责：
1. 回答常见健康问题
2. 提供健康生活方式建议
3. 解释医学术语

限制：
- 不做具体诊断
- 不开处方
- 遇到严重症状建议就医
"""

# 给出具体例子
system = """你是一个代码审查助手。

审查要点：
1. 安全性（SQL注入、XSS等）
2. 性能问题
3. 代码可读性

反馈格式：
[安全问题]: 描述 + 建议修复
[性能问题]: 描述 + 优化建议
"""

# 太模糊
system = "你是AI助手，回答用户问题"  # 太泛了

# 太长太复杂
system = """你要扮演一个在某个领域有很多年经验的人，
从很早以前就开始学习和工作...
[1000字介绍]...
现在请回答用户的问题"""  # 太长了，效果反而差

# 指令冲突
system = """你是一个诚实的AI助手。
但有时候为了用户体验可以说善意的谎言。"""  # 指令冲突

def test_system_prompt(system_prompt, test_cases):
    """测试系统提示词"""
    for i, test in enumerate(test_cases):
        response = client.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=500,
            system=system_prompt,
            messages=[{"role": "user", "content": test}]
        )
        print(f"测试{i+1}: {test}")
        print(f"响应: {response.content[0].text[:200]}...")
        print("-" * 50)

response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1000,
    messages=[{
        "role": "user",
        "content": """返回一个JSON对象，包含水果信息：
        {"name": "水果名", "color": "颜色", "taste": "味道"}"""
    }]
)

# 解析响应
import json
text = response.content[0].text
# 尝试提取JSON（可能有markdown格式）
if "```json" in text:
    text = text.split("```json")[1].split("```")[0]
elif "```" in text:
    text = text.split("```")[1].split("```")[0]

data = json.loads(text.strip())
print(data)

# Anthropic API支持直接指定JSON Schema
response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1000,
    messages=[{
        "role": "user",
        "content": "返回3个编程语言的列表"
    }],
    response_format={
        "type": "json_object",
        "json_schema": {
            "type": "object",
            "properties": {
                "languages": {
                    "type": "array",
                    "items": {
                        "type": "object",
                        "properties": {
                            "name": {"type": "string"},
                            "year": {"type": "integer"},
                            "paradigm": {"type": "string"}
                        }
                    }
                }
            }
        }
    }
)

data = json.loads(response.content[0].text)
print(data)

# 定义工具，让Claude调用
tools = [{
    "name": "return_data",
    "description": "返回结构化数据",
    "input_schema": {
        "type": "object",
        "properties": {
            "result": {
                "type": "string",
                "description": "处理结果"
            },
            "status": {
                "type": "string", 
                "enum": ["success", "error"],
                "description": "处理状态"
            }
        },
        "required": ["result", "status"]
    }
}]

response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1000,
    tools=tools,
    messages=[{"role": "user", "content": "处理用户注册"}]
)

# 处理工具调用
for content in response.content:
    if content.type == "tool_use":
        result = content.input
        print(f"Status: {result['status']}")
        print(f"Result: {result['result']}")

def safe_json_parse(text):
    """安全解析JSON，处理各种格式"""
    import json
    import re
    
    # 清理markdown代码块
    text = re.sub(r'```json\s*', '', text)
    text = re.sub(r'```\s*$', '', text)
    text = text.strip()
    
    # 尝试直接解析
    try:
        return json.loads(text)
    except json.JSONDecodeError:
        pass
    
    # 尝试提取JSON对象
    try:
        # 找第一个{和最后一个}
        start = text.find('{')
        end = text.rfind('}') + 1
        if start != -1 and end > start:
            return json.loads(text[start:end])
    except:
        pass
    
    return None