Zum Inhalt springen
TokIQ
Agenten

LLM Tool Calling erklärt: Function Calling und KI-Agents

Wie LLM Tool Calling funktioniert, wie du Tool-Beschreibungen richtig schreibst, wie Agent-Schleifen laufen und enden und welche Fehler du einplanst.

TokIQ Editorial5 Min. Lesezeit
In diesem Artikel
  1. Wie sieht eine Tool-Definition aus?
  2. Wie schreibst du Tool-Beschreibungen, die das Modell richtig nutzt?
  3. Wie funktioniert eine Agent-Schleife?
  4. Wie soll ein Agent entscheiden, wann er aufhört?
  5. Was sind die häufigsten Fehler von Agents?
  6. Und die Sicherheit?
  7. Brauchst du überhaupt einen Agent?
  8. Wo passt MCP hinein?

Tool Calling (oder Function Calling) lässt ein Sprachmodell deine Anwendung bitten, eine Funktion auszuführen: Du beschreibst die verfügbaren Tools mit Namen, Beschreibungen und Parameter-Schemas, das Modell antwortet mit einem strukturierten Aufruf wie get_order_status(order_id="A-1042"), dein Code führt ihn aus, und das Ergebnis geht zurück an das Modell. Ein Agent ist derselbe Mechanismus in einer Schleife, in der das Modell weiter Tools wählt und Ergebnisse liest, bis es entscheidet, dass die Aufgabe erledigt ist.

Das Modell führt nie selbst etwas aus. Es erzeugt Text, der zufällig eine wohlgeformte Anfrage ist. Behalte das im Kopf, dann werden die meisten Designentscheidungen zu Agents klarer, vor allem die zur Sicherheit.

Wie sieht eine Tool-Definition aus?

Bei OpenAI, Anthropic und Google unterscheiden sich die Anfrageformate leicht, aber jede Tool-Definition hat dieselben drei Teile: einen Namen, eine Beschreibung in natürlicher Sprache und ein JSON Schema für die Parameter.

Eine schwache Definition:

{
  "name": "search",
  "description": "Sucht nach Zeug.",
  "parameters": {
    "type": "object",
    "properties": { "q": { "type": "string" } }
  }
}

Eine bessere:

{
  "name": "search_help_center",
  "description": "Volltextsuche über die öffentlichen Hilfeartikel der Ledgerly-App. Nutze sie, wenn der Nutzer fragt, wie eine Funktion funktioniert oder wie man ein Problem behebt. Durchsucht nicht die eigenen Kontodaten des Nutzers; dafür gibt es get_account_summary. Gibt bis zu 5 Artikel mit Titel, URL und kurzem Auszug zurück.",
  "parameters": {
    "type": "object",
    "properties": {
      "query": {
        "type": "string",
        "description": "Eine kurze Suchphrase auf Englisch, z. B. 'export invoices to CSV'. Formuliere die Frage des Nutzers in Stichwörter um, statt sie wörtlich zu übergeben."
      }
    },
    "required": ["query"]
  }
}

Die Beschreibung ist ein Prompt. Das Modell liest sie, um zu entscheiden, wann es das Tool nutzt, was es übergibt und was es zurückerwartet. Die Dokumentation von Anthropic zu Tool Use betont ausführliche Beschreibungen als wichtigsten Faktor für die Leistung von Tools, und das deckt sich mit der Praxis.

Wie schreibst du Tool-Beschreibungen, die das Modell richtig nutzt?

Beantworte die Fragen, die ein neuer Entwickler stellen würde, bevor er eine unbekannte API aufruft:

  • Was tut es, und was tut es nicht? „Durchsucht nicht die Kontodaten des Nutzers“ verhindert eine ganze Klasse falscher Aufrufe.
  • Wann soll es statt eines ähnlichen Tools genutzt werden? Sich überschneidende Tools sind die häufigste Ursache für falsche Tool-Auswahl. Könnten zwei Tools eine Anfrage plausibel bearbeiten, sag, welches Vorrang hat.
  • Was bedeuten die Parameter, mit Beispielen? Formate (ISO-Datum, Cent vs. Dollar, IDs mit oder ohne Präfix) und ein Beispielwert für alles Mehrdeutige.
  • Was gibt es zurück? Auch, was ein leeres Ergebnis bedeutet.
  • Hat es Nebenwirkungen? „Sendet die E-Mail sofort; kann nicht rückgängig gemacht werden“ verändert, wie sich ein sorgfältiges Modell verhält, und sollte verändern, wie deine App den Aufruf absichert.

Benenne Tools so, dass sie nebeneinander klar lesbar sind: search_help_center, get_account_summary, create_support_ticket. Vermeide allgemeine Namen wie search oder run, die Missbrauch einladen.

