KI Agenten erstellen: Eine Schritt-für-Schritt Anleitung

Der Aufstieg großer Sprachmodelle und flexibler KI-Tools hat den Bau maßgeschneiderter KI-Agenten zugänglicher denn je gemacht. Egal, ob Sie einen Agenten zur Automatisierung von Aufgaben, zur Unterstützung bei der Recherche, zur Verbesserung der Benutzerinteraktionen oder zur Bereitstellung neuer Dienste wünschen – der Ansatz, von Grund auf neu zu beginnen und für Ihre Bedürfnisse zu entwickeln, führt oft zu den flexibelsten und leistungsfähigsten Ergebnissen. In diesem Leitfaden führen wir Sie durch einen neunstufigen Prozess zum Aufbau eines KI-Agenten von Grund auf – von der Definition des Zwecks bis zum Aufbau einer Benutzeroberfläche oder API darum herum.

💡

Möchten Sie ein großartiges API-Testtool, das schöne API-Dokumentation generiert?

Möchten Sie eine integrierte All-in-One-Plattform für Ihr Entwicklerteam, um mit maximaler Produktivität zusammenzuarbeiten?

Apidog erfüllt all Ihre Anforderungen und ersetzt Postman zu einem wesentlich günstigeren Preis!

Schaltfläche

Schritt 1: Definieren Sie Zweck und Umfang Ihres Agenten

Bevor Sie eine einzige Zeile Code oder einen Prompt schreiben, müssen Sie klar definieren, was Ihr Agent tun soll. Das bedeutet:

Die genaue Aufgabe festlegen, die der Agent erledigen soll (z. B. „Verkaufsleads qualifizieren“, „Outreach-E-Mails entwerfen“, „Support-Tickets zusammenfassen“, „Bücher basierend auf Benutzerpräferenzen empfehlen“).
Die Zielbenutzer identifizieren – sind es interne Teammitglieder, Endkunden oder andere Agenten?
Die Lieferobjekte klären – welche Ausgabe der Agent produzieren soll (z. B. ein JSON-Objekt, ein formatierter Bericht, eine Entwurfsnachricht, eine Entscheidung usw.).

Beispiel: Angenommen, Sie möchten einen „Verkaufsassistenten“-Agenten. Sie könnten definieren, dass er: die Profildaten eines Leads als Eingabe nimmt, die öffentlichen Informationen des Leads recherchiert, die Lead-Passung bewertet und eine Entwurfs-Outreach-E-Mail ausgibt. Mit diesem klar definierten Umfang wird alles andere – von Prompts bis zum Datenfluss – einfacher zu planen.

Schritt 2: Klare Eingabe-/Ausgabeschemata festlegen

Sobald der Zweck klar ist, entwerfen Sie strukturierte Eingabe- und Ausgabeschemata, anstatt alles freiformuliert zu lassen. Dies gibt Ihrem Agenten einen stabilen „Vertrag“, ähnlich wie APIs Anforderungs- und Antwortstrukturen definieren.

Verwenden Sie Tools wie Pydantic (in Python), JSON Schema oder TypeScript-Schnittstellen, um Eingaben und Ausgaben formal zu definieren (dieser Punkt wurde auch von RDD hervorgehoben).
Definieren Sie genau, welche Felder der Agent erwartet (mit Typen, erforderlich vs. optional, Werteinschränkungen usw.).
Für Ausgaben legen Sie nicht nur die Daten fest (z. B. „email_subject“, „email_body“, „lead_score“), sondern auch Metadaten (z. B. Zeitstempel, model_version, processing_time), falls hilfreich – besonders nützlich für Logging, Debugging oder das Verketten von Agenten.

from pydantic import BaseModel, Field
from typing import Optional, List

class LeadProfile(BaseModel):
    name: str
    email: Optional[str]
    company: Optional[str]
    description: Optional[str]

class OutreachEmail(BaseModel):
    subject: str
    body: str
    lead_score: float = Field(..., ge=0, le=1)

# Example usage:
lead = LeadProfile(name="Alice Johnson", email="alice@example.com", company="Acme Corp")
print(lead.json())

Codebeispiel

Dieser Schema-first-Ansatz gewährleistet Konsistenz, erleichtert die Validierung von Ausgaben und vereinfacht die Integration mit anderen Systemen oder Benutzeroberflächen.

Schritt 3: Die Systemanweisungen schreiben

Mit einem vorhandenen Schema schreiben Sie detaillierte Rollendefinitionen und Systemanweisungen für Ihren Agenten. Im Wesentlichen sagen Sie der KI: „Du bist X. Hier sind deine Verantwortlichkeiten, Einschränkungen, dein Stil, Ton und dein Ausgabeformat.“

