1. Einrichtung und erster Erfolg

Willkommen auf Ihrer Reise zum Erstellen von KI-Agenten (AI agents) mit Python! Am Ende dieses Kapitels haben Sie Ihren ersten erfolgreichen Aufruf an ein Large Language Model (LLM) gemacht und genau verstanden, was hinter den Kulissen passiert ist. Das ist Ihr Fundament für alles, was folgt.

Voraussetzungen

Zielgruppe & Annahmen

Dieses Buch richtet sich an Python-Entwickler, die KI-Agenten bauen möchten, aber keine Vorerfahrung mit LLMs oder KI-Frameworks haben. Wir gehen davon aus, dass Sie sich auskennen mit:

Python-Grundlagen: Funktionen, Klassen, Imports, grundlegende Datenstrukturen
Python 3.10+: Sie sollten Python 3.10 oder höher auf Ihrem System installiert haben
Virtuellen Umgebungen: Erstellen und Aktivieren von venvs mit python -m venv
Paketverwaltung: Installieren von Paketen mit pip
Umgebungsvariablen: Setzen und Lesen von Umgebungsvariablen in Ihrer Shell
API-Keys: Verstehen, was API-Keys sind und wie Sie sie bei Service-Providern erhalten

Wenn Ihnen eines dieser Konzepte unbekannt ist, empfehlen wir, es separat zu wiederholen, bevor Sie fortfahren. Die Python-Dokumentation und Tutorials zu virtuellen Umgebungen und pip sind ausgezeichnete Einstiegspunkte.

Was wir NICHT voraussetzen: Sie brauchen keinen Hintergrund in Machine Learning, neuronalen Netzen, Transformern oder KI-Theorie. Wir erklären LLM-spezifische Konzepte, sobald wir ihnen begegnen, und verbinden sie immer mit vertrauten Programmiermustern.

Modellkonvention

Im gesamten Buch verwenden wir GPT-5-mini als Standardmodell für Beispiele. Hier ist der Grund:

Breit verfügbar: Die API von OpenAI ist weltweit zugänglich und die Anmeldung ist unkompliziert
Angemessene Geschwindigkeit: Mit minimalem Reasoning-Aufwand kommen Antworten schnell genug für iterative Entwicklung
Kosteneffektiv: Mit $0.25 pro Million Input-Token und $2.00 pro Million Output-Token (Stand 2026) ist es erschwinglich zum Lernen und Experimentieren
Ausreichende Fähigkeiten: Es bewältigt die große Mehrheit praktischer Aufgaben für KI-Agenten gut

Wenn Sie Codebeispiele ohne explizit angegebenes Modell sehen, gehen Sie davon aus, dass wir GPT-5-mini verwenden. In Kapitel 2 erkunden wir die gesamte Landschaft verfügbarer Modelle (Claude, Gemini und andere GPT-Varianten) und besprechen, wann Sie je nach Kontextfenstergröße, Kosten oder spezialisierten Fähigkeiten Alternativen wählen könnten.

1.1) Was ist ein LLM?

Bevor wir Code schreiben, sollten wir festhalten, womit wir eigentlich arbeiten. Ein Large Language Model (LLM) ist ein neuronales Netz, das auf riesigen Mengen an Textdaten trainiert wurde, um vorherzusagen, welcher Text als Nächstes in einer Sequenz kommen sollte.

Stellen Sie es sich wie ein extrem ausgeklügeltes Autocomplete-System vor. Wenn Sie auf Ihrem Handy tippen und es das nächste Wort vorschlägt, ist das eine einfache Version dessen, was LLMs tun. Aber LLMs arbeiten in einem Maßstab und mit einer Raffinesse, die es ihnen ermöglicht, Folgendes zu tun:

Kohärente, kontextuell passende Antworten auf Fragen zu generieren
Code, Essays, E-Mails und andere strukturierte Inhalte zu schreiben
Zwischen Sprachen zu übersetzen
Lange Dokumente zusammenzufassen
Informationen aus unstrukturiertem Text zu extrahieren
Und vieles mehr

Wie sich LLMs von traditioneller Software unterscheiden

Traditionelle Software folgt expliziten Regeln, die Sie programmieren:

python

def calculate_discount(price, customer_type):
    if customer_type == "premium":
        return price * 0.8  # 20% Rabatt
    elif customer_type == "regular":
        return price * 0.95  # 5% Rabatt
    else:
        return price

Diese Funktion liefert für dieselben Eingaben immer dieselbe Ausgabe. Die Logik ist deterministisch und transparent.

