# Wie man Unsloth als API-Endpunkt verwendet

Sie können **lokale LLMs** mit Tools wie [Claude Code](/docs/de/grundlagen/claude-code.md) und [Codex](/docs/de/grundlagen/codex.md) verwenden, indem Sie diese Tools mit Unsloths **OpenAI-kompatiblem API-Endpunkt**verbinden. Damit können Sie Modelle wie [Qwen](/docs/de/modelle/qwen3.6.md) und [Gemma](/docs/de/modelle/gemma-4.md) lokal für agentisches Codieren ausführen. Unsloth bietet 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 hilft, fehlerhafte oder fehlerhaft formatierte Tool-Aufrufe um 50 % zu reduzieren
* [**Code-Ausführung**](/docs/de/neu/studio/chat.md#code-execution) Unterstützung, die Bash- und Python-Ausführung 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 ausführliche 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`bereitgestellt. Aus Sicherheitsgründen wird ein langer API-Schlüssel generiert, ähnlich wie OpenAI einen bereitstellt.

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

{% column %}

<figure><img src="/files/4d7f67e24fb64209883a9782fb1c8e4d7782a66f" alt=""><figcaption></figcaption></figure>
{% endcolumn %}
{% endcolumns %}

* **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

1. **Installieren oder aktualisieren Sie** [**Unsloth Studio**](/docs/de/neu/studio.md)**.** Dann starten Sie Unsloth.
2. **Laden Sie ein Modell.** Klicken Sie auf **Neuer Chat**, wählen oder suchen Sie ein Modell (GGUF) und warten Sie, bis das Laden abgeschlossen ist.
3. **Erstellen Sie einen API-Schlüssel.** Klicken Sie auf Ihr **Unsloth** Avatar unten links → **Einstellungen** → **API** → geben Sie einen Schlüsselnamen ein → **Erstellen**. Kopieren Sie den `sk-unsloth-…` Wert, der erscheint. Unsloth zeigt ihn nur einmal an.
4. **Richten Sie Ihren Client auf Unsloth aus.** Verwenden Sie `http://localhost:PORT` als Basis-URL und Ihren `sk-unsloth-…` Schlüssel zur Authentifizierung. Springen Sie unten zur Anleitung für Ihr Tool.

### 🔑 Einen API-Schlüssel erstellen

1. Öffnen Sie die Seitenleiste und klicken Sie unten links auf Ihren **Unsloth** Avatar.
2. Gehen Sie zu **Einstellungen** → **API** (Globus :globe\_with\_meridians: -Symbol).
3. Geben Sie einen freundlichen Namen ein (z. B. `claude-code-macbook`). Legen Sie ein Ablaufdatum fest (optional)
4. Klicken Sie auf **Erstellen**.
5. **Kopieren Sie den Schlüssel.** Unsloth speichert nur einen Hash, und Sie können ihn nicht erneut anzeigen.

<div data-with-frame="true"><figure><img src="/files/67a8c8b8df05a09f74fb22b504d79bc62f7b6236" alt="" width="375"><figcaption></figcaption></figure></div>

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

{% hint style="warning" %}
Behandeln Sie Ihren API-Schlüssel wie ein Passwort. Jeder mit dem Schlüssel und Netzwerkzugriff auf Ihre Unsloth-Instanz kann Anfragen an Ihr geladenes Modell senden.
{% endhint %}

### ⏳ Modellladen

{% stepper %}
{% step %}

#### Modell auswählen

Bevor Sie die API verwenden, laden Sie ein Modell über das Dropdown-Menü **Modell auswählen** oben links auf der Chat-Seite.

<figure><img src="/files/35a6966ece42497bdc299b98050269c7636c7c98" alt=""><figcaption></figcaption></figure>

In dieser Anleitung verwenden wir:

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

{% step %}

#### Modell testen

Bevor Sie den Client verwenden, senden Sie eine kurze Nachricht:

<div data-with-frame="true"><figure><img src="/files/245fe14776c68639a801acfab0d58e75d6cf1ce4" alt="" width="563"><figcaption></figcaption></figure></div>

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

{% step %}

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

Öffnen Sie in Studio **Einstellungen → API** um Ihren API-Schlüssel anzuzeigen oder zu erstellen.

<figure><img src="/files/96dbb4b6e52ce8bc33d050cacf1e90d03b66c1ae" alt=""><figcaption></figcaption></figure>

Behandeln Sie Ihren API-Schlüssel wie ein Passwort und vermeiden Sie, ihn in Screenshots oder Repositories offenzulegen.
{% endstep %}
{% endstepper %}

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

1. **Installieren oder aktualisieren Sie Unsloth Unsloth.** Frühere Versionen stellen die externe API nicht bereit. Siehe Installation.
2. **Laden Sie ein GGUF-Modell.** Laden Sie ein GGUF-Modell mit dem Ausführungsbefehl. Dadurch wird auch die Benutzeroberfläche auf dem Standardport geladen. Die Endpunkt-URL und der API-Schlüssel werden in der Konsole ausgegeben und stehen Ihnen dann für den Client Ihrer Wahl zur Verfügung.

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

#### Ein Modell über die CLI laden

Sie können ein Modell laden und automatisch einen API-Schlüssel für sich erstellen lassen, indem Sie das `unsloth` CLI-Tool verwenden. Wenn das Modell fertig geladen ist, werden die Endpunkt-URL und der API-Schlüssel in Ihrer Konsole ausgegeben. Kopieren Sie sie in Ihren bevorzugten Client, und schon kann es losgehen.

#### Bevor Sie beginnen

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

#### Der schnelle Weg

Öffnen Sie ein Terminal und laden Sie ein GGUF-Modell:

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

Dies startet den Server auf dem Standardport, lädt die Benutzeroberfläche und gibt Ihre Endpunkt-URL und Ihren API-Schlüssel aus.

#### Wie der Modellname funktioniert

Sie können ein Modell auf verschiedene Arten angeben. Wählen Sie die, die Ihnen 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 Sie von dort kommen)
unsloth run -hf unsloth/gemma-4-26B-A4B-it-GGUF:UD-Q4_K_XL
```

#### Lauf anpassen (optional)

Für das grundlegende Laden brauchen Sie das alles nicht, aber wenn Sie mehr Kontrolle möchten, können Sie zusätzliche Flags übergeben, und sie werden direkt an das zugrunde liegende `llama-server`weitergeleitet. Ihre Werte überschreiben die Standardwerte von Studio.

Ein paar Beispiele:

```bash
# Größeres Kontextfenster setzen und Threads festlegen
unsloth run --model unsloth/gemma-4-26B-A4B-it-GGUF:UD-Q4_K_XL -c 131072 --threads 32

