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

# Einen MLX-LM Server von überall nutzen – sicher

> Erreichen Sie Ihren MLX-LM Server auf Apple Silicon von überall – richten Sie sicheren Fernzugriff mit dem Tokios-Connector und Authentifizierung per API-Schlüssel ein. Starten Sie das Serving in 5 Minuten.

Standardmäßig lauscht `mlx_lm.server` auf `http://127.0.0.1:8080/v1` — er ist von keinem anderen Rechner erreichbar, außer man bindet ihn breiter oder leitet den Port weiter. MLX-LM Server hat keine integrierte Authentifizierung: Alles, was Port `8080` erreichen kann, kann die API ohne Anmeldedaten aufrufen. Lassen Sie MLX-LM Server auf localhost und starten Sie den Tokios-Connector daneben: Der Connector wählt sich nach `https://api.tokios.com` hinaus, und Ihre Tools, Teammitglieder oder Agenten rufen von überall einen einzigen authentifizierten Endpunkt auf.

> [!NOTE]
>
> Zuletzt überprüft: 2026-10-14. MLX-LM Server wird mit dem [`mlx-lm`](https://github.com/ml-explore/mlx-lm) Python-Paket von Apples ml-explore-Team ausgeliefert. Dieser Guide deckt die aktuelle Version ab.

> [!TIP]
>
> **Apple Silicon nativ.** MLX-LM Server ist der Referenz-Inferenzserver für Apple Silicon. Er verwendet die Unified-Memory-Architektur des MLX-Frameworks mit Zero-Copy-Datenpfaden — Modellgewichte leben im selben Speicher-Pool wie CPU und GPU, es gibt also keinen separaten VRAM zu verwalten. Auf M5-Chips liefern Neural Accelerators bis zu 4x schnellere Prompt-Verarbeitung im Vergleich zu M4.

## What is Apple Silicon native inference

MLX-LM Server unterscheidet sich von den anderen Backends, die Tokios unterstützt: Er läuft nur auf Apple Silicon Macs (M1 und später) und nutzt direkt die Unified-Memory-Architektur, die alle Apple Silicon Chips teilen.

| Feature | MLX-LM Server | llama.cpp on Mac | vLLM |
| - | - | - | - |
| Hardware | Apple Silicon only | Cross-platform (CPU + GPU) | NVIDIA GPU (CUDA) |
| Memory model | Unified memory, zero-copy | Unified memory via Metal | Separate VRAM |
| Neural Accelerators (ANE) | Yes — automatic on M5 | No | No |
| Installation | `pip install mlx-lm` | Build from source or prebuilt binary | `pip install vllm` + CUDA |
| Quantization | 4-bit, 8-bit, BF16 | GGUF (Q2\_K through Q8\_0) | AWQ, GPTQ, FP16, BF16 |
| Prompt processing on M5 | Up to 4x vs M4 | Baseline | N/A |

Da MLX Unified Memory verwendet, kann ein Mac Studio mit 192 GB RAM 70B-Modelle bei voller Präzision servieren, ohne das Multi-GPU-Setup, das andere Plattformen benötigen. Es gibt keine VRAM-Grenze — das Modell, der KV-Cache und der Arbeitsspeicher teilen sich alle denselben Pool.

## MLX-LM Server's auth is off by default

`mlx_lm.server` startet einen OpenAI-kompatiblen HTTP-Server auf Port `8080`. Starten Sie ihn und er akzeptiert Anfragen von jedem, der den Port erreichen kann — keine Anmeldedaten erforderlich:

```bash theme={"theme":{"light":"github-light","dark":"css-variables"}}
mlx_lm.server --model mlx-community/Qwen-3.5-4B-8bit
```

MLX-LM Server bringt keine Authentifizierungsschicht mit. Die [eigene Dokumentation](https://github.com/ml-explore/mlx-lm/blob/main/mlx_lm/SERVER.md) vermerkt, dass der Server nicht für den Produktionseinsatz ohne Reverse Proxy davor empfohlen wird. Das ist in Ordnung für rein lokale Nutzung, aber es bedeutet, dass das Exponieren des Ports über Loopback hinaus — über `--host 0.0.0.0`, Port-Weiterleitung oder einen Tunnel — nicht-authentifizierten API-Zugriff für jeden gibt, der ihn erreichen kann.

> [!NOTE]
>
> Das ist keine Kritik an MLX-LM Server — es ist ein leichtgewichtiger, Apple-Silicon-nativer Inferenzserver, und die Auth einem externen Proxy zu überlassen, hält den Server einfach. Tokios ist speziell für ein anderes Problem gebaut: diesen lokalen Endpunkt in eine authentifizierte API zu verwandeln, die Sie von überall aufrufen können, ohne einen eingehenden Port zu öffnen oder TLS selbst zu basteln.

## Der ausschließlich ausgehende Weg

**1. Install MLX-LM and start the server locally**

MLX-LM Server erfordert einen Apple Silicon Mac (M1 oder später) mit macOS 14.0 (Sonoma) oder später. Installieren Sie das Paket und starten Sie den Server:

```bash theme={"theme":{"light":"github-light","dark":"css-variables"}}
pip install mlx-lm
mlx_lm.server --model mlx-community/Qwen-3.5-4B-8bit
```

Der Server lädt das Modell beim ersten Gebrauch von [mlx-community](https://huggingface.co/mlx-community) herunter und lauscht auf `http://127.0.0.1:8080`. Lassen Sie ihn auf dem Standard `127.0.0.1` — übergeben Sie nicht `--host 0.0.0.0`.

> [!TIP]
>
> **Quantisierung wählen.** Modelle auf mlx-community werden in 4-Bit (Standard, kleinstes), 8-Bit und BF16 (volle Präzision) Varianten ausgeliefert. Ein 70B-Modell bei 4-Bit benötigt ungefähr 35 GB Unified Memory; bei 8-Bit ungefähr 70 GB; bei BF16 ungefähr 140 GB. Wählen Sie die Quantisierung, die in den Speicher Ihres Mac passt.

**2. Pair the Tokios connector**

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

Führen Sie auf dem Mac, auf dem MLX-LM Server läuft, den macOS-Installations-Einzeiler aus:

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

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

```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. Point the connector at MLX-LM Server's /v1 API**

MLX-LM Server spricht bereits die OpenAI-Chat-Completions-Oberfläche, die Tokios erwartet. Für den einfachen Single-Modell-Pfad verwendet der Setup-Assistent der Konsole automatisch `http://127.0.0.1:8080/v1` als Upstream. Wenn Sie mehrere Modelle über eine `tokios-connector.json`-Konfiguration servieren, setzen Sie die Upstream-`BaseUrl` explizit:

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

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

**4. Register a deployment**

Im Reiter [Models](https://tokios.com/console/models) registrieren Sie das MLX-LM-Modell und wählen einen **öffentlichen Namen** — zum Beispiel `mlx-qwen-tunnel`. Dieser öffentliche Name, nicht die HuggingFace-Modell-ID, ist, was Clients im `model`-Feld senden.

**5. Create an API key**

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

## Von überall nutzen

Sobald Sie einen Deployment-Namen und einen API-Schlüssel haben, kann jeder OpenAI- oder Anthropic-kompatible Client Ihr MLX-LM-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": "mlx-qwen-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="mlx-qwen-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 mlx-qwen-tunnel
```

> [!TIP]
>
> Das `model`-Feld ist immer Ihr registrierter **Deployment**-Name (oben `mlx-qwen-tunnel`), nie die HuggingFace-Modell-ID. Siehe [Use Claude Code](/de/guides/claude-code.md) zum Persistieren der Umgebungsvariablen über Sitzungen hinweg.

## Server-Konfigurationsreferenz

MLX-LM Server bietet mehrere Flags zur Optimierung der Inferenz. Die nützlichsten:

| Flag | Standard | Zweck |
| - | - | - |
| `--model` | (erforderlich) | HuggingFace-Modell-ID oder lokaler Pfad |
| `--host` | `127.0.0.1` | Bindungsadresse — auf `127.0.0.1` belassen für Tokios |
| `--port` | `8080` | Listen-Port |
| `--adapter-path` | — | Pfad zu einem LoRA-Adapter für feinabgestimmte Modelle |
| `--max-tokens` | `512` | Standard-Maximaltokens pro Generierung |
| `--temp` | `0.0` | Sampling-Temperatur |
| `--top-p` | `1.0` | Top-p (Nucleus) Sampling |
| `--top-k` | `0` | Top-k Sampling (0 = deaktiviert) |
| `--kv-bits` | — | KV-Cache-Quantisierungs-Bits (reduziert Speicher) |
| `--kv-group-size` | `64` | Gruppengröße für KV-Cache-Quantisierung |
| `--prefill-step-size` | `2048` | Prefill-Blockgröße für lange Kontexte |
| `--draft-model` | — | Modell für Speculative Decoding |
| `--num-draft-tokens` | `3` | Draft-Tokens pro Speculative-Decoding-Schritt |
| `--prompt-cache-size` | `10` | Anzahl der zu cachenden Prompts |
| `--decode-concurrency` | `32` | Maximale gleichzeitige Decode-Operationen |
| `--prompt-concurrency` | `8` | Maximale gleichzeitige Prompt-Operationen |
| `--trust-remote-code` | `false` | Remote-Code aus HuggingFace-Repos vertrauen |

Der Server bietet diese Endpunkte:

| Endpunkt | Zweck |
| - | - |
| `/v1/chat/completions` | Chat Completions (OpenAI-kompatibel) |
| `/v1/completions` | Text Completions (OpenAI-kompatibel) |
| `/v1/models` | Geladene Modelle auflisten |
| `/health` | Health Check |

> [!TIP]
>
> **Speculative decoding** kann die Generierung bei großen Modellen um 2-3x beschleunigen. Übergeben Sie `--draft-model` mit einem kleineren Modell derselben Familie — verwenden Sie zum Beispiel ein 4B-Modell als Draft für ein 32B-Modell. MLX-LM Server verifiziert Draft-Tokens parallel und berechnet nur Fehltreffer neu.

## FAQ

> **What are the prerequisites for MLX-LM Server?**
>
> Sie benötigen einen Apple Silicon Mac (M1, M2, M3, M4 oder M5) mit macOS 14.0 (Sonoma) oder später, Python 3.9 oder später, und `pip` oder `conda`. Installieren Sie mit `pip install mlx-lm`. Das MLX-Framework verwendet Metal für GPU-Beschleunigung und Unified Memory für Modellgewichte — keine separaten GPU-Treiber oder CUDA-Toolkit erforderlich.

> **How do I install MLX-LM Server?**
>
> Installieren Sie das Python-Paket mit `pip install mlx-lm` (oder `conda install -c conda-forge mlx-lm`). Starten Sie dann den Server mit `mlx_lm.server --model <model-id>`. Das Modell wird beim ersten Gebrauch von HuggingFace heruntergeladen. Modelle der [mlx-community](https://huggingface.co/mlx-community)-Organisation sind vorab ins MLX-Format konvertiert und sofort einsatzbereit.

> **What port does MLX-LM Server use?**
>
> MLX-LM Server lauscht standardmäßig auf Port **8080**, gebunden an `127.0.0.1` (nur localhost). Ändern Sie den Port mit `--port` und die Bindungsadresse mit `--host`. Für Tokios behalten Sie die Standards bei — der Connector erreicht den Server auf `http://127.0.0.1:8080/v1`.

> **Does MLX-LM Server support streaming?**
>
> Ja. Setzen Sie `"stream": true` im Anfrage-Body und der Server gibt Standard Server-Sent Events (SSE) zurück. Über Tokios funktioniert Streaming Ende-zu-Ende — setzen Sie `"stream": true` und Tokios gibt SSE im OpenAI- oder Anthropic-Format zurück, je nachdem, welche API-Oberfläche Sie aufgerufen haben.

> **Does MLX-LM Server support tool calling?**
>
> Ja. MLX-LM Server unterstützt strukturiertes Tool Calling. Verwenden Sie ein Modell, das Chat-Templates mit Tool-Definitionen unterstützt — Modelle der [mlx-community](https://huggingface.co/mlx-community) wie Qwen 3.5 und Llama 3 enthalten die erforderlichen Chat-Templates. Übergeben Sie Tools im OpenAI-kompatiblen `tools`-Feld der Anfrage.

> **Can I use LoRA adapters with MLX-LM Server?**
>
> Ja. Übergeben Sie `--adapter-path` mit dem Pfad zu einem Verzeichnis mit LoRA-Adapter-Gewichten. Feinabstimmen Sie Adapter mit `mlx_lm.lora` (im selben Paket enthalten) und servieren Sie dann das Basismodell mit dem überlagerten Adapter. Registrieren Sie den Adapter als eigenes Tokios-Deployment mit eigenem öffentlichen Namen.

> **How does MLX-LM Server compare to llama.cpp on Apple Silicon?**
>
> Beide verwenden Unified Memory auf Apple Silicon. MLX-LM Server ist der Apple-native Weg — er verwendet Metal-GPU-Beschleunigung direkt und nutzt auf M5-Chips Neural Accelerators für bis zu 4x schnellere Prompt-Verarbeitung. llama.cpp ist plattformübergreifend und unterstützt eine breitere Palette von Quantisierungsformaten (GGUF-Varianten). Für reine Apple-Silicon-Performance ist MLX-LM Server konkurrenzfähig mit oder leicht voraus gegenüber llama.cpp auf M-Series-Chips.

> **Can I serve more than one model?**
>
> Ja. Führen Sie mehrere `mlx_lm.server`-Prozesse auf verschiedenen Ports aus oder registrieren Sie zusätzliche Deployments im Reiter [Models](https://tokios.com/console/models). Verwenden Sie eine `tokios-connector.json`-Konfigurationsdatei, um mehrere Upstreams und Routen für einen einzigen Connector zu definieren. Siehe [Connector config](/de/reference/connector-config.md) für das vollständige Multi-Modell-Dateiformat.

> **Can I share access with teammates without exposing MLX-LM Server directly?**
>
> Ja. Erstellen Sie einen separaten `sk-tok-...` Schlüssel pro Teammitglied im Reiter [Keys](https://tokios.com/console/keys) und schränken Sie jeden Schlüssel nur auf die Deployments ein, die sie benötigen. Das Widerrufen eines Schlüssels stoppt die Authentifizierung sofort, sodass Sie den Zugriff abschalten können, ohne MLX-LM Server oder den Connector anzufassen.

> **What models work with MLX-LM Server?**
>
> Jedes Modell auf HuggingFace, das ins MLX-Format konvertiert wurde. Die [mlx-community](https://huggingface.co/mlx-community)-Organisation pflegt vorab konvertierte Versionen populärer Modelle — Llama, Qwen, Mistral, Gemma, Phi und mehr — in 4-Bit-, 8-Bit- und BF16-Quantisierungen. Sie können Modelle auch selbst mit `mlx_lm.convert` konvertieren.

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

MLX-LM Server macht genau weiter wie bisher, auf localhost, ohne eingehende Ports und ohne exponierte API. Der Connector wählt sich nur hinaus. Alles danach — Auth, Routing, Streaming — ist ein Endpunkt, den Sie von jedem Rechner, Teammitglied oder Agenten aufrufen können, dem Sie einen Schlüssel geben.

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

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

> **[Mac Studio setup](/de/use-cases/mac-studio.md)**
>
> Verwandeln Sie einen Mac Studio in eine headless Inferenz-Box mit Unified Memory für 70B+-Modelle.

## Quellen

* [ml-explore/mlx-lm](https://github.com/ml-explore/mlx-lm) — offizielles Repository für das MLX-LM Python-Paket und den Server
* [MLX-LM Server documentation (SERVER.md)](https://github.com/ml-explore/mlx-lm/blob/main/mlx_lm/SERVER.md) — Server-API-Referenz und unterstützte Endpunkte
* [MLX framework](https://github.com/ml-explore/mlx) — das zugrundeliegende Array-Framework für Apple Silicon
* [mlx-framework.org](https://mlx-framework.org/) — MLX-Framework-Überblick und Ökosystem-Links
* [mlx-community on HuggingFace](https://huggingface.co/mlx-community) — vorab konvertierte MLX-Modelle, bereit zum Servieren
* [Exploring LLMs with MLX and the Neural Accelerators in M5](https://machinelearning.apple.com/research/exploring-llms-mlx-m5) — Apple Machine Learning Research zur M5-ANE-Performance
* [Run local agentic AI on the Mac using MLX (WWDC26)](https://developer.apple.com/videos/play/wwdc2026/232/) — Apple-Session zu MLX-LM Server, Continuous Batching und verteilter Inferenz


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