Wie man Tool-Nutzung implementiert

import anthropic

client = anthropic.Anthropic()

# Tools definieren
tools = [
    {
        "name": "get_weather",
        "description": "Das aktuelle Wetter an einem bestimmten Ort abrufen",
        "input_schema": {
            "type": "object",
            "properties": {
                "location": {
                    "type": "string",
                    "description": "Die Stadt und der Staat, z.B. San Francisco, CA"
                }
            },
            "required": ["location"]
        }
    },
    {
        "name": "get_time",
        "description": "Die aktuelle Zeit in einer bestimmten Zeitzone abrufen",
        "input_schema": {
            "type": "object",
            "properties": {
                "timezone": {
                    "type": "string",
                    "description": "Die Zeitzone, z.B. America/New_York"
                }
            },
            "required": ["timezone"]
        }
    }
]

# Erste Anfrage
response = client.messages.create(
    model="claude-sonnet-4-5",
    max_tokens=1024,
    tools=tools,
    messages=[
        {
            "role": "user",
            "content": "Wie ist das Wetter in SF und NYC, und wie spät ist es dort?"
        }
    ]
)

# Claudes Antwort mit parallelen Tool-Aufrufen
print("Claude möchte Tools verwenden:", response.stop_reason == "tool_use")
print("Anzahl der Tool-Aufrufe:", len([c for c in response.content if c.type == "tool_use"]))

# Das Gespräch mit Tool-Ergebnissen aufbauen
messages = [
    {
        "role": "user",
        "content": "Wie ist das Wetter in SF und NYC, und wie spät ist es dort?"
    },
    {
        "role": "assistant",
        "content": response.content  # Enthält mehrere tool_use Blöcke
    },
    {
        "role": "user",
        "content": [
            {
                "type": "tool_result",
                "tool_use_id": "toolu_01",  # Muss mit der ID von tool_use übereinstimmen
                "content": "San Francisco: 68°F, teilweise bewölkt"
            },
            {
                "type": "tool_result",
                "tool_use_id": "toolu_02",
                "content": "New York: 45°F, klarer Himmel"
            },
            {
                "type": "tool_result",
                "tool_use_id": "toolu_03",
                "content": "San Francisco Zeit: 2:30 PM PST"
            },
            {
                "type": "tool_result",
                "tool_use_id": "toolu_04",
                "content": "New York Zeit: 5:30 PM EST"
            }
        ]
    }
]

# Endgültige Antwort erhalten
final_response = client.messages.create(
    model="claude-sonnet-4-5",
    max_tokens=1024,
    tools=tools,
    messages=messages
)

print(final_response.content[0].text)

#!/usr/bin/env python3
"""Testskript zur Überprüfung paralleler Tool-Aufrufe mit der Claude API"""

import os
from anthropic import Anthropic

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

# Tools definieren
tools = [
    {
        "name": "get_weather",
        "description": "Das aktuelle Wetter an einem bestimmten Ort abrufen",
        "input_schema": {
            "type": "object",
            "properties": {
                "location": {
                    "type": "string",
                    "description": "Die Stadt und der Staat, z.B. San Francisco, CA"
                }
            },
            "required": ["location"]
        }
    },
    {
        "name": "get_time",
        "description": "Die aktuelle Zeit in einer bestimmten Zeitzone abrufen",
        "input_schema": {
            "type": "object",
            "properties": {
                "timezone": {
                    "type": "string",
                    "description": "Die Zeitzone, z.B. America/New_York"
                }
            },
            "required": ["timezone"]
        }
    }
]

# Testgespräch mit parallelen Tool-Aufrufen
messages = [
    {
        "role": "user",
        "content": "Wie ist das Wetter in SF und NYC, und wie spät ist es dort?"
    }
]

# Erste Anfrage stellen
print("Parallele Tool-Aufrufe anfordern...")
response = client.messages.create(
    model="claude-sonnet-4-5",
    max_tokens=1024,
    messages=messages,
    tools=tools
)

# Auf parallele Tool-Aufrufe prüfen
tool_uses = [block for block in response.content if block.type == "tool_use"]
print(f"\n✓ Claude hat {len(tool_uses)} Tool-Aufrufe gemacht")

if len(tool_uses) > 1:
    print("✓ Parallele Tool-Aufrufe erkannt!")
    for tool in tool_uses:
        print(f"  - {tool.name}: {tool.input}")
else:
    print("✗ Keine parallelen Tool-Aufrufe erkannt")

# Tool-Ausführung simulieren und Ergebnisse korrekt formatieren
tool_results = []
for tool_use in tool_uses:
    if tool_use.name == "get_weather":
        if "San Francisco" in str(tool_use.input):
            result = "San Francisco: 68°F, teilweise bewölkt"
        else:
            result = "New York: 45°F, klarer Himmel"
    else:  # get_time
        if "Los_Angeles" in str(tool_use.input):
            result = "2:30 PM PST"
        else:
            result = "5:30 PM EST"
    
    tool_results.append({
        "type": "tool_result",
        "tool_use_id": tool_use.id,
        "content": result
    })

# Gespräch mit Tool-Ergebnissen fortsetzen
messages.extend([
    {"role": "assistant", "content": response.content},
    {"role": "user", "content": tool_results}  # Alle Ergebnisse in einer Nachricht!
])

# Endgültige Antwort erhalten
print("\nEndgültige Antwort erhalten...")
final_response = client.messages.create(
    model="claude-sonnet-4-5",
    max_tokens=1024,
    messages=messages,
    tools=tools
)

print(f"\nClaudes Antwort:\n{final_response.content[0].text}")

# Formatierung überprüfen
print("\n--- Überprüfung ---")
print(f"✓ Tool-Ergebnisse in einer einzigen Benutzernachricht gesendet: {len(tool_results)} Ergebnisse")
print("✓ Kein Text vor Tool-Ergebnissen im Content-Array")
print("✓ Gespräch korrekt für zukünftige parallele Tool-Nutzung formatiert")