# Sampling anpassen
unsloth run --model unsloth/Qwen3-1.7B-GGUF --top-k 20 --seed 42

# Eine benutzerdefinierte Chat-Vorlage verwenden
unsloth run --model unsloth/gemma-4-26B-A4B-it-GGUF:UD-Q4_K_XL \
  --chat-template-file /path/to/template.jinja
```

Die meisten `llama-server` Flags funktionieren für Dinge wie Kontextgröße, GPU-Layer, Sampling-Parameter, KV-Cache-Typen, Reasoning-Einstellungen und so weiter. Siehe die [llama-server-Dokumentation](https://github.com/ggml-org/llama.cpp/tree/master/tools/server) für die vollständige Liste.

#### **Serverseitige Tool-Richtlinie**

`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 **standardmäßig** ein. Nur Ihr 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 netzwerkzugänglichen Server bedeutet beliebige Codeausführung auf dem Host.

**Flags:**

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

Die aufgelöste Richtlinie ist eine harte Überschreibung auf Prozessebene — einzelne Anfragen können sie nicht umgehen über `enable_tools=true` im Request-Body.

<div data-with-frame="true"><figure><img src="/files/64c4a3226214c0d7de03f170ef9efa901a01176b" alt=""><figcaption></figcaption></figure></div>

### 🌐 **Endpunkte**

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

