Agentische KI / Generative KI

Agentic AI / Generative AI

Die Landschaft der künstlichen Intelligenz durchläuft einen fundamentalen Wandel von der passiven Inhaltserstellung hin zur aktiven autonomen Ausführung. Generative AI legte das Fundament, indem sie Maschinen befähigte, kohärente Texte, realistische Bilder und funktionalen Code zu produzieren. Agentic AI baut auf diesem Fundament auf und verwandelt Modelle von statischen Generatoren in dynamische Systeme, die planen, Schlussfolgern, Werkzeuge nutzen und iterativ auf Ziele hinarbeiten. Das Ergebnis ist eine neue Klasse von Software, die nicht nur Fragen beantwortet, sondern Arbeitsabläufe vollständig abwickelt.

Organisationen in der gesamten Branche treiben beide Paradigmen voran. OpenAI, Anthropic, Microsoft und NVIDIA leisten jeweils durch ihre Forschungs- und Entwicklungskanäle Beiträge zur sich weiterentwickelnden technischen Diskussion. Ihre Arbeit erstreckt sich über Foundation-Model-Training, Sicherheitsausrichtung, Cloud-Infrastruktur und Hardware-Beschleunigung. Während diese Schichten reifen, erhalten Entwickler praktischen Zugang zu agentischen Fähigkeiten, die zuvor auf Forschungslabore beschränkt waren. Dieser Artikel bietet eine praxisnahe Anleitung zum Bauen mit generativer und agentischer AI – von der Einrichtung der Umgebung bis hin zu einem funktionierenden ReAct-Agenten.

Verständnis der Landschaft

Generative AI bezieht sich auf Modelle – typischerweise große Transformer oder Diffusionsnetzwerke – die Muster aus Trainingsdaten lernen und neuartige Ausgaben synthetisieren. Ob bei der Erstellung von Marketingtexten, der Fehlerbehebung in Code oder der Generierung synthetischer Daten, die Kerninteraktion ist Anfrage-und-Antwort. Das Modell erhält einen Prompt und liefert eine Vervollständigung.

Agentic AI erweitert diese Interaktionsschleife durch die Einführung von Autonomie. Ein agentisches System erkennt ein Ziel, zerlegt es in Teilaufgaben, wählt geeignete Werkzeuge aus, beobachtet Zwischenergebnisse und passt seinen Plan an. Diese Architektur stützt sich oft auf ein Sprachmodell als Reasoning-Engine, doch die Intelligenz ist über die gesamte Schleife verteilt, statt in einem einzelnen Forward-Pass konzentriert zu sein. Werkzeugnutzung, Gedächtnis und Steuerungslogik werden zu gleichberechtigten Komponenten.

Die Konvergenz dieser Ansätze ist die Richtung, in die die moderne Anwendungsentwicklung steuert. Ein generatives Modell liefert das semantische Reasoning; ein agentisches Framework liefert die Zustandsmaschine und Werkzeugbindungen. Gemeinsam ermöglichen sie Anwendungen, die mit APIs interagieren, Datenbanken abfragen, Code ausführen und ihre eigenen Ausgaben validieren. Die folgenden Abschnitte führen durch den praktischen Aufbau eines solchen Systems.

Voraussetzungen

Bevor Sie Software installieren, stellen Sie sicher, dass Ihre Umgebung die Basiskriterien erfüllt. Sie benötigen ein modernes Betriebssystem – Linux, macOS oder Windows Subsystem for Linux (WSL) – mit installiertem Python 3.9 oder neuer. Das Tutorial verwendet pip zur Paketverwaltung, verifizieren Sie also, dass pip neben Ihrem Python-Interpreter verfügbar ist.

Sie benötigen außerdem einen API-Schlüssel von OpenAI. Dieser Schlüssel ermöglicht den Zugriff auf den Chat-Completions-Endpunkt, der als Reasoning-Rückgrat für sowohl die generativen als auch die agentischen Beispiele dient. Falls Ihre Organisation den Azure OpenAI Service nutzt, kann der Code durch Austausch der Client-Initialisierung angepasst werden, obwohl diese Anleitung von der Standard-OpenAI-Plattform ausgeht.

Die Hardware-Anforderungen sind bescheiden. CPU-Ausführung ist für die Orchestrierungsschicht ausreichend, da die rechenintensive Inferenz remote auf OpenAIs Infrastruktur läuft. Stellen Sie jedoch sicher, dass mindestens 2 GB RAM verfügbar sind und eine stabile Internetverbindung besteht. Die Speicherplatzanforderungen sind minimal; die Python-Umgebung und Bibliotheken werden weniger als 500 MB beanspruchen.

Optional, aber empfohlen, sind Git zur Versionskontrolle und ein Virtual-Environment-Manager wie venv. Diese sind nicht zwingend erforderlich, verhindern jedoch Abhängigkeitskonflikte und machen die Einrichtung reproduzierbar.

Schritt-für-Schritt-Installation

Beginnen Sie damit, ein dediziertes Verzeichnis für das Projekt zu erstellen. Die Isolierung Ihrer Arbeit verhindert, dass bestehende Ordner mit neuen Abhängigkeiten überladen werden.

```bash mkdir agentic-ai-lab && cd agentic-ai-lab ```

Erstellen Sie eine Python-Virtual-Environment innerhalb dieses Verzeichnisses. Eine Virtual-Environment stellt sicher, dass die installierten Pakete nicht mit Ihrer systemweiten Python-Installation interferieren.

```bash python3 -m venv venv ```

