> 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

Sie können **lokale LLMs** mit Tools wie [Claude Code](/docs/de/grundlagen/claude-code.md) und [Codex](/docs/de/grundlagen/codex.md) ausführen, indem Sie diese Tools mit Unsloths **OpenAI-kompatiblem API-Endpunkt**. So können Sie Modelle wie [Qwen](/docs/de/modelle/qwen3.6.md) und [Gemma](/docs/de/modelle/gemma-4.md) lokal für agentisches Programmieren ausführen. Unsloth bietet außerdem nützliche Funktionen wie selbstheilende **Tool-Aufrufe**, **Codeausführung**und **Websuche**.

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

* [**Selbstheilende Tool-Aufrufe**](/docs/de/neu/studio/chat.md#auto-healing-tool-calling), die dabei helfen, fehlerhafte oder missformte Tool-Aufrufe um 50 % zu reduzieren
* [**Codeausführung**](/docs/de/neu/studio/chat.md#code-execution) Unterstützung, wodurch Bash- und Python-Ausführung für genauere Codeausgaben möglich wird.
* **Fortgeschrittene** [**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 auf demselben Port. Beide unterstützen Streaming, Tool-Aufrufe (OpenAI `Tools` / Anthropic `Tools`), und 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 %}

Unabhängig davon, ob Ihr Modell über Unsloths Inferenz oder über Ihren eigenen Remote-OpenAI-kompatiblen Endpunkt läuft, können Sie ihm Zugriff auf Unsloths vollständige Tool-Suite geben, einschließlich Websuche, Codeausführung, tiefgehender Recherche 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 Weg, loszulegen, ist die Installation der [Unsloth Desktop](/docs/de/desktop.md) App. Sie unterstützt [macOS](/docs/de/loslegen/install/mac.md), Linux, [Windows](/docs/de/loslegen/install/windows-installation.md), [NVIDIA](/docs/de/loslegen/install/pip-install.md), [AMD](/docs/de/loslegen/install/amd.md), Intel- und CPU-Setups.

<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 Sie eine manuelle Installation bevorzugen:

**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. Öffnen Sie das Unsloth-Installationsprogramm (`.dmg`, `.exe` Dateien)
2. Ziehen Sie Unsloth unter Anwendungen auf dem Mac oder schließen Sie die Einrichtung für Windows ab.
3. Starten Sie die App und warten Sie, bis die Installation abgeschlossen ist
   {% endstep %}

{% step %}

#### Wählen Sie ein Modell

Öffnen Sie das Dropdown-Menü „Modell auswählen“ oben oder den Tab „Model hub“, wählen Sie ein Modell und eine Quantisierung, die zu Ihrem Gerät passt, und laden Sie es dann herunter. Sobald der Download abgeschlossen ist, können Sie 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, geben Sie eine Nachricht ein und drücken Sie Enter.

* **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 angezeigt wird. Unsloth zeigt ihn nur einmal an.
* **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.

<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. Öffnen Sie die Seitenleiste und klicken Sie unten links auf Ihr **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. **Schlüssel kopieren.** Unsloth speichert nur einen Hash, und Sie können 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. Sie können einen Schlüssel jederzeit auf derselben Seite widerrufen. Anfragen mit einem widerrufenen Schlüssel schlagen mit `401 Unauthorized`.

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

### ⏳ Modell wird geladen

{% stepper %}
{% step %}

#### Modell auswählen

Bevor Sie die API verwenden, laden Sie ein Modell aus dem **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 %}

#### Das Modell testen

Bevor Sie den Client verwenden, senden Sie 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 ist zu antworten.
{% endhint %}
{% endstep %}

{% step %}

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

Öffnen Sie in Unsloth **Einstellungen → API** um Ihren 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>

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

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

1. **Installieren oder aktualisieren Sie Unsloth Studio.** 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, damit Sie sie sofort mit Ihrem bevorzugten Client verwenden können.

   ```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"}'
   ```

Passen Sie die Einstellungen nach Bedarf an.

#### Ein Modell über die CLI laden

Sie können ein Modell laden und sich automatisch einen API-Schlüssel 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
```

Dadurch wird der Server auf dem Standardport gestartet, die Benutzeroberfläche geladen und Ihre Endpunkt-URL sowie Ihr API-Schlüssel ausgegeben.

#### Wie der Modellname funktioniert

Sie können ein Modell auf verschiedene Arten angeben. Wählen Sie die für Sie einfachste:

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

# Getrennt: Repository 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
```

### Den Lauf anpassen (optional)

Sie brauchen davon nichts für einen einfachen Ladevorgang, aber `unsloth run` unterstützt viele Laufzeit-Flags von llama-server zur Anpassung von Leistung, Speichernutzung, Kontextlänge, Generierungsverhalten, Netzwerk und Tool-Zugriff.

Zusätzliche Flags werden direkt an den zugrunde liegenden Inferenzserver weitergeleitet, und Ihre 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.

#### Das Reasoning-Verhalten steuern

Einige reasoning-fähige Modelle unterstützen zusätzliche Flags zur Steuerung von Denken und Reasoning-Verhalten.

```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.

#### Das Generierungsverhalten anpassen

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

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

Niedrigere Temperaturwerte erzeugen in der Regel stabilere Ausgaben, während Top-p-, Top-k-, Min-p- und Repeat-Penalty-Einstellungen die Token-Auswahl und Wiederholung weiter steuern.

```bash
# Token-Auswahl und Wiederholungsverhalten fein abstimmen
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 Sie mit großen Projekten, langen Chats oder Agenten-Workflows arbeiten, die mehr Speicher benötigen.

```bash
# 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 in Ihrem lokalen Netzwerk bereitstellen

Standardmäßig läuft Unsloth nur lokal auf Ihrem Rechner. Sie können die API anderen Geräten in Ihrem Netzwerk zugänglich machen, indem Sie binden 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

Steuern Sie, ob Tools wie Websuche und Codeausfü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 Runtime-Flags von llama-server, einschließlich Kontextgröße, GPU-Ebenen, 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 Runtime-Flags.

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

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

* **`127.0.0.1` (localhost)** — Tools **an** standardmäßig. Nur Ihr Rechner kann den Server erreichen.
* **`0.0.0.0` oder jede andere Nicht-Loopback-Adresse** — Tools **aus** standardmäßig. Ein geleakter API-Schlüssel auf einem netzwerkseitig erreichbaren Server bedeutet beliebige Codeausführung auf dem Host.

**Flags:**

* `--enable-tools` / `--disable-tools` — erzwingt an 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 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 seine API auf dem Port bereit, auf dem es gestartet wurde, typischerweise `http://localhost:8000` oder `http://localhost:8888`.

Authentifizieren Sie sich mit einem `Authorization: Bearer sk-unsloth-…` Header in jeder Anfrage. Die Verfügbarkeit der Endpunkte hängt von Ihrer Unsloth-Version, dem Backend und dem Modell ab.

**Chat und Text**

| Endpunkt                    | Zweck                                                                                      |
| --------------------------- | ------------------------------------------------------------------------------------------ |
| `POST /v1/chat/completions` | OpenAI-kompatible Chat-Completions, einschließlich Streaming und Tool-Aufrufe.             |
| `POST /v1/responses`        | OpenAI-kompatible Responses-API für Codex und andere kompatible Clients.                   |
| `POST /v1/messages`         | Anthropic-kompatible Messages-API für Claude Code, OpenClaw und andere kompatible Clients. |
| `POST /v1/completions`      | Text-Completions ohne Chat-Formatierung. Erfordert ein GGUF- oder MLX-Modell.              |

Für Responses-Anfragen senden Sie den Gesprächsverlauf in `input`. Serververwalteter Verlauf über `previous_response_id` oder `conversation` wird nicht unterstützt.

**Modelle, Embeddings und Tokenzählung**

| Endpunkt                         | Zweck                                                                                                                                        |
| -------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
| `GET /v1/models`                 | Aufgelistete geladene und lokal verfügbare Modelle. Prüfen Sie `loaded` um Modelle zu identifizieren, die sich derzeit im Speicher befinden. |
| `GET /v1/models/{model_id}`      | Metadaten für ein Modell abrufen.                                                                                                            |
| `GET /v1/props`                  | Llama-server-kompatible Servereigenschaften lesen.                                                                                           |
| `POST /v1/embeddings`            | Embeddings mithilfe eines geladenen Embedding-GGUFs oder von Unsloths konfiguriertem Embedding-Modell erzeugen.                              |
| `POST /v1/chat/count_tokens`     | Prompt-Tokens für Nachrichten im OpenAI-Format zählen.                                                                                       |
| `POST /v1/messages/count_tokens` | Input-Tokens für Nachrichten im Anthropic-Format zählen.                                                                                     |

**Bilder**

| Endpunkt                      | Zweck                                                                                   |
| ----------------------------- | --------------------------------------------------------------------------------------- |
| `POST /v1/images/generations` | Bilder aus einer Eingabeaufforderung mit einem unterstützten Diffusionsmodell erzeugen. |

**Audio**

| Endpunkt                        | Zweck                                                                                                                |
| ------------------------------- | -------------------------------------------------------------------------------------------------------------------- |
| `POST /v1/audio/speech`         | OpenAI-kompatible Text-zu-Sprache.                                                                                   |
| `POST /v1/audio/generate`       | Sprache aus Nachrichten im Chat-Format erzeugen; gibt base64-WAV-Audio zurück.                                       |
| `POST /v1/audio/transcriptions` | Eine hochgeladene Audiodatei transkribieren.                                                                         |
| `POST /v1/audio/translations`   | Sprache in einer hochgeladenen Audiodatei ins Englische übersetzen.                                                  |
| `POST /v1/audio/inputs`         | Audio zur Wiederverwendung hochladen. Senden Sie Audio als rohen Request-Body.                                       |
| `POST /v1/audio/run`            | Einen Audio-Workflow ausführen, etwa Klonen, Bearbeiten, Konvertieren, Musikerzeugung oder Trennung, je nach Modell. |

Unterstützung für gespeicherte Audio-Eingaben `GET /v1/audio/inputs/{input_id}/file` und `DELETE /v1/audio/inputs/{input_id}`.

Gespeicherte Stimmen verwalten über `GET` oder `POST /v1/audio/voices`, `PATCH` oder `DELETE /v1/audio/voices/{voice_id}`und `GET /v1/audio/voices/{voice_id}/file`.

**Video**

| Endpunkt                            | Zweck                                                |
| ----------------------------------- | ---------------------------------------------------- |
| `POST /v1/videos`                   | Einen Videoerstellungsauftrag erstellen.             |
| `GET /v1/videos`                    | Videoaufträge auflisten.                             |
| `GET /v1/videos/{video_id}`         | Den Status und die Metadaten eines Auftrags abrufen. |
| `GET /v1/videos/{video_id}/content` | Ein fertiges Video herunterladen.                    |
| `DELETE /v1/videos/{video_id}`      | Einen Videoauftrag löschen.                          |

Bild-, Audio- und Videoerzeugung erfordern Modelle, die die angeforderte Aufgabe unterstützen.

**Strukturierte Entscheidungen**

| Endpunkt             | Zweck                                                       |
| -------------------- | ----------------------------------------------------------- |
| `POST /v1/systemone` | Strukturierte Fragen mithilfe der Decision API beantworten. |

Aktivieren Sie die Decision API in **Einstellungen → API** und wählen Sie zuerst ein Entscheidungsmodell aus. Anfragen verwenden `Status` und benannt `Fragen`, mit Fragetypen `noul`, `Auswahl`, oder `Punktzahl`.

**Erkunden Sie Ihre lokale API**

Öffnen `http://localhost:8888/docs` für die von Unsloth generierte interaktive API-Referenz oder `/openapi.json` für das maschinenlesbare Schema. Ersetzen Sie `8888` durch Ihren Unsloth-Port.

Diese Referenz spiegelt Ihre installierte Version wider und enthält interne Unsloth-Routen. Einige Kompatibilitätsrouten sind ausgeblendet, und manuell geparste Request-Bodies verfügen möglicherweise nicht über vollständige Schemas.

Siehe [Curl & HTTP](https://unsloth.ai/docs/integrations/connect-curl-and-http-to-unsloth) für Anforderungsbeispiele.

### 🖇️ Verbinden Sie Ihren Client

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

Um diesen Endpunkt von einem anderen Rechner aus zu erreichen, starten Sie mit `unsloth studio --secure`. Unsloth bleibt an localhost gebunden und veröffentlicht sich unter einer kostenlosen Cloudflare-HTTPS-URL; verwenden Sie diese URL anstelle von `http://127.0.0.1:8888` als Basis-URL Ihres Clients. Beachten Sie, dass Server-Sent Events einen Cloudflare-Quick-Tunnel nicht überstehen, setzen Sie daher `stream: false` wenn Sie darüber aufrufen.

### 🧰 Tool-Aufrufe

Beide Endpunkte unterstützen Funktions-/Tool-Aufrufe in ihrem nativen Format sowie eine Unsloth-spezifische Kurzform für die integrierten Tools von Unsloth.

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

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

Serverseitige Tools von Unsloth: Unsloth kann Python, Websuche und Bash *serverseitig* und die Ergebnisse zurückstreamen als `tool_result` Events. Aktivieren Sie dies, indem Sie einem der beiden Endpunkte diese zusätzlichen Felder hinzufügen:

```json
{
  "messages": [{"role": "user", "content": "Was ist 123 * 456? Verwenden Sie 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 umfassendere Abdeckung (Schemas, Streaming-Events, Verkettung) siehe .

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

### 📈 API-Überwachung

Jeder Aufruf über diesen Endpunkt wird in Unsloth live an zwei Stellen aufgelistet:

Das API-Monitor-Seitenpanel öffnet sich 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>

Drücken Sie „Auf den vollständigen Monitor erweitern“ oder gehen Sie 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 Sie den Schlüssel verloren haben, erstellen Sie 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. Normalerweise war das Modell fertig geladen, ist aber abgestürzt, oder der Modell-Tab wurde in Unsloth geschlossen. Laden Sie das Modell erneut aus **Neuer Chat** und versuchen Sie es erneut.

**Claude Code zeigt das standardmäßige Anthropic-Modell an, nicht mein lokales** :  Prüfen Sie, ob alle drei Umgebungsvariablen in der **gleichen** Shell exportiert sind, in der Sie `claude`:

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

Führen Sie dann `/model` in Claude Code aus, um dies zu bestätigen. Unter Windows PowerShell verwenden Sie `$env:ANTHROPIC_BASE_URL` usw.

**`stream: true` gibt statt SSE einen einzelnen JSON-Blob zurück** :  Stellen Sie sicher, dass Sie den richtigen Pfad aufrufen (`/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 opencode (oder OpenClaw / einem anderen Client) hinzufügen soll** : Fragen Sie direkt Unsloth. `GET /v1/models` gibt die genaue Modell-ID zurück, die Sie in das Feld „Modell-ID“ des Clients eintragen müssen:

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

Sie erhalten ein JSON-Payload der Form `{"data": [{"id": "gemma-4-26B-A4B-it-GGUF", ...}]}`. Kopieren Sie den `id` Wert; das ist die Zeichenkette, die opencodes **Modell-ID** Feld (linke Spalte) und OpenClaws `models[].id` erwarten. Der Anzeigename rechts ist das, was Benutzer sehen sollen.

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

* **Mein Client meldet einen Verbindungsfehler.** Öffnen Sie den API-Monitor. Wenn es keine Zeile für den Aufruf gibt, hat er Unsloth nie erreicht; vergleichen Sie die Basis-URL Ihres Clients mit der **Basis-URL** oben auf dieser Seite angezeigten.
* **Die Antwort wird vorzeitig abgeschnitten.** Prüfen Sie **Verwendeter Kontext** der Anfrage im API-Monitor. Nahe 100 % oder ein Stoppgrund von `Länge`, bedeutet, dass das Kontextfenster voll ist und nicht, 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 by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

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

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

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.