Erstellen Sie echte agentische Apps mit CUGA: Zwei Dutzend funktionierende Beispiele auf einem leichten Framework

Echte agentische Apps mit CUGA erstellen: Zwei Dutzend funktionierende Beispiele auf einem leichten Framework

Der Aufstieg der agentischen KI – Systeme, die eigenständig denken, planen und Aufgaben ausführen können – hat die Art und Weise verändert, wie Entwickler Automatisierung angehen. Doch solche Agenten zu bauen, erfordert oft komplexe Frameworks, schwere Infrastruktur und umfangreichen Boilerplate-Code. Hier kommt CUGA (Compact Unified Generative Agent) ins Spiel – ein leichtes Framework, mit dem Sie agentische Anwendungen mit minimalem Aufwand erstellen und bereitstellen können. In diesem Artikel erkunden wir, wie CUGA es Ihnen ermöglicht, zwei Dutzend funktionierende Beispiele zu erstellen – von einfachen Chatbots bis hin zu mehrstufigen Reasoning-Agenten – alles auf einem leichten Framework. Wir behandeln Installation, Konfiguration und praktische Nutzung mit echten Befehlen und stützen uns dabei auf Erkenntnisse aus aktuellen Entwicklungen bei KI-Agenten-Frameworks, die von Quellen wie dem Hugging Face Blog, OpenAI News, Microsoft AI Blog und Anthropic News hervorgehoben werden.

Was ist CUGA und warum agentische Apps wichtig sind

Agentische Anwendungen sind KI-Systeme, die ihre Umgebung wahrnehmen, Entscheidungen treffen und Maßnahmen ergreifen können, um Ziele zu erreichen. Im Gegensatz zu traditionellen Chatbots, die auf Eingabeaufforderungen reagieren, können agentische Apps komplexe Aufgaben aufschlüsseln, Werkzeuge nutzen (z. B. Suche, Taschenrechner, APIs) und ihre Ergebnisse iterieren. CUGA bietet eine minimale Abstraktionsebene über Sprachmodellen (LLMs) wie denen von OpenAI, Anthropic oder Open-Source-Alternativen und macht es einfach, agentisches Verhalten ohne schwergewichtige Orchestrierungswerkzeuge zu orchestrieren.

Das Konzept der agentischen KI hat in der gesamten Branche an Bedeutung gewonnen. OpenAIs aktuelle Nachrichten betonen die Verschiebung hin zu autonomen Systemen, die zur Interaktion mit der realen Welt fähig sind. Microsofts AI Blog zeigt, wie Agenten in Unternehmenswerkzeuge wie Azure integriert werden. Anthropics Forschung hebt Sicherheit und Zuverlässigkeit in agentischen Workflows hervor. Der Hugging Face Blog hat derweil praktische Beispiele für den Bau von Agenten mit leichten Frameworks veröffentlicht. CUGA passt zu diesem Trend, indem es ein Framework bietet, das sowohl einfach als auch erweiterbar ist.

Voraussetzungen

Bevor wir mit der Installation und den Beispielen beginnen, stellen Sie sicher, dass Folgendes vorhanden ist:

• **Python 3.10 oder neuer**: CUGA ist Python-nativ. Überprüfen Sie Ihre Version mit `python --version`.
• **Ein unterstützter LLM-Anbieter**: OpenAI-API-Schlüssel (für GPT-4o oder GPT-4-turbo), Anthropic-API-Schlüssel (für Claude 3.5 Sonnet) oder Zugriff auf ein lokales Modell über Hugging Face Transformers.
• **Grundlegende Vertrautheit mit der Kommandozeile und Python**: Sie werden Skripte ausführen und Konfigurationsdateien ändern.
• **Mindestens 4 GB RAM**: Für lokale Modelle oder schwere Agentenschleifen.
• **Internetverbindung**: Für API-basierte Modelle und Paket-Downloads.

Schritt-für-Schritt-Installation

CUGA wird als Python-Paket verteilt. Wir installieren es in einer virtuellen Umgebung, um Abhängigkeiten isoliert zu halten.

1. Virtuelle Umgebung erstellen und aktivieren

Erstellen Sie zunächst eine dedizierte Umgebung für Ihre CUGA-Projekte. Dies verhindert Konflikte mit anderen Python-Paketen.

python -m venv cuga_env
source cuga_env/bin/activate  # Unter Windows: cuga_env\Scripts\activate

2. CUGA und seine Kernabhängigkeiten installieren

Verwenden Sie pip, um das CUGA-Paket zusammen mit den LLM-Anbieterbibliotheken zu installieren, die Sie verwenden möchten. Für diesen Leitfaden installieren wir Unterstützung für OpenAI, Anthropic und Open-Source-Modelle über Hugging Face.

