Anthropic Claude API

Claude ist das LLM von Anthropic - bekannt fuer starkes Reasoning und sehr gute Code-Faehigkeiten. Die API ist schlank und gut dokumentiert. Wir nutzen hier den offiziellen Python- und TypeScript-SDK.

API-Key holen

1. Registriere dich auf console.anthropic.com
2. Gehe zu API Keys und erstelle einen neuen Key
3. Aufladen mit Guthaben (wenige Cent reichen zum Testen)

Key niemals in Code-Repositories hardcoden - nutze Environment-Variablen:

export ANTHROPIC_API_KEY="sk-ant-..."

Python-Setup

pip install anthropic

Erste Anfrage

from anthropic import Anthropic

client = Anthropic()  # holt ANTHROPIC_API_KEY aus env

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Was ist Rekursion in drei Saetzen?"}
    ],
)

print(response.content[0].text)

Die Grundbausteine

messages

Ein Array von Nachrichten - der Gespraechsverlauf:

messages=[
    {"role": "user", "content": "Hallo!"},
    {"role": "assistant", "content": "Hi, was gibt es?"},
    {"role": "user", "content": "Kannst du Python?"},
]

• user - das, was wir schicken
• assistant - was das Modell geantwortet hat (bei Multi-Turn-Dialogen)

Claude hat kein State - bei jedem Aufruf musst du die komplette Historie mitschicken.

system - der System-Prompt

Der System-Prompt definiert Verhalten, Rolle und Regeln:

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    system="Du bist ein freundlicher Python-Tutor. Antworte immer auf Deutsch.",
    messages=[{"role": "user", "content": "Was ist eine Liste?"}],
)

Das ist der Ort fuer:

• Rolle und Persona
• Formatvorgaben
• Grundsaetzliche Regeln
• Langlebiger Kontext

Modell waehlen

Modell	Staerke	Kosten/1M
claude-opus-4-7	Maximum Intelligence	hoch
claude-sonnet-4-6	Bester Mix	mittel
claude-haiku-4-5-20251001	Schnell & guenstig	niedrig

Im Alltag: Sonnet - der beste Kompromiss. Fuer anspruchsvolle Aufgaben: Opus. Fuer Masse: Haiku.

Streaming

Statt auf die ganze Antwort zu warten - Tokens einzeln bekommen (wie bei ChatGPT):

with client.messages.stream(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Erzaehle einen kurzen Witz."}],
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)

print()  # finaler Zeilenumbruch

Das ist die UX, die Nutzer von modernen Chat-Interfaces erwarten.

Ein Chatbot mit Historie

from anthropic import Anthropic

client = Anthropic()
history = []

system = """
Du bist ein hilfreicher Assistent, der praegnant antwortet.
"""

print("Chat gestartet. 'exit' zum Beenden.\n")

while True:
    user_input = input("Du: ").strip()
    if user_input.lower() == "exit":
        break

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

    response = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=1024,
        system=system,
        messages=history,
    )

    antwort = response.content[0].text
    history.append({"role": "assistant", "content": antwort})

    print(f"Claude: {antwort}\n")

Das ist ein kompletter, funktionierender Chatbot in ~20 Zeilen.

TypeScript-SDK

npm install @anthropic-ai/sdk

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();

const response = await client.messages.create({
  model: "claude-sonnet-4-6",
  max_tokens: 1024,
  messages: [
    { role: "user", content: "Erklaere Promises in 3 Saetzen." }
  ],
});

const textBlock = response.content[0];
if (textBlock.type === "text") {
  console.log(textBlock.text);
}

Kosten und Tokens

Jeder API-Call kostet Geld - basierend auf Input- und Output-Tokens. Die Response enthaelt einen usage-Block:

print(response.usage)
# Usage(input_tokens=150, output_tokens=340, ...)

Kosten-Beispiel: 1.000 Queries à 500 Input + 500 Output Tokens mit Sonnet = ein paar Euro.

Tokens zaehlen

count = client.messages.count_tokens(
    model="claude-sonnet-4-6",
    messages=[{"role": "user", "content": "Hallo"}]
)
print(count.input_tokens)  # z.B. 8

Hilft bei Budget-Berechnungen.

Prompt Caching - der Kostenkiller

Wenn du denselben langen System-Prompt immer wieder schickst, ist Prompt Caching Gold wert:

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    system=[
        {
            "type": "text",
            "text": "Du bist ein Assistent. Hier alle Policies: ...",
            "cache_control": {"type": "ephemeral"}
        }
    ],
    messages=[{"role": "user", "content": "Frage"}],
)

Beim ersten Call: voller Preis. Bei den naechsten Calls (innerhalb von ca. 5 Minuten): 90% Rabatt auf den gecachten Teil.

Tool Use (Function Calling)

Claude kann Funktionen aufrufen, die du definierst - Grundlage fuer Agenten:

tools = [
    {
        "name": "wetter",
        "description": "Gibt das aktuelle Wetter fuer einen Ort",
        "input_schema": {
            "type": "object",
            "properties": {
                "stadt": {"type": "string"}
            },
            "required": ["stadt"]
        }
    }
]

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    tools=tools,
    messages=[{"role": "user", "content": "Wie ist das Wetter in Berlin?"}],
)

# Pruefen, ob das Modell ein Tool aufrufen will
for block in response.content:
    if block.type == "tool_use":
        print(f"Call: {block.name}({block.input})")

Mehr dazu im Agenten-Kapitel.

Error Handling

from anthropic import APIError, RateLimitError

try:
    response = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=100,
        messages=[{"role": "user", "content": "Hallo"}],
    )
except RateLimitError:
    print("Rate-Limit erreicht, kurz warten...")
except APIError as e:
    print(f"API-Fehler: {e}")

Best Practices

• System-Prompt fuer allgemeine Anweisungen
• User-Messages fuer konkrete Aufgaben
• Streaming fuer UX in Chats
• Caching wenn System-Prompt gross ist
• Structured Output via JSON in User-Message erzwingen
• Tokens zaehlen fuer Budget-Ueberwachung
• Retries bei Rate Limits (mit exponential backoff)

Zusammenfassung

• API-Key als Environment-Variable setzen
• messages.create(model, max_tokens, messages) ist die Grundform
• system= fuer globale Verhaltensregeln
• messages.stream() fuer Live-Ausgabe
• Prompt Caching spart bei langen System-Prompts massiv Geld
• Tool Use als Grundlage fuer Agenten
• Modelle: Haiku (guenstig), Sonnet (Standard), Opus (Top)

Im naechsten Kapitel: Die OpenAI-API - GPT in deinen Apps.