---
title: "Function Calling mit offenen Modellen · OpenAI-kompatibel"
description: "Lassen Sie offene Modelle Ihre Funktionen und APIs aufrufen, mit OpenAI-kompatiblem Tool Calling. Werkzeuge definieren, Schleife ausführen, in der EU."
canonical: "https://inference.eu/de/api/tool-calling/"
language: "de"
---

Anleitungen · Tool calling

# Tool Calling: offene Modelle rufen Ihre Funktionen auf

Mit Tool Calling, auch Function Calling genannt, bittet ein Modell Ihren Code um etwas, das es selbst nicht kann: eine Bestellung nachschlagen, eine Datenbank abfragen, eine E-Mail senden oder eine andere API aufrufen. Sie beschreiben die Werkzeuge, das Modell entscheidet, wann und mit welchen Argumenten es sie nutzt, und Ihr Code führt sie aus. Darauf basiert jeder Agent, im OpenAI- wie im Anthropic-Format.

[Vertrieb kontaktieren](https://inference.eu/de/kontakt/)[Beispielanfrage](#example)

1.  01API-Format: OpenAI und Anthropic
2.  02Rechenzentren in der EU
3.  03Durch einen AV-Vertrag abgedeckt

tools.py

```
import json, os
from openai import OpenAI

client = OpenAI(base_url="https://api.inference.eu/v1", api_key=os.environ["INFERENCE_EU_API_KEY"])

def get_order_status(order_id: str) -> dict:
    return {"order_id": order_id, "status": "shipped", "carrier": "DHL", "eta": "2026-11-05"}

tools = [{
    "type": "function",
    "function": {
        "name": "get_order_status",
        "description": "Look up the shipping status of a customer order by its id.",
        "parameters": {
            "type": "object",
            "properties": {"order_id": {"type": "string", "description": "Order id, e.g. A-10293"}},
            "required": ["order_id"],
        },
    },
}]

messages = [{"role": "user", "content": "Where is my order A-10293?"}]
reply = client.chat.completions.create(model="gpt-oss-120b", messages=messages, tools=tools)
msg = reply.choices[0].message

if msg.tool_calls:
    messages.append(msg)
    for call in msg.tool_calls:
        result = get_order_status(**json.loads(call.function.arguments))
        messages.append({"role": "tool", "tool_call_id": call.id, "content": json.dumps(result)})
    reply = client.chat.completions.create(model="gpt-oss-120b", messages=messages, tools=tools)

print(reply.choices[0].message.content)
```

## So funktioniert Tool Calling

Sie übergeben mit der Anfrage ein Array `tools`. Jedes Werkzeug hat `type: "function"` und ein Objekt `function` mit `name`, `description` und `parameters` als JSON Schema. Das Modell liest diese zusammen mit dem Gespräch. Hält es ein Werkzeug für nötig, antwortet es nicht mit Text, sondern liefert `message.tool_calls` mit `id`, Funktionsname und `arguments` als JSON-String; `finish_reason` ist dann `tool_calls`.

Das Modell führt selbst nichts aus. Ihr Code parst die Argumente, ruft die echte Funktion auf und sendet das Ergebnis als Nachricht mit `role: "tool"` und passender `tool_call_id` zurück. Danach antwortet das Modell oder fordert ein weiteres Werkzeug an.

## Steuern, wann Werkzeuge genutzt werden

`tool_choice` steuert die Entscheidung. `auto`, der Standard, lässt das Modell zwischen Antwort und Werkzeug wählen. `required` erzwingt mindestens einen Aufruf, nützlich für Extraktionsschritte. `none` schaltet Werkzeuge für eine Runde ab, die Angabe einer bestimmten Funktion erzwingt genau diese. Mit `parallel_tool_calls: false` beschränken Sie das Modell auf einen Aufruf pro Runde, falls Ihre Werkzeuge nacheinander laufen müssen.

Gute Beschreibungen sind entscheidend. Erklären Sie, was das Werkzeug tut, wann es passt und was jeder Parameter bedeutet, mit einem Beispielwert. Halten Sie die Zahl der Werkzeuge pro Anfrage überschaubar: Wer zwischen wenigen klaren Werkzeugen wählt, irrt seltener als bei fünfzig.

## Die Agenten-Schleife in der Praxis

Echte Aufgaben brauchen oft mehrere Runden: suchen, Details holen, handeln. Bauen Sie eine Schleife. Senden Sie die Anfrage; enthält die Antwort Tool Calls, führen Sie sie aus, hängen die Assistentennachricht und jedes Ergebnis an und senden erneut. Beenden Sie die Schleife, wenn das Modell mit Text antwortet oder eine selbst gewählte Höchstzahl an Runden erreicht ist.

Prüfen Sie Argumente, bevor Sie handeln, denn das Modell kann eine falsche ID oder ein fehlendes Feld liefern. Werkzeuge, die etwas verändern, etwa Zahlungen oder E-Mails, verdienen besondere Sorgfalt: Lassen Sie einen Menschen bestätigen oder beschränken Sie sie auf sichere Werte. Geben Sie Fehler als Ergebnis mit klarer Meldung zurück, damit das Modell sich korrigieren kann.

## Formate, Modelle und Sonderfälle

Dieselben Werkzeuge funktionieren über die Responses API, in der Funktionsaufrufe und Ausgaben typisierte Elemente sind, und über das Anthropic-Messages-Format, in dem Werkzeuge `input_schema` nutzen und Aufrufe als `tool_use`\-Blöcke kommen, die Sie mit `tool_result` beantworten. Wählen Sie das Format Ihres Frameworks.

Nicht jedes Modell beherrscht Werkzeuge gleich gut. Große instruktionsoptimierte Modelle wie `gpt-oss-120b` meistern mehrstufige Schleifen zuverlässig, kleine Modelle übersehen Aufrufe oder erfinden Argumente. Ist `arguments` kein gültiges JSON, senden Sie einen Fehler zurück und lassen das Modell es erneut versuchen, oder nutzen Sie `strict`\-Schemas. Werkzeugdefinitionen zählen bei jeder Anfrage als Eingabe-Tokens.

## Tool calling

Kategorie

Anleitungen

API-Format

OpenAI und Anthropic

Base URL

api.inference.eu/v1

Verarbeitung

Rechenzentren in der EU

Training mit Ihren Daten

Nie

## Tool calling: häufige Fragen

Die Fragen, die uns Einkauf, Entwicklung und Rechtsabteilungen am häufigsten stellen. Etwas fehlt? Fragen Sie uns direkt.

Ja. Die meisten aktuellen instruktionsoptimierten offenen Modelle, darunter \`gpt-oss-120b\`, sind für Werkzeugnutzung trainiert, und die inference.eu API stellt sie im üblichen OpenAI- und Anthropic-Format bereit. Jede Modellseite vermerkt, ob Tool Calling unterstützt wird. Die Qualität schwankt, testen Sie daher Ihre eigenen Werkzeuge.

Ja. \`tools\`, \`tool\_choice\`, \`parallel\_tool\_calls\`, \`message.tool\_calls\` und Nachrichten mit \`role: "tool"\` funktionieren genau wie in der OpenAI Chat Completions API. Darauf aufbauende Frameworks wie LangChain, LlamaIndex, das Vercel AI SDK und das OpenAI Agents SDK laufen ohne Änderungen.

Nein. Das Modell liefert nur Funktionsnamen und Argumente. Ihr Code entscheidet, ob die Funktion läuft, führt sie aus und sendet das Ergebnis zurück. So behalten Sie die volle Kontrolle darüber, was passiert und welche Daten Ihre Systeme verlassen.

Setzen Sie \`tool\_choice\` auf \`required\`, um irgendeinen Aufruf zu erzwingen, oder auf \`{"type": "function", "function": {"name": "get\_order\_status"}}\` für ein bestimmtes Werkzeug. Mit \`none\` verhindern Sie Aufrufe in einer Runde, in der Sie nur Text möchten.

Ja. Eine Antwort kann mehrere Einträge in \`tool\_calls\` enthalten, etwa drei Bestellungen auf einmal nachschlagen. Führen Sie sie aus, gern parallel, und hängen Sie pro Aufruf eine \`tool\`-Nachricht mit passender \`tool\_call\_id\` an. Mit \`parallel\_tool\_calls: false\` erzwingen Sie Aufrufe nacheinander.

Parsen Sie \`arguments\` mit einem JSON-Parser und prüfen Sie das Ergebnis gegen Ihr Schema. Schlägt das fehl, senden Sie eine \`tool\`-Nachricht, die das Problem erklärt, etwa ein fehlendes Feld, und lassen das Modell es erneut versuchen. \`strict: true\` in der Funktionsdefinition sorgt für schematreuere Argumente.

Beim Tool Calling definieren Sie jede Funktion und führen sie in Ihrem eigenen Code aus. Bei MCP liegen die Werkzeuge auf einem MCP-Server, und die API kann diesen Server für Sie aufrufen, wenn Sie ihn einer Responses-Anfrage hinzufügen. Beides lässt sich in einer Anfrage kombinieren.

Ja. In \`/v1/messages\` definieren Sie Werkzeuge mit \`name\`, \`description\` und \`input\_schema\`. Das Modell antwortet mit \`tool\_use\`-Blöcken und \`stop\_reason: "tool\_use"\`, Sie antworten mit \`tool\_result\`-Blöcken. Coding-Agenten für Anthropic nutzen genau diese Schleife.

[Frage stellen](https://inference.eu/de/kontakt/)

## Verwandte Seiten

[API-Überblick](https://inference.eu/de/api/)

-   [Structured outputsErhalten Sie von offenen Modellen gültiges JSON nach Ihrem Schema, mit OpenAI-kompatiblen Structured Outputs. JSON-Modus, json\_schema, strict und Stolperfallen.Anleitungen](https://inference.eu/de/api/structured-outputs/)
-   [Remote MCP serversBinden Sie entfernte MCP-Server über das mcp-Werkzeug der Responses API in Anfragen ein. Die API listet und ruft die Werkzeuge für Sie auf, in der EU.Tools](https://inference.eu/de/api/mcp/)
-   [StreamingStreamen Sie Tokens offener Modelle während der Generierung, mit Server-Sent Events im OpenAI- und Anthropic-Format. Beispiele, Chunk-Format, Fehler.Anleitungen](https://inference.eu/de/api/streaming/)
-   [ResponsesNutzen Sie das Format der OpenAI Responses API mit Open-Weight-Modellen auf inference.eu. Typisierte Ausgaben, eingebaute Werkzeuge, Verarbeitung in der EU.Endpunkte](https://inference.eu/de/api/responses/)

## Verlagern Sie Ihre KI-Workloads auf europäische Infrastruktur

Sagen Sie uns, welche Modelle Sie nutzen und wie viel Verkehr Sie ungefähr haben. Wir antworten innerhalb eines Werktags mit Preisen und nächsten Schritten.

-   Antwort innerhalb eines Werktags
-   Preise für Ihr Volumen
-   AV-Vertrag unterschriftsreif