Wie ein Agent Tools verwendet (Grundlagen)

Wenn wir sagen, dass ein Agent ein "Tool nutzen" kann, klingt es so, als würde er einen Button klicken oder ein Programm starten.

Aber intern läuft es anders. Der Agent kann nicht selbst eine Datei öffnen, eine E-Mail senden oder eine API aufrufen.

Er arbeitet nur mit Text.

Wie interagiert der Agent dann mit der realen Welt?

Wie kann ein Textmodell:

• Daten aus einer Datenbank holen
• Eine Anfrage an einen Server senden
• Ein Ergebnis in eine Datei schreiben

Die Antwort ist Tool-Aufruf (tool calling).

Das Modell führt Aktionen nicht selbst aus. Es bittet das System, sie auszuführen.

Es entscheidet, wann ein Tool gebraucht wird.
Und das umgebende System führt aus.

Was ein Tool wirklich ist

Ein Tool ist eine Aktion, deren Ausführung der Agent anfordern kann.

Das kann sein:

• Daten aus einer API holen
• Informationen in einer Datenbank finden
• Eine Datei lesen
• Eine Nachricht senden
• Ein Ergebnis schreiben

Für das Modell ist das einfach eine weitere Antwortoption.

Statt Text zu schreiben, kann es sagen:

"Um weiterzukommen, muss diese Aktion ausgeführt werden."

Und angeben:

• Welches Tool genutzt werden soll
• Mit welchen Parametern

Zum Beispiel:

{
  "tool": "get_user_data",
  "parameters": {
    "user_id": 123
  }
}

In diesem Moment führt das Modell die Aktion nicht selbst aus. Es schlägt nur vor, sie auszuführen.

Wenn das System die Aktion erlaubt, führt es das Tool aus und gibt das Ergebnis (Daten, Status oder Fehler) an das Modell zurück.

Danach entscheidet der Agent, was als Nächstes zu tun ist.

Wie das Modell weiß, welche Tools es gibt

Das Modell sucht Tools nicht selbst.

Es wird vorher informiert, welche Aktionen verfügbar sind.

Vor dem Start übergibt das System dem Modell eine Liste von Tools, die es nutzen darf.

Jedes Tool hat:

• Name - wie es heißt
• Beschreibung - was es macht
• Parameter - welche Daten es braucht

Zum Beispiel:

{
  "name": "get_user_data",
  "description": "Holt Benutzerinformationen per ID",
  "parameters": {
    "user_id": "number"
  }
}

Für das Modell ist das ein Satz möglicher Aktionen, die es im richtigen Moment auswählen kann.

Es erfindet keine neuen Tools.
Es wählt aus den Tools, die erlaubt sind.

Deshalb kann ein Agent nicht irgendeine API aufrufen.
Nur die, die ihm gegeben wurden.

Wie der Agent ein Tool auswählt

Der Agent kann jederzeit mehrere Handlungsoptionen haben.

Er kann:

• Eine Antwort schreiben
• Ein Tool verwenden
• Oder die Aufgabe abschließen

Für die Auswahl schaut er auf:

• Das aktuelle Ziel
• Die verfügbaren Daten
• Das Ergebnis der vorherigen Schritte

Und stellt sich eine einfache Frage:

"Was bringt mich jetzt direkt näher an das Ergebnis?"

Wenn die Antwort nicht ausreicht, sollte er vielleicht ein Tool aufrufen und neue Daten holen.

Wenn die Daten schon ausreichen, kann er ohne Tool weitermachen.

Wenn die Aufgabe erledigt ist, kann er beenden.

Das ist kein starres Skript.
Es ist eine Entscheidung, die der Agent in jedem Zyklus trifft.

Genau deshalb kann er je nach Situation unterschiedliche Tools nutzen, statt einer festen Reihenfolge zu folgen.

Was nach einem Tool-Aufruf passiert

Wenn der Agent ein Tool auswählt und die Ausführung anfordert, übernimmt das umgebende System.

Es:

• Prüft, ob dieses Tool erlaubt ist
• Führt die Aktion aus
• Holt das Ergebnis

Das kann sein:

• Daten aus einer API
• Dateiinhalt
• Ausführungsstatus
• Oder ein Fehler

Danach wird das Ergebnis als Text an das Modell zurückgegeben.

Für den Agenten ist das neue Information, die er nutzen kann.

Er analysiert das Ergebnis:

• Hat er die benötigten Daten bekommen?
• Ist er dem Ziel näher gekommen?
• Braucht er noch einen Schritt?