Gib auch nützliche Fehler zurück. Schlägt ein Aufruf fehl, lässt ein Tool-Ergebnis wie "error": "order_id must look like A-1234; got 1234" das Modell im nächsten Schritt seinen eigenen Aufruf korrigieren. Ein nacktes 500 tut das nicht.

Wie funktioniert eine Agent-Schleife?

Die Grundschleife, die die meisten Agent-Frameworks mit Variationen umsetzen:

  1. Schick dem Modell die Unterhaltung, den System-Prompt und die Tool-Definitionen.
  2. Antwortet das Modell nur mit Text, ist die Runde zu Ende.
  3. Antwortet es mit einem oder mehreren Tool-Aufrufen, validiert und führt dein Code sie aus.
  4. Hänge die Ergebnisse als Tool-Ergebnisse an die Unterhaltung an.
  5. Geh zurück zu Schritt 1.

Dieses Muster, bei dem Überlegung mit Aktionen und Beobachtungen abwechselt, wurde im ReAct-Paper (Yao et al., 2022) beschrieben und ist das Rückgrat der meisten seither gebauten Agents. Moderne APIs unterstützen es nativ, auch mehrere Tool-Aufrufe in einer einzigen Runde.

Die Schleife ist einfach. Sie zum gewünschten Verhalten zu bringen, ist die eigentliche Arbeit.

Wie soll ein Agent entscheiden, wann er aufhört?

Es gibt zwei Arten von Abbruchbedingungen, und du brauchst beide.

Auf Aufgabenebene, im Prompt. Sag dem Agent, was „fertig“ bedeutet:

Du bist fertig, wenn die Frage des Nutzers beantwortet ist oder du
festgestellt hast, dass sie mit den verfügbaren Tools nicht beantwortet
werden kann.
Hast du nach zwei Suchen keine relevanten Artikel gefunden, höre auf zu
suchen und sage dem Nutzer, was du versucht hast.
Stelle dem Nutzer eine Rückfrage, statt zu raten, wenn sich die Anfrage
auf mehr als ein Konto oder eine Rechnung beziehen könnte.

Ohne solche Hinweise neigen Agents dazu, entweder zu früh aufzuhören (aus eigenem Wissen zu antworten, ohne zu suchen) oder weiterzumachen (mit leichten Abwandlungen erneut zu suchen, in der Hoffnung auf ein besseres Ergebnis).

Harte Limits, im Code. Eine maximale Zahl von Iterationen, ein Token- oder Kostenbudget und ein Timeout in Echtzeit. Ist ein Limit erreicht, beende sauber: gib zurück, was bisher gefunden wurde, und sag, dass die Aufgabe nicht abgeschlossen wurde. Verlass dich nie allein auf das Modell, um eine Schleife zu stoppen, die Geld kostet.

Was sind die häufigsten Fehler von Agents?

Falsche Tool-Auswahl. Meist verursacht durch sich überschneidende Tools oder vage Beschreibungen. Verbessere zuerst die Beschreibungen; reicht das nicht, verringere die Zahl der Tools, die für diese Aufgabe verfügbar sind.

Halluzinierte Argumente. Das Modell erfindet eine Bestell-ID, weil der Nutzer „meine letzte Bestellung“ gesagt hat. Weise es an, IDs mit einem Tool nachzuschlagen oder den Nutzer zu fragen, und validiere Argumente im Code, bevor du ausführst.

Endlosschleifen. Der Agent wiederholt einen fehlschlagenden Aufruf mit winzigen Abwandlungen. Erkenne in deiner Schleife wiederholte identische oder fast identische Aufrufe und brich ab, und mach Tool-Fehler aussagekräftig genug, damit sie sich beheben lassen.

Voreiliger Erfolg. Der Agent meldet „Fertig, ich habe den Datensatz aktualisiert“, obwohl der Update-Aufruf tatsächlich fehlgeschlagen ist. Mach Tool-Ergebnisse bei Erfolg oder Misserfolg eindeutig, und prüfe bei wichtigen Aufgaben das Ergebnis mit einem eigenen Lese-Aufruf.

Aufgeblähter Kontext. Tool-Ergebnisse können riesig sein (eine ganze Webseite, eine Abfrage mit 2.000 Zeilen). Lange Schleifen füllen den Kontext mit veralteter Ausgabe, und das Modell verliert das ursprüngliche Ziel aus den Augen. Kürze oder fasse Tool-Ergebnisse zusammen, bevor du sie zurückgibst, und gib nur Felder zurück, die das Modell braucht.

Zu viele Tools. Die Genauigkeit sinkt tendenziell, wenn du Tools hinzufügst, besonders ähnliche. Gib jeder Aufgabe die kleinste sinnvolle Menge oder lade Tools dynamisch anhand der Anfrage.

Und die Sicherheit?

