def get_stock_price(company):
    # 向股票市场 API 发送请求，获取指定公司的实时股价
    # 返回包含当前股价信息的字典
    ...

tool_definition = {
    "name": "get_stock_price",
    "description": "Retrieves the current stock price for a given company",
    "input_schema": {
        "type": "object",
        "properties": {
            "company": {
                "type": "string",
                "description": "The company name to fetch stock data for"
            }
        },
        "required": ["company"]
    }
}

response = client.messages.create(
    model="claude-opus-4-5",
    messages=[{"role": "user", "content": "How many shares of General Motors can I buy with $500?"}],
    max_tokens=500,
    tools=[tool_definition]
)

{
  "stop_reason": "tool_use",
  "tool_use": {
    "name": "get_stock_price",
    "input": {
      "company": "General Motors"
    }
  }
}

# 工具执行结果
stock_result = {"symbol": "GM", "price": 43.09}

# 将结果返回给 Claude
messages.append({
    "role": "user",
    "content": [{
        "type": "tool_result",
        "tool_use_id": response.content[0].id,
        "content": str(stock_result)
    }]
})

from anthropic import Anthropic
from dotenv import load_dotenv

load_dotenv()
client = Anthropic()

response = client.messages.create(
    model="claude-haiku-4-5",
    messages=[{"role": "user", "content": "Multiply 1984135 by 9343116. Only respond with the result"}],
    max_tokens=300
)
print(response.content[0].text)

def calculator(operation, operand1, operand2):
    if operation == "add":
        return operand1 + operand2
    elif operation == "subtract":
        return operand1 - operand2
    elif operation == "multiply":
        return operand1 * operand2
    elif operation == "divide":
        if operand2 == 0:
            return "Error: Division by zero"
        return operand1 / operand2
    else:
        return "Error: Unknown operation" 

{
  "name": "send_email",
  "description": "Sends an email to the specified recipient with the given subject and body",
  "input_schema": {
    "type": "object",
    "properties": {
      "to": {
        "type": "string",
        "description": "The recipient's email address"
      },
      "subject": {
        "type": "string",
        "description": "The subject line of the email"
      },
      "body": {
        "type": "string",
        "description": "The body text of the email message"
      }
    },
    "required": ["to", "subject", "body"]
  }
}

{
  "name": "search_product",
  "description": "Search for a product by name or keyword and return its current price and availability.",
  "input_schema": {
    "type": "object",
    "properties": {
      "query": {
        "type": "string",
        "description": "The product name or search keyword"
      },
      "category": {
        "type": "string",
        "enum": ["electronics", "clothing", "home", "toys", "sports"],
        "description": "The product category to narrow down the search results"
      },
      "max_price": {
        "type": "number",
        "description": "The maximum price of the product"
      }
    },
    "required": ["query"]
  }
}

calculator_tool = {
    "name": "calculator",
    "description": "A simple calculator that performs basic arithmetic operations.",
    "input_schema": {
        "type": "object",
        "properties": {
            "operation": {
                "type": "string",
                "enum": ["add", "subtract", "multiply", "divide"],
                "description": "The arithmetic operation to perform."
            },
            "operand1": {
                "type": "number",
                "description": "The first number."
            },
            "operand2": {
                "type": "number",
                "description": "The second number."
            }
        },
        "required": ["operation", "operand1", "operand2"]
    }
}

response = client.messages.create(
    model="claude-haiku-4-5",
    messages=[{"role": "user", "content": "Multiply 1984135 by 9343116. Only respond with the result"}],
    max_tokens=300,
    tools=[calculator_tool]   # 告知 Claude 工具的存在
)

print(response.stop_reason)   # tool_use

# 提取工具名称和输入参数
tool_name = response.content[0].name
tool_inputs = response.content[0].input

print("Claude 想调用的工具：", tool_name)
print("调用参数：", tool_inputs)

# 执行工具
operation = tool_inputs["operation"]
operand1 = tool_inputs["operand1"]
operand2 = tool_inputs["operand2"]

result = calculator(operation, operand1, operand2)
print("计算结果：", result)   # 18538003464660 ✓

response = client.messages.create(
    model="claude-haiku-4-5",
    system="You have access to tools, but only use them when necessary. "
           "If a tool is not required, respond as normal",
    messages=[{"role": "user", "content": "What color are emeralds?"}],
    max_tokens=400,
    tools=[calculator_tool]
)

print(response.stop_reason)    # end_turn（而非 tool_use）
print(response.content[0].text)  # "Emeralds are green in color."