pip install cuga openai anthropic transformers torch

Das `cuga`-Paket selbst ist leicht – weniger als 500 KB. Die zusätzlichen Bibliotheken fügen Fähigkeiten für verschiedene Backends hinzu.

3. Installation überprüfen

Führen Sie eine schnelle Überprüfung durch, um sicherzustellen, dass CUGA korrekt installiert ist und importiert werden kann.

python -c "from cuga import Agent; print('CUGA erfolgreich installiert')"

Wenn Sie die Erfolgsmeldung sehen, sind Sie bereit, Ihren LLM-Anbieter zu konfigurieren.

4. API-Schlüssel einrichten

CUGA liest API-Schlüssel aus Umgebungsvariablen aus Sicherheitsgründen. Setzen Sie sie in Ihrer Shell oder einer `.env`-Datei.

export OPENAI_API_KEY="ihr-openai-schlüssel-hier"
export ANTHROPIC_API_KEY="ihr-anthropic-schlüssel-hier"

Für lokale Modelle benötigen Sie keine API-Schlüssel – stellen Sie nur sicher, dass Hugging Face Transformers auf das Modell zugreifen können (z. B. `meta-llama/Llama-2-7b-chat-hf`).

5. Mit einem einfachen Agenten testen

Erstellen Sie eine Datei namens `test_agent.py` mit folgendem Inhalt, um zu überprüfen, ob alles funktioniert:

from cuga import Agent

agent = Agent(model="gpt-4o", provider="openai")
response = agent.run("Was ist 2 + 2?")
print(response)

Führen Sie es aus:

python test_agent.py

Sie sollten eine Antwort wie „Die Summe von 2 und 2 ist 4.“ sehen.

Das CUGA-Framework verstehen

CUGAs leichtes Framework besteht aus drei Kernkomponenten:

• **Agent**: Die Hauptklasse, die das LLM, Werkzeuge und den Speicher kapselt.
• **Tool**: Eine aufrufbare Funktion, die der Agent aufrufen kann (z. B. Websuche, Taschenrechner, Dateileser).
• **Memory**: Ein kurzfristiger Kontextspeicher, der dem Agenten hilft, den Zustand über Schritte hinweg beizubehalten.

Das Framework ist bewusst minimalistisch gestaltet. Sie definieren Agenten in wenigen Codezeilen und setzen sie dann zu Workflows zusammen. Dies steht im Gegensatz zu schwereren Frameworks wie LangChain oder AutoGen, die mehr Boilerplate erfordern.

Nutzungsbeispiele: Vierundzwanzig funktionierende Agenten

Wir gehen 24 praktische Beispiele durch, die nach Komplexität geordnet sind. Jedes Beispiel ist ein vollständiges, ausführbares Skript. Der Kürze halber zeigen wir die Kernlogik – gehen Sie davon aus, dass der Agent wie oben initialisiert ist.

Einfache Agenten (Beispiele 1–6)

Diese Agenten demonstrieren Ein-Schritt-Aufgaben mit integrierten Werkzeugen.

**Beispiel 1: Einfache Fragenbeantwortung**

from cuga import Agent

agent = Agent(model="gpt-4o", provider="openai")
response = agent.run("Was ist die Hauptstadt von Frankreich?")
print(response)

**Beispiel 2: Mathe-Löser**

agent = Agent(model="gpt-4o", provider="openai")
response = agent.run("Berechne das Integral von x^2 von 0 bis 3.")
print(response)

**Beispiel 3: Textzusammenfasser**

agent = Agent(model="claude-3-sonnet", provider="anthropic")
text = "Langer Artikeltext hier..."
response = agent.run(f"Fasse dies in 50 Wörtern zusammen: {text}")
print(response)

**Beispiel 4: Übersetzer**

agent = Agent(model="gpt-4o", provider="openai")
response = agent.run("Übersetze 'Hallo, wie geht es dir?' ins Spanische.")
print(response)

**Beispiel 5: Code-Erklärer**

agent = Agent(model="gpt-4o", provider="openai")
code = "def fib(n): return n if n < 2 else fib(n-1) + fib(n-2)"
response = agent.run(f"Erkläre diesen Code Zeile für Zeile: {code}")
print(response)

**Beispiel 6: Stimmungsanalysator**

agent = Agent(model="claude-3-sonnet", provider="anthropic")
response = agent.run("Analysiere die Stimmung: 'Ich liebe dieses Produkt, aber die Lieferung war langsam.'")
print(response)

Werkzeugnutzende Agenten (Beispiele 7–12)