Jedes Tool ist eine Fähigkeit, die sich eine Prompt Injection borgen kann. Liest dein Agent Webseiten oder E-Mails und hat zugleich ein Tool, das Nachrichten sendet, kann ein Angreifer, der den richtigen Text auf eine Seite schreibt, ihn womöglich dazu bringen, Nachrichten zu senden.

Praktische Regeln:

  • Autorisiere im Code, nicht im Prompt. Das Tool sollte mit den Berechtigungen des Endnutzers laufen, damit ein getäuschtes Modell nicht an Daten kommt, an die der Nutzer nicht käme.
  • Lass folgenreiche Aktionen bestätigen. Zahlungen, Löschungen, ausgehende Nachrichten, Berechtigungsänderungen: Zeig dem Nutzer genau, was passieren wird, und verlange eine Freigabe.
  • Validiere Argumente. Schema-Validierung plus Geschäftsregeln (Betragslimits, erlaubte Empfänger) vor der Ausführung.
  • Trenne Lese- und Schreib-Tools. Ein Recherche-Schritt, der nur Lese-Tools hat, kann nichts beschädigen, so verwirrt er auch wird.

Brauchst du überhaupt einen Agent?

Oft nicht. Stehen die Schritte vorab fest (abrufen, dann zusammenfassen, dann formatieren), ist eine feste Pipeline einzelner Modellaufrufe günstiger, schneller, leichter zu testen und leichter zu debuggen. Agents rechtfertigen ihre Komplexität, wenn der Weg tatsächlich von Zwischenergebnissen abhängt: Das Modell muss etwas nachschlagen, um zu wissen, was es als Nächstes nachschlagen soll.

Eine sinnvolle Abfolge: Beginne mit einem einzelnen Prompt; ergänze Retrieval, wenn Fakten nötig sind (Was ist RAG?); ergänze einen einzelnen Tool-Aufruf für eine Aktion; erst dann baue eine Schleife.

Wo passt MCP hinein?

Das Model Context Protocol, Ende 2024 von Anthropic eingeführt und seither von anderen Anbietern und Tools übernommen, standardisiert, wie Anwendungen Tools und Daten für Modelle bereitstellen. Es löst die Verkabelung: Eine Server-Definition, die sich aus vielen Clients nutzen lässt. An keinem der obigen Ratschläge ändert es etwas. Ein schlecht beschriebenes Tool ist über MCP genauso verwirrend, und viele Drittanbieter-Server anzubinden bringt sowohl Fähigkeiten als auch Angriffsfläche.

Zur Ausgabeseite von Tool-Aufrufen (Schemas, strikte Modi, Validierung) siehe zuverlässiges JSON von LLMs. Das Thema Tools und Agents zerlegt diese Designentscheidungen in Übungsfragen.

Häufige Fragen

Was ist Tool Calling bei LLMs?

Tool Calling, auch Function Calling genannt, lässt ein Modell mit einer strukturierten Anfrage antworten, eine von dir definierte Funktion auszuführen, etwa eine Datenbanksuche oder das Senden einer E-Mail. Dein Code führt die Funktion aus und gibt das Ergebnis an das Modell zurück, das dann weitermacht.

Führt das Modell das Tool selbst aus?

Nein. Das Modell gibt nur den Tool-Namen und die Argumente aus. Deine Anwendung entscheidet, ob sie es ausführt, führt es aus und schickt das Ergebnis zurück. Deshalb gehören Berechtigungsprüfungen in deinen Code.

Was ist der Unterschied zwischen Tool Calling und einem KI-Agent?

Tool Calling ist eine einzelne Fähigkeit: Das Modell bittet darum, eine Funktion auszuführen. Ein Agent ist eine Schleife, in der das Modell wiederholt entscheidet, welches Tool es als Nächstes aufruft, Ergebnisse beobachtet und weitermacht, bis die Aufgabe erledigt oder ein Limit erreicht ist.

Wie viele Tools kann man einem Agent geben?

Ein festes Limit gibt es nicht, aber die Genauigkeit sinkt tendenziell, wenn Tool-Listen wachsen und sich Tools überschneiden. Halte die Menge pro Aufgabe klein und klar abgegrenzt oder lade relevante Tools dynamisch.

  • #Tool Calling
  • #Function Calling
  • #KI-Agents
  • #Agent-Schleife
  • #MCP

Jetzt üben

TokIQ macht aus Prompt Engineering kurze Quizze, mit einer Erklärung zu jeder Antwort.

Bald beiApp StoreJetzt beiGoogle Play

Schreibe bessere Prompts, mit ein paar Fragen am Tag.

Kurze Quizze zu echten Prompting-Entscheidungen, mit einer Erklärung zu jeder Antwort. Kostenlos starten auf iPhone und Android.

Bald beiApp StoreJetzt beiGoogle Play