Mythos gebiert Fabel, Cursor's Composer 2.5, Agenten bauen Agenten

Mythos erzeugt Fabel, Cursors Composer 2.5, Agenten bauen Agenten

Die Landschaft der künstlichen Intelligenz verändert sich unter unseren Füßen. Was einst wie Science-Fiction wirkte – autonome Agenten, die Code schreiben, Geschichten verfassen und sogar andere Agenten bauen – ist zur praktischen Realität geworden. Dieser Artikel untersucht drei miteinander verbundene Entwicklungen, die die Art und Weise, wie Entwickler und Kreative mit KI interagieren, neu gestalten: die narrative Kraft des Mythos in KI-generiertem Storytelling, den technischen Sprung von Cursors Composer 2.5 und die Entstehung von Meta-Agenten, die andere Agenten bauen und orchestrieren können. Wir werden diese Konzepte in konkrete, umsetzbare Schritte einbetten, die Sie noch heute anwenden können.

Voraussetzungen

Bevor Sie in die praktischen Implementierungen eintauchen, stellen Sie sicher, dass Ihre Umgebung diese Mindestanforderungen erfüllt:

• **Betriebssystem**: macOS 12+ oder Ubuntu 22.04+ / Windows 11 (WSL2 empfohlen)
• **Python**: Version 3.10 oder höher
• **Node.js**: Version 18.x oder höher (für Cursor IDE)
• **Git**: Version 2.30 oder höher
• **OpenAI API-Schlüssel**: Mit Zugriff auf GPT-4 oder neuere Modelle
• **Cursor IDE**: Version 0.45 oder höher (Composer 2.5-kompatibel)
• **Hardware**: Mindestens 16 GB RAM, 50 GB freier Festplattenspeicher
• **Internet**: Stabile Verbindung für API-Aufrufe und Paket-Downloads

Schritt-für-Schritt-Installation

1. Einrichten der Python-Umgebung

Erstellen Sie zunächst eine dedizierte virtuelle Umgebung, um Abhängigkeiten zu isolieren.

# Virtuelle Umgebung erstellen und aktivieren
python3 -m venv agent-builder-env
source agent-builder-env/bin/activate

Dieser Befehl erstellt eine saubere Python-Umgebung namens `agent-builder-env` und aktiviert sie. Alle nachfolgenden Installationen werden hierin ausgeführt.

2. Installieren der Kernabhängigkeiten

Installieren Sie die Bibliotheken, die für den Bau von Agenten und die API-Interaktion benötigt werden.

# Erforderliche Pakete installieren
pip install openai langchain langchain-community chromadb pydantic

• `openai`: Offizieller Client für die OpenAI-API
• `langchain`: Framework zum Erstellen von LLM-basierten Anwendungen
• `langchain-community`: Community-Erweiterungen für LangChain
• `chromadb`: Vektordatenbank für das Agentengedächtnis
• `pydantic`: Datenvalidierung und Einstellungsverwaltung

3. Installieren der Cursor IDE mit Composer 2.5

Cursor ist ein auf VS Code basierender Code-Editor mit tiefer KI-Integration. Composer 2.5 ist die neueste Version seines Multi-File-Bearbeitungsagenten.

# Cursor herunterladen und installieren (macOS/Linux)
curl -L https://download.cursor.sh/linux/appImage/x64 -o cursor.AppImage
chmod +x cursor.AppImage
./cursor.AppImage --install

Für Windows laden Sie den Installer von der offiziellen Cursor-Website herunter und führen ihn normal aus. Starten Sie nach der Installation Cursor und melden Sie sich mit Ihrem GitHub- oder Google-Konto an.

4. Konfigurieren des API-Zugriffs

Erstellen Sie eine Konfigurationsdatei, um Ihre API-Schlüssel sicher zu speichern.

# .env-Datei für Umgebungsvariablen erstellen
touch .env
echo "OPENAI_API_KEY=ihr-api-schluessel-hier" >> .env
echo "ANTHROPIC_API_KEY=ihr-anthropic-schluessel-hier" >> .env

Ersetzen Sie `ihr-api-schluessel-hier` durch tatsächliche Schlüssel aus den OpenAI- und Anthropic-Portalen. Committen Sie diese Datei niemals in die Versionskontrolle.

