Leitfaden zum Verständnis, Aufbau und Optimieren von API-aufrufenden Agenten To-Do-Liste-API version: 1.0.0 paths: /aufgaben: post: zusammenfassung: Eine neue Aufgabe hinzufügen anforderungskörper: erforderlich: wahr inhalt: anwendung/json: schema: typ: objekt eigenschaften: beschreibung: typ: zeichenfolge antworten: ‘201’: beschreibung: Aufgabe erfolgreich erstellt Schritt 2: Standardisieren Sie den Tool-Zugriff Konvertieren Sie die OpenAPI-Spezifikation in Model Context Protocol (MCP)-Konfigurationen. Mit einem Tool wie Stainless.ai könnte dies Folgendes ergeben: Tool-Name Beschreibung Eingabeparameter Ausgabebeschreibung Aufgabe hinzufügen Fügt eine neue Aufgabe zur To-Do-Liste hinzu. `beschreibung` (Zeichenfolge, erforderlich): Die Beschreibung der Aufgabe. Bestätigung der Aufgabeerstellung. Aufgaben abrufen Ruft alle Aufgaben aus der To-Do-Liste ab. Keine Eine Liste von Aufgaben mit ihren Beschreibungen. Schritt 3: Implementieren Sie den Agenten Verwenden Sie Pydantic für die Datenmodellierung und erstellen Sie Funktionen, die den MCP-Tools entsprechen. Verwenden Sie dann ein LLM, um natürliche Sprachabfragen zu interpretieren und das geeignete Tool und die Parameter auszuwählen. Schritt 4: Kuratieren Sie einen qualitativ hochwertigen Evaluierungsdatensatz Erstellen Sie einen Datensatz: Abfrage Erwarteter API-Aufruf Erwartetes Ergebnis “Fügen Sie ‘Einkaufen’ meiner Liste hinzu.” `Aufgabe hinzufügen` mit `beschreibung` = “Einkaufen” Bestätigung der Aufgabeerstellung “Was ist auf meiner Liste?” `Aufgaben abrufen` Liste von Aufgaben, einschließlich “Einkaufen” Schritt 5: Optimieren Sie Agenten-Prompts und -Logik Verwenden Sie DSPy, um die Prompts zu verfeinern, wobei Sie klare Anweisungen, Tool-Auswahl und Parameter-Extraktion mithilfe des kuratierten Datensatzes für die Bewertung und Verbesserung konzentrieren. Durch die Integration dieser Bausteine – von strukturierten API-Definitionen und standardisierten Tool-Protokollen bis hin zu strengen Datenpraktiken und systematischer Optimierung – können Ingenieursteams leistungsfähigere, zuverlässigere und wartbare API-aufrufende künstliche Intelligenz-Agenten bauen.

Die Rolle von künstlicher Intelligenz in Technologieunternehmen entwickelt sich rasch; die Anwendungsfälle von künstlicher Intelligenz haben sich von der passiven Informationsverarbeitung zu proaktiven Agenten entwickelt, die Aufgaben ausführen können. Laut einer Umfrage von Georgian und NewtonX aus März 2025 nutzen oder planen 91 % der technischen Führungskräfte in Wachstums- und Unternehmensunternehmen den Einsatz von agentenbasierter künstlicher Intelligenz.

API-aufrufende Agenten sind ein primäres Beispiel für diesen Wechsel zu Agenten. API-aufrufende Agenten nutzen Large Language Models (LLMs), um über ihre Application Programming Interfaces (APIs) mit Softwaresystemen zu interagieren.

Zum Beispiel können Agenten durch die Übersetzung von natürlichen Sprachbefehlen in präzise API-Aufrufe Echtzeitdaten abrufen, Routineaufgaben automatisieren oder sogar andere Softwaresysteme steuern. Diese Fähigkeit verwandelt künstliche Intelligenz-Agenten in nützliche Vermittler zwischen menschlicher Absicht und Softwaresystemen.

Unternehmen nutzen derzeit API-aufrufende Agenten in verschiedenen Bereichen, einschließlich:

• Consumer-Anwendungen: Assistenten wie Apples Siri oder Amazons Alexa sind dafür entwickelt worden, tägliche Aufgaben zu vereinfachen, wie z.B. die Steuerung von Smart-Home-Geräten und das Buchen von Reservierungen.
• Unternehmensworkflows: Unternehmen haben API-Agenten bereitgestellt, um wiederkehrende Aufgaben wie das Abrufen von Daten aus CRM-Systemen, das Erstellen von Berichten oder das Konsolidieren von Informationen aus internen Systemen zu automatisieren.
• Datenabruf und -analyse: Unternehmen nutzen API-Agenten, um den Zugriff auf proprietäre Datensätze, abonnementbasierte Ressourcen und öffentliche APIs zu vereinfachen, um so Erkenntnisse zu gewinnen.

