> ## Documentation Index
> Fetch the complete documentation index at: https://docs.tokios.com/llms.txt
> Use this file to discover all available pages before exploring further.

> ## Agent Instructions
> Tokios exposes private local models through https://api.tokios.com using an outbound-only connector tunnel.
> Use 'connector' for the local tokios-connector process.
> Use 'deployment' for the public model name in the API model field.
> Use 'upstream model id' for the model served by Ollama, llama.cpp, vLLM, LM Studio, or another local backend.
> API keys use the prefix sk-tok-. Connector tokens use the prefix ct-tok-.

# Fernzugriff auf Lemonade Server – AMD NPU und GPU

> Erreichen Sie Ihre Lemonade Server-API von überall – AMD NPU, Vulkan, ROCm, CUDA. Richten Sie sicheren Fernzugriff mit dem Tokios-Connector ein. Starten Sie das Serving in 5 Minuten.

Standardmäßig lauscht Lemonade Server auf `http://127.0.0.1:13305/v1` — er ist von einem anderen Rechner nicht erreichbar, außer Sie binden ihn breiter oder leiten den Port weiter. Lemonade Server bringt keine eingebaute Authentifizierung für den Fernzugriff mit. Lassen Sie ihn auf localhost und betreiben Sie den Tokios-Connector daneben: Der Connector wählt sich ausgehend zu `https://api.tokios.com` ein, und Ihre Tools, Teammitglieder oder Agenten rufen einen authentifizierten Endpunkt von überall auf.