| Endpunkt                    | Kompatibel mit              | Verwenden Sie es von                                                 |
| --------------------------- | --------------------------- | -------------------------------------------------------------------- |
| `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-Modelleliste         | Listet die in Unsloth derzeit geladenen Modelle auf                  |

Authentifizieren Sie sich mit einem `Authorization: Bearer sk-unsloth-…` Header bei jeder Anfrage.

{% hint style="info" %}
Sie müssen für die beiden Formate keine unterschiedlichen Server ausführen. Studio verarbeitet beide über denselben Port.
{% endhint %}

### 🖇️ Ihren Client verbinden

Unsloth ermöglicht es Ihnen, lokale LLMs über die meisten Frameworks auszuführen, darunter [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. Klicken Sie unten auf die jeweiligen Tools, um eine Anleitung zu erhalten:

{% 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-and-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 %}

### 🧰 Tool-Calling

Beide Endpunkte unterstützen Funktions- / Tool-Calling im nativen Format sowie eine Unsloth-spezifische Kurzform für die integrierten Tools von Studio.

**OpenAI-Stil Tools:** senden Sie `Tools` und `tool_choice` an `/v1/chat/completions` genau so, wie Sie es mit OpenAI tun würden. Claude Code (über `/v1/messages`), opencode, Cursor, Continue und Cline funktionieren direkt ohne Einrichtung.

**Anthropic-Stil Tools:** senden Sie `Tools` (mit `input_schema`) und `tool_choice` an `/v1/messages` genau so, wie Sie es mit Claude tun würden.

**Tools auf Studio-Serverseite:** Studio kann Python, Websuche und bash ausführen *serverseitig* und die Ergebnisse als `tool_result` Ereignisse zurückstreamen. Aktivieren Sie dies, indem Sie diese zusätzlichen Felder zu einem der beiden Endpunkte hinzufügen:

```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 Sie den Anthropic `/v1/messages` Endpunkt `tool_choice` verwenden, `wird sauber zugeordnet: Anthropic` auto `wird sauber zugeordnet: Anthropic`→ OpenAI `jede` auto `erforderlich`→ OpenAI `{type: "tool", name: "x"}` auto `{type: "function", function: {name: "x"}}`→ OpenAI `keine` auto `keine`.
{% endhint %}

### ❔ Fehlerbehebung

**`401 Unauthorized`** : entweder fehlt der `Authorization` Header oder der Schlüssel ist falsch. Schlüssel müssen als `Authorization: Bearer sk-unsloth-…`übergeben werden. Wenn Sie den Schlüssel verloren haben, erstellen Sie einen neuen unter **Einstellungen → API.** Studio zeigt nach der Erstellung keine alten Schlüssel an.

**`Verbindung zum Modellserver verloren`** : Studio konnte den zugrunde liegenden llama.cpp-Server nicht erreichen. Meistens war das Modell fertig geladen, ist aber abgestürzt, oder der Modell-Tab wurde in Studio geschlossen. Laden Sie das Modell erneut von **Neuer Chat** und versuchen Sie es erneut.

**Claude Code zeigt das Standard-Anthropic-Modell an, nicht mein lokales** : prüfen Sie, ob alle drei Umgebungsvariablen im **gleichen** Shell exportiert sind, in dem Sie `claude`:

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

Dann führen Sie `/model` innerhalb von Claude Code aus, um es zu bestätigen. Unter Windows PowerShell verwenden Sie `$env:ANTHROPIC_BASE_URL` usw.

**`stream: true` gibt einen einzelnen JSON-Blob statt SSE zurück** : stellen Sie sicher, dass Sie den richtigen Pfad treffen (`/v1/messages` oder `/v1/chat/completions`) und dass Ihr HTTP-Client die Antwort tatsächlich als Stream verarbeitet und nicht puffert.

**Ich finde den Namen des Modells nicht, den ich zu opencode (oder OpenClaw / jedem anderen Client) hinzufügen soll** : fragen Sie direkt Studio. `GET /v1/models` gibt die genaue Modell-ID zurück, die Sie in das Feld "Model ID" des Clients eintragen müssen:

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

Sie erhalten eine JSON-Nutzlast in der Form `{"data": [{"id": "gemma-4-26B-A4B-it-GGUF", ...}]}`. Kopieren Sie den `id` Wert, das ist die Zeichenkette, die das Feld **Model ID** von opencode (linke Spalte) und `models[].id` von OpenClaw erwarten. Der Anzeigename rechts ist beliebig und wird den Nutzern so angezeigt, wie Sie es möchten.

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


---

# Agent Instructions: 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:

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

The question should be specific, self-contained, and written in natural language.
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.