In diesem Artikel werde ich einen ingenieurzentrierten Ansatz zum Verständnis, Aufbau und Optimieren von API-aufrufenden Agenten verwenden. Der Inhalt dieses Artikels basiert teilweise auf der praktischen Forschung und Entwicklung, die von Georgian’s AI Lab durchgeführt wurde. Die motivierende Frage für viel von der Forschung des AI Lab im Bereich von API-aufrufenden Agenten war: “Wenn eine Organisation eine API hat, was ist der effektivste Weg, einen Agenten zu bauen, der mit dieser API über natürliche Sprache kommunizieren kann?”

Ich werde erklären, wie API-aufrufende Agenten funktionieren und wie man diese Agenten erfolgreich architektiert und entwickelt, um ihre Leistung zu verbessern. Schließlich werde ich einen systematischen Workflow bereitstellen, den Ingenieursteams verwenden können, um API-aufrufende Agenten zu implementieren.

I. Schlüsseldefinitionen:

• API oder Application Programming Interface: Eine Menge von Regeln und Protokollen, die es verschiedenen Softwaresystemen ermöglichen, miteinander zu kommunizieren und Informationen auszutauschen.
• Agent: Ein künstliches Intelligenzsystem, das so konzipiert ist, dass es seine Umgebung wahrnimmt, Entscheidungen trifft und Aktionen ausführt, um bestimmte Ziele zu erreichen.
• API-aufrufender Agent: Ein spezialisierter künstlicher Intelligenzagent, der natürliche Sprachanweisungen in präzise API-Aufrufe übersetzt.
• Code-Generierender Agent: Ein künstliches Intelligenzsystem, das bei der Softwareentwicklung hilft, indem es Code schreibt, modifiziert und debuggt. Obwohl dies damit verwandt ist, liegt mein Fokus hier hauptsächlich auf Agenten, die APIs aufrufen, obwohl künstliche Intelligenz auch helfen kann, diese Agenten zu bauen.
• MCP (Model Context Protocol): Ein Protokoll, das insbesondere von Anthropic entwickelt wurde, das definiert, wie LLMs mit externen Tools und Datenquellen verbinden und diese nutzen können.

II. Kernaufgabe: Übersetzung von natürlicher Sprache in API-Aktionen

Die grundlegende Funktion eines API-aufrufenden Agents besteht darin, eine natürliche Sprachanfrage des Benutzers zu interpretieren und sie in einen oder mehrere präzise API-Aufrufe umzuwandeln. Dieser Prozess umfasst typischerweise:

1. Intent-Erkennung: Verständnis des Ziels des Benutzers, auch wenn es mehrdeutig ausgedrückt wird.
2. Tool-Auswahl: Identifizierung des geeigneten API-Endpunkts (oder “Tools”) aus einer Menge verfügbarer Optionen, die das Intent erfüllen kann.
3. Parameter-Extraktion: Identifizierung und Extraktion der notwendigen Parameter für die ausgewählten API-Aufrufe aus der Benutzeranfrage.
4. Ausführung und Antwortgenerierung: Ausführen des API-Aufrufs, Empfangen der Antwort und Synthese dieser Informationen in eine kohärente Antwort oder Ausführung einer nachfolgenden Aktion.

Betrachten Sie eine Anfrage wie “Hey Siri, wie ist das Wetter heute?” Der Agent muss die Notwendigkeit erkennen, einen Wetter-API-Aufruf durchzuführen, den aktuellen Standort des Benutzers bestimmen (oder die Angabe eines Standorts zulassen) und dann den API-Aufruf formulieren, um die Wetterinformationen abzurufen.

Für die Anfrage “Hey Siri, wie ist das Wetter heute?” könnte ein Beispiel-API-Aufruf wie folgt aussehen:

GET /v1/wetter?ort=New%20York&einheiten=metrisch

Anfängliche Herausforderungen auf hohem Niveau sind in diesem Übersetzungsprozess inhärent, einschließlich der Mehrdeutigkeit der natürlichen Sprache und der Notwendigkeit für den Agenten, den Kontext über mehrstufige Interaktionen hinweg beizubehalten.