Anwendungsbeispiele

Beispiel 1: Mythos erzeugt Fabel – KI-Geschichtengenerierung mit narrativer Architektur

Das Konzept „Mythos erzeugt Fabel“ bezieht sich darauf, wie grundlegende Erzählungen (Mythos) spezifischere Geschichten (Fabeln) hervorbringen. Hier ist eine Implementierung eines Systems, das kohärente Erzählketten erstellt.

Erstellen Sie eine Datei namens `mythos_to_fable.py`:

import os
from dotenv import load_dotenv
from openai import OpenAI

load_dotenv()
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

def generate_mythos(theme: str) -> str:
    """Generiert einen grundlegenden Mythos aus einem Thema."""
    response = client.chat.completions.create(
        model="gpt-4",
        messages=[
            {"role": "system", "content": "Sie sind ein Weltenbauer, der grundlegende Mythen erschafft."},
            {"role": "user", "content": f"Erstellen Sie einen kurzen Mythos über {theme}. Fügen Sie einen zentralen Konflikt und eine moralische Ambiguität hinzu."}
        ],
        temperature=0.8,
        max_tokens=500
    )
    return response.choices[0].message.content

def generate_fable(mythos: str, character: str) -> str:
    """Generiert eine aus dem Mythos abgeleitete Fabel."""
    response = client.chat.completions.create(
        model="gpt-4",
        messages=[
            {"role": "system", "content": "Sie sind ein Geschichtenerzähler, der Fabeln aus Mythen erschafft."},
            {"role": "user", "content": f"Schreiben Sie basierend auf diesem Mythos: '{mythos}' eine Fabel über {character}, die eine Lehre aus dem Mythos veranschaulicht."}
        ],
        temperature=0.7,
        max_tokens=800
    )
    return response.choices[0].message.content

# Verwendung
mythos = generate_mythos("das erste Feuer")
print("=== MYTHOS ===")
print(mythos)
print("\n=== FABEL ===")
fable = generate_fable(mythos, "ein junges Mädchen, das eine Glut findet")
print(fable)

Führen Sie es aus:

python mythos_to_fable.py

Dieses Skript zeigt, wie eine übergeordnete Erzählung (Mythos) spezifischere Geschichten (Fabeln) hervorbringen kann. Das System bewahrt thematische Konsistenz und erlaubt gleichzeitig kreative Variation.

Beispiel 2: Cursors Composer 2.5 – Multi-File-Agenten-Bearbeitung

Composer 2.5 in Cursor ermöglicht die gleichzeitige Bearbeitung mehrerer Dateien durch natürliche Sprachbefehle. Hier ist ein praktischer Workflow.

1. Öffnen Sie Cursor und erstellen Sie einen neuen Projektordner. 2. Drücken Sie `Cmd+Shift+I` (macOS) oder `Ctrl+Shift+I` (Windows/Linux), um Composer zu öffnen. 3. Geben Sie diesen Prompt ein:

Erstellen Sie eine Flask-Web-App mit diesen Dateien:
- app.py: Hauptanwendung mit zwei Routen: / und /health
- templates/index.html: eine einfache Landingpage mit einer Überschrift "Willkommen bei Mythos"
- static/style.css: minimales Styling mit einem dunklen Thema
- requirements.txt: Flask, python-dotenv

Composer 2.5 generiert alle vier Dateien gleichzeitig unter Berücksichtigung von Abhängigkeiten und Konventionen. Sie können dann mit Folge-Prompts verfeinern, wie zum Beispiel:

Füge app.py eine Fehlerbehandlung hinzu und verbessere index.html mit einem Hero-Bereich.

Der Agent verfolgt Änderungen über Dateien hinweg und bewahrt die Konsistenz.

Beispiel 3: Agenten bauen Agenten – Ein Meta-Agenten-Framework

Dieses Beispiel baut einen Agenten, der spezialisierte Unteragenten erstellen und bereitstellen kann. Erstellen Sie `agent_factory.py`:

import os
from langchain.agents import Tool, AgentExecutor, LLMSingleActionAgent
from langchain.llms import OpenAI
from langchain.memory import ConversationBufferMemory
from langchain.chains import LLMChain
from langchain.prompts import StringPromptTemplate
from typing import List, Dict
import json