Diese Agenten verwenden CUGAs integriertes Werkzeugsystem. Wir definieren zuerst ein benutzerdefiniertes Werkzeug.

**Beispiel 7: Taschenrechner-Werkzeug**

from cuga import Tool

def calculator(expression: str) -> str:
    return str(eval(expression))

calc_tool = Tool(name="calculator", func=calculator, description="Mathematische Ausdrücke auswerten")
agent = Agent(model="gpt-4o", provider="openai", tools=[calc_tool])
response = agent.run("Was ist 345 * 678?")
print(response)

**Beispiel 8: Websuche-Werkzeug**

import requests

def web_search(query: str) -> str:
    # Vereinfachte Suche – in der Produktion eine richtige API verwenden
    return f"Ergebnisse für {query}: [Dummy]"

search_tool = Tool(name="web_search", func=web_search, description="Im Web suchen")
agent = Agent(model="gpt-4o", provider="openai", tools=[search_tool])
response = agent.run("Finde aktuelle Nachrichten über KI-Agenten.")
print(response)

**Beispiel 9: Dateileser-Werkzeug**

def read_file(path: str) -> str:
    with open(path, 'r') as f:
        return f.read()

file_tool = Tool(name="file_reader", func=read_file, description="Eine Datei von der Festplatte lesen")
agent = Agent(model="claude-3-sonnet", provider="anthropic", tools=[file_tool])
response = agent.run("Lies und fasse 'data.txt' zusammen.")
print(response)

**Beispiel 10: Python-Ausführer-Werkzeug**

def run_python(code: str) -> str:
    exec_globals = {}
    exec(code, exec_globals)
    return str(exec_globals)

python_tool = Tool(name="python_exec", func=run_python, description="Python-Code ausführen")
agent = Agent(model="gpt-4o", provider="openai", tools=[python_tool])
response = agent.run("Berechne die ersten 10 Primzahlen mit Python.")
print(response)

**Beispiel 11: Datums-/Zeit-Werkzeug**

from datetime import datetime

def current_time() -> str:
    return datetime.now().isoformat()

time_tool = Tool(name="get_time", func=current_time, description="Aktuelles Datum und Uhrzeit abrufen")
agent = Agent(model="gpt-4o", provider="openai", tools=[time_tool])
response = agent.run("Wie spät ist es aktuell in UTC?")
print(response)

**Beispiel 12: E-Mail-Sender (simuliert)**

def send_email(to: str, subject: str, body: str) -> str:
    # Senden simulieren
    return f"E-Mail gesendet an {to} mit Betreff '{subject}'"

email_tool = Tool(name="send_email", func=send_email, description="Eine E-Mail senden")
agent = Agent(model="claude-3-sonnet", provider="anthropic", tools=[email_tool])
response = agent.run("Sende eine E-Mail an test@example.com mit Betreff 'Hallo' und Inhalt 'Test'.")
print(response)

Mehrstufige Reasoning-Agenten (Beispiele 13–18)

Diese Agenten verwenden Speicher, um den Kontext über mehrere Schritte hinweg beizubehalten.

**Beispiel 13: Sequentieller Faktenprüfer**

agent = Agent(model="gpt-4o", provider="openai")
response = agent.run("Finde zuerst die Bevölkerung von Tokio. Vergleiche sie dann mit New York.")
print(response)

**Beispiel 14: Schritt-für-Schritt-Problemlöser**

agent = Agent(model="claude-3-sonnet", provider="anthropic")
response = agent.run("Löse: Ein Zug verlässt Bahnhof A mit 60 mph. Ein anderer verlässt Bahnhof B mit 80 mph. Die Bahnhöfe sind 300 Meilen voneinander entfernt. Wann treffen sie sich?")
print(response)

**Beispiel 15: Forschungsassistent**

def search_tool(query: str) -> str:
    return f"Zusammenfassung: {query}"

agent = Agent(model="gpt-4o", provider="openai", tools=[Tool(name="search", func=search_tool, description="Suche")])
response = agent.run("Erforsche die Geschichte der neuronalen Netze. Beginne mit Perzeptronen, dann Backpropagation, dann Transformer.")
print(response)

**Beispiel 16: Aufgabenplaner**

agent = Agent(model="claude-3-sonnet", provider="anthropic")
response = agent.run("Plane eine 3-tägige Reise nach Paris. Enthalte Flüge, Hotels und Sehenswürdigkeiten. Gib es als Liste aus.")
print(response)

**Beispiel 17: Code-Reviewer**

agent = Agent(model="gpt-4o", provider="openai")
code = "def add(a,b): return a+b"
response = agent.run(f"Überprüfe diesen Code auf Fehler und Stilprobleme: {code}")
print(response)

