Zum Inhalt springen

Function Calling & Agent Loop

Function Calling (auch Tool Calling genannt) ist die technische Grundlage, über die ein LLM-basierter Agent externe Werkzeuge aufruft. Das Verständnis dieses Mechanismus ist entscheidend, um zu beurteilen, wie ein Agent zu seinen Ergebnissen kommt, wo er scheitern kann und wie er sich verlässlich gestalten lässt.

Was ist Function Calling?

Function Calling ermöglicht es einem LLM, bei Bedarf externe Funktionen, APIs oder Wissensdatenbanken aufzurufen, anstatt ausschließlich auf sein Trainingswissen zurückzugreifen. Das Modell entscheidet eigenständig, wann ein solcher Aufruf nötig ist, und generiert dabei strukturierte Anfragen mit den benötigten Parametern.

Ein einfaches Beispiel: Die Frage „Wie ist das Wetter in Paris?" kann ein LLM allein nicht aktuell beantworten. Mit Function Calling erkennt es den Bedarf, ruft eine Wetter-API mit dem Parameter Paris auf und formuliert die Antwort auf Basis der zurückgegebenen Daten. Ohne Werkzeuge bleibt das Modell auf veraltetes Trainingswissen beschränkt; genau diese Schranke hebt Function Calling auf.

Der Ablauf: Schritt für Schritt

1. Nutzeranfrage
   └─ „Was ist das aktuelle Wetter in Paris?"

2. Kontext-Aufbau (Context Assembly)
   └─ Systemnachricht + Werkzeugdefinitionen + Nutzeranfrage

3. Werkzeugentscheidung (Tool Decision)
   └─ LLM: „Ich brauche get_current_weather(location='Paris')"

4. Werkzeugausführung (Tool Execution)
   └─ Code ruft Wetter-API auf

5. Beobachtung (Observation)
   └─ API gibt zurück: { temp: 18°C, condition: 'Cloudy' }

6. Antwortgenerierung
   └─ LLM formuliert Antwort auf Basis der Beobachtung

Ein zentraler Aspekt: Das Modell erhält bei jedem Schritt den vollständigen bisherigen Kontext: alle Nachrichten, alle Werkzeugaufrufe, alle Beobachtungen. Diese Kontextkontinuität ist die Grundlage für intelligente Folgeentscheidungen.

Werkzeugdefinitionen: der kritischste Faktor

Wie gut ein Agent Werkzeuge nutzt, hängt weniger von der technischen Implementierung ab als von der Qualität der Werkzeugdefinitionen. Sie sind die einzige Informationsquelle, aus der das Modell schlussfolgert, welches Werkzeug wann einzusetzen ist.

Eine vollständige Werkzeugdefinition enthält:

  • Name: Ein eindeutiger Bezeichner für die Funktion
  • Description: Erklärung, was das Werkzeug tut und wann es eingesetzt werden soll
  • Parameters: Eingabewerte mit Typen, Beschreibungen und Einschränkungen

Das Beschreibungsfeld ist dabei besonders wichtig. Bei mehreren verfügbaren Werkzeugen entscheidet die Präzision der Beschreibung darüber, ob das Modell das richtige Werkzeug wählt.

{
  "name": "get_current_weather",
  "description": "Gibt das aktuelle Wetter für einen Ort zurück. Verwenden, wenn nach aktuellen Wetterbedingungen gefragt wird.",
  "parameters": {
    "location": {
      "type": "string",
      "description": "Stadt und Land, z.B. 'Paris, FR'"
    },
    "unit": {
      "type": "string",
      "enum": ["celsius", "fahrenheit"]
    }
  }
}

Note

Werkzeugdefinitionen verbrauchen Token und beeinflussen damit Kosten und Latenz. Prägnante, aber eindeutige Formulierungen sind in der Praxis entscheidend.

Der Agent Loop

Der Agent Loop ist das Grundprinzip der Ausführung. Er besteht aus sich wiederholenden Zyklen:

Aktion (Action)

Der Agent entscheidet, ein Werkzeug aufzurufen.

Umgebungsantwort (Environment Response)

Das externe System (eine API, eine Datenbank oder ein anderer Agent) gibt ein Ergebnis zurück.

Beobachtung (Observation)

Das Ergebnis wird als Teil des Kontexts verarbeitet.

Entscheidung (Decision)

Der Agent prüft: Ist die Aufgabe erfüllt? Wenn nein, folgt der nächste Aktionsschritt.

Ein konkretes Beispiel für einen einfachen Rechercheauftrag:

Nutzer: „Aktuelle Neuigkeiten von OpenAI"

Agent:  Ich brauche aktuelle Informationen.
        → web_search("OpenAI Neuigkeiten 2025")

Beobachtung: [Suchergebnisse mit aktuellen Artikeln...]

Agent:  Ich habe genug Informationen für eine Antwort.
        → Ausgabe: „Hier sind die aktuellen Meldungen von OpenAI..."

Bei komplexeren Aufgaben können mehrere Werkzeugaufrufe nötig sein. Jeder Aufruf erweitert den Kontext und gibt dem Agenten mehr Grundlage für folgende Entscheidungen.

Häufige Fehlerquellen und Debugging

Beim Aufbau von Agentensystemen treten charakteristische Fehler auf, die sich systematisch analysieren lassen:

FehlertypSymptomUrsache
Falsche WerkzeugwahlAgent nutzt falsches WerkzeugUnklare oder zu ähnliche Beschreibungen
Fehlerhafte ParameterWerkzeugaufruf schlägt fehlUnvollständige Parameterdefinition
FehlinterpretationAntwort ignoriert WerkzeugresultatUnklares Ausgabeformat der Funktion
Übersprungene SchritteAgent antwortet ohne vollständige RechercheZu vage Ausführungsanweisung im System-Prompt

Viele Agenten-Frameworks bieten die Möglichkeit, Intermediate Steps zu protokollieren: welche Werkzeuge aufgerufen wurden, mit welchen Argumenten, und was zurückkam. Diese Transparenz ist unverzichtbar für das Verstehen und Verbessern eines Agenten.

Empfehlungen für die Praxis

Beschreibungen präzisieren: Statt „Suche im Web" besser: „Suche im Web nach aktuellen Informationen. Einsetzen, wenn der Nutzer nach Ereignissen fragt, die nach dem Trainingsschnitt des Modells liegen."

Werkzeugauswahl im System-Prompt explizit machen: Ergänzende Hinweise im System-Prompt darüber, welches Werkzeug für welchen Zweck bevorzugt werden soll, verbessern die Entscheidungsqualität, besonders bei Mehrfachwerkzeug-Setups.

Fehlerfälle antizipieren: Werkzeuge sollten bei Fehler informative Rückmeldungen zurückgeben, die dem Agenten erlauben, einen alternativen Weg zu versuchen, anstatt still zu scheitern.

Parameterwerte einschränken: Wo möglich enum-Felder nutzen, um Halluzinationen bei Parameterwerten zu vermeiden.

Zuletzt aktualisiert am