Von generativer zu agentischer KI: Die nächste Grenze autonomer Systeme

Von generativer zu agentischer KI: Die nächste Grenze autonomer Systeme

Die rasante Entwicklung der künstlichen Intelligenz hat die einfache Textgenerierung und Bilderstellung längst hinter sich gelassen. Heute stehen wir an der Schwelle zu einem neuen Paradigma: der agentischen KI. Während generative KI-Modelle wie GPT-4 und Claude Inhalte in menschlicher Qualität produzieren können, sind agentische Systeme in der Lage, in realen Umgebungen autonom zu planen, zu handeln und sich anzupassen. Dieser Wandel von passiver Generierung zu proaktivem Handeln stellt die nächste Grenze autonomer Systeme dar.

Den Wandel verstehen: Generative vs. agentische KI

Generative KI zeichnet sich durch die Erzeugung von Ausgaben auf der Grundlage von Mustern in Trainingsdaten aus. Sie beantwortet Fragen, schreibt Code und erstellt Kunst. Allerdings arbeitet sie typischerweise einmalig oder zustandslos – jede Anfrage ist unabhängig, und das Modell behält keine Ziele bei oder lernt aus Ergebnissen.

Agentische KI hingegen ist für **zielorientiertes Verhalten** konzipiert. Ein agentisches System:

• Nimmt ein übergeordnetes Ziel an
• Zerlegt es in Teilaufgaben
• Führt Aktionen aus (z. B. API-Aufrufe, Dateioperationen, Websuchen)
• Überwacht den Fortschritt und passt Pläne an
• Lernt aus Erfolgen und Misserfolgen

Wie im KI-Blog von NVIDIA festgestellt, kombinieren agentische Architekturen generative Modelle mit Planung, Gedächtnis und Werkzeugnutzung. Der KI-Blog von Microsoft hebt ebenfalls Frameworks wie AutoGen und Semantic Kernel hervor, die die Zusammenarbeit mehrerer Agenten ermöglichen.

Voraussetzungen

Bevor Sie ein agentisches KI-System aufbauen, stellen Sie sicher, dass Sie Folgendes haben:

• **Python 3.10 oder neuer** (empfohlen: 3.11)
• **OpenAI-API-Schlüssel** oder **Anthropic-API-Schlüssel** (für das Sprachmodell)
• **Git** (zum Klonen von Repositorys)
• **Internetverbindung** (für API-Aufrufe und Paketdownloads)
• **Grundlegende Vertrautheit** mit der Befehlszeile

Optional, aber empfohlen:

• Docker (für containerisierte Bereitstellung)
• Eine Vektordatenbank (z. B. ChromaDB, Pinecone) für das Langzeitgedächtnis

Schritt-für-Schritt-Installation

Wir werden ein praktisches agentisches KI-System mit **LangChain** und **AutoGen** einrichten – zwei führenden Open-Source-Frameworks. AutoGen, entwickelt von Microsoft Research, ermöglicht Gespräche zwischen mehreren Agenten.

1. Erstellen einer Python-Virtual-Umgebung

Isolieren Sie Abhängigkeiten, um Konflikte zu vermeiden.

python3 -m venv agentic-env
source agentic-env/bin/activate

2. Installieren der Kernabhängigkeiten

Installieren Sie LangChain, AutoGen und unterstützende Bibliotheken.

pip install langchain langchain-openai langchain-community
pip install pyautogen
pip install python-dotenv requests

3. Festlegen der Umgebungsvariablen

Speichern Sie API-Schlüssel sicher. Erstellen Sie eine `.env`-Datei in Ihrem Projektstammverzeichnis:

echo "OPENAI_API_KEY=your_openai_api_key_here" >> .env
echo "ANTHROPIC_API_KEY=your_anthropic_api_key_here" >> .env

4. Überprüfen der Installation

Führen Sie einen kurzen Test durch, um sicherzustellen, dass alles funktioniert.

# test_imports.py
from langchain_openai import ChatOpenAI
from autogen import AssistantAgent, UserProxyAgent
print("All imports successful")

Ausführen:

python test_imports.py

Sie sollten "All imports successful" sehen.

Anwendungsbeispiele

Beispiel 1: Einzelagenten-Aufgabenausführung (LangChain)

Erstellen Sie einen Agenten, der autonom Websuchen und Berechnungen durchführen kann.

# agentic_web_search.py
import os
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
from langchain.agents import create_react_agent, AgentExecutor
from langchain.tools import Tool
from langchain import hub

load_dotenv()

# Initialisieren des Sprachmodells
llm = ChatOpenAI(model="gpt-4", temperature=0)

# Definieren von Werkzeugen
def search_web(query: str) -> str:
    """Simuliert eine Websuche. Durch tatsächlichen API-Aufruf ersetzen."""
    return f"Simulierte Ergebnisse für: {query}"

def calculate(expression: str) -> str:
    """Wertet einen mathematischen Ausdruck aus."""
    try:
        return str(eval(expression))
    except Exception as e:
        return f"Fehler: {e}"

tools = [
    Tool(name="WebSearch", func=search_web, description="Das Web durchsuchen"),
    Tool(name="Calculator", func=calculate, description="Mathematische Berechnungen durchführen"),
]

# Laden des ReAct-Prompts
prompt = hub.pull("hwchase17/react")

# Erstellen des Agenten
agent = create_react_agent(llm, tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

# Ausführen der Aufgabe
result = agent_executor.invoke({"input": "Was ist 25 * 4 + 100? Suche dann nach 'neueste KI-Nachrichten'."})
print(result["output"])

Führen Sie das Skript aus:

python agentic_web_search.py

**Erwartete Ausgabe:** Der Agent berechnet zunächst `25 * 4 + 100 = 200` und führt dann eine simulierte Websuche durch.

Beispiel 2: Multi-Agenten-Zusammenarbeit mit AutoGen

Erstellen Sie ein System, in dem zwei Agenten – ein Assistent und ein Benutzerproxy – zusammenarbeiten, um ein Problem zu lösen.

# multi_agent_autogen.py
import os
from dotenv import load_dotenv
from autogen import AssistantAgent, UserProxyAgent, config_list_from_json

load_dotenv()

# Konfigurieren des LLM
config_list = [
    {
        "model": "gpt-4",
        "api_key": os.getenv("OPENAI_API_KEY"),
    }
]

# Erstellen des Assistenten-Agenten
assistant = AssistantAgent(
    name="Assistant",
    llm_config={"config_list": config_list},
    system_message="Sie sind ein hilfreicher KI-Assistent. Sie können Python-Code schreiben und ausführen, um Probleme zu lösen.",
)

# Erstellen des Benutzerproxy-Agenten (simuliert menschliche Interaktion)
user_proxy = UserProxyAgent(
    name="UserProxy",
    human_input_mode="NEVER",
    max_consecutive_auto_reply=10,
    is_termination_msg=lambda x: x.get("content", "").rstrip().endswith("TERMINATE"),
    code_execution_config={
        "work_dir": "coding",
        "use_docker": False,
    },
)

# Initiieren eines Gesprächs
user_proxy.initiate_chat(
    assistant,
    message="Berechne die 10. Fibonacci-Zahl und schreibe sie in eine Datei namens fibonacci.txt.",
)

Ausführen:

mkdir -p coding
python multi_agent_autogen.py

Der Assistent generiert Python-Code, führt ihn aus und schreibt das Ergebnis in `coding/fibonacci.txt`.

Beispiel 3: Agent mit Gedächtnis und Planung

Nutzen Sie die Gedächtnis- und Planungsfähigkeiten von LangChain für längere Aufgaben.

# agent_with_memory.py
from langchain.memory import ConversationSummaryBufferMemory
from langchain.chains import ConversationChain
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4", temperature=0.7)

memory = ConversationSummaryBufferMemory(
    llm=llm,
    max_token_limit=1000,
    memory_key="history",
    return_messages=True,
)

conversation = ConversationChain(
    llm=llm,
    memory=memory,
    verbose=True,
)

# Erste Interaktion
response1 = conversation.predict(input="Mein Name ist Alex. Ich möchte eine Wetter-App erstellen.")
print("Antwort 1:", response1)

# Zweite Interaktion (der Agent erinnert sich an den Namen und das Ziel)
response2 = conversation.predict(input="Welchen Technologie-Stack sollte ich verwenden?")
print("Antwort 2:", response2)

Wichtige architektonische Unterschiede

| Merkmal | Generative KI | Agentische KI | |---------|---------------|---------------| | **Zustand** | Zustandslos | Zustandsbehaftet (Gedächtnis, Kontext) | | **Ziel** | Einzelne Antwort | Mehrschrittige Aufgabenerfüllung | | **Werkzeuge** | Keine oder eingeschränkt | API-Aufrufe, Codeausführung, Websuche | | **Lernen** | Keine Anpassung | Kann aus Feedback lernen | | **Autonomie** | Niedrig | Hoch (plant und führt aus) |

Praxisnahe Anwendungen

Wie von OpenAI News und Anthropic News berichtet, werden agentische Systeme eingesetzt in:

• **Softwareentwicklung**: Autonome Codegenerierung, Tests und Bereitstellung
• **Wissenschaftliche Forschung**: Hypothesengenerierung, Versuchsplanung, Datenanalyse
• **Kundensupport**: Mehrschrittige Problemlösung mit Eskalationslogik
• **Finanzen**: Automatisierte Handelsstrategien mit Risikoüberwachung
• **Gesundheitswesen**: Optimierung von Behandlungsplänen und Patientenüberwachung

Der KI-Blog von Microsoft hebt hervor, dass agentische Frameworks wie AutoGen bereits in der Produktion eingesetzt werden, um komplexe Arbeitsabläufe zu automatisieren, die zuvor menschliches Eingreifen erforderten.

Herausforderungen und Überlegungen

1. **Zuverlässigkeit**: Agenten können falsche Entscheidungen treffen, wenn das zugrunde liegende Modell halluziniert. 2. **Sicherheit**: Autonome Systeme benötigen Schutzmechanismen, um schädliche Aktionen zu verhindern. 3. **Kosten**: Mehrschrittiges Denken mit großen Modellen kann teuer sein. 4. **Beobachtbarkeit**: Das Debuggen von Agentenverhalten erfordert detaillierte Protokollierung.

Der KI-Blog von NVIDIA betont, dass die Branche stark in Evaluierungsframeworks, Sicherheitsebenen und Kostenoptimierungsstrategien investiert, um diese Herausforderungen zu bewältigen.

Zukunftsausblick

Der Übergang von generativer zu agentischer KI spiegelt den Wandel von Dampfmaschinen zu autonomen Fahrzeugen wider. Generative Modelle liefern die "Intelligenz", aber agentische Systeme liefern die "Handlungsfähigkeit" – die Fähigkeit, unabhängig in der Welt zu handeln.

Wichtige Trends, die es zu beobachten gilt:

• **Multi-Agenten-Systeme**, in denen spezialisierte Agenten zusammenarbeiten (z. B. Forscher, Programmierer, Prüfer)
• **Werkzeugnutzungs-Ökosysteme** mit standardisierten APIs für Agenten
• **Selbstverbessernde Agenten**, die ihre eigenen Prompts und Strategien verfeinern
• **Regulierungsrahmen** speziell für autonome KI-Systeme

Fazit

Generative KI gab uns die Fähigkeit zu erschaffen. Agentische KI gibt uns die Fähigkeit zu **handeln**. Durch die Kombination großer Sprachmodelle mit Planung, Gedächtnis und Werkzeugnutzung können wir jetzt Systeme bauen, die nicht nur Fragen beantworten – sie lösen Probleme.

Die obigen Beispiele zeigen, dass die Einrichtung eines agentischen Systems für jeden Entwickler mit grundlegenden Python-Kenntnissen zugänglich ist. Beginnen Sie mit einem einzelnen Agenten und einfachen Werkzeugen, und fügen Sie dann schrittweise Gedächtnis, Multi-Agenten-Zusammenarbeit und reale Integrationen hinzu.

Die Grenze autonomer Systeme besteht nicht darin, intelligentere Modelle zu bauen – es geht darum, Modelle zu bauen, die **Dinge selbstständig tun** können. Die Werkzeuge sind bereit. Die APIs sind verfügbar. Der nächste Schritt liegt bei Ihnen.