Zum Beispiel muss der Agent oft “merken”, was in früheren Teilen einer Konversation oder in früheren API-Aufruf-Ergebnissen besprochen wurde, um aktuelle Aktionen zu informieren. Kontextverlust ist ein häufiger Fehlermodus, wenn er nicht explizit gemanagt wird.

III. Architektur der Lösung: Schlüsselkomponenten und Protokolle

Der Bau effektiver API-aufrufender Agenten erfordert einen strukturierten architektonischen Ansatz.

1. Definition von “Tools” für den Agenten

Damit ein LLM eine API nutzen kann, müssen die Fähigkeiten dieser API in einer Weise beschrieben werden, die das LLM verstehen kann. Jeder API-Endpunkt oder jede Funktion wird oft als “Tool” dargestellt. Eine robuste Tool-Definition umfasst:

• Eine klare, natürliche Sprachbeschreibung des Zwecks und der Funktionalität des Tools.
• Eine präzise Spezifikation seiner Eingabeparameter (Name, Typ, ob es erforderlich oder optional ist und eine Beschreibung).
• Eine Beschreibung der Ausgabe oder der Daten, die das Tool zurückgibt.

2. Die Rolle des Model Context Protocol (MCP)

MCP ist ein wichtiger Enabler für eine standardisierte und robuste Tool-Nutzung durch LLMs. Es bietet ein strukturiertes Format für die Definition, wie Modelle mit externen Tools und Datenquellen verbinden können.

Die Standardisierung von MCP ist vorteilhaft, da sie eine einfachere Integration vielfältiger Tools ermöglicht, die Wiederverwendbarkeit von Tool-Definitionen über verschiedene Agenten oder Modelle fördert. Darüber hinaus ist es eine bewährte Methode für Ingenieursteams, die mit gut definierten API-Spezifikationen beginnen, wie z.B. einer OpenAPI-Spezifikation. Tools wie Stainless.ai sind dazu gedacht, diese OpenAPI-Spezifikationen in MCP-Konfigurationen umzuwandeln, wodurch der Prozess des “Agenten-Ready”-Machens von APIs vereinfacht wird.

3. Agenten-Frameworks und Implementierungswahl

Es gibt mehrere Frameworks, die beim Bau des Agenten selbst helfen können. Dazu gehören:

• Pydantic: Obwohl es nicht ausschließlich ein Agenten-Framework ist, ist Pydantic nützlich für die Definition von Datenstrukturen und die Gewährleistung von Typsicherheit für Tool-Eingaben und -Ausgaben, was für die Zuverlässigkeit wichtig ist. Viele benutzerdefinierte Agenten-Implementierungen nutzen Pydantic für diese strukturelle Integrität.
• LastMiles mcp_agent: Dieses Framework ist speziell dafür entwickelt worden, mit MCPs zu arbeiten und bietet eine mehr strukturierte Struktur, die mit bewährten Methoden für den Bau effektiver Agenten übereinstimmt, wie sie in Forschungseinrichtungen wie Anthropic beschrieben werden.
• Internes Framework: Es ist auch zunehmend üblich, AI-Code-Generierungsagenten (mit Tools wie Cursor oder Cline) zu verwenden, um den Boilerplate-Code für den Agenten, seine Tools und die umgebende Logik zu schreiben. Die Erfahrung von Georgian’s AI Lab bei der Arbeit mit Unternehmen bei der Implementierung von agenterbasierter künstlicher Intelligenz zeigt, dass dies großartig sein kann, um sehr minimalistische, benutzerdefinierte Frameworks zu erstellen.

IV. Ingenieurwesen für Zuverlässigkeit und Leistung

Die Gewährleistung, dass ein Agent API-Aufrufe zuverlässig durchführt und gut performt, erfordert einen gezielten Ingenieursaufwand. Zwei Möglichkeiten, dies zu tun, sind (1) Datensatz-Erstellung und -Validierung und (2) Prompt-Engineering und -Optimierung.

1. Datensatz-Erstellung und -Validierung

Das Training (falls zutreffend), Testen und Optimieren eines Agenten erfordert einen hochwertigen Datensatz. Dieser Datensatz sollte repräsentative natürliche Sprachabfragen und die entsprechenden gewünschten API-Aufrufsequenzen oder -ergebnisse enthalten.