Verhaltensregeln definieren (z. B. „immer JSON zurückgeben, das dem Schema entspricht“, „falls Daten fehlen, mit einem Fehlerobjekt antworten“, „höflich, prägnant und professionell sein“).
Konsistente Prompting-/Anweisungs-Templates verwenden, um Variationen in den Antworten zu reduzieren. Viele Agenten profitieren von einer stabilen Struktur aus „System-Prompt + Benutzer-Prompt + Schemaerzwingung“.
Verschiedene Anweisungsstile ausprobieren – einige Agenten reagieren besser auf sehr explizite Anweisungen, andere auf flexiblere oder konversationelle.

Sie können jedes LLM verwenden, das diesen Stil unterstützt – z. B. GPT-4, Claude oder andere Modelle. Viele Entwickler betten die Systemanweisungen direkt in die Initialisierung ihres Agenten ein.

Schritt 4: Begründung & externe Aktionen ermöglichen

Ein Agent wird viel leistungsfähiger, wenn er logisch argumentieren und mit externen Systemen interagieren kann – Datenbanken, APIs, Tools, Websuche, Codeausführung usw.

Verwenden Sie Frameworks wie ReAct (Reasoning + Action) oder ähnliche Muster: Der Agent argumentiert, wählt dann eine Aktion (wie den Aufruf einer API), beobachtet das Ergebnis, argumentiert erneut und so weiter.
Stellen Sie dem Agenten Tool-Funktionen/Schnittstellen zur Verfügung, die er aufrufen kann, mit klar definierten Eingaben und Ausgaben (passend zum Schema), wie z. B. „search_web(query)“ → gibt Ergebnisse zurück; „send_email(payload)“; „query_database(params)“; usw.
Für Aufgaben wie Datenabruf, Berechnungen, Datenbankoperationen, Web Scraping, Dokumentenverarbeitung – die Verknüpfung dieser externen Aktionen macht den Agenten zu mehr als nur einem Textgenerator.

Dieser Schritt verwandelt Ihren Agenten von einem „intelligenten Textgenerator“ in einen echten „Agenten“, der handeln kann, nicht nur „antworten“.

import openai, os, json

openai.api_key = os.getenv("OPENAI_API_KEY")

SYSTEM_PROMPT = """
You are a helpful assistant. Use the available tools when needed.
Return output in JSON with keys: {action, action_input} or {final_answer}.
"""

TOOLS = {
    "search": lambda query: f"[search results for: {query}]",
    # add more tools as needed
}

def call_llm(messages):
    resp = openai.chat.completions.create(
        model="gpt-4o",
        messages=messages
    )
    return resp.choices[0].message["content"]

def agent_loop(user_input):
    messages = [{"role":"system","content":SYSTEM_PROMPT},
                {"role":"user","content":user_input}]
    while True:
        reply = call_llm(messages)
        data = json.loads(reply)
        if "action" in data:
            result = TOOLS[data["action"]](data["action_input"])
            messages.append({"role":"assistant","content":reply})
            messages.append({"role":"tool","content":result})
        elif "final_answer" in data:
            return data["final_answer"]

if __name__ == "__main__":
    answer = agent_loop("Find the population of France and compute 10% of it.")
    print(answer)

Codebeispiel

Schritt 5: Mehrere Agenten orchestrieren (falls erforderlich)

Für komplexe Workflows – zum Beispiel einen mehrstufigen Verkaufstrichter, eine Datenanalyse- + Berichterstattungspipeline oder abteilungsübergreifende Workflows – möchten Sie möglicherweise, dass mehrere Agenten zusammenarbeiten, jeder mit einer definierten Rolle.

Zum Beispiel: ein Planer-Agent entscheidet über die Schritte, ein Worker-Agent führt Aufgaben aus (z. B. Datenabruf, Berechnungen) und ein Verifier-Agent überprüft die Ergebnisse auf Qualität.
Erstellen Sie eine Koordinationslogik (Orchestrator), die Agenten Aufgaben zuweist, Aktionen sequenziert, Abhängigkeiten verwaltet und Ergebnisse aggregiert.
Verwenden Sie Frameworks oder Orchestrierungsbibliotheken oder schreiben Sie eine benutzerdefinierte Logik. Es ist oft hilfreich, diese Orchestrierung wie die „Controller“-Schicht in einer Anwendung zu behandeln – Aufgaben, Ergebnisse, Status zu übergeben und Agenten zu koordinieren.

Dies macht Ihr System modular, wartbar und fähig, komplexe oder groß angelegte Aufgaben zu bewältigen.

Schritt 6: Speicher und Kontext hinzufügen

Viele nützliche Agenten – Chat-Assistenten, Support-Bots, Forschungsagenten, persönliche Assistenten – müssen sich frühere Interaktionen oder persistentes Wissen über die Zeit hinweg merken. Ohne Speicher ist jede Interaktion zustandslos und kontextlos.