class AgentBlueprint:
    """Vorlage zum Erstellen neuer Agenten."""
    def __init__(self, name: str, purpose: str, tools: List[str]):
        self.name = name
        self.purpose = purpose
        self.tools = tools
        
    def to_dict(self) -> Dict:
        return {
            "name": self.name,
            "purpose": self.purpose,
            "tools": self.tools
        }

class MetaAgent:
    """Ein Agent, der andere Agenten entwirft und bereitstellt."""
    def __init__(self, api_key: str):
        self.llm = OpenAI(api_key=api_key, temperature=0.7)
        self.memory = ConversationBufferMemory()
        self.blueprint_history = []
        
    def design_agent(self, task_description: str) -> AgentBlueprint:
        """Entwirft einen neuen Agenten-Bauplan basierend auf einer Aufgabe."""
        prompt = f"""
        Sie sind ein leitender KI-Architekt. Gegeben diese Aufgabe: '{task_description}'
        Entwerfen Sie einen spezialisierten Agenten mit:
        1. Einem beschreibenden Namen (keine Leerzeichen)
        2. Einer klaren Zweckbeschreibung
        3. Erforderlichen Werkzeugen aus: [web_search, code_execution, data_analysis, file_management, api_caller]
        
        Geben Sie JSON-Format zurück: {{"name": "...", "purpose": "...", "tools": [...]}}
        """
        response = self.llm(prompt)
        try:
            blueprint_data = json.loads(response)
            blueprint = AgentBlueprint(
                name=blueprint_data["name"],
                purpose=blueprint_data["purpose"],
                tools=blueprint_data["tools"]
            )
            self.blueprint_history.append(blueprint)
            return blueprint
        except:
            # Fallback-Bauplan
            return AgentBlueprint("default_agent", "Allzweck-Agent", ["web_search"])
    
    def deploy_agent(self, blueprint: AgentBlueprint) -> str:
        """Generiert ausführbaren Code für den entworfenen Agenten."""
        tools_config = ", ".join(blueprint.tools)
        code = f"""
import os
from langchain.agents import Tool, AgentExecutor
from langchain.llms import OpenAI

# Agent: {blueprint.name}
# Zweck: {blueprint.purpose}

class {blueprint.name}:
    def __init__(self):
        self.tools = [{tools_config}]
        self.llm = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
    
    def run(self, task: str) -> str:
        # Agentenlogik hier
        return f"Führe Aufgabe aus: {{task}} mit Werkzeugen: {{self.tools}}"

if __name__ == "__main__":
    agent = {blueprint.name}()
    print(agent.run("Beispielaufgabe"))
"""
        # Agenten-Code in Datei speichern
        filename = f"{blueprint.name}.py"
        with open(filename, "w") as f:
            f.write(code)
        return filename

# Verwendung
meta = MetaAgent(api_key=os.getenv("OPENAI_API_KEY"))
blueprint = meta.design_agent("Erstelle einen Recherche-Agenten, der die neuesten KI-Papiere findet")
print(f"Entworfener Agent: {blueprint.name}")
filename = meta.deploy_agent(blueprint)
print(f"Agenten-Code gespeichert unter: {filename}")

Führen Sie den Meta-Agenten aus:

python agent_factory.py

Dies erstellt eine neue Python-Datei mit einer funktionalen Agentenklasse. Der Meta-Agent kann dann erweitert werden, um mehrere Unteragenten zu testen, zu iterieren und zu verbinden.

Beispiel 4: Orchestrieren mehrerer Agenten

Bauen Sie auf dem vorherigen Beispiel auf, um einen Agenten zu erstellen, der Unteragenten koordiniert. Erstellen Sie `orchestrator.py`:

import asyncio
from agent_factory import MetaAgent, AgentBlueprint

class AgentOrchestrator:
    """Koordiniert mehrere spezialisierte Agenten, um komplexe Aufgaben zu erledigen."""
    
    def __init__(self, meta_agent: MetaAgent):
        self.meta = meta_agent
        self.agents = {}
        
    async def build_team(self, tasks: List[str]):
        """Baut ein Team von Agenten für gegebene Aufgaben."""
        for task in tasks:
            blueprint = self.meta.design_agent(task)
            self.agents[blueprint.name] = blueprint
            print(f"Agent hinzugefügt: {blueprint.name} für '{blueprint.purpose}'")
    
    async def assign_work(self, main_task: str) -> Dict[str, str]:
        """Zerlegt die Hauptaufgabe und weist sie Unteragenten zu."""
        results = {}
        for agent_name, blueprint in self.agents.items():
            # Simuliere Agentenausführung
            results[agent_name] = f"Abgeschlossen: {blueprint.purpose}"
        return results

async def main():
    meta = MetaAgent(api_key=os.getenv("OPENAI_API_KEY"))
    orchestrator = AgentOrchestrator(meta)
    
    tasks = [
        "Recherchiere die neuesten GPT-4-Fähigkeiten",
        "Analysiere technische Dokumentation für API-Änderungen",
        "Generiere einen Zusammenfassungsbericht in Markdown"
    ]
    
    await orchestrator.build_team(tasks)
    results = await orchestrator.assign_work("Schreibe einen Blogbeitrag über KI-Updates")
    
    for agent, result in results.items():
        print(f"{agent}: {result}")

if __name__ == "__main__":
    asyncio.run(main())

Ausführen:

python orchestrator.py

Dies demonstriert, wie Agenten dynamisch erstellt und koordiniert werden können, was das Paradigma „Agenten bauen Agenten“ widerspiegelt.

Praktische Überlegungen

1. Verwaltung der API-Kosten

Jeder API-Aufruf verursacht Kosten. Implementieren Sie Caching und Ratenbegrenzung:

import hashlib
import json
from functools import lru_cache

@lru_cache(maxsize=100)
def cached_llm_call(prompt: str) -> str:
    """Cachet LLM-Antworten, um API-Aufrufe zu reduzieren."""
    # Tatsächlicher API-Aufruf hier
    return response

2. Fehlerbehandlung in Agenten-Pipelines

Agenten können fehlschlagen. Implementieren Sie robuste Fehlerbehandlung:

def safe_agent_call(agent_func, task: str, retries: int = 3):
    for attempt in range(retries):
        try:
            return agent_func(task)
        except Exception as e:
            print(f"Versuch {attempt+1} fehlgeschlagen: {e}")
            time.sleep(2 ** attempt)  # Exponentielles Backoff
    raise Exception("Alle Wiederholungen ausgeschöpft")

3. Versionskontrolle für Agenten-Baupläne

Verfolgen Sie Agentenentwürfe mit Git:

git init
git add *.py
git commit -m "Erste Agenten-Baupläne"

Dies ermöglicht Rollbacks und Zusammenarbeit an Agentenentwürfen.

Fazit

Die Konvergenz von mythosgetriebener Narrativgenerierung, Cursors Composer 2.5 Multi-File-Bearbeitung und Meta-Agenten-Architekturen markiert eine neue Ära in der KI-Entwicklung. Wir haben uns von Einzweckmodellen zu Systemen entwickelt, die andere KI-Komponenten autonom erstellen, orchestrieren und verfeinern können.

Die hier skizzierten praktischen Schritte – vom Einrichten von Umgebungen bis zum Bau von Meta-Agenten, die Unteragenten entwerfen – bieten eine Grundlage für jeden, der an dieser Transformation teilhaben möchte. Die entscheidende Erkenntnis ist, dass diese Werkzeuge keine inkrementellen Verbesserungen sind; sie repräsentieren einen Wandel in der Art und Weise, wie wir über KI-Entwicklung denken. Anstatt monolithische Lösungen zu bauen, setzen wir sie jetzt aus spezialisierten, selbstorganisierenden Komponenten zusammen.

Während Sie mit diesen Beispielen experimentieren, werden Sie entdecken, dass die wahre Stärke nicht in einer einzelnen Technik liegt, sondern in ihrer Kombination: Mythos bietet narrative Kohärenz, Composer 2.5 ermöglicht schnelle Iterationen und Meta-Agenten schaffen skalierbare Intelligenz. Die Zukunft der KI besteht nicht aus größeren Modellen, sondern aus intelligenteren Systemen, die sich selbst bauen können. Fangen Sie klein an, aber denken Sie groß – die Agenten, die Sie heute bauen, werden die Architekten von morgen sein.