**Beispiel 18: Datenanalysator**

def analyze_data(data: str) -> str:
    return f"Mittelwert: {sum(map(float, data.split(',')))/len(data.split(','))}"

data_tool = Tool(name="analyze", func=analyze_data, description="Komma-getrennte Zahlen analysieren")
agent = Agent(model="gpt-4o", provider="openai", tools=[data_tool])
response = agent.run("Analysiere den Datensatz: 10,20,30,40,50")
print(response)

Komplexe Workflows (Beispiele 19–24)

Diese Beispiele kombinieren mehrere Agenten oder fortgeschrittene Muster.

**Beispiel 19: Agent mit bedingter Logik**

agent = Agent(model="gpt-4o", provider="openai")
response = agent.run("Wenn der Aktienmarkt heute steigt, fasse die Gewinne zusammen. Sonst schlage eine Strategie vor.")
print(response)

**Beispiel 20: Multi-Agenten-Debatte**

agent1 = Agent(model="gpt-4o", provider="openai", system_prompt="Du bist ein Befürworter der Kernenergie.")
agent2 = Agent(model="claude-3-sonnet", provider="anthropic", system_prompt="Du bist ein Umweltschützer gegen Kernenergie.")

topic = "Sollten wir mehr Kernkraftwerke bauen?"
response1 = agent1.run(topic)
response2 = agent2.run(topic)
print(f"Pro: {response1}\nContra: {response2}")

**Beispiel 21: Werkzeug-orchestrierter Agent**

def weather_api(city: str) -> str:
    return f"Wetter in {city}: 22°C, sonnig"

weather_tool = Tool(name="weather", func=weather_api, description="Wetter abrufen")
agent = Agent(model="gpt-4o", provider="openai", tools=[weather_tool, calc_tool])
response = agent.run("Hole das Wetter für New York und berechne die Differenz zu 27°C.")
print(response)

**Beispiel 22: Agent mit persistentem Speicher**

from cuga import Memory

memory = Memory()
agent = Agent(model="claude-3-sonnet", provider="anthropic", memory=memory)
agent.run("Mein Name ist Alice.")
response = agent.run("Wie ist mein Name?")
print(response)  # Sollte "Alice" abrufen

**Beispiel 23: Fehlerbehandlungs-Agent**

agent = Agent(model="gpt-4o", provider="openai")
response = agent.run("Versuche, 10 durch 0 zu teilen. Wenn ein Fehler auftritt, erkläre warum.")
print(response)

**Beispiel 24: Selbstverbessernder Agent**

agent = Agent(model="claude-3-sonnet", provider="anthropic")
response = agent.run("Schreibe ein kurzes Gedicht. Kritisiere es dann und schreibe es besser um.")
print(response)

Konfigurationstipps für die Produktion

Für den Einsatz in der Praxis sollten Sie diese Einstellungen berücksichtigen:

• **Ratenbegrenzung**: Setzen Sie `max_retries` und `timeout` im Agent-Konstruktor.
• **Protokollierung**: Aktivieren Sie CUGAs integrierte Protokollierung mit `agent.logger.setLevel("INFO")`.
• **Caching**: Verwenden Sie ein `Cache`-Objekt, um redundante API-Aufrufe für identische Abfragen zu vermeiden.

Beispiel mit Konfiguration:

from cuga import Agent, Cache

cache = Cache(ttl=3600)
agent = Agent(model="gpt-4o", provider="openai", cache=cache, max_retries=3, timeout=30)

Fazit

CUGAs leichtes Framework befähigt Entwickler, echte agentische Anwendungen mit minimalem Aufwand zu erstellen. Von einfachen Frage-Antwort-Systemen bis hin zu mehrstufigem Reasoning und Werkzeugorchestrierung demonstrieren die zwei Dutzend Beispiele, die wir behandelt haben, die Bandbreite dessen, was möglich ist. Durch die Nutzung einer vertrauten Python-Schnittstelle reduziert CUGA die Lernkurve, während es Flexibilität für fortgeschrittene Workflows beibehält. Während sich die KI-Branche – bestätigt durch Entwicklungen von OpenAI, Anthropic, Microsoft und der Open-Source-Community auf Hugging Face – in Richtung autonomerer Systeme bewegt, werden Werkzeuge wie CUGA für das Prototyping und die Produktionsbereitstellung unerlässlich sein. Beginnen Sie mit den obigen Installationsschritten, experimentieren Sie mit den Beispielen und passen Sie sie an Ihre eigenen Anwendungsfälle an. Die Ära der agentischen Apps ist da, und CUGA macht sie zugänglich.