Implementieren Sie Kurzzeitgedächtnis (Konversationsverlauf, Sitzungskontext) für Aufgaben, die eine Interaktion über mehrere Runden erfordern.
Implementieren Sie Langzeitgedächtnis/Wissensbasis – speichern Sie Fakten, Benutzerpräferenzen, frühere Entscheidungen, externe Daten – oft unter Verwendung von Vektordatenbanken oder anderen Speicherlösungen.
Für den Gedächtnisabruf und die Verankerung sollten Sie die Retrieval-Augmented Generation (RAG) in Betracht ziehen: Wenn der Agent Kontext benötigt, werden relevante vergangene Daten oder Dokumente abgerufen, mit dem aktuellen Prompt eingebettet und dann generiert.

Durch das Hinzufügen von Speicher kann Ihr Agent Kontinuität, Personalisierung und ein zunehmend nützliches Verhalten bieten.

class ConversationMemory:
    def __init__(self):
        self.history = []

    def add(self, message: str):
        self.history.append(message)
        # Optional: trim if too long

    def get_context(self) -> str:
        return "\n".join(self.history)

mem = ConversationMemory()

def run_conversation(input_text):
    mem.add(f"User: {input_text}")
    # pass context to agent
    # agent generates response...
    response = "..."  # from LLM
    mem.add(f"Agent: {response}")
    return response

# Example usage
run_conversation("Hello, who are you?")
run_conversation("Remember my name is Alice.")

Codebeispiel

Schritt 7: Multimedia-Fähigkeiten integrieren

Je nach Zweck des Agenten möchten Sie möglicherweise Unterstützung für Bilder, Sprache, Video oder Datei-/Dokumentenverarbeitung hinzufügen oder auch nicht (je nachdem, welchen KI-Agenten Sie erstellen möchten, könnte dieser Schritt für andere optional sein, aber für die meisten ist er ziemlich notwendig).

Für Sprache oder Audio: integrieren Sie Spracherkennungs- / Text-to-Speech-Tools (z. B. Whisper, andere ASR/TTS-Systeme).
Für Bilder / Visuals: ermöglichen Sie die Bildgenerierung oder vision-fähige Modelle (falls erforderlich), damit der Agent Bilder analysieren oder Visuals produzieren kann.
Für die Dokumentenverarbeitung: PDFs, Word-Dokumente oder andere Datenformate parsen und den Agenten strukturierte Ausgaben lesen oder produzieren lassen.

Multimedia-Unterstützung erweitert die Palette der Aufgaben, die Ihr Agent bewältigen kann – von der Dokumentenzusammenfassung bis zur bildbasierten Analyse oder interaktiven UI-Aufgaben.

Schritt 8: Ausgabe formatieren und bereitstellen

Die Ausgabe Ihres Agenten sollte gut strukturiert, sauber und nutzbar sein – sowohl für Menschen als auch für andere Programme oder Systeme.

Verwenden Sie strukturierte Ausgabeformate (JSON, XML, typisierte Schemata), wenn die Ausgabe programmatisch konsumiert wird.
Wenn der Agent Berichte, Logs oder menschenlesbare Zusammenfassungen produziert – formatieren Sie diese klar (Markdown, HTML, PDF usw.).
Für Debugging oder Introspektion – fügen Sie Metadaten (Zeitstempel, Tool-Aufrufprotokolle, Token-Nutzung) als Teil der Ausgabe hinzu.

Dies stellt sicher, dass die Ausgaben zuverlässig, parsbar und einfacher in Benutzeroberflächen, Pipelines oder nachgeschaltete Systeme integrierbar sind.

Schritt 9: Eine Benutzeroberfläche oder API-Schicht erstellen

Ummanteln Sie Ihren KI-Agenten schließlich mit einer benutzerorientierten Oberfläche oder API, damit er von anderen genutzt werden kann – seien es interne Benutzer, Kunden oder andere Systeme.

Optionen umfassen:

Eine REST-API (testen Sie alle Ihre API-Endpunkte mit Apidog) oder einen HTTP-Endpunkt (z. B. unter Verwendung von Frameworks wie FastAPI), damit externe Anwendungen den Agenten programmatisch aufrufen können. (Weitere Codebeispiele unter Real Python)

Testing API Endpoints with Apidog — API-Endpunkte in Apidog testen

Eine einfache Chat-Benutzeroberfläche (Web oder Desktop) oder eine Kommandozeilenoberfläche für die Interaktion der Benutzer.
Einbettung in bestehende Anwendungen, Slack-Bots, Dashboards oder benutzerdefinierte Frontends.

Dieser letzte Schritt verwandelt Ihren Agenten von einem „Projekt“ in ein nutzbares Werkzeug – effektiv ein Produkt, das Mehrwert liefert.

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class AgentRequest(BaseModel):
    prompt: str