• Manuelle Erstellung: Die manuelle Kuratierung eines Datensatzes gewährleistet hohe Präzision und Relevanz, kann aber arbeitsintensiv sein.
• Synthetische Generierung: Die programmatische Generierung von Daten oder die Verwendung von LLMs kann die Datensatzerstellung skalieren, stellt aber erhebliche Herausforderungen dar. Die Forschung von Georgian AI Lab hat ergeben, dass die Gewährleistung der Richtigkeit und realistischen Komplexität von synthetisch generierten API-Aufrufen und -Abfragen sehr schwierig ist. Oft sind die generierten Fragen entweder zu trivial oder unmöglich komplex, was es schwierig macht, die nuancierte Leistung des Agenten zu messen. Eine sorgfältige Validierung von synthetischen Daten ist absolut kritisch.

Für eine kritische Bewertung bietet ein kleiner, hochwertiger, manuell verifizierter Datensatz oft zuverlässigere Einblicke als ein großer, verrauschter synthetischer Datensatz.

2. Prompt-Engineering und -Optimierung

Die Leistung eines LLM-basierten Agenten wird stark von den Prompts beeinflusst, die seine Argumentation und Tool-Auswahl leiten.

• Effektives Prompting beinhaltet die klare Definition der Aufgabe des Agenten, die Bereitstellung von Beschreibungen verfügbarer Tools und die Strukturierung des Prompts, um eine genaue Parameter-Extraktion zu fördern.
• Systematische Optimierung mithilfe von Frameworks wie DSPy kann die Leistung erheblich verbessern. DSPy ermöglicht es Ihnen, die Komponenten des Agenten zu definieren (z.B. Module für die Argumentationsgenerierung, Tool-Auswahl, Parameter-Formatierung) und dann mithilfe von Few-Shot-Beispielen aus Ihrem Datensatz eine optimierte Prompt- oder Konfigurationsfindung für diese Komponenten durchzuführen.

V. Ein empfohlener Weg zu effektiven API-Agenten

Die Entwicklung robuster API-aufrufender künstlicher Intelligenz-Agenten ist eine iterative Ingenieurdisziplin. Basierend auf den Ergebnissen der Forschung von Georgian AI Lab kann die Ergebnisqualität durch einen systematischen Workflow wie den folgenden verbessert werden:

1. Beginnen Sie mit klaren API-Definitionen: Beginnen Sie mit gut strukturierten OpenAPI-Spezifikationen für die APIs, mit denen Ihr Agent interagieren wird.
2. Standardisieren Sie den Tool-Zugriff: Konvertieren Sie Ihre OpenAPI-Spezifikationen in MCP. Tools wie Stainless.ai können diesen Prozess erleichtern und eine standardisierte Möglichkeit schaffen, wie Ihr Agent APIs “versteht” und nutzt.
3. Implementieren Sie den Agenten: Wählen Sie ein geeignetes Framework oder einen Ansatz. Dies kann die Verwendung von Pydantic für die Datenmodellierung innerhalb einer benutzerdefinierten Agentenstruktur oder die Nutzung eines Frameworks wie LastMiles mcp_agent umfassen, das speziell für den Einsatz mit MCPs entwickelt wurde.
   • Bevor Sie dies tun, sollten Sie in Betracht ziehen, MCP mit einem Tool wie Claude Desktop oder Cline zu verbinden und diese Schnittstelle manuell zu verwenden, um ein Gefühl dafür zu bekommen, wie gut ein generischer Agent es nutzen kann, wie viele Iterationen es normalerweise benötigt, um MCP korrekt zu verwenden, und andere Details, die Ihnen während der Implementierung Zeit sparen könnten.
4. Kuratieren Sie einen qualitativ hochwertigen Evaluierungsdatensatz: Erstellen oder validieren Sie sorgfältig einen Datensatz von Abfragen und erwarteten API-Interaktionen. Dies ist für zuverlässiges Testen und Optimieren unerlässlich.
5. Optimieren Sie Agenten-Prompts und -Logik: Nutzen Sie Frameworks wie DSPy, um die Prompts und die interne Logik Ihres Agenten zu verfeinern, indem Sie Ihren Datensatz zur Steuerung von Verbesserungen in Genauigkeit und Zuverlässigkeit verwenden.

VI. Ein illustrierendes Beispiel des Workflows

Hier ist ein vereinfachtes Beispiel, das den empfohlenen Workflow zum Aufbau eines API-aufrufenden Agenten veranschaulicht:

Schritt 1: Beginnen Sie mit klaren API-Definitionen

Stellen Sie sich eine API zum Verwalten einer einfachen To-Do-Liste vor, definiert in OpenAPI:

openapi: 3.0.0

info: