> 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](https://unsloth.ai/docs/de/grundlagen/claude-code.md) und [Codex](https://unsloth.ai/docs/de/grundlagen/codex.md) ausführen, indem du diese Tools mit Unsloths **OpenAI-kompatiblem API-Endpunkt**verbindest. So kannst du Modelle wie [Qwen](https://unsloth.ai/docs/de/modelle/qwen3.6.md) und [Gemma](https://unsloth.ai/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**.

Mit Unsloth lässt sich ganz einfach ein schneller API-Inferenzendpunkt bereitstellen, der Folgendes bietet:

* [**Selbstheilende Tool-Aufrufe**](https://unsloth.ai/docs/de/neu/studio/chat.md#auto-healing-tool-calling), die dazu beitragen, fehlerhafte oder falsch formatierte Tool-Aufrufe um 50 % zu reduzieren
* [**Codeausführung**](https://unsloth.ai/docs/de/neu/studio/chat.md#code-execution) , einschließlich der Ausführung von Bash und Python für genauere Codeausgaben.
* **Erweiterte** [**Websuche**](https://unsloth.ai/docs/de/neu/studio/chat.md#advanced-web-search) , bei der Webseiten aufgerufen und tatsächlich gelesen werden, um detaillierte Informationen zu sammeln.
* [**Automatische Inferenz** einstellungen](https://unsloth.ai/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 über eine **authentifizierte API** mittels `llama-server`bereitgestellt. Aus Sicherheitsgründen wird ein langer API-Schlüssel generiert, ähnlich wie bei OpenAI.

Deine **lokalen Modelle** kannst du dann direkt mit deinem bevorzugten KI-Agenten, SDK oder Chat-Client verwenden. Unsloth unterstützt zwei Dialekte am selben Port. Beide bieten Streaming, Tool-Aufrufe (OpenAI `tools` / Anthropic `tools`) und Bildeingaben:
{% 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 dein Modell über die Inferenz von Unsloth oder einen eigenen entfernten OpenAI-kompatiblen Endpunkt ausgeführt wird, kannst du ihm Zugriff auf die gesamte Tool-Suite von Unsloth geben, einschließlich Websuche, Codeausfü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

Am einfachsten gelingt der Einstieg durch die Installation von [Unsloth Desktop](https://unsloth.ai/docs/de/desktop.md) App. Sie unterstützt [macOS](https://unsloth.ai/docs/de/loslegen/install/mac.md), Linux, [Windows](https://unsloth.ai/docs/de/loslegen/install/windows-installation.md), [NVIDIA](https://unsloth.ai/docs/de/loslegen/install/pip-install.md), [AMD](https://unsloth.ai/docs/de/loslegen/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, falls 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 das Unsloth-Installationsprogramm (`.dmg`, `.exe` Dateien)
2. Ziehe Unsloth auf dem Mac in den Ordner „Programme“ oder schließe die Einrichtung unter Windows ab.
3. Starte die App und warte, bis die Installation abgeschlossen ist.
   {% endstep %}

{% step %}

#### Modell auswählen

Öffne oben das Dropdown-Menü „Modell auswählen“ oder den Tab „Modell-Hub“, wähle ein Modell und eine Quantisierung aus, die zu deinem Gerät passt, und lade sie herunter. Sobald der Download abgeschlossen ist, kannst du direkt loschatten – eine Einrichtung ist nicht 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 einsatzbereit

Um loszuchatten, gib eine Nachricht ein und drücke die Eingabetaste.

* **API-Schlüssel erstellen.** Klicke auf deinen **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. Wechsle 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 %}

### 🔑 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. Du kannst den Schlüssel später nicht mehr anzeigen lassen.

<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 Präfix `sk-unsloth-` . 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. Jede Person mit dem Schlüssel und Netzwerkzugriff auf deine Unsloth-Instanz kann Anfragen an das geladene Modell senden.
{% endhint %}

### ⏳ Modell wird geladen

{% stepper %}
{% step %}

#### Modell auswählen

Bevor du die API verwendest, lade ein Modell über das Dropdown-Menü **Modell auswählen** oben links auf 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 dieser Anleitung verwenden wir:

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

{% step %}

#### Modell testen

Sende eine kurze Nachricht, bevor du den Client verwendest:

<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" %}
Damit wird bestätigt, dass das Modell korrekt geladen wurde und bereit ist, zu antworten.
{% endhint %}
{% endstep %}

{% step %}

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

Öffne in Unsloth **Einstellungen → 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 zeige ihn nicht in Screenshots oder Repositories.
{% endstep %}
{% endstepper %}

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

1. **Installiere oder aktualisiere Unsloth Studio.** In früheren Versionen ist die externe API nicht verfügbar. Siehe Installation.
2. **Lade ein GGUF-Modell.** Lade ein GGUF-Modell mit dem Ausführungsbefehl. Dadurch wird auch die Benutzeroberfläche am Standardport geladen. Die Endpunkt-URL und der API-Schlüssel werden in der Konsole ausgegeben und können direkt mit dem Client deiner Wahl 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 bei Bedarf an.

#### Ein Modell über die CLI laden

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

#### Bevor du loslegst

Stelle sicher, dass du eine aktuelle Version von Unsloth Studio verwendest, da ältere Versionen die externe API nicht bereitstellen. Siehe [Installation](https://unsloth.ai/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 wird der Server am Standardport gestartet, die Benutzeroberfläche geladen und die Endpunkt-URL sowie der API-Schlüssel ausgegeben.

#### So funktioniert der Modellname

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

```bash
# Kombiniert: Repository und Quantisierungsvariante in einer Zeichenfolge (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 du von dort kommst)
unsloth run -hf unsloth/gemma-4-26B-A4B-it-GGUF:UD-Q4_K_XL
```

### Ausführung anpassen (optional)

Für ein einfaches Laden brauchst du nichts davon, aber `unsloth run` unterstützt zahlreiche Laufzeit-Flags von llama-server, mit denen sich Leistung, Speicherverbrauch, Kontextlänge, Generierungsverhalten, Netzwerk und Toolzugriff anpassen lassen.

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

#### Reasoning-Verhalten steuern

Einige Reasoning-fähige Modelle unterstützen zusätzliche Flags, mit denen sich Denk- und Reasoning-Verhalten steuern lassen.

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

Die Reasoning-Stufe und die verfügbaren Flags hängen davon ab, was das Modell unterstützt.

#### Generierungsverhalten anpassen

Sampling-Einstellungen bestimmen, wie kreativ, fokussiert oder vorhersehbar sich das Modell während 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 führen in der Regel zu stabileren Ausgaben. Einstellungen für top-p, top-k, min-p und die Wiederholungsstrafe steuern zusätzlich die Token-Auswahl und Wiederholungen.

```bash
# Token-Auswahl 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 bei der Arbeit mit großen Projekten, langen Chats oder Agenten-Workflows, 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
```

#### API im lokalen Netzwerk bereitstellen

Standardmäßig wird Unsloth nur lokal auf deinem Rechner ausgeführt. Du kannst die API für andere Geräte in deinem Netzwerk bereitstellen, indem du sie an `0.0.0.0`.

```bash
# Verbindungen von Geräten im LAN zulassen
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 der Inferenzserver Tools wie die Websuche und Codeausführung bereitstellt.

```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 Laufzeit-Flags von llama-server, darunter Einstellungen für Kontextgröße, GPU-Layer, Threading, Sampling, Netzwerk und Tools.

Die vollständige Liste der unterstützten Laufzeit-Flags finden Sie in der [llama-server](https://github.com/ggml-org/llama.cpp/tree/master/tools/server) Dokumentation.

#### **Tool-Richtlinie auf Serverseite**

Serverseitige Tools führen Websuchen, Python-Code und Terminalbefehle auf dem Host aus. Bind-Adressen haben keinen Einfluss auf die Tool-Richtlinie.

**Standardeinstellungen (ohne Flags):**

* `unsloth run` / `unsloth studio run`: Tools sind aktiviert, auch bei `0.0.0.0`. Anfragen können sie mit `"enable_tools": false`deaktivieren, wie es auch die Benutzeroberfläche tut, wenn die Tool-Schalter ausgeschaltet sind.
* `unsloth studio` / Desktop: pro Anfrage steuert `enable_tools` den Zugriff; fehlt die Angabe, sind die Tools deaktiviert.

**Flags (für beide Befehle):**

* `--enable-tools`: erzwingt die Aktivierung von Tools für OpenAI-kompatible Anfragen und setzt `"enable_tools": false`.
* `--disable-tools`: erzwingt die Deaktivierung von Tools an allen Endpunkten; Anfragen können diese Einstellung nicht überschreiben. Verwenden Sie dieses Flag, wenn Sie Unsloth bereitstellen oder externen Agenten die Ausführung eigener Tools ermöglichen.
* `--yes` / `-y`: nur aus Kompatibilitätsgründen vorhanden. Die Tool-Richtlinie löst niemals eine Eingabeaufforderung aus.

**Anthropic-kompatibler Endpunkt** `/v1/messages`: erfordert `"enable_tools": true` oder ein integriertes Server-Tool wie `web_search`. Weder die CLI-Standardeinstellungen noch `--enable-tools` aktivieren es allein. `--disable-tools` oder `"enable_tools": false` deaktivieren es.

{% hint style="warning" %}
Diese Tools führen Code mit den Rechten Ihres Benutzerkontos aus. Halten Sie Ihren API-Schlüssel geheim: Jeder, der über den Schlüssel und Netzwerkzugriff verfügt, kann aktivierte Tools verwenden. Verwenden Sie `--disable-tools` wenn Sie Unsloth bereitstellen.
{% endhint %}

<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%2FZcUxtSPiIJ4cXqe3zCYg%2Funsloth_run_model.lossless.webp?alt=media" alt=""><figcaption></figcaption></figure></div>

### 🌐 Endpunkte

Unsloth stellt seine API an dem Port bereit, auf dem es gestartet wurde, üblicherweise unter `http://localhost:8000` oder `http://localhost:8888`.

Authentifizieren Sie sich mit einem `Authorization: Bearer sk-unsloth-…` -Header bei 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 Chatvervollständigungen, einschließlich Streaming und Tool-Aufrufen.     |
| `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`      | Textvervollständigungen ohne Chat-Formatierung. Erfordert ein GGUF- oder MLX-Modell.       |

Senden Sie bei Responses-Anfragen den Gesprächsverlauf in `input`. Serverseitig verwalteter Verlauf über `previous_response_id` oder `conversation` wird nicht unterstützt.

**Modelle, Embeddings und Tokenzählung**

| Endpunkt                         | Zweck                                                                                                                                     |
| -------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------- |
| `GET /v1/models`                 | Listet geladene und lokal verfügbare Modelle auf. Prüfen Sie `loaded` um festzustellen, welche Modelle sich derzeit im Speicher befinden. |
| `GET /v1/models/{model_id}`      | Ruft Metadaten zu einem Modell ab.                                                                                                        |
| `GET /v1/props`                  | Liest mit llama-server kompatible Servereigenschaften aus.                                                                                |
| `POST /v1/embeddings`            | Erzeugt Embeddings mit einem geladenen Embedding-GGUF oder dem von Unsloth konfigurierten Embedding-Modell.                               |
| `POST /v1/chat/count_tokens`     | Zählt Prompt-Tokens für Nachrichten im OpenAI-Format.                                                                                     |
| `POST /v1/messages/count_tokens` | Zählt Eingabe-Tokens für Nachrichten im Anthropic-Format.                                                                                 |

**Bilder**

| Endpunkt                      | Zweck                                                                     |
| ----------------------------- | ------------------------------------------------------------------------- |
| `POST /v1/images/generations` | Erzeugt Bilder aus einem Prompt mit einem unterstützten Diffusionsmodell. |

**Audio**

| Endpunkt                        | Zweck                                                                                                                         |
| ------------------------------- | ----------------------------------------------------------------------------------------------------------------------------- |
| `POST /v1/audio/speech`         | Mit OpenAI kompatible Sprachsynthese aus Text.                                                                                |
| `POST /v1/audio/generate`       | Erzeugt Sprache aus Nachrichten im Chat-Format; gibt WAV-Audio als Base64 zurück.                                             |
| `POST /v1/audio/transcriptions` | Transkribiert eine hochgeladene Audiodatei.                                                                                   |
| `POST /v1/audio/translations`   | Übersetzt die Sprache in einer hochgeladenen Audiodatei ins Englische.                                                        |
| `POST /v1/audio/inputs`         | Audio zur Wiederverwendung hochladen. Senden Sie das Audio als rohen Request-Body.                                            |
| `POST /v1/audio/run`            | Einen Audio-Workflow ausführen, z. B. Klonen, Bearbeiten, Konvertieren, Musik generieren oder Audio trennen – je nach Modell. |

Gespeicherte Audioeingaben lassen sich über `GET /v1/audio/inputs/{input_id}/file` und `DELETE /v1/audio/inputs/{input_id}`.

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

**Video**

| Endpunkt                            | Zweck                                    |
| ----------------------------------- | ---------------------------------------- |
| `POST /v1/videos`                   | Einen Video-Generierungsjob erstellen.   |
| `GET /v1/videos`                    | Videojobs auflisten.                     |
| `GET /v1/videos/{video_id}`         | Status und Metadaten eines Jobs abrufen. |
| `GET /v1/videos/{video_id}/content` | Ein fertiges Video herunterladen.        |
| `DELETE /v1/videos/{video_id}`      | Einen Videojob löschen.                  |

Für die Bild-, Audio- und Videogenerierung sind Modelle erforderlich, die die angeforderte Aufgabe unterstützen.

**Strukturierte Entscheidungen**

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

Aktivieren Sie die Decision API unter **Einstellungen → API** und wählen Sie zuerst ein Entscheidungsmodell aus. Anfragen verwenden `state` sowie benannte `questions`, mit den Fragetypen `noul`, `choice`oder `score`.

**Ihre lokale API erkunden**

Öffnen Sie `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 entspricht Ihrer installierten Version und umfasst interne Unsloth-Routen. Einige Kompatibilitätsrouten sind ausgeblendet, und manuell geparste Request-Bodies verfügen möglicherweise nicht über vollständige Schemas.

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

### 🖇️ Client verbinden

Mit Unsloth kannst du lokale LLMs über die meisten Frameworks ausführen, darunter [Claude Code](https://unsloth.ai/docs/de/grundlagen/claude-code.md), [Codex](https://unsloth.ai/docs/de/grundlagen/codex.md), [OpenClaw](https://unsloth.ai/docs/de/integrationen/openclaw.md), [OpenCode](https://unsloth.ai/docs/de/integrationen/opencode.md) und weitere. Klicke unten auf das jeweilige Tool, um eine Anleitung aufzurufen:

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

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

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

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

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

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

Um diesen Endpunkt von einem anderen Rechner aus zu erreichen, starte Unsloth mit `unsloth studio --secure`. Unsloth bleibt an localhost gebunden und stellt sich unter einer freien HTTPS-URL von Cloudflare bereit. Verwende diese URL anstelle von `http://127.0.0.1:8888` als Basis-URL deines Clients. Beachte, dass Server-Sent Events einen schnellen Cloudflare-Tunnel nicht überstehen. Setze daher `stream: false` bei Aufrufen über einen solchen Tunnel.

### 🧰 Tool-Aufrufe

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

**Tools im OpenAI-Format:** Sende `tools` und `tool_choice` an `/v1/chat/completions` genauso wie bei OpenAI. Claude Code (über `/v1/messages`), opencode, Cursor, Continue und Cline funktionieren sofort.

**Tools im Anthropic-Format:** Sende `tools` (mit `input_schema`) und `tool_choice` an `/v1/messages` genauso wie bei Claude.

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

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

Das Modell erhält die Ausgabe jedes Tools in seinem nächsten Gesprächsschritt. Ausführlichere Informationen zu Schemas, Streaming-Ereignissen und Verkettungen findest du unter .

{% hint style="info" %}
Wenn Sie den Anthropic `/v1/messages` -Endpunkt verwenden, `tool_choice` lässt sich einfach zuordnen: Anthropic `auto` → OpenAI `auto`, Anthropic `any` → OpenAI `required`, Anthropic `{type: "tool", name: "x"}` → OpenAI `{type: "function", function: {name: "x"}}`, Anthropic `none` → OpenAI `none`.
{% endhint %}

### 📈 API-Monitor

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

Sobald API-Schlüssel-Traffic eingeht, öffnet sich das Seitenpanel des API-Monitors automatisch in der Ecke. 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>

Klicken Sie auf „Zum vollständigen Monitor wechseln“ oder gehen Sie zu Settings>API Monitor, um die vollständige **API-** Seite aufzurufen. Dort werden im Monitor das Laden von Modellen, Prompts, Antworten, Tokenanzahlen, die Zeit bis zum ersten Token, der Durchsatz und Fehlermeldungen angezeigt.

<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 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 unter **Settings → API** einen neuen. Unsloth zeigt alte Schlüssel nach ihrer Erstellung nicht mehr an.

**`Lost connection to the model server`** : Unsloth konnte den zugrunde liegenden llama.cpp-Server nicht erreichen. Meistens wurde das Modell zwar vollständig geladen, ist aber abgestürzt, oder der Modell-Tab wurde in Unsloth geschlossen. Laden Sie das Modell über **Neuer Chat** neu und versuchen Sie es erneut.

**Claude Code zeigt das Anthropic-Standardmodell statt meines lokalen Modells an** : Prüfen Sie, ob alle drei Umgebungsvariablen in derselben **Shell** exportiert sind, in der Sie `claude`:

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

Führen Sie anschließend `/model` in Claude Code aus, um dies zu überprüfen. Verwenden Sie in Windows PowerShell `$env:ANTHROPIC_BASE_URL` usw.

**`stream: true` gibt statt SSE ein einzelnes JSON-Objekt 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 Modellnamen nicht, den ich zu opencode (oder OpenClaw bzw. einem anderen Client) hinzufügen muss.** : Fragen Sie direkt bei Unsloth nach. `GET /v1/models` liefert die genaue Modell-ID, 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 dieser Form: `{"data": [{"id": "gemma-4-26B-A4B-it-GGUF", ...}]}`. Kopieren Sie den Wert `id` . Das ist der String, den opencode im Feld **Model ID**  (linke Spalte) und OpenClaw in `models[].id` erwartet. Der Anzeigename rechts kann beliebig sein.

**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, `enable_tools: true` **zu setzen und** die gewünschten Tools in `enabled_tools` aufzulisten (z. B. `["python", "web_search"]`).

* **Mein Client meldet einen Verbindungsfehler.** Öffnen Sie den API-Monitor. Wenn für den Aufruf kein Eintrag angezeigt wird, hat er Unsloth nie erreicht. Vergleichen Sie die Base URL Ihres Clients mit der **Base URL** oben auf dieser Seite.
* **Die Antwort wird abgeschnitten.** Prüfen Sie bei der Anfrage im API-Monitor den Wert für **Context used** . Ein Wert nahe 100 % oder ein Stop-Grund mit dem Wert `length`bedeutet, dass das Kontextfenster voll war und nicht, dass das Modell ausgefallen 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.