# 定义情感分析工具
sentiment_tool = {
    "name": "record_sentiment",
    "description": "Record the sentiment analysis result for a piece of text.",
    "input_schema": {
        "type": "object",
        "properties": {
            "sentiment": {
                "type": "string",
                "enum": ["positive", "negative", "neutral"],
                "description": "The overall sentiment of the text."
            },
            "score": {
                "type": "number",
                "description": "Confidence score from 0.0 to 1.0."
            },
            "explanation": {
                "type": "string",
                "description": "Brief explanation of the sentiment."
            }
        },
        "required": ["sentiment", "score", "explanation"]
    }
}

def analyze_sentiment(text):
    response = client.messages.create(
        model="claude-haiku-4-5",
        max_tokens=500,
        tools=[sentiment_tool],
        tool_choice={"type": "tool", "name": "record_sentiment"},  # 强制使用此工具
        messages=[{"role": "user", "content": f"Analyze the sentiment of this text: {text}"}]
    )
    return response.content[0].input

result = analyze_sentiment("I absolutely love this product! It's amazing.")
print(result)
# {"sentiment": "positive", "score": 0.98, "explanation": "..."} 

entity_tool = {
    "name": "extract_entities",
    "description": "Extract named entities from text.",
    "input_schema": {
        "type": "object",
        "properties": {
            "people": {
                "type": "array",
                "items": {"type": "string"},
                "description": "Names of people mentioned."
            },
            "organizations": {
                "type": "array",
                "items": {"type": "string"},
                "description": "Names of organizations mentioned."
            },
            "locations": {
                "type": "array",
                "items": {"type": "string"},
                "description": "Names of locations mentioned."
            },
            "dates": {
                "type": "array",
                "items": {"type": "string"},
                "description": "Dates or time references mentioned."
            }
        },
        "required": ["people", "organizations", "locations", "dates"]
    }
}

def extract_entities(text):
    response = client.messages.create(
        model="claude-haiku-4-5",
        max_tokens=500,
        tools=[entity_tool],
        tool_choice={"type": "tool", "name": "extract_entities"},
        messages=[{"role": "user", "content": f"Extract all named entities from this text: {text}"}]
    )
    return response.content[0].input

text = "On January 15th, Apple CEO Tim Cook met with Microsoft's Satya Nadella in Seattle."
result = extract_entities(text)
print(result)
# {"people": ["Tim Cook", "Satya Nadella"], "organizations": ["Apple", "Microsoft"], ...}

wikipedia_summary_tool = {
    "name": "save_wikipedia_summary",
    "description": "Save a structured summary of a Wikipedia article.",
    "input_schema": {
        "type": "object",
        "properties": {
            "title": {"type": "string", "description": "Article title"},
            "summary": {"type": "string", "description": "2-3 sentence summary"},
            "key_facts": {
                "type": "array",
                "items": {"type": "string"},
                "description": "List of 3-5 key facts"
            },
            "categories": {
                "type": "array",
                "items": {"type": "string"},
                "description": "Relevant categories or topics"
            }
        },
        "required": ["title", "summary", "key_facts", "categories"]
    }
}

import wikipedia

def search_wikipedia(query):
    """Search Wikipedia and return a summary."""
    try:
        results = wikipedia.search(query, results=1)
        if not results:
            return "No results found."
        page = wikipedia.page(results[0], auto_suggest=False)
        return page.summary[:1500]  # 限制长度
    except wikipedia.exceptions.DisambiguationError as e:
        return f"Disambiguation: {e.options[:3]}"
    except Exception as e:
        return f"Error: {str(e)}" 

wiki_tool = {
    "name": "search_wikipedia",
    "description": "Search Wikipedia for information on a topic and return a summary.",
    "input_schema": {
        "type": "object",
        "properties": {
            "query": {
                "type": "string",
                "description": "The search query to look up on Wikipedia."
            }
        },
        "required": ["query"]
    }
}

def answer_with_wikipedia(user_question):
    messages = [{"role": "user", "content": user_question}]

    # 步骤 1：发送请求，提供工具
    response = client.messages.create(
        model="claude-opus-4-5",
        max_tokens=1000,
        tools=[wiki_tool],
        messages=messages
    )

    # 步骤 2：检查 Claude 是否要使用工具
    while response.stop_reason == "tool_use":
        tool_use_block = next(b for b in response.content if b.type == "tool_use")
        tool_name = tool_use_block.name
        tool_input = tool_use_block.input

        print(f"[调用工具] {tool_name}({tool_input})")

        # 步骤 3：执行工具
        tool_result = search_wikipedia(tool_input["query"])

        # 将 Claude 的响应和工具结果加入消息历史
        messages.append({"role": "assistant", "content": response.content})
        messages.append({
            "role": "user",
            "content": [{
                "type": "tool_result",
                "tool_use_id": tool_use_block.id,
                "content": tool_result
            }]
        })

        # 步骤 4：让 Claude 利用工具结果生成回答
        response = client.messages.create(
            model="claude-opus-4-5",
            max_tokens=1000,
            tools=[wiki_tool],
            messages=messages
        )

    # 提取最终文本回答
    return next((b.text for b in response.content if hasattr(b, "text")), "No answer.")