LLMs funktionieren anders. Statt expliziter Regeln nutzen sie Muster, die sie aus Trainingsdaten gelernt haben, um Antworten zu generieren. Sie geben Eingabetext (genannt Prompt) vor, und das Modell erzeugt Ausgabetext (genannt eine Completion oder Response).

python

# Konzeptuelles Beispiel – wir schreiben gleich echten Code
response = llm.generate("Welcher Rabatt ist gut für Premium-Kunden?")
# Beispielausgabe: "Premium-Kunden erhalten typischerweise 15-25 % Rabatt..."

Das LLM hat keinen hartcodierten Rabattprozentsatz. Es generiert eine Antwort basierend auf Mustern, die es während des Trainings gelernt hat. Das bedeutet:

Antworten können variieren: Derselbe Prompt kann jedes Mal leicht unterschiedliche Antworten erzeugen
Verhalten ist gelernt, nicht programmiert: Sie steuern das Modell mit Prompts, statt explizite Logik zu schreiben
Fähigkeiten entstehen durch Skalierung: Das Modell kann Aufgaben bewältigen, für die es nicht explizit trainiert wurde

Wichtige Terminologie

Definieren wir Begriffe, die Ihnen ständig begegnen werden:

Prompt: Der Eingabetext, den Sie an das Modell senden (engl. „prompt“). Stellen Sie ihn sich als „Frage“ oder „Anweisung“ vor
Completion/Response: Der Text, den das Modell als Antwort auf Ihren Prompt generiert (engl. häufig „completion“ oder „response“ genannt)
Token: Die Basiseinheit, mit der LLMs arbeiten (engl. „token“). Grob gilt: 1 Token ≈ 4 Zeichen oder ¾ eines Wortes. „Hello world“ sind etwa 2 Token
Kontextfenster: Die maximale Textmenge (in Token), die das Modell auf einmal verarbeiten kann (engl. „context window“). GPT-5-mini hat ein Kontextfenster von 400K Token
Temperatur: Ein Parameter, der Zufälligkeit steuert (engl. „temperature“). Niedrig (0.0–0.3) = fokussierter und deterministischer. Hoch (0.7–1.0) = kreativer und variabler

Was LLMs können und was nicht

Zu verstehen, was LLMs zuverlässig leisten – und was sie nur so wirken lassen – ist entscheidend, um robuste KI-Agenten zu bauen.

LLMs sind hervorragend in:

Verstehen und Generieren natürlicher Sprache: Sie können Absicht erkennen, kohärente Antworten erzeugen und komplexe Formulierungen handhaben

"Ich möchte eine Rückerstattung" → Erkennt Intention: refund_request
"Fassen Sie dieses Dokument zusammen" → Erzeugt knappe Zusammenfassung

Befolgen von Anweisungen in Prompts: Bei klaren Vorgaben können sie strukturierte Ausgaben wie JSON oder formatierten Text erzeugen

"In JSON umwandeln: John Smith, 32, lebt in Boston"
→ {"name": "John Smith", "age": 32, "city": "Boston"}

Erkennen von Mustern in Text: Sentimentanalyse, Kategorisierung und Informationsextraktion funktionieren zuverlässig
Generieren von Code und strukturierten Inhalten: Können gültiges Python, SQL oder andere formatierte Ausgaben schreiben, wenn sie passend gepromptet werden
Schritt-für-Schritt-Reasoning: Wenn explizit angewiesen, „schrittweise zu denken“, zerlegen sie Probleme methodisch

LLM-Einschränkungen:

Keine Datenbank: Sie rufen keine Fakten ab – sie generieren statistisch plausible Texte. Sie können falsche Informationen selbstbewusst darstellen, die autoritativ klingen.

"Wann wurde Python 4.0 veröffentlicht?" 
→ Könnte generieren: "Python 4.0 wurde 2023 veröffentlicht" (falsch, aber plausibel)

Kein Taschenrechner: Sie sagen voraus, wie eine Antwort aussehen sollte, statt sie zu berechnen. Einfache Arithmetik klappt oft; komplexe Mathematik scheitert unvorhersehbar.

"Was ist 8.247 × 6.839?" → Kann ein falsches Ergebnis liefern, das plausibel wirkt

Nicht deterministisch: Derselbe Prompt kann jedes Mal andere Ausgaben erzeugen. Diese Variabilität wird über den Temperatur-Parameter gesteuert.
Nicht immer korrekt: Sie generieren plausibel klingenden Text unabhängig von faktischer Korrektheit. „Halluzinationen“ – detaillierte, selbstsichere, aber vollständig erfundene Informationen – treten häufig auf.

