> For the complete documentation index, see [llms.txt](https://unsloth.ai/docs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://unsloth.ai/docs/de/grundlagen/api.md).

# Wie man Unsloth als API-Endpunkt verwendet

Du kannst **lokale LLMs** mit Tools wie [Claude Code](/docs/de/grundlagen/claude-code.md) und [Codex](/docs/de/grundlagen/codex.md) indem du diese Tools mit Unsloths **OpenAI-kompatiblen API-Endpunkt**. So kannst du Modelle wie [Qwen](/docs/de/modelle/qwen3.6.md) und [Gemma](/docs/de/modelle/gemma-4.md) lokal für agentisches Coding ausführen. Unsloth hat außerdem nützliche Funktionen wie selbstheilendes **Tool-Calling**, **Code-Ausführung**und **Websuche**.

Unsloth macht es einfach, einen schnellen API-Inferenz-Endpunkt bereitzustellen, der Folgendes bietet:

* [**Selbstheilendes Tool-Calling**](/docs/de/neu/studio/chat.md#auto-healing-tool-calling), was dazu beiträgt, fehlerhafte oder ungültige Tool-Aufrufe um 50 % zu reduzieren
* [**Code-Ausführung**](/docs/de/neu/studio/chat.md#code-execution) Unterstützung, die die Ausführung von Bash und Python für genauere Code-Ausgaben ermöglicht.
* **Erweiterte** [**Websuche**](/docs/de/neu/studio/chat.md#advanced-web-search) die Webseiten besucht und tatsächlich liest, um detaillierte Informationen zu sammeln.
* [**Automatische Inferenz** Einstellungen](/docs/de/neu/studio/chat.md#auto-parameter-tuning) für GGUF-Modelle (temp, top-k usw.)

{% columns %}
{% column %}
In Unsloth geladene Modelle (einschließlich GGUFs) werden als **authentifizierte API** über `llama-server`. Aus Sicherheitsgründen wird ein langer API-Schlüssel generiert, so wie OpenAI einen bereitstellt.

Deine **lokalen Modelle** können dann direkt in deinem bevorzugten KI-Agenten, SDK oder Chat-Client verwendet werden. Unsloth spricht zwei Dialekte auf demselben Port. Beide unterstützen Streaming, Tool-Calling (OpenAI `Tools` / Anthropic `Tools`), sowie Vision-Eingaben:
{% endcolumn %}

{% column %}

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FgCthbL3uUmrNgxFBePK5%2Fimage.png?alt=media&amp;token=060dbc41-6fd5-496d-ba00-0ba13fde86ff" alt=""><figcaption></figcaption></figure>
{% endcolumn %}
{% endcolumns %}

Egal, ob dein Modell über Unsloths Inferenz oder deinen eigenen entfernten OpenAI-kompatiblen Endpunkt läuft, du kannst ihm Zugriff auf Unsloths vollständige Werkzeug-Suite geben, einschließlich Websuche, Code-Ausführung, Deep Research und mehr.

* **Anthropic-kompatibel `/v1/messages`**  für Claude Code, OpenClaw, das Anthropic SDK und jeden Client, der die Messages API erwartet.
* **OpenAI-kompatibel `/v1/chat/completions`** und **`/v1/responses`** für das OpenAI SDK, OpenCode, Cursor, Continue, Cline, Open WebUI, SillyTavern und jedes OpenAI-kompatible Tool.

### ⚡ Schnellstart

{% stepper %}
{% step %}

#### Unsloth herunterladen

Der einfachste Einstieg ist die Installation der [Unsloth Desktop](/docs/de/desktop.md) App. Sie unterstützt [macOS](/docs/de/erste-schritte/install/mac.md), Linux, [Windows](/docs/de/erste-schritte/install/windows-installation.md), [NVIDIA](/docs/de/erste-schritte/install/pip-install.md), [AMD](/docs/de/erste-schritte/install/amd.md), Intel- und CPU-Konfigurationen.

<a href="https://unsloth.ai/download" class="button primary" data-icon="down-to-bracket">Unsloth herunterladen</a>

* <i class="fa-apple">:apple:</i> [Für macOS herunterladen](https://unsloth.ai/download/mac)
* <i class="fa-windows">:windows:</i> [Für Windows herunterladen](https://unsloth.ai/download/windows)
* <i class="fa-linux">:linux:</i> [Für Linux herunterladen](https://unsloth.ai/download/linux)

Oder, wenn du die manuelle Installation bevorzugst:

**macOS, Linux, WSL:**

```bash
curl -fsSL https://unsloth.ai/install.sh | sh
```

**Windows PowerShell:**

```bash
irm https://unsloth.ai/install.ps1 | iex
```

{% endstep %}

{% step %}

#### Installieren

1. Öffne den Unsloth-Installer (`.dmg`, `.exe` Dateien)
2. Ziehe Unsloth auf Anwendungen auf dem Mac oder schließe das Setup für Windows ab.
3. Starte die App und warte, bis die Installation abgeschlossen ist
   {% endstep %}

{% step %}

#### Wähle ein Modell

Öffne oben das Dropdown-Menü 'Modell auswählen' oder den Tab 'Model hub', wähle ein Modell und eine Quantisierung, die zu deinem Gerät passt, und lade es dann herunter. Sobald der Download abgeschlossen ist, kannst du mit dem Chatten beginnen – keine Einrichtung erforderlich.

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FNCEVgKLJI0goPqjgcg9B%2Fmodel%20hub%20models.png?alt=media&amp;token=533b5e3c-a901-4b33-963e-4a703cc9d5a6" alt="" width="563"><figcaption></figcaption></figure>
{% endstep %}

{% step %}

#### Unsloth ist jetzt bereit

Um mit dem Chatten zu beginnen, gib eine Nachricht ein und drücke Enter.

* **Erstelle einen API-Schlüssel.** Klicke auf dein **Unsloth** Avatar unten links → **Einstellungen** → **API** → gib einen Schlüsselnamen ein → **Erstellen**. Kopiere den `sk-unsloth-…` angezeigten Wert. Unsloth zeigt ihn nur einmal an.
* **Richte deinen Client auf Unsloth aus.** Verwende `http://localhost:PORT` als Basis-URL und deinen `sk-unsloth-…` Schlüssel zur Authentifizierung. Springe unten zum Rezept für dein Tool.

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FpAGvwjGD0iVMZKBoyu7m%2Fgreeennn.png?alt=media&amp;token=d17a5528-8375-444c-9aff-f9e9f7903bcd" alt="" width="563"><figcaption></figcaption></figure>
{% endstep %}
{% endstepper %}

### 🔑 Einen API-Schlüssel erstellen

1. Öffne die Seitenleiste und klicke auf deinen **Unsloth** Avatar unten links.
2. Gehe zu **Einstellungen** → **API** (Globus :globe\_with\_meridians: -Symbol).
3. Gib einen aussagekräftigen Namen ein (z. B. `claude-code-macbook`). Lege ein Ablaufdatum fest (optional)
4. Klicke auf **Erstellen**.
5. **Kopiere den Schlüssel.** Unsloth speichert nur einen Hash, und du kannst ihn nicht erneut anzeigen.

<div data-with-frame="true"><figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FR7fhygHCl5RwG4P1MSoS%2Fimage.png?alt=media&amp;token=e2781a00-7fe5-4831-9fdb-a57234843b34" alt="" width="563"><figcaption></figcaption></figure></div>

Alle Schlüssel beginnen mit dem `sk-unsloth-` Präfix. Du kannst einen Schlüssel jederzeit auf derselben Seite widerrufen. Anfragen mit einem widerrufenen Schlüssel schlagen mit `401 Unauthorized`.

{% hint style="warning" %}
Behandle deinen API-Schlüssel wie ein Passwort. Jeder mit dem Schlüssel und Netzwerkzugriff auf deine Unsloth-Instanz kann Anfragen an dein geladenes Modell senden.
{% endhint %}

### ⏳ Modell wird geladen

{% stepper %}
{% step %}

#### Modell auswählen

Bevor du die API verwendest, lade ein Modell über das **Modell auswählen** Dropdown-Menü in der oberen linken Ecke der Chat-Seite.

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FuZqd6tcZ5LgMSh4ZND5x%2Fexport-1778505117710-24fps.gif?alt=media&amp;token=9defec95-5404-4654-9c33-67be967c9820" alt=""><figcaption></figcaption></figure>

In diesem Leitfaden verwenden wir:

`unsloth/gemma-4-26B-A4B-it-GGUF` mit der empfohlenen `UD-Q4_K_XL` Quantisierung.
{% endstep %}

{% step %}

#### Modell testen

Bevor du den Client verwendest, sende eine kurze Nachricht:

<div data-with-frame="true"><figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2F2Ivilke0aJX8AHWDwSmr%2Fimage.png?alt=media&amp;token=9f9380b9-f963-4861-a17b-fd0fe16684d4" alt="" width="563"><figcaption></figcaption></figure></div>

{% hint style="info" %}
Dies bestätigt, dass das Modell korrekt geladen wurde und bereit zum Antworten ist.
{% endhint %}
{% endstep %}

{% step %}

#### **Unsloth-API-Schlüssel**

Öffne in Unsloth **Settings → API** um deinen API-Schlüssel anzuzeigen oder zu erstellen.

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FAZwaRmBVPpXA2SFhMGW9%2Fexport-1778506924396-30fps.gif?alt=media&amp;token=96f3f1a7-fce4-4508-b1b0-e8b6294dc423" alt=""><figcaption></figcaption></figure>

Behandle deinen API-Schlüssel wie ein Passwort und vermeide es, ihn in Screenshots oder Repositories offenzulegen.
{% endstep %}
{% endstepper %}

### <i class="fa-terminal">:terminal:</i> Unsloth-Ausführungsbefehl

1. **Installiere oder aktualisiere Unsloth Studio.** Frühere Versionen stellen die externe API nicht bereit. Siehe Installation.
2. **Lade ein GGUF-Modell.** Lade ein GGUF-Modell mit dem Run-Befehl. Dadurch wird auch die Benutzeroberfläche auf dem Standardport geladen. Die Endpunkt-URL und der API-Schlüssel werden in der Konsole ausgegeben und können direkt mit deinem bevorzugten Client verwendet werden.

   ```bash
   unsloth run --model unsloth/qwen3.8-27B-GGUF-GGUF:UD-Q4_K_XL
       --temp 1.0 \\
       --top-p 0.95 \\
       --top-k 20 \\
       --min-p 0.0 \\
       --chat-template-kwargs '{"reasoning_effort":"medium"}'
   ```

Passe die Einstellungen nach Bedarf an.

#### Ein Modell über die CLI laden

Du kannst ein Modell laden und dir automatisch einen API-Schlüssel erstellen lassen, indem du das `unsloth` CLI-Tool verwendest. Wenn das Modell fertig geladen ist, werden die Endpunkt-URL und der API-Schlüssel in deiner Konsole ausgegeben. Kopiere sie in deinen bevorzugten Client, und schon kann es losgehen.

#### Bevor du beginnst

Stelle sicher, dass du eine aktuelle Version von Unsloth Studio verwendest, da frühere Versionen die externe API nicht bereitstellen. Siehe [Installation](/docs/de/neu/studio/install.md).

#### Der schnelle Weg

Öffne ein Terminal und lade ein GGUF-Modell:

```bash
unsloth run --model unsloth/gemma-4-26B-A4B-it-GGUF:UD-Q4_K_XL
```

Dadurch startet der Server auf dem Standardport, die Benutzeroberfläche wird geladen und deine Endpunkt-URL sowie dein API-Schlüssel werden ausgegeben.

#### Wie der Modellname funktioniert

Du kannst auf ein Modell auf verschiedene Arten verweisen. Wähle die, die dir am einfachsten erscheint:

```bash
# Kombiniert: Repo und Quantisierungsvariante in einem String (empfohlen – am kürzesten)
unsloth run --model unsloth/gemma-4-26B-A4B-it-GGUF:UD-Q4_K_XL

# Getrennt: Repo und Variante als zwei Flags (der ältere Stil, funktioniert weiterhin)
unsloth run --model unsloth/gemma-4-26B-A4B-it-GGUF --gguf-variant UD-Q4_K_XL

# Mit -hf / --hf-repo (entspricht der Schreibweise von llama.cpp, praktisch, wenn du von dort kommst)
unsloth run -hf unsloth/gemma-4-26B-A4B-it-GGUF:UD-Q4_K_XL
```

### Den Lauf anpassen (optional)

Für einen einfachen Ladevorgang brauchst du nichts davon, aber `unsloth run` unterstützt viele llama-server-Laufzeitflags zur Anpassung von Leistung, Speichernutzung, Kontextlänge, Generierungsverhalten, Netzwerk und Tool-Zugriff.

Zusätzliche Flags werden direkt an den zugrunde liegenden Inferenzserver weitergeleitet, und deine Werte überschreiben die Standardwerte von Unsloth. Wenn keine Einstellungs-/Sampling-Flags gesetzt sind, wählt Unsloth automatisch die besten/empfohlenen Einstellungen für das Modell, einschließlich Kontextlänge, Temperatur usw.

#### Steuere das Reasoning-Verhalten

Einige Modelle mit Reasoning-Fähigkeit unterstützen zusätzliche Flags zur Steuerung des Denk- und Reasoning-Verhaltens.

```bash
# Reasoning-/Denkausgabe deaktivieren
unsloth run \\
  --model unsloth/Qwen3.8-27B-GGUF:UD-Q4_K_XL \\
  --reasoning on  \\
  --reasoning-effort medium
```

Reasoning-Aufwand und Flags hängen davon ab, was das Modell unterstützt.

#### Generierungsverhalten anpassen

Sampling-Einstellungen steuern, wie kreativ, fokussiert oder deterministisch sich das Modell bei der Generierung verhält.

```bash
# Zufälligkeit verringern und Reproduzierbarkeit verbessern
unsloth run \\
  --model unsloth/Qwen3-1.7B-GGUF \\
  --temp 0.6 \\
  --seed 42
```

Niedrigere Temperaturwerte erzeugen normalerweise stabilere Ausgaben, während top-p-, top-k-, min-p- und Repeat-Penalty-Einstellungen die Tokenauswahl und Wiederholung weiter steuern.

```bash
# Tokenauswahl und Wiederholungsverhalten anpassen
unsloth run \\
  --model unsloth/Qwen3-1.7B-GGUF \\
  --top-p 0.95 \\
  --top-k 20 \\
  --min-p 0.05 \\
  --repeat-penalty 1.1
```

#### Kontextlänge und CPU-Threads erhöhen

Nützlich, wenn du mit großen Projekten, langen Chats oder Agent-Workflows arbeitest, die mehr Speicher benötigen.

```bash
# Ein größeres Kontextfenster und mehr CPU-Threads verwenden
unsloth run \\
  --model unsloth/gemma-4-26B-A4B-it-GGUF:UD-Q4_K_XL \\
  -c 131072 \\
  --threads 32
```

#### Die API im lokalen Netzwerk freigeben

Standardmäßig läuft Unsloth nur lokal auf deinem Rechner. Du kannst die API anderen Geräten in deinem Netzwerk zugänglich machen, indem du an `0.0.0.0`.

```bash
# LAN-Geräten die Verbindung erlauben
unsloth run \\
  --model unsloth/gemma-4-26B-A4B-it-GGUF:UD-Q4_K_XL \\
  -H 0.0.0.0 \\
  -p 8888
```

#### Serverseitige Tools aktivieren oder deaktivieren

Steuere, ob Tools wie Websuche und Code-Ausführung vom Inferenzserver bereitgestellt werden.

```bash
# Tools explizit aktivieren
unsloth run \\
  --model unsloth/gemma-4-26B-A4B-it-GGUF:UD-Q4_K_XL \\
  --enable-tools
```

```bash
# Tools explizit deaktivieren
unsloth run \\
  --model unsloth/gemma-4-26B-A4B-it-GGUF:UD-Q4_K_XL \\
  --disable-tools
```

Unsloth unterstützt die meisten llama-server-Laufzeitflags, einschließlich Kontextgröße, GPU-Layer, Threading, Sampling, Netzwerk und Tool-Konfiguration.

Siehe die [llama-server](https://github.com/ggml-org/llama.cpp/tree/master/tools/server) Dokumentation für die vollständige Liste der unterstützten Laufzeitflags.

#### **Richtlinie für serverseitige Tools**

`unsloth run` steuert, ob serverseitige Tools (Websuche, Code-Ausführung usw.) vom Inferenzserver bereitgestellt werden. Die Standardwerte basieren auf der Bind-Adresse:

* **`127.0.0.1` (localhost)** — Tools **ein** standardmäßig. Nur dein Rechner kann den Server erreichen.
* **`0.0.0.0` oder jede Nicht-Loopback-Adresse** — Tools **aus** standardmäßig. Ein geleakter API-Schlüssel auf einem im Netzwerk exponierten Server bedeutet beliebige Code-Ausführung auf dem Host.

**Flags:**

* `--enable-tools` / `--disable-tools` — erzwingt ein oder aus. Ein `0.0.0.0`, `--enable-tools` zeigt eine Sicherheitsabfrage mit y/N an.
* `--yes` / `-y` — überspringt die Abfrage (für Automatisierung).

Die festgelegte Richtlinie ist ein harter Override auf Prozessebene — einzelne Anfragen können sie nicht umgehen über `enable_tools=true` im Request-Body.

<div data-with-frame="true"><figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FeIJIvZl7HvOCjtVPm3en%2Funsloth_run_model.png?alt=media&amp;token=84c45c38-78a9-4b55-b9b7-08bad9dc6238" alt=""><figcaption></figcaption></figure></div>

### 🌐 **Endpunkte**

Unsloth stellt diese Endpunkte auf dem Port bereit, auf dem es gestartet wurde (typischerweise `http://localhost:8000` oder `http://localhost:8888`):

| Endpunkt                    | Kompatibel mit              | Verwende es mit                                                      |
| --------------------------- | --------------------------- | -------------------------------------------------------------------- |
| `POST /v1/messages`         | Anthropic Messages API      | Claude Code, Anthropic SDK, OpenClaw, alles, was Anthropic spricht   |
| `POST /v1/chat/completions` | OpenAI Chat Completions API | OpenAI SDK, opencode, Cursor, Continue, Cline, Open WebUI, curl usw. |
| `GET /v1/models`            | OpenAI-Modellliste          | Listet die aktuell in Unsloth geladenen Modelle auf                  |

Authentifiziere dich mit einem `Authorization: Bearer sk-unsloth-…` Header bei jeder Anfrage.

{% hint style="info" %}
Du musst für die beiden Formate keine unterschiedlichen Server betreiben. Unsloth behandelt beide auf demselben Port.
{% endhint %}

### 🖇️ Deinen Client verbinden

Unsloth ermöglicht es dir, lokale LLMs über die meisten Frameworks auszuführen, einschließlich [Claude Code](/docs/de/grundlagen/claude-code.md), [Codex](/docs/de/grundlagen/codex.md), [OpenClaw](/docs/de/integrationen/openclaw.md), [OpenCode](/docs/de/integrationen/opencode.md) und mehr. Klicke unten auf die jeweiligen Tools für eine Anleitung:

{% columns %}
{% column width="50%" %}
{% content-ref url="/pages/d12c953ceacbd6c3e44f3aa911056928e0488f5b" %}
[Claude Code](/docs/de/grundlagen/claude-code.md)
{% endcontent-ref %}

{% content-ref url="/pages/1813c928d883d651dff92062bc0da6e96d06e50a" %}
[OpenAI Codex](/docs/de/grundlagen/codex.md)
{% endcontent-ref %}

{% content-ref url="/pages/cede767fc3b9f7535c2c3cc36963872488a3bd1d" %}
[Curl & HTTP](/docs/de/integrationen/curl-und-http-mit-unsloth-verbinden.md)
{% endcontent-ref %}
{% endcolumn %}

{% column width="50%" %}
{% content-ref url="/pages/4ad33e7ce59bb7203a1fddd7e6e0102f70c191db" %}
[OpenClaw](/docs/de/integrationen/openclaw.md)
{% endcontent-ref %}

{% content-ref url="/pages/69edb30cadb1e5ecada5bd2a700b63f49e94955f" %}
[OpenCode](/docs/de/integrationen/opencode.md)
{% endcontent-ref %}

{% content-ref url="/pages/67298920320a528a941c4123bc768cc0a79e7332" %}
[Python SDK](/docs/de/integrationen/python-sdk-mit-unsloth-verbinden.md)
{% endcontent-ref %}
{% endcolumn %}
{% endcolumns %}

Um diesen Endpunkt von einem anderen Rechner aus zu erreichen, starte mit `unsloth studio --secure`. Unsloth bleibt an localhost gebunden und stellt sich unter einer kostenlosen Cloudflare-HTTPS-URL bereit; verwende diese URL anstelle von `http://127.0.0.1:8888` als Basis-URL deines Clients. Beachte, dass servergesendete Ereignisse einen Cloudflare Quick Tunnel nicht überstehen; setze daher `stream: false` wenn du über einen solchen verbindest.

### 🧰 Tool-Calling

Beide Endpunkte unterstützen Function-/Tool-Calling in ihrem nativen Format sowie eine Unsloth-spezifische Kurzform für die eingebauten Tools von Unsloth.

**Tools im OpenAI-Stil:** sende `Tools` und `tool_choice` an `/v1/chat/completions` genau so, wie du es mit OpenAI tun würdest. Claude Code (über `/v1/messages`)

**Tools im Anthropic-Stil:** sende `Tools` (mit `input_schema`) und `tool_choice` an `/v1/messages` genau so, wie du es mit Claude tun würdest.

Unsloth-Tools auf Serverseite: Unsloth kann Python, Websuche und Bash ausführen *serverseitig* und die Ergebnisse als `tool_result` Ereignisse zurückstreamen. Aktiviere dies, indem du diese zusätzlichen Felder zu einem der beiden Endpunkte hinzufügst:

```json
{
  "messages": [{"role": "user", "content": "Was ist 123 * 456? Verwende Python."}],
  "stream": true,
  "enable_tools": true,
  "enabled_tools": ["python", "web_search","terminal"],
  "session_id": "my-session"
}
```

Das Modell sieht die Ausgabe jedes Tools in seinem nächsten Durchlauf. Für eine ausführlichere Abdeckung (Schemas, Streaming-Ereignisse, Verkettung) siehe .

{% hint style="info" %}
Wenn du den Anthropic `/v1/messages` Endpunkt, `tool_choice` lässt sich sauber zuordnen: Anthropic `auto` → OpenAI `auto`, Anthropic `beliebig` → OpenAI `erforderlich`, Anthropic `{type: "tool", name: "x"}` → OpenAI `{type: "function", function: {name: "x"}}`, Anthropic `keins` → OpenAI `keins`.
{% endhint %}

### 📈 API-Monitor

Jeder Aufruf über diesen Endpunkt wird in Studio live an zwei Stellen angezeigt:

Das Seitenpanel des API-Monitors öffnet sich automatisch in der Ecke, sobald API-Schlüssel-Traffic eingeht. Es fasst das aktive Modell, Live-Anfragen, Fehler und die durchschnittliche Latenz zusammen.

<div data-with-frame="true"><figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FqbcbkrU9tnkg5VCnDzCz%2Fimage.png?alt=media&amp;token=733b2b37-4e57-48c6-b826-9f356d648344" alt=""><figcaption></figcaption></figure></div>

Klicke auf "Zum vollständigen Monitor erweitern" oder gehe zu Einstellungen > API-Monitor, um zur vollständigen **API** Seite zu gelangen, auf der Modellladen, Prompts, Antworten, Token-Zahlen, Time-to-First-Token, Durchsatz und Fehlermeldungen im Monitor angezeigt werden.

<div data-with-frame="true"><figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FfjIh57Mb278c072g27nk%2Fimage.png?alt=media&amp;token=3a236c7c-1f00-430b-92f3-42799346aa3c" alt="" width="563"><figcaption></figcaption></figure></div>

### ❔ Fehlerbehebung

**`401 Unauthorized`** : entweder ist der `Authorization` Header fehlt oder der Schlüssel ist falsch. Schlüssel müssen als `Authorization: Bearer sk-unsloth-…`. Wenn du den Schlüssel verloren hast, erstelle einen neuen unter **Einstellungen → API.** Unsloth zeigt alte Schlüssel nach der Erstellung nicht an.

**`Verbindung zum Modellserver verloren`** : Unsloth konnte den zugrunde liegenden llama.cpp-Server nicht erreichen. In der Regel wurde das Modell zwar fertig geladen, ist dann aber abgestürzt, oder der Modell-Tab wurde in Unsloth geschlossen. Lade das Modell erneut von **Neuer Chat** und versuche es erneut.

**Claude Code zeigt das standardmäßige Anthropic-Modell an, nicht mein lokales** :  überprüfe, ob alle drei Umgebungsvariablen in der **derselben** Shell exportiert sind, in der du `claude`:

```bash
echo $ANTHROPIC_BASE_URL
echo $ANTHROPIC_AUTH_TOKEN
echo $ANTHROPIC_MODEL
```

Dann führe `/model` in Claude Code aus, um es zu bestätigen. Unter Windows PowerShell verwende `$env:ANTHROPIC_BASE_URL` usw.

**`stream: true` liefert einen einzelnen JSON-Block statt SSE** :  stelle sicher, dass du den richtigen Pfad triffst (`/v1/messages` oder `/v1/chat/completions`) und dass dein HTTP-Client die Antwort tatsächlich als Stream verarbeitet und nicht puffert.

**Ich kann den Namen des Modells nicht finden, um es opencode (oder OpenClaw / einem anderen Client) hinzuzufügen** : frage direkt bei Unsloth nach. `GET /v1/models` liefert die genaue Modell-ID, die du in das Feld „Model ID“ des Clients eintragen musst:

```bash
curl http://localhost:8888/v1/models \
  -H "Authorization: Bearer sk-unsloth-xxxxxxxxxxxx"
```

Du erhältst ein JSON-Payload in der Form `{"data": [{"id": "gemma-4-26B-A4B-it-GGUF", ...}]}`. Kopiere den `ID` Wert, das ist die Zeichenfolge, die opencode erwartet **Modell-ID** Feld (linke Spalte) und OpenClaws `models[].id` erwarten. Der Anzeigename rechts ist alles, was die Benutzer sehen sollen.

**Tool-Aufrufe werden nicht ausgeführt** :  Das Modell muss Tool-Calling für clientseitige Tools unterstützen (`Tools` / `tool_choice`). Denk bei Unsloths integrierten Tools daran, `enable_tools: true` **und** die gewünschten in `enabled_tools` (z. B. `["python", "web_search"]`).

* **Mein Client meldet einen Verbindungsfehler.** Öffne den API-Monitor. Keine Zeile für den Aufruf bedeutet, dass er Unsloth nie erreicht hat; vergleiche die Base-URL deines Clients mit der **Base-URL** oben auf dieser Seite angezeigt wird.
* **Die Antwort wird abgeschnitten.** Prüfe **Verwendeter Kontext** für die Anfrage im API-Monitor. Nahe 100 % oder ein Stoppgrund von `length`, bedeutet, dass das Kontextfenster vollgelaufen ist, statt dass das Modell fehlgeschlagen ist.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://unsloth.ai/docs/de/grundlagen/api.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.