Aktivieren Sie die Virtual-Environment, damit nachfolgende pip-Befehle Pakete in diesen isolierten Kontext statt in die globale Umgebung installieren.

```bash source venv/bin/activate ```

Auf Windows-Systemen mit PowerShell oder Eingabeaufforderung führen Sie stattdessen das Aktivierungsskript im Scripts-Verzeichnis aus.

```bash venv\Scripts\activate ```

Mit aktivierter Umgebung aktualisieren Sie pip auf die neueste Version. Dies minimiert Kompatibilitätsprobleme während der Installation.

```bash pip install --upgrade pip ```

Installieren Sie die Kernbibliotheken, die für den Zugriff auf generative AI und die agentische Orchestrierung benötigt werden. Sie benötigen den offiziellen OpenAI-Client, LangChain-Bindungen für OpenAI und LangGraph für das Agenten-Framework.

```bash pip install openai langchain langchain-openai langgraph ```

Um Ihren API-Schlüssel aus dem Quellcode herauszuhalten, erstellen Sie eine lokale Umgebungsdatei. Der folgende Befehl erzeugt eine versteckte `.env`-Datei in Ihrem Projektstamm.

```bash touch .env ```

Öffnen Sie die `.env`-Datei in Ihrem bevorzugten Texteditor und fügen Sie Ihren OpenAI-API-Schlüssel hinzu. Ersetzen Sie den Platzhalter durch Ihren tatsächlichen Schlüssel.

```bash echo "OPENAI_API_KEY=sk-your-key-here" > .env ```

Exportieren Sie den Schlüssel in Ihre aktuelle Shell-Sitzung, damit die Python-Skripte ihn während dieses Tutorials direkt lesen können.

```bash export OPENAI_API_KEY=$(grep OPENAI_API_KEY .env | cut -d '=' -f2) ```

Verifizieren Sie, dass der Schlüssel korrekt geladen wurde, indem Sie die ersten Zeichen ausgeben. Geben Sie niemals den gesamten Schlüssel in einem gemeinsam genutzten Terminal aus.

```bash echo $OPENAI_API_KEY | cut -c1-10 ```

Bestätigen Sie, dass alle Pakete korrekt installiert wurden, indem Sie einen schnellen Import-Test durchführen. Dieser Befehl sollte lautlos ohne Ausgabe abgeschlossen werden, falls alles ordnungsgemäß verknüpft ist.

```bash python -c "import openai, langchain, langgraph; print('OK')" ```

Ihre Umgebung ist nun bereit. Die verbleibenden Schritte umfassen das Schreiben und Ausführen von Python-Skripten, die sowohl generative als auch agentische Muster anwenden.

Nutzungsbeispiele

Beispiel 1: Fundamentale Generative AI

Der einfachste Einstiegspunkt ist die direkte Interaktion mit einem großen Sprachmodell über den OpenAI-Client. Dies stellt sicher, dass Ihr API-Schlüssel, Netzwerkzugriff und Bibliotheksversionen funktionieren. Erstellen Sie eine Datei namens `generate.py` und füllen Sie sie mit dem folgenden Code.

Dieses Skript importiert den OpenAI-Client und initialisiert eine Verbindung unter Verwendung des zuvor exportierten API-Schlüssels.

```python from openai import OpenAI

client = OpenAI() ```

Der Client sendet eine Chat-Completion-Anfrage an das Modell `gpt-4o-mini`. Dieses Modell bietet für Prototyping eine starke Balance aus Leistungsfähigkeit und Latenz.

```python response = client.chat.completions.create( model="gpt-4o-mini", messages=[ {"role": "system", "content": "You are a concise technical assistant."}, {"role": "user", "content": "Explain the difference between generative AI and agentic AI in one paragraph."} ], temperature=0.2 ) ```

Schließlich extrahieren und geben Sie den generierten Text aus dem Antwortobjekt aus.

```python print(response.choices[0].message.content) ```

Führen Sie das Skript von Ihrem Terminal aus.

```bash python generate.py ```

Sie sollten einen kohärenten Absatz erhalten, der generative AI als Inhaltserstellungstechnologie und agentische AI als zielgerichtetes, werkzeugnutzendes System unterscheidet. Dies bestätigt, dass Ihre generative Pipeline funktionsfähig ist.

Beispiel 2: Agentic AI mit Werkzeugen und Reasoning

Das Überschreiten der Einzelrunden-Generierung erfordert ein agentisches Framework. Dieses Beispiel verwendet LangGraph zur Konstruktion eines ReAct-Agenten – einer Architektur, die Reasoning und Handeln miteinander verwebt. Das Modell denkt über ein Problem nach, entscheidet, ob ein Werkzeug verwendet werden soll, beobachtet die Werkzeugausgabe und wiederholt dies, bis es eine finale Antwort erreicht.

Erstellen Sie eine neue Datei namens `agent.py`. Beginnen Sie mit dem Import der benötigten Module. `ChatOpenAI` stellt die Modellschnittstelle bereit, `tool` dekoriert benutzerdefinierte Funktionen, und `create_react_agent` baut die Zustandsmaschine.

```python from langchain_openai import ChatOpenAI from langchain_core.tools import tool from langgraph.prebuilt import create_react_agent ```

Definieren Sie ein einfaches Rechenwerkzeug. Der `@tool`-Dektor macht die Funktion dem Agenten mit einem Namen und einer Beschreibung aus der Docstring zugänglich.

```python @tool def multiply(a: float, b: float) -> float: """Multiply two numbers and return the product.""" return a * b ```

Definieren Sie ein zweites Werkzeug, das simuliert