Die wichtigste Erkenntnis: Bauen Sie Agenten, die LLMs (für Verständnis und Entscheidungsfindung) mit traditionellen Tools (für Berechnung, Datenabruf und faktische Operationen) kombinieren. Dieses Muster implementieren wir ab Kapitel 13, wo das LLM entscheidet, wann es einen Taschenrechner nutzt, statt selbst Mathe zu versuchen.

Was Sie lernen werden

In diesem Buch lernen Sie, KI-Agenten zu bauen – Systeme, in denen das LLM autonom entscheidet, welche Aktionen es ausführt, um Ziele zu erreichen, statt vorgegebener Logik zu folgen. Dieses Paradigma erkunden wir in Kapitel 2 ausführlich.

1.2) Abhängigkeiten installieren

Richten wir Ihre Entwicklungsumgebung ein. Wir erstellen eine saubere Projektstruktur und installieren LangChain, das Framework, mit dem wir KI-Agenten bauen werden.

Python-Installation prüfen

Stellen Sie zuerst sicher, dass Python auf Ihrem System installiert ist. Wir empfehlen Python 3.10 oder höher (Stand 2026 sind Python 3.13 oder 3.14 gute Optionen).

Prüfen Sie Ihre Python-Version:

bash

python --version
# or
python3 --version

Sie sollten eine Ausgabe wie Python 3.13.x oder Python 3.14.x sehen.

Wenn Python nicht installiert ist:

macOS:
- Download von python.org
- Oder Homebrew nutzen: brew install python@3.14
Windows:
- Download von python.org
- Während der Installation „Add Python to PATH“ auswählen
Linux:
- Ubuntu/Debian: sudo apt update && sudo apt install python3.14
- Fedora: sudo dnf install python3.14

Prüfen Sie nach der Installation erneut mit python --version.

Hinweis: Auf manchen Systemen müssen Sie python3 statt python verwenden. In diesem Buch gilt: Wenn python nicht funktioniert, probieren Sie python3.

Erstellen Sie Ihr Projekt

Öffnen Sie Ihr Terminal und erstellen Sie ein neues Verzeichnis für Ihr Projekt:

bash

mkdir agentic-ai-project
cd agentic-ai-project

Erstellen Sie eine virtuelle Umgebung, um Abhängigkeiten zu isolieren:

bash

python -m venv venv

Aktivieren Sie die virtuelle Umgebung:

bash

# On macOS/Linux:
source venv/bin/activate
 
# On Windows:
venv\Scripts\activate

Sie sollten (venv) in Ihrem Terminal-Prompt sehen; das zeigt an, dass die virtuelle Umgebung aktiv ist.

LangChain und OpenAI installieren

Wir installieren die OpenAI-Integration von LangChain, die alles enthält, was Sie für die Arbeit mit den Modellen von OpenAI benötigen:

bash

pip install langchain-openai

Das installiert langchain-openai zusammen mit seinen Abhängigkeiten, einschließlich langchain-core (die zentralen LangChain-Abstraktionen) und dem OpenAI-Python-Client. Sie sollten eine Ausgabe sehen, die die Installation mehrerer Pakete bestätigt.

Überprüfen Sie die Installation:

bash

pip show langchain-openai

Sie sollten Details zum installierten Paket sehen, einschließlich Versionsnummer und Speicherort. Das bestätigt, dass die Installation erfolgreich war.

Holen Sie sich Ihren OpenAI API Key

Um die Modelle von OpenAI aufzurufen, benötigen Sie einen API-Key:

Gehen Sie zu platform.openai.com
Registrieren Sie sich oder melden Sie sich an
Navigieren Sie in Ihren Kontoeinstellungen zu API Keys
Klicken Sie auf „Create new secret key“
Kopieren Sie den Key (er beginnt mit sk-)

⚠️ Sicherheitswarnung: Behandeln Sie diesen Key wie ein Passwort. Committen Sie ihn niemals in die Versionsverwaltung und teilen Sie ihn nicht öffentlich. Jede Person mit Ihrem Key kann API-Aufrufe durchführen, die Ihrem Konto in Rechnung gestellt werden.

Setzen Sie Ihren API-Key als Umgebungsvariable

Der empfohlene Weg, Ihren API-Key bereitzustellen, ist über eine Umgebungsvariable:

bash