Und auf dieser Basis entscheidet er:

• Ein anderes Tool nutzen
• Ohne Tool weitermachen
• Oder die Aufgabe abschließen

So wird jeder Tool-Aufruf Teil des Handlungszyklus.

Im Code sieht das so aus

Stell dir vor, der Agent will Benutzerdaten holen. Er kann eine Funktion nicht selbst aufrufen. Er kann das System nur darum bitten, es auszuführen, in Form einer Textanfrage:

# Modell entscheidet:
# "Um weiterzukommen, brauche ich Benutzerdaten"

model_output = {
    "tool": "get_user_data",
    "parameters": {
        "user_id": 123
    }
}

Das Modell führt nichts aus. Es sagt nur: "Bitte führe dieses Tool aus."

Jetzt bekommt das umgebende System diese Anfrage:

def get_user_data(user_id: int):
    return {"id": user_id, "name": "Anna"}


TOOLS = {
    "get_user_data": get_user_data
}

Das System prüft:

• ob es dieses Tool gibt
• ob seine Nutzung erlaubt ist

Und erst danach wird ausgeführt:

tool_name = model_output["tool"]
params = model_output["parameters"]

result = TOOLS[tool_name](**params)

Danach wird das Ergebnis als Text an das Modell zurückgegeben:

tool_result = f"User data: {result}"

Und jetzt kann der Agent entscheiden:

• diese Daten zu verwenden
• ein anderes Tool aufzurufen
• oder die Aufgabe abzuschließen

In diesem Beispiel haben wir model_output manuell erstellt. In einem echten Agenten wird es vom Sprachmodell selbst erzeugt. Es analysiert die Aufgabe, entscheidet, dass ein Tool nötig ist, und erstellt automatisch dieselbe Anfrage.

Analogie aus dem Alltag

Stell dir vor, du kochst Abendessen.

Du hast:

• einen Kühlschrank
• einen Herd
• ein Messer
• eine Mikrowelle

Das sind alle Tools, die du nutzen kannst.

Du kannst nicht:

• einen Ofen nutzen, wenn keiner da ist
• oder einen Mixer nehmen, wenn er nicht in der Küche steht

Jetzt willst du Suppe kochen.

Du denkst:

Was hilft mir jetzt direkt?

Du kannst:

• den Kühlschrank öffnen
• den Herd einschalten
• oder ein Messer nehmen

Du wählst ein Tool, nutzt es und schaust, was sich geändert hat.

Dann wählst du das nächste.

Und so weiter, bis das Gericht fertig ist.

Genau so läuft es beim Agenten.

Er bekommt eine Liste verfügbarer Tools.
Er kann keine neuen erfinden, nur aus den vorhandenen wählen.

In jedem Schritt entscheidet er:

welches Tool hilft, dem Ergebnis näherzukommen

Er nutzt es und geht weiter.

Kurz gesagt

Tool calling ist die Art, wie ein Agent mit der realen Welt interagiert.

Das Modell führt Aktionen nicht selbst aus. Es bittet das System, sie in seinem Namen auszuführen.

Das System gibt ihm eine Liste verfügbarer Tools. Das Modell wählt im richtigen Moment das passende Tool. Das System prüft die Erlaubnis, führt die Aktion aus und gibt das Ergebnis zurück.

Und darauf basierend entscheidet der Agent, was als Nächstes passiert.

FAQ

Q: Führt der Agent Aktionen selbstständig aus?
A: Nein. Das Modell führt Aktionen nicht selbst aus. Es bittet nur das System, ein Tool in seinem Namen auszuführen.

Q: Was ist tool calling?
A: Es ist ein Weg, wie das Modell eine Aktion anfordern kann, zum Beispiel Daten holen oder ein Ergebnis schreiben, um dem Ziel näherzukommen.

Q: Woher weiß der Agent, welche Tools er nutzen darf?
A: Vor dem Start gibt das System dem Modell eine Liste verfügbarer Tools, aus denen es in jedem Schritt wählen kann.

Wie geht es weiter

Jetzt kennst du die Grundlagen von tool calling.

Aber in echter Arbeit kommen schwierigere Fragen:

Wie kontrollierst du, welche Tools der Agent nutzen darf?
Was machst du, wenn ein Tool teuer und ein anderes riskant ist?
Wie gibst du dem Agenten Zugriff auf Daten, aber verbietest das Löschen?

Das sind nicht mehr Grundlagen.
Das ist production-Realität.