answer = answer_with_wikipedia("When was the Eiffel Tower built and how tall is it?")
print(answer)

def execute_tool(tool_name, tool_input, available_tools):
    """Execute a tool by name with given input."""
    tool_functions = {
        "search_wikipedia": search_wikipedia,
        # 可以在此添加更多工具
    }
    if tool_name in tool_functions:
        return tool_functions[tool_name](**tool_input)
    return f"Error: Unknown tool '{tool_name}'" 

response = client.messages.create(
    model="claude-opus-4-5",
    system="""You are a helpful assistant with access to Wikipedia.
Use the search_wikipedia tool whenever you need factual information
about people, places, events, or concepts. Always search Wikipedia
before answering factual questions.""",
    max_tokens=1000,
    tools=[wiki_tool],
    messages=messages
)

response = client.messages.create(
    model="claude-haiku-4-5",
    max_tokens=500,
    tools=[calculator_tool],
    tool_choice={"type": "auto"},  # 这是默认值
    messages=[{"role": "user", "content": "What is 15% of 847?"}]
)
# Claude 会使用计算器工具

response = client.messages.create(
    model="claude-haiku-4-5",
    max_tokens=500,
    tools=[calculator_tool],
    tool_choice={"type": "auto"},
    messages=[{"role": "user", "content": "What is the capital of France?"}]
)
# Claude 不会使用工具，直接回答

response = client.messages.create(
    model="claude-haiku-4-5",
    max_tokens=500,
    tools=[calculator_tool],
    tool_choice={"type": "tool", "name": "calculator"},  # 强制使用计算器
    messages=[{"role": "user", "content": "Tell me something interesting about the number 42"}]
)
# Claude 会被强制调用计算器，即使这个问题并不需要计算

print(response.stop_reason)  # tool_use
print(response.content[0].input)  # 强制输出的 JSON

tools = [calculator_tool, wiki_tool, weather_tool]

response = client.messages.create(
    model="claude-haiku-4-5",
    max_tokens=500,
    tools=tools,
    tool_choice={"type": "any"},  # 必须使用某个工具，但可以自由选择
    messages=[{"role": "user", "content": "What is 25 * 4?"}]
)
# Claude 会选择计算器工具（最合适的选择）

response = client.messages.create(
    model="claude-haiku-4-5",
    max_tokens=500,
    tools=tools,
    tool_choice={"type": "any"},
    messages=[{"role": "user", "content": "Who invented the telephone?"}]
)
# Claude 会选择 Wikipedia 工具

# 模拟客户数据库
CUSTOMERS = {
    "C001": {"name": "Alice Johnson", "email": "alice@example.com", "tier": "premium"},
    "C002": {"name": "Bob Smith", "email": "bob@example.com", "tier": "standard"},
    "C003": {"name": "Carol White", "email": "carol@example.com", "tier": "premium"},
}

# 模拟订单数据库
ORDERS = {
    "O001": {"customer_id": "C001", "product": "Widget Pro", "status": "shipped", "total": 149.99},
    "O002": {"customer_id": "C002", "product": "Basic Kit", "status": "processing", "total": 29.99},
    "O003": {"customer_id": "C001", "product": "Premium Pack", "status": "delivered", "total": 299.99},
}

def get_customer_info(customer_id):
    """获取客户信息"""
    customer = CUSTOMERS.get(customer_id)
    if customer:
        return {"found": True, "customer_id": customer_id, **customer}
    return {"found": False, "error": f"Customer {customer_id} not found"}

def get_order_details(order_id):
    """获取订单详情"""
    order = ORDERS.get(order_id)
    if order:
        return {"found": True, "order_id": order_id, **order}
    return {"found": False, "error": f"Order {order_id} not found"}

def get_customer_orders(customer_id):
    """获取指定客户的所有订单"""
    customer_orders = [
        {"order_id": oid, **odata}
        for oid, odata in ORDERS.items()
        if odata["customer_id"] == customer_id
    ]
    if not customer_orders:
        return {"customer_id": customer_id, "orders": [], "count": 0}
    return {"customer_id": customer_id, "orders": customer_orders, "count": len(customer_orders)}