class AgentResponse(BaseModel):
    result: str

@app.post("/api/agent", response_model=AgentResponse)
def call_agent(req: AgentRequest):
    response = agent_loop(req.prompt)  # assume agent_loop is defined
    return {"result": response}

Codebeispiel

Häufig gestellte Fragen

F1. Warum strukturierte Eingabe-/Ausgabeschemata definieren, anstatt Freitext zu verwenden?
Strukturierte Schemata (über Pydantic, JSON Schema usw.) bieten Garantien – sie stellen sicher, dass der Agent erwartete Felder empfängt und vorhersagbare, maschinenlesbare Ausgaben zurückgibt. Dies reduziert die Wahrscheinlichkeit fehlerhafter Daten, vereinfacht die Validierung und macht die Integration mit anderen Systemen wesentlich robuster.

F2. Was ist ReAct und warum ist es nützlich?
ReAct steht für „Reasoning + Action“ (Argumentation + Aktion). Es ist ein Designmuster, bei dem ein Agent zwischen Denken (Argumentation) und Handeln (Aufrufen eines Tools oder Ausführen einer Aktion) wechselt, dann das Ergebnis beobachtet und bei Bedarf weiter argumentiert. Dies ermöglicht Agenten, mehrstufige Logik auszuführen, externe Tools oder APIs aufzurufen und nachfolgende Schritte auf Ergebnissen zu basieren – wodurch sie wesentlich leistungsfähiger sind als einfache Ein-Schuss-Prompt-und-Antwort-Bots.

F3. Wann sollte ich mehrere Agenten anstelle eines einzelnen Agenten verwenden?
Verwenden Sie mehrere Agenten, wenn die Aufgabe komplex ist und unterschiedliche Unteraufgaben umfasst, die von Spezialisierung profitieren – zum Beispiel Planung, Ausführung, Validierung oder verschiedene Domänen wie Datenabruf, Argumentation und Berichterstattung. Multi-Agenten-Setups verbessern Modularität, Klarheit und Robustheit. (Praxisleitfaden bei Empathy First Media)

F4. Wie verbessert der Speicher einen Agenten – und welche Art von Speicher ist am besten?
Speicher ermöglicht Kontinuität – er erlaubt Agenten, sich an frühere Interaktionen, Benutzerpräferenzen, vergangene Entscheidungen oder angesammeltes Wissen zu erinnern. Kurzzeitgedächtnis (Sitzungskontext) hilft bei Konversationen über mehrere Runden; Langzeitgedächtnis (Vektordatenbanken, Dokumentenspeicher) unterstützt den Wissensabruf, die Personalisierung und die Argumentation über die Zeit hinweg. Für viele Anwendungen ist eine Kombination ideal.

F5. Wie setze ich einen KI-Agenten sicher ein – und vermeide Endlosschleifen oder unsicheres Verhalten?
Fügen Sie vor der Bereitstellung Sicherheit und Überwachung hinzu: Begrenzen Sie die Anzahl der Argumentations- oder Tool-Aufrufschleifen pro Anfrage; implementieren Sie Logging, Fehlerbehandlung und Human-in-the-Loop-Prüfpunkte für sensible Aktionen; überwachen Sie Nutzung, Kosten und Leistung; und testen Sie Randfälle gründlich.

Fazit

Einen KI-Agenten von Grund auf neu zu erstellen, ist ein lohnendes – und zunehmend zugängliches – Unterfangen. Indem Sie einem strukturierten Prozess folgen – Zweck definieren, klare Schemata entwerfen, solide Anweisungen schreiben, Argumentation und Werkzeugnutzung ermöglichen, optional mehrere Agenten orchestrieren, Speicher und Kontext hinzufügen, Ausgaben korrekt formatieren und eine nutzbare Schnittstelle bereitstellen – können Sie leistungsstarke, zuverlässige Agenten erstellen, die auf Ihre spezifischen Bedürfnisse zugeschnitten sind.

Egal, was Sie bauen (einen Verkaufsassistenten, ein Forschungstool, einen Chatbot oder eine Automatisierungsmaschine), dieser Schritt-für-Schritt-Leitfaden gibt Ihnen die Blaupause. Mit durchdachtem Design und guter Architektur kann sich Ihr KI-Agent von einem Prototyp zu einem nützlichen, wartbaren und skalierbaren Werkzeug entwickeln.

Wenn Sie bereit sind, Ihren ersten Agenten zu bauen – wählen Sie einen einfachen Zweck, schreiben Sie dessen Schema und probieren Sie es aus. Sobald die Grundlagen funktionieren, können Sie Speicher, Tools und Schnittstellen hinzufügen und zusehen, wie Ihre Kreation zu etwas wirklich Mächtigem heranwächst.

💡

Schaltfläche