> [!NOTE]
>
> **Zuletzt überprüft: 2026-10-14.** Lemonade Server wird aktiv weiterentwickelt — prüfen Sie [lemonade-server.ai](https://lemonade-server.ai/) für die neueste Version.

> [!TIP]
>
> **AMD NPU-Unterstützung.** Lemonade Server ist der einzige lokale LLM-Server, der Inferenz auf AMD Ryzen AI NPUs beschleunigt (Ryzen AI 300/400 Serie). Er erkennt auch automatisch Vulkan-, ROCm-, CUDA- und Metal-Backends, sodass er über AMD-, NVIDIA- und Apple Silicon-Hardware ohne manuelle Konfiguration funktioniert.

## Was ist Lemonade Server

Lemonade Server ist ein Open-Source-lokaler LLM-Server, der von AMD unterstützt wird. Er bietet eine OpenAI-kompatible API unter `http://localhost:13305/v1` und unterstützt mehrere Modellformate (GGUF, ONNX, FLM) über mehrere Backends:

* **AMD Ryzen 7000/8000/200 Serie** — GPU-Beschleunigung über Vulkan (llama.cpp-Backend)
* **AMD Ryzen AI MAX+ (Strix Halo)** — ROCm mit vLLM oder llama.cpp
* **AMD Ryzen AI 300/400 Serie** — NPU-Beschleunigung über ONNX Runtime GenAI (hybride NPU+iGPU-Ausführung)
* **NVIDIA GPUs** — CUDA-Beschleunigung
* **Apple Silicon** — Metal-Backend

Lemonade Server erkennt automatisch Ihre Hardware und wählt das beste Backend. Sie können das Backend bei Bedarf auch manuell überschreiben.

> **Warum Lemonade Server nicht einfach an 0.0.0.0 binden?**
>
> Lemonade Server an alle Schnittstellen zu binden (`0.0.0.0`) macht ihn von Ihrem Netzwerk aus erreichbar, aber Lemonade Server bringt keine eingebaute Authentifizierung für entfernte Aufrufer mit — jeder, der Port `13305` erreichen kann, kann die API aufrufen. Wenn Ihr ISP CGNAT verwendet, haben Sie ohnehin keine stabile öffentliche IP, an die Sie weiterleiten könnten. Tokios fügt Bereichs-`sk-tok-…` API-Schlüssel hinzu, ohne einen eingehenden Port zu öffnen.

> **Warum nicht Tailscale oder Cloudflare Tunnel verwenden?**
>
> Tailscale löst persönlichen Zugriff gut — Ihre eigenen Geräte treten einem privaten Mesh-Netzwerk bei und können sich sicher gegenseitig erreichen. Der Haken ist bei allem über persönliche Nutzung hinaus: Teammitglieder oder SaaS-Clients, die Ihr Modell aufrufen müssen, müssen zuerst Ihrem Tailnet beitreten, was nicht zu einem öffentlichen API-Schlüssel-Modell passt. Cloudflare Tunnel leitet Traffic über Cloudflares Edge ohne erforderlichen eingehenden Port weiter, aber standardmäßig puffert Cloudflare Antworten, anstatt sie zu streamen, es sei denn, die Antwort trägt einen `text/event-stream` Content-Type-Header, und proxied Anfragen unterliegen Cloudflares Proxy-Timeouts (ungefähr 100 Sekunden im kostenlosen Tarif) — lange Generierungen können mitten im Stream abgeschnitten werden.

> [!NOTE]
>
> Das ist keine Kritik an diesen Tools — sie lösen ein anderes Problem (Geräte-Mesh-Netzwerke, Edge-Proxying). Tokios ist speziell für eine Sache gebaut: einen lokalen Modell-Endpunkt in eine authentifizierte API zu verwandeln, die Sie von überall aufrufen können.

## Voraussetzungen

Bevor Sie beginnen, stellen Sie sicher, dass Sie haben:

* **Lemonade Server installiert** — siehe [Wie Lemonade Server installieren](#how-to-install-lemonade-server) unten
* **Ein Modell heruntergeladen** — verwenden Sie `lemonade pull <model>` um ein Modell herunterzuladen
* **Tokios-Connector** — Sie installieren ihn während der Einrichtung

## Wie Lemonade Server installieren

Lemonade Server bietet Installer für Windows, Linux, macOS und Docker. Ab v10.1 ist der CLI-Befehl `lemonade` (die alte `lemonade-server`-CLI ist veraltet).

```powershell Windows (MSI) theme={"theme":{"light":"github-light","dark":"css-variables"}}
Download the MSI installer from the [Lemonade Server releases page](https://github.com/lemonade-sdk/lemonade/releases) and run it. The `lemond` service auto-starts on install.
```

```bash Linux (Snap) theme={"theme":{"light":"github-light","dark":"css-variables"}}
sudo snap install lemonade-server
```

```bash Linux (APT, Ubuntu/Debian) theme={"theme":{"light":"github-light","dark":"css-variables"}}
sudo apt update
sudo apt install lemonade-server
```

```bash macOS theme={"theme":{"light":"github-light","dark":"css-variables"}}
Download the macOS installer from the [Lemonade Server releases page](https://github.com/lemonade-sdk/lemonade/releases).
```

```bash Docker theme={"theme":{"light":"github-light","dark":"css-variables"}}
docker run -p 13305:13305 lemonade-sdk/lemonade-server
```

Überprüfen Sie nach der Installation, dass Lemonade Server läuft:

```bash theme={"theme":{"light":"github-light","dark":"css-variables"}}
lemonade status
```

Sie sollten den Serverstatus und das erkannte Backend sehen (Vulkan, ROCm, CUDA, Metal oder NPU).

## Wie ein Modell mit Lemonade Server bereitstellen

Laden Sie ein Modell herunter und stellen Sie es mit 2 Befehlen bereit:

```bash theme={"theme":{"light":"github-light","dark":"css-variables"}}
# Download a model
lemonade pull Qwen3-0.6B-GGUF

# Serve the model
lemonade run Qwen3-0.6B-GGUF
```

Lemonade Server erkennt automatisch Ihre Hardware und wählt das beste Backend. Das Modell wird jetzt unter `http://localhost:13305/v1` bereitgestellt.

> [!TIP]
>
> **NPU-Beschleunigung auf AMD Ryzen AI.** Wenn Sie einen AMD Ryzen AI 300/400 Serie-Prozessor haben, kann Lemonade Server die NPU für Inferenz verwenden. Laden Sie ein für die NPU optimiertes ONNX-Modell:
>
> ```bash theme={"theme":{"light":"github-light","dark":"css-variables"}}
> lemonade pull Llama-3.2-1B-Instruct-NPU
> lemonade run Llama-3.2-1B-Instruct-NPU
> ```
>
> NPU-Modelle verwenden hybride NPU+iGPU-Ausführung und werden am `-NPU`-Suffix erkannt.

### Häufige Lemonade Server CLI-Befehle

| Befehl | Beschreibung |
| - | - |
| `lemonade pull <model>` | Ein Modell herunterladen |
| `lemonade run <model>` | Ein Modell bereitstellen |
| `lemonade run <model> --ctx-size 8192` | Mit benutzerdefinierter Kontextgröße bereitstellen |
| `lemonade list` | Verfügbare Modelle auflisten |
| `lemonade list --downloaded` | Heruntergeladene Modelle auflisten |
| `lemonade status` | Serverstatus und erkanntes Backend prüfen |
| `lemonade status --json` | Status im JSON-Format prüfen |
| `lemonade bench <model>` | Ein Modell benchmarken |

## Der rein ausgehende Weg

**1. Lassen Sie Lemonade Server lokal wie gewohnt laufen**

Behalten Sie Lemonade Server auf `127.0.0.1` — binden Sie ihn nicht breiter als Loopback. Laden Sie Ihr Modell und stellen Sie es bereit:

```bash theme={"theme":{"light":"github-light","dark":"css-variables"}}
lemonade pull Qwen3-0.6B-GGUF
lemonade run Qwen3-0.6B-GGUF
```

Lassen Sie ihn auf dem Standard `http://127.0.0.1:13305` lauschen.

**2. Paaren Sie den Tokios-Connector**

Melden Sie sich bei [tokios.com/console](https://tokios.com/console) an, öffnen Sie den Tab **Setup** und klicken Sie auf **Start pairing**. Tokios zeigt einen einmaligen **Pairing-Code** wie `TKS-XXXX-XXXX` an, der etwa 15 Minuten gültig ist.

Führen Sie auf dem Rechner, auf dem Lemonade Server läuft, den Install-Einzeiler für Ihr Betriebssystem aus:

```powershell Windows theme={"theme":{"light":"github-light","dark":"css-variables"}}
irm https://tokios.com/downloads/install/windows | iex; tokios-install -Code 'TKS-XXXX-XXXX'
```

```bash macOS theme={"theme":{"light":"github-light","dark":"css-variables"}}
curl -fsSL https://tokios.com/downloads/install/macos | sh -s -- --code TKS-XXXX-XXXX
```

```bash Linux theme={"theme":{"light":"github-light","dark":"css-variables"}}
curl -fsSL https://tokios.com/downloads/install/linux | sh -s -- --code TKS-XXXX-XXXX
```

Haben Sie `tokios-connector` bereits installiert? Übergeben Sie den Code direkt stattdessen:

```bash theme={"theme":{"light":"github-light","dark":"css-variables"}}
tokios-connector TKS-XXXX-XXXX
```

Zurück in der Konsole, **approve** das Gerät auf dem Reiter **Setup** oder **Connectors**. Das Token des Connectors wird über den Tunnel geliefert, sobald er genehmigt ist — Sie sehen es nie auf dem Bildschirm oder fügen es in eine Datei ein.

**3. Richten Sie den Connector auf Lemonade Servers /v1 API**

Lemonade Server bietet eine OpenAI-kompatible Oberfläche unter `/v1`, und das ist es, womit Tokios spricht. Für den grundlegenden Single-Modell-Pfad verwendet der Setup-Assistent der Konsole automatisch `http://127.0.0.1:13305/v1` als Upstream. Wenn Sie mehrere Modelle über eine `tokios-connector.json`-Konfiguration bereitstellen, setzen Sie die Upstream-`BaseUrl` explizit:

```json theme={"theme":{"light":"github-light","dark":"css-variables"}}
{
  "Upstream": {
    "BaseUrl": "http://127.0.0.1:13305/v1"
  }
}
```

Siehe [Connector-Konfiguration](/de/reference/connector-config.md) für das vollständige Multi-Modell-Dateiformat.

**4. Registrieren Sie ein Deployment**

Im Tab [Models](https://tokios.com/console/models) registrieren Sie das Lemonade Server-Modell und wählen einen **öffentlichen Namen** — zum Beispiel `qwen3-tunnel`. Dieser öffentliche Name, nicht Lemonades lokale Modell-ID, ist es, was Clients im `model`-Feld senden.

**5. Erstellen Sie einen API-Schlüssel**

Im Tab [Keys](https://tokios.com/console/keys) klicken Sie auf **Create key**. Optional können Sie ihn mit Modellnamen-Mustern auf bestimmte Deployments einschränken (kommagetrennte Globs, `*` für alle). Kopieren Sie den `sk-tok-…`-Schlüssel jetzt — er wird nur einmal angezeigt.

## Von überall aus nutzen

Sobald Sie einen Deployment-Namen und einen API-Schlüssel haben, kann jeder OpenAI- oder Anthropic-kompatible Client Ihr Lemonade Server-Modell erreichen — von einem anderen Rechner, dem Laptop eines Teammitglieds oder einem gehosteten Agenten.

```bash curl theme={"theme":{"light":"github-light","dark":"css-variables"}}
curl https://api.tokios.com/v1/chat/completions \
  -H "Authorization: Bearer sk-tok-YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen3-tunnel",
    "stream": true,
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python (OpenAI SDK) theme={"theme":{"light":"github-light","dark":"css-variables"}}
from openai import OpenAI

client = OpenAI(
    base_url="https://api.tokios.com/v1",
    api_key="sk-tok-YOUR_KEY",
)

response = client.chat.completions.create(
    model="qwen3-tunnel",
    messages=[{"role": "user", "content": "Hello!"}],
    stream=True,
)

for chunk in response:
    print(chunk.choices[0].delta.content or "", end="")
```

```bash Claude Code theme={"theme":{"light":"github-light","dark":"css-variables"}}
export ANTHROPIC_BASE_URL=https://api.tokios.com
export ANTHROPIC_API_KEY=sk-tok-YOUR_KEY
claude --model qwen3-tunnel
```

> [!TIP]
>
> Das `model`-Feld ist immer Ihr registrierter **Deployment**-Name (`qwen3-tunnel` oben), niemals Lemonades lokale Modell-ID. Siehe [Claude Code verwenden](/de/guides/claude-code.md) für das Persistieren der Umgebungsvariablen über Sitzungen hinweg.

## Was ist AMD NPU-Unterstützung

AMD Ryzen AI 300/400 Serie-Prozessoren enthalten eine dedizierte Neural Processing Unit (NPU) für KI-Workloads. Lemonade Server ist der einzige lokale LLM-Server, der Inferenz auf der AMD NPU mit hybrider NPU+iGPU-Ausführung beschleunigt.

### Wie NPU-Beschleunigung funktioniert

* **Modellformat**: NPU-optimierte Modelle verwenden das ONNX-Format (am `-NPU`-Suffix erkannt, z.B. `Llama-3.2-1B-Instruct-NPU`)
* **Ausführung**: Lemonade Server teilt die Inferenz zwischen NPU und iGPU mit OnnxRuntime GenAI auf
* **Backend**: Das NPU-Backend ist automatisch — Lemonade Server erkennt Ihren Ryzen AI-Prozessor und wählt die NPU-Ausführung, wenn Sie ein NPU-optimiertes Modell ausführen
* **Leistung**: NPU-Beschleunigung lagert Arbeit von CPU und GPU aus, reduziert den Stromverbrauch und gibt Ressourcen für andere Aufgaben frei

### Welche AMD-Prozessoren NPU-Inferenz unterstützen

| Prozessor-Serie | NPU-Unterstützung | Backend |
| - | - | - |
| AMD Ryzen AI 300 Serie (Strix Point) | Ja | NPU über ONNX |
| AMD Ryzen AI 400 Serie | Ja | NPU über ONNX |
| AMD Ryzen AI MAX+ (Strix Halo) | Keine NPU, aber leistungsstarke iGPU | ROCm/vLLM oder Vulkan |
| AMD Ryzen 7000/8000 Serie | Keine NPU | Vulkan (llama.cpp) |

> [!NOTE]
>
> NPU-Unterstützung erfordert AMD Ryzen AI Software-Treiber. Lemonade Server bündelt die erforderliche Laufzeitumgebung, aber stellen Sie sicher, dass Ihr System die neuesten AMD Adrenalin-Treiber installiert hat.

## Lemonade Server im Vergleich zu anderen Backends

Lemonade Server ist eines von mehreren Backends, die Tokios unterstützt. So vergleicht es sich:

| Funktion | Lemonade Server | Ollama | llama.cpp | vLLM |
| - | - | - | - | - |
| **AMD NPU-Unterstützung** | Ja (Ryzen AI 300/400) | Nein | Nein | Nein |
| **Backend automatisch erkennen** | Ja (Vulkan/ROCm/CUDA/Metal) | Manuell | Manuell | Manuell |
| **Einrichtungskomplexität** | Niedrig (Installer) | Niedrig (ein Befehl) | Mittel (Build) | Hoch (Python-GPU-Server) |
| **Modellformate** | GGUF, ONNX, FLM | GGUF | GGUF | Hugging Face |
| **Am besten für** | AMD-Hardware; plattformübergreifend | Einsteiger; schnellster Start | Praktische GGUF-Bereitstellung | Hochdurchsatz-GPU-Bereitstellung |

> [!TIP]
>
> Lemonade Server ist eine gute Wahl, wenn Sie AMD-Hardware haben (insbesondere Ryzen AI mit NPU) oder einen plattformübergreifenden Server wollen, der Ihr Backend automatisch erkennt. Wenn Sie einfach nur den schnellsten Start auf beliebiger Hardware wollen, ist [Ollama](/de/guides/ollama-remote-access.md) immer noch am einfachsten.

## FAQ

> **Welchen Port verwendet Lemonade Server?**
>
> Lemonade Server lauscht standardmäßig auf Port **13305**, gebunden an `127.0.0.1` (nur localhost). Die OpenAI-kompatible API ist unter `http://localhost:13305/v1`. Sie können mit `lemonade status` oder `curl http://localhost:13305/v1/models` überprüfen, ob Lemonade Server läuft.

> **Wie erkenne ich, welches Backend Lemonade Server verwendet?**
>
> Führen Sie `lemonade status` aus, um das erkannte Backend zu sehen (Vulkan, ROCm, CUDA, Metal oder NPU). Lemonade Server erkennt automatisch Ihre Hardware und wählt das beste Backend. Sie können auch `lemonade status --json` für maschinenlesbare Ausgabe verwenden.

> **Unterstützt Lemonade Server AMD NPU?**
>
> Ja. Lemonade Server ist der einzige lokale LLM-Server, der Inferenz auf AMD Ryzen AI 300/400 Serie NPUs beschleunigt. Laden Sie ein NPU-optimiertes Modell mit `lemonade pull <model>-NPU` und führen Sie es mit `lemonade run <model>-NPU` aus. Das NPU-Backend verwendet hybride NPU+iGPU-Ausführung über OnnxRuntime GenAI.

> **Kann ich Lemonade Server mit NVIDIA GPUs verwenden?**
>
> Ja. Lemonade Server erkennt NVIDIA GPUs automatisch und verwendet das CUDA-Backend. Er funktioniert auf jeder Hardware, die Vulkan, ROCm, CUDA oder Metal unterstützt — AMD, NVIDIA und Apple Silicon werden alle unterstützt.

> **Wie mache ich Lemonade Server für mein Netzwerk zugänglich?**
>
> Stellen Sie Lemonade Server nicht direkt bereit — verwenden Sie stattdessen Tokios. Tokios fügt authentifizierten Fernzugriff hinzu, ohne einen eingehenden Port zu öffnen. Siehe [die Einrichtungsschritte oben](#the-outbound-only-way) für die vollständige Anleitung.

> **Funktioniert Streaming?**
>
> Ja. Setzen Sie `"stream": true` und Tokios gibt Standard Server-Sent Events (SSE) im OpenAI- oder Anthropic-Format zurück, je nachdem, welche API-Oberfläche Sie aufgerufen haben.

> **Kann ich den Zugriff mit Teammitgliedern teilen, ohne Lemonade Server direkt freizugeben?**
>
> Ja. Erstellen Sie einen separaten `sk-tok-…` Schlüssel pro Teammitglied im Tab [Keys](https://tokios.com/console/keys) und beschränken Sie jeden Schlüssel auf nur die Deployments, die sie brauchen. Das Widerrufen eines Schlüssels stoppt die Authentifizierung sofort, sodass Sie den Zugriff abschneiden können, ohne Lemonade Server oder den Connector anzufassen.

> **Kann ich mehr als 1 Lemonade Server-Modell freigeben?**
>
> Ja. Registrieren Sie zusätzliche Deployments im Tab [Models](https://tokios.com/console/models) oder verwenden Sie eine `tokios-connector.json`-Konfigurationsdatei, um mehrere Upstreams und Routen für einen einzelnen Connector zu definieren. Siehe [Connector-Konfiguration](/de/reference/connector-config.md).

> **Wie aktualisiere ich Lemonade Server?**
>
> Führen Sie unter Linux `sudo apt update && sudo apt upgrade lemonade-server` (APT) oder `sudo snap refresh lemonade-server` (Snap) aus. Laden Sie unter Windows den neuesten MSI-Installer von der [Releases-Seite](https://github.com/lemonade-sdk/lemonade/releases) herunter.

> **Welche Modellarchitekturen unterstützt die NPU?**
>
> Die NPU unterstützt spezifische Modellarchitekturen, die für die ONNX-Ausführung optimiert sind. Führen Sie `lemonade list` aus, um verfügbare NPU-Modelle zu sehen (am `-NPU`-Suffix erkannt). Nicht alle Modelle sind NPU-kompatibel — GGUF-Modelle laufen stattdessen auf dem GPU/CPU-Backend. Siehe die [Lemonade FAQ](https://lemonade-server.ai/docs/guide/faq/) für die vollständige Liste der NPU-unterstützten Architekturen.

## Ihr Modell verlässt nie Ihren Rechner — Ihr Endpunkt funktioniert überall

Lemonade Server macht weiterhin genau das, was er heute tut, auf localhost, ohne eingehende Ports und ohne freigelegte API. Der Connector wählt sich nur ausgehend ein. Alles darüber hinaus — Auth, Routing, Streaming — ist ein Endpunkt, den Sie von jedem Rechner, Teammitglied oder Agenten aufrufen können, dem Sie einen Schlüssel geben.

> **[Schnellstart](/de/quickstart.md)**
>
> Paaren Sie einen Connector und registrieren Sie Ihr erstes Modell von Anfang bis Ende.

> **[API-Schlüssel](/de/setup/api-keys.md)**
>
> Erstellen, einschränken und rotieren Sie `sk-tok-…` Schlüssel für Teammitglieder und Agenten.

> **[Strix Halo-Einrichtung](/de/use-cases/strix-halo.md)**
>
> Verwandeln Sie Ihre AMD Strix Halo-Kiste mit Lemonade Server in einen Modell-Endpunkt.

> **[Unterstützte Backends](/de/setup/supported-backends.md)**
>
> Sehen Sie alle Backends, die Tokios unterstützt — Ollama, llama.cpp, vLLM, LM Studio und mehr.

## Quellen

* [Lemonade SDK GitHub-Repository](https://github.com/lemonade-sdk/lemonade)
* [Lemonade Server offizielle Dokumentation](https://lemonade-server.ai/docs/guide/faq/)
* [AMD: Unlocking a Wave of LLM Apps on Ryzen AI Through Lemonade Server](https://www.amd.com/en/developer/resources/technical-articles/unlocking-a-wave-of-llm-apps-on-ryzen-ai-through-lemonade-server.html)
* [Getting Started with Lemonade | AMD AI Playbooks](https://developer.amd.com/playbooks/lemonade-getting-started/)
* [Lemonade Server CLI-Dokumentation](https://lemonade-server.ai/docs/guide/cli/)


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.