def cancel_order(order_id, reason):
    """取消订单"""
    order = ORDERS.get(order_id)
    if not order:
        return {"success": False, "error": f"Order {order_id} not found"}
    if order["status"] == "delivered":
        return {"success": False, "error": "Cannot cancel delivered orders"}
    return {"success": True, "order_id": order_id, "message": f"Order {order_id} cancelled. Reason: {reason}"}

tools = [
    {
        "name": "get_customer_info",
        "description": "Retrieve customer information by customer ID.",
        "input_schema": {
            "type": "object",
            "properties": {
                "customer_id": {"type": "string", "description": "The customer ID (e.g., C001)"}
            },
            "required": ["customer_id"]
        }
    },
    {
        "name": "get_order_details",
        "description": "Get details of a specific order by order ID.",
        "input_schema": {
            "type": "object",
            "properties": {
                "order_id": {"type": "string", "description": "The order ID (e.g., O001)"}
            },
            "required": ["order_id"]
        }
    },
    {
        "name": "get_customer_orders",
        "description": "Get all orders for a specific customer.",
        "input_schema": {
            "type": "object",
            "properties": {
                "customer_id": {"type": "string", "description": "The customer ID"}
            },
            "required": ["customer_id"]
        }
    },
    {
        "name": "cancel_order",
        "description": "Cancel an order that hasn't been delivered yet.",
        "input_schema": {
            "type": "object",
            "properties": {
                "order_id": {"type": "string", "description": "The order ID to cancel"},
                "reason": {"type": "string", "description": "Reason for cancellation"}
            },
            "required": ["order_id", "reason"]
        }
    }
]

import json

def process_tool_call(tool_name, tool_input):
    """根据工具名称分发调用"""
    tool_functions = {
        "get_customer_info": get_customer_info,
        "get_order_details": get_order_details,
        "get_customer_orders": get_customer_orders,
        "cancel_order": cancel_order,
    }
    if tool_name in tool_functions:
        result = tool_functions[tool_name](**tool_input)
        return json.dumps(result, ensure_ascii=False)
    return json.dumps({"error": f"Unknown tool: {tool_name}"}),

def run_customer_service_bot():
    """运行客户服务聊天机器人"""
    messages = []
    system_prompt = """You are a helpful customer service assistant for an e-commerce company.
You have access to tools to look up customer information and order details.
Always be polite and helpful. Use the available tools to answer customer questions accurately."""

    print("客户服务机器人已启动！输入 'quit' 退出。\n")

    while True:
        user_input = input("用户: ").strip()
        if user_input.lower() in ["quit", "exit", "退出"]:
            print("感谢您的使用，再见！")
            break
        if not user_input:
            continue

        messages.append({"role": "user", "content": user_input})

        # 循环处理工具调用
        while True:
            response = client.messages.create(
                model="claude-opus-4-5",
                system=system_prompt,
                max_tokens=1000,
                tools=tools,
                messages=messages
            )

            if response.stop_reason == "tool_use":
                # 处理所有工具调用（可能有多个）
                tool_results = []
                for block in response.content:
                    if block.type == "tool_use":
                        print(f"  [调用工具] {block.name}({block.input})")
                        result = process_tool_call(block.name, block.input)
                        tool_results.append({
                            "type": "tool_result",
                            "tool_use_id": block.id,
                            "content": result
                        })

                # 将 Claude 的响应和工具结果加入消息历史
                messages.append({"role": "assistant", "content": response.content})
                messages.append({"role": "user", "content": tool_results})

            elif response.stop_reason == "end_turn":
                # 获取最终文本回答
                final_text = next(
                    (b.text for b in response.content if hasattr(b, "text")), ""
                )
                if final_text:
                    print(f"\n助手: {final_text}\n")
                messages.append({"role": "assistant", "content": response.content})
                break

run_customer_service_bot()

system_prompt = """You are a helpful customer service assistant.

Available tools:
- get_customer_info: Look up customer details by ID
- get_order_details: Get information about a specific order
- get_customer_orders: See all orders for a customer
- cancel_order: Cancel an undelivered order

Guidelines:
1. When a customer mentions their customer ID or order ID, use the appropriate tool immediately.
2. For cancellation requests, always confirm the order status first.
3. Premium tier customers should receive priority handling.
4. Be empathetic when handling complaints or cancellations.
5. If you don't have enough information to help, ask clarifying questions."""