# On macOS/Linux:
export OPENAI_API_KEY='sk-your-actual-key-here'
 
# On Windows (Command Prompt):
set OPENAI_API_KEY=sk-your-actual-key-here
 
# On Windows (PowerShell):
$env:OPENAI_API_KEY='sk-your-actual-key-here'

Hinweis: Diese Einstellung ist temporär und geht verloren, wenn Sie das Terminal schließen. Für eine dauerhafte Lösung können Sie entweder:

Den export-Befehl zu Ihrer Shell-Konfigurationsdatei hinzufügen (.bashrc, .zshrc, etc.)
Eine .env-Datei verwenden (das richten wir in Kapitel 3 für bessere Projektorganisation ein)

Für den Moment reicht die temporäre Einstellung aus, um fortzufahren.

Prüfen Sie, ob sie gesetzt ist:

bash

# On macOS/Linux:
echo $OPENAI_API_KEY
 
# On Windows (Command Prompt):
echo %OPENAI_API_KEY%
 
# On Windows (PowerShell):
echo $env:OPENAI_API_KEY

Sie sollten Ihren API-Key ausgegeben sehen. Falls nicht, wiederholen Sie den export-/set-Befehl und stellen Sie sicher, dass keine Tippfehler vorhanden sind.

1.3) Ihr erster LLM-Aufruf

Jetzt kommt der spannende Teil – machen wir Ihren ersten Aufruf an ein LLM. Erstellen Sie eine Datei namens first_call.py:

python

# first_call.py
from langchain_openai import ChatOpenAI
 
# Initialisiert das LLM
llm = ChatOpenAI(model="gpt-5-mini")
 
# Sendet einen Prompt und erhält eine Antwort
response = llm.invoke("Was ist LangChain?")
 
# Gibt die Antwort aus
print(response.content)

Führen Sie es aus:

bash

python first_call.py

Sie sollten eine Ausgabe ähnlich dieser sehen (die genaue Formulierung kann variieren):

LangChain ist ein Framework, das entwickelt wurde, um die Entwicklung von Anwendungen zu vereinfachen, die von großen Sprachmodellen (LLMs) angetrieben werden. Es stellt Tools und Abstraktionen bereit, um Ketten von LLM-Aufrufen zu bauen, externe Datenquellen zu integrieren, Prompts zu verwalten und Agenten zu erstellen, die mit verschiedenen APIs und Datenbanken interagieren können. LangChain erleichtert das Erstellen komplexer KI-Anwendungen, indem es wiederverwendbare Komponenten und Muster bereitstellt.

Glückwunsch! Sie haben gerade Ihren ersten LLM-Aufruf gemacht. Schauen wir uns an, was in diesem Code passiert ist.

Fehlersuche: Wenn Sie einen Fehler sehen:

AuthenticationError: API-Key ist ungültig oder nicht gesetzt → Prüfen Sie Ihre OPENAI_API_KEY-Umgebungsvariable (siehe Abschnitt 1.2)
RateLimitError: Anfragen zu schnell oder Usage-Limit überschritten → Warten Sie ein paar Sekunden und versuchen Sie es erneut, oder prüfen Sie die Nutzung unter platform.openai.com/usage
APIConnectionError: Problem mit der Netzwerkverbindung → Prüfen Sie Ihre Internetverbindung

Den Code verstehen

Importieren Sie den LLM-Wrapper:

python

from langchain_openai import ChatOpenAI

ChatOpenAI ist LangChains Wrapper um OpenAIs Chat-Modelle. Er übernimmt für Sie API-Authentifizierung, Request-Formatierung und Response-Parsing.

Initialisieren Sie das Modell:

python

llm = ChatOpenAI(model="gpt-5-mini")

Das erzeugt eine Instanz, die für GPT-5-mini konfiguriert ist. Hinter den Kulissen liest LangChain Ihre OPENAI_API_KEY-Umgebungsvariable zur Authentifizierung. Sie könnten den Key auch explizit übergeben:

python

llm = ChatOpenAI(model="gpt-5-mini", api_key="sk-your-key")

Aber Umgebungsvariablen zu verwenden ist sicherer und flexibler.

Rufen Sie das Modell auf:

python

response = llm.invoke("Was ist LangChain?")

Die Methode invoke() sendet Ihren Prompt an die API von OpenAI und wartet auf die vollständige Antwort. Das ist ein synchroner Aufruf – Ihr Programm pausiert, bis die Antwort eintrifft.

Greifen Sie auf den Response-Inhalt zu:

python

print(response.content)

Das Response-Objekt enthält mehrere Felder. Das Feld .content enthält den tatsächlichen Text, den das Modell generiert hat. Andere Felder untersuchen wir im nächsten Abschnitt.

Probieren Sie verschiedene Prompts aus

Ändern Sie den Prompt, um zu sehen, wie das Modell auf unterschiedliche Eingaben reagiert:

python

# first_call.py
from langchain_openai import ChatOpenAI
 
llm = ChatOpenAI(model="gpt-5-mini")
 
# Probieren Sie verschiedene Prompts aus
prompts = [
    "Erklären Sie Python-Decorators in einem Satz.",
    "Was ist 15 * 23?",
    "Nennen Sie drei Vorteile der Nutzung von Type Hints in Python.",
]
 
for prompt in prompts:
    response = llm.invoke(prompt)
    print(f"Prompt: {prompt}")
    print(f"Response: {response.content}\n")

Das Modell verarbeitet unterschiedliche Arten von Anfragen – Erklärungen, Berechnungen und strukturierte Listen. Ihnen wird auffallen, dass Antworten leicht variieren können, wenn Sie denselben Prompt mehrfach ausführen. Das ist normales Verhalten – warum das passiert und wie Sie es steuern, erkunden wir in Kapitel 2.

1.4) Was ist gerade passiert? (Request → Model → Response Flow)

Schauen wir uns genau an, was passiert ist, als Sie llm.invoke() aufgerufen haben. Diesen Ablauf zu verstehen, ist entscheidend, um zuverlässige KI-Agenten zu bauen.

Der vollständige Request-Response-Zyklus

Verfolgen wir jeden Schritt:

Schritt 1: Ihr Code ruft invoke() auf

python

response = llm.invoke("Was ist LangChain?")

Die Methode invoke() ist Ihre Hauptschnittstelle zum LLM. Sie übergeben einen Prompt-String, und sie gibt ein Response-Objekt zurück, das die Antwort des Modells enthält. Hinter diesem einfachen Aufruf passieren mehrere Schritte automatisch.

Schritt 2: LangChain formatiert den Request

LangChain transformiert Ihren String in einen strukturierten API-Request. Hinter den Kulissen erstellt es ein JSON-Payload wie dieses:

json

{
  "model": "gpt-5-mini",
  "messages": [
    {
      "role": "user",
      "content": "Was ist LangChain?"
    }
  ],
  "temperature": 1.0
}

Das Array messages ist die Art, wie Chat-Modelle Eingaben erhalten. Jede Nachricht hat eine role (user, assistant oder system) und content (den Text). Message-Rollen schauen wir uns in Kapitel 4 an.

Schritt 3: API-Aufruf an OpenAI

LangChain sendet eine HTTPS-POST-Anfrage an den API-Endpunkt von OpenAI:

POST https://api.openai.com/v1/chat/completions
Authorization: Bearer sk-your-api-key
Content-Type: application/json
 
{request payload}

Ihr API-Key authentifiziert die Anfrage. Die Server von OpenAI empfangen die Anfrage und leiten sie an das angegebene Modell weiter.

Schritt 4: Das Modell verarbeitet den Prompt

GPT-5-mini erhält Ihren Prompt und generiert eine Antwort Token für Token. Das Modell:

Wandelt Ihren Text in Tokens um (numerische Repräsentationen)
Verarbeitet Tokens durch seine neuronalen Netzwerkschichten
Sagt das wahrscheinlichste nächste Token voraus
Wiederholt das, bis es eine vollständige Antwort generiert oder eine Stop-Bedingung erreicht

Das passiert auf den Servern von OpenAI – Ihr Code wartet nur auf das Ergebnis.

Schritt 5: Die API gibt die Response zurück

Die API von OpenAI sendet eine JSON-Response zurück:

json

{
  "id": "chatcmpl-8x7y9z",
  "object": "chat.completion",
  "created": 1704067200,
  "model": "gpt-5-mini",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "LangChain ist ein Framework, das entwickelt wurde, um zu vereinfachen..."
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 12,
    "completion_tokens": 58,
    "total_tokens": 70
  }
}

Wichtige Felder:

message.content: Der generierte Text
usage: Token-Zählungen für Abrechnung und Monitoring
finish_reason: Warum die Generierung gestoppt wurde („stop“ = natürliche Beendigung, „length“ = Token-Limit erreicht)

Schritt 6: LangChain parst die Response

LangChain konvertiert das JSON in ein Python-Objekt, mit dem Sie arbeiten können:

python

from langchain_openai import ChatOpenAI
 
llm = ChatOpenAI(model="gpt-5-mini")
response = llm.invoke("Was ist LangChain?")
 
# Erkunden Sie das Response-Objekt
print(f"Content: {response.content}")
print(f"Type: {type(response)}")
print(f"Response metadata: {response.response_metadata}")

Ausgabe:

Content: LangChain ist ein Framework, das entwickelt wurde, um zu vereinfachen...
Type: <class 'langchain_core.messages.ai.AIMessage'>
Response metadata: {'token_usage': {'completion_tokens': 58, 'prompt_tokens': 12, 'total_tokens': 70}, 'model_name': 'gpt-5-mini', 'finish_reason': 'stop'}

Die Response ist ein AIMessage-Objekt mit mehreren nützlichen Attributen:

content: Der generierte Text (was Sie normalerweise wollen)
response_metadata: Token-Nutzung, Modellname, Finish-Reason
id: Eindeutiger Identifier für diese Response
usage_metadata: Detaillierte Token-Aufschlüsselung

Token-Nutzung verstehen

Bevor wir uns Token-Zählungen ansehen, ein kurzer Hinweis: Tokens sind die Basiseinheiten, die LLMs verarbeiten. Im Englischen nutzt Text typischerweise etwas mehr als 1 Token pro Wort (z. B. „explain quantum computing“ = 3 Wörter, 4–5 Tokens), aber nicht-englische Sprachen wie Koreanisch oder Chinesisch benötigen deutlich mehr Tokens, um denselben Text darzustellen. Tokens betrachten wir in Kapitel 2 genauer.

Schauen wir uns den Token-Verbrauch genauer an:

python

from langchain_openai import ChatOpenAI
 
llm = ChatOpenAI(model="gpt-5-mini")
response = llm.invoke("Explain quantum computing in simple terms.")
 
usage = response.response_metadata['token_usage']
print(f"Input tokens: {usage['prompt_tokens']}")
print(f"Output tokens: {usage['completion_tokens']}")
print(f"Total tokens: {usage['total_tokens']}")

Ausgabe:

Input tokens: 11
Output tokens: 95
Total tokens: 106

Hinweis: prompt_tokens = Input-Token (Ihr Prompt), completion_tokens = Output-Token (Antwort des Modells), total_tokens = Summe aus beidem.

Der Token-Verbrauch variiert je nach:

Prompt-Länge: Längere Prompts nutzen mehr Input-Token
Antwort-Detailgrad: Detaillierte Antworten generieren mehr Output-Token
Sprachkomplexität: Fachbegriffe und Code können unterschiedlich tokenisiert werden

Zum Beispiel kann ein kurzer Prompt wie „What's 2+2?“ nur 5–6 Input-Token und 8–10 Output-Token nutzen, während „Write a detailed essay about the history of Python programming language“ 15–20 Input-Token und 500+ Output-Token nutzen könnte.

Kostenberechnung für das obige Beispiel:

Bei den Preisen von GPT-5-mini ($0.25 pro Million Input-Token, $2.00 pro Million Output-Token):

Input: 11 Tokens × $0.25 / 1,000,000 = $0.00000275
Output: 95 Tokens × $2.00 / 1,000,000 = $0.00019
Gesamt: ~$0.0002 (zwei Hundertstel eines Cents)

Sie zahlen sowohl für Input- als auch für Output-Token, aber Output-Token kosten mehr (in diesem Fall 8×).

Was Sie gelernt haben

Sie verstehen jetzt den vollständigen Lebenszyklus eines LLM-Aufrufs:

Ihr Code stellt einen Prompt-String bereit
LangChain formatiert ihn in einen API-Request mit Authentifizierung
Die OpenAI API leitet die Anfrage an das Modell weiter
Das Modell generiert eine Response Token für Token
Die API gibt strukturiertes JSON mit Response und Metadaten zurück
LangChain parst es in ein Python-Objekt
Ihr Code greift auf Content und Metadaten zu

Außerdem haben Sie gelernt:

Wie Sie Response-Objekte untersuchen und Metadaten extrahieren
Wie Token-Nutzung die Kosten beeinflusst

Dieses Fundament bereitet Sie auf Kapitel 2 vor, in dem wir erkunden, wie LLMs unter der Haube tatsächlich funktionieren, verschiedene Modelle vergleichen und Prompt-Engineering-Techniken lernen, um bessere Ergebnisse zu erzielen.