# Tool Calling und JSON-Ausgabe mit Open-Weight-Modellen

> Function Calling mit Open-Weight-Modellen im OpenAI-Format: Tools, tool_choice und die Schleife aus Aufruf und Antwort für eine gültige JSON-Ausgabe.

- URL: https://llmwithcrypto.com/de/docs/tool-calling/
- Zuletzt aktualisiert: 2026-10-23
- Herausgeber: LLMwithCrypto (https://llmwithcrypto.com)

Das Modell kann Ihren Code bitten, eine Funktion auszuführen, und das Ergebnis dann in seiner Antwort verwenden; oder es antwortet mit einem JSON-Objekt, das Ihr Programm direkt liest. Beides nutzt das OpenAI-Anfrageformat, und beides hängt vom gewählten Modell ab.

**Kurze Antwort — Wie funktioniert Tool Calling auf LLMwithCrypto?**

Senden Sie Ihre Funktionen in `tools` im OpenAI-Format. Wenn das Modell eine davon möchte, gibt **LLMwithCrypto** `finish_reason: "tool_calls"` mit dem Funktionsnamen und den JSON-Argumenten zurück; Ihr Code führt sie aus und schickt das Ergebnis als `tool`-Nachricht zurück. Für strukturierte Antworten fordert `response_format: {"type": "json_object"}` gültiges JSON an. Beides funktioniert bei den Modellen, die es unterstützen, wie am 23. Oktober 2026 dokumentiert.

## Welche Modelle unterstützen Tools und JSON?

Streaming funktioniert bei jedem Modell; Tool Calling und JSON-Ausgabe richten sich nach dem, was das jeweilige Modell selbst unterstützt.

Testen Sie Ihr eigenes Schema mit dem Modell, das Sie verwenden möchten, bevor Sie sich darauf verlassen. Ein Modell ohne Tool-Unterstützung antwortet stattdessen in reinem Text, statt die Funktion aufzurufen; ein Modell ohne JSON-Modus gibt für `response_format` einen `400`-Fehler zurück.

## Was ist die Schleife?

1. **Beschreiben Sie die Funktionen** — Jedes Tool hat einen name, eine description, die das Modell liest, um zu entscheiden, wann es das Tool nutzt, und parameters als JSON Schema.
2. **Senden Sie die Konversation mit Tools** — Das Modell antwortet entweder in Text oder stoppt mit finish_reason: "tool_calls" und einem oder mehreren Aufrufen in message.tool_calls.
3. **Führen Sie jeden Aufruf aus** — Parsen Sie function.arguments (einen JSON-String), führen Sie Ihre Funktion aus und vertrauen Sie den Argumenten nie blind: Validieren Sie sie wie jede Benutzereingabe.
4. **Senden Sie die Ergebnisse zurück** — Hängen Sie die Assistant-Nachricht an, dann pro Aufruf eine tool-Nachricht mit ihrer tool_call_id und dem Ergebnis als Text. Rufen Sie die API erneut auf; wiederholen Sie das, bis das Modell in Text antwortet.

*Python: eine vollständige Tool-Schleife mit gpt-oss-120b*

```python
import json
import os

from openai import OpenAI

client = OpenAI(
    base_url="https://llmwithcrypto.com/api/v1",
    api_key=os.environ["LLMWITHCRYPTO_API_KEY"],
)

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_order_status",
            "description": "Return the delivery status of an order.",
            "parameters": {
                "type": "object",
                "properties": {"order_id": {"type": "string"}},
                "required": ["order_id"],
            },
        },
    }
]


def get_order_status(order_id):
    return {"order_id": order_id, "status": "shipped", "eta": "2026-10-25"}


messages = [{"role": "user", "content": "Where is my order A-1042?"}]
while True:
    resp = client.chat.completions.create(model="gpt-oss-120b", messages=messages, tools=tools, max_tokens=300)
    msg = resp.choices[0].message
    if not msg.tool_calls:
        print(msg.content)
        break
    messages.append(msg)
    for call in msg.tool_calls:
        args = json.loads(call.function.arguments)
        result = get_order_status(**args)
        messages.append({"role": "tool", "tool_call_id": call.id, "content": json.dumps(result)})

```

## Wie sieht ein Tool-Aufruf in der Antwort aus?

Die Assistant-Nachricht hat keinen Text, ein `tool_calls`-Array, und die Auswahl endet mit `finish_reason: "tool_calls"`. Die Argumente kommen als JSON-String, nicht als Objekt. Die IDs und Zahlen unten sind nur Beispiele.

*Antwort, die einen Funktionsaufruf anfordert (beispielhaft)*

```json
{
  "id": "chatcmpl-3c9d27e1",
  "object": "chat.completion",
  "created": 1792742400,
  "model": "gpt-oss-120b",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": null,
        "tool_calls": [
          {
            "id": "call_7f31",
            "type": "function",
            "function": {
              "name": "get_order_status",
              "arguments": "{\"order_id\": \"A-1042\"}"
            }
          }
        ]
      },
      "finish_reason": "tool_calls"
    }
  ],
  "usage": {
    "prompt_tokens": 118,
    "completion_tokens": 22,
    "total_tokens": 140
  }
}

```

## Wie steuere ich, wann Tools verwendet werden?

- **`"tool_choice": "auto"`** (der Standard, wenn `tools` gesetzt ist): Das Modell entscheidet.
- **`"tool_choice": "none"`**: Das Modell antwortet in Text, obwohl Tools aufgelistet sind.
- **`"tool_choice": "required"`**: Das Modell muss mindestens ein Tool aufrufen.
- **`{"type": "function", "function": {"name": "get_order_status"}}`**: Das Modell muss genau dieses eine aufrufen.

Jede Tool-Definition wird bei jedem Aufruf als Eingabe gesendet, daher erhöhen lange Beschreibungen und viele Tools die Eingabe-Tokens. Halten Sie Beschreibungen kurz und senden Sie nur die Tools, die ein Schritt braucht.

## Wie bekomme ich gültiges JSON zurück?

Setzen Sie `response_format` auf `{"type": "json_object"}` und beschreiben Sie die erwarteten Schlüssel in der Systemnachricht: Der JSON-Modus garantiert, dass die Antwort parsbar ist, nicht dass sie die gewünschten Schlüssel enthält. Halten Sie `temperature` niedrig für stabile Ausgaben und prüfen Sie das geparste Objekt in Ihrem Code, bevor Sie es verwenden.

*Node.js: eine JSON-Antwort mit response_format*

```javascript
import OpenAI from 'openai';

const client = new OpenAI({
  baseURL: 'https://llmwithcrypto.com/api/v1',
  apiKey: process.env.LLMWITHCRYPTO_API_KEY,
});

const resp = await client.chat.completions.create({
  model: 'gpt-oss-120b',
  messages: [
    { role: 'system', content: 'Reply with a JSON object {"sentiment": "positive" | "negative" | "neutral", "reason": string}.' },
    { role: 'user', content: 'The delivery was late but support fixed it in an hour.' },
  ],
  response_format: { type: 'json_object' },
  temperature: 0.2,
  max_tokens: 150,
});
const result = JSON.parse(resp.choices[0].message.content);
console.log(result.sentiment, '-', result.reason);

```

## Tools und JSON: häufige Fragen

### Kosten Tool-Aufrufe extra?

Keine eigene Gebühr. Die Tool-Definitionen, der Aufruf und die zurückgesendeten Ergebnisse sind alles Tokens, die wie alle anderen abgerechnet werden. Sie zahlen pro Token aus Ihrem Guthaben: Input- und Output-Tokens werden mit dem eigenen Tokenizer des Modells gezählt und zum Preis des Modells pro 1M Tokens berechnet. Ein Aufruf, der mit einem Fehler endet, kostet nichts.

### Kann das Modell mehrere Tools gleichzeitig aufrufen?

Manche Modelle geben mehr als einen Aufruf in `tool_calls` zurück. Führen Sie alle aus und senden Sie vor der nächsten Anfrage pro Aufruf eine `tool`-Nachricht.

### Führt die API meine Funktionen aus?

Nein. Das Modell sagt nur, welche Funktion mit welchen Argumenten aufgerufen werden soll; Ihr Code führt sie aus. Auf unserer Seite wird nichts ausgeführt, und nichts aus dem Austausch wird gespeichert: Wir speichern Ihre Prompts und die Antworten der Modelle nicht: Sobald eine Antwort gesendet ist, ist ihr Text weg. Jeder Aufruf hinterlässt eine Logzeile mit Zeit, Konto, Modell und Token-Anzahl, die nach 30 Tagen gelöscht wird.

---

LLMwithCrypto: LLMwithCrypto ist eine OpenAI-kompatible LLM-API für Open-Weight-Modelle — DeepSeek V4 Pro, DeepSeek V4.1 Flash, DeepSeek R1, Qwen3.5 397B A17B, Qwen3 235B A22B Instruct, gpt-oss-120b, gpt-oss-20b, GLM-4.7, Llama 3.3 70B Instruct, Gemma 4 31B, Mistral Large 3, Mistral Small 4 — pro Token aus einem vorausbezahlten Krypto-Guthaben bezahlt, 5 % unter dem Medianpreis der öffentlichen Hosts. Ohne KYC: kein Ausweis, kein Selfie, keine Dokumente. Prompts und Ausgaben werden nicht gespeichert.
