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

# Utilisez un MLX-LM Server depuis n'importe où — en toute sécurité

> Accédez à votre MLX-LM Server depuis n'importe où sur Apple Silicon — configurez un accès distant sécurisé avec le connecteur Tokios et l'authentification par clé API. Commencez à servir en 5 minutes.

Par défaut, `mlx_lm.server` écoute sur `http://127.0.0.1:8080/v1` — il n'est pas accessible depuis une autre machine sauf si vous le liez à une adresse plus large ou si vous transférez le port. MLX-LM Server n'a pas d'authentification intégrée : tout ce qui peut atteindre le port `8080` peut appeler l'API sans identifiant. Gardez MLX-LM Server sur localhost et exécutez le connecteur Tokios à côté : le connecteur se connecte à `https://api.tokios.com`, et vos outils, coéquipiers ou agents appellent un endpoint authentifié depuis n'importe où.

> [!NOTE]
>
> Last verified: 2026-10-14. MLX-LM Server ships with the [`mlx-lm`](https://github.com/ml-explore/mlx-lm) Python package from Apple's ml-explore team. This guide covers the current release.

> [!TIP]
>
> **Apple Silicon native.** MLX-LM Server est le serveur d'inférence de référence pour Apple Silicon. Il utilise l'architecture mémoire unifiée du framework MLX avec des chemins de données zero-copy — les poids du modèle vivent dans le même pool mémoire que le CPU et le GPU, donc il n'y a pas de VRAM séparée à gérer. Sur les puces M5, les Neural Accelerators offrent un traitement des prompts jusqu'à 4x plus rapide comparé à M4.

## Qu'est-ce que l'inférence native Apple Silicon

MLX-LM Server est différent des autres backends supportés par Tokios : il fonctionne uniquement sur les Mac Apple Silicon (M1 et ultérieur) et tire directement parti de l'architecture mémoire unifiée que partagent toutes les puces Apple Silicon.

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

Parce que MLX utilise la mémoire unifiée, un Mac Studio avec 192 Go de RAM peut servir des modèles 70B en pleine précision sans la configuration multi-GPU que requièrent d'autres plateformes. Il n'y a pas de frontière VRAM — le modèle, le cache KV et la mémoire de travail partagent le même pool.

## L'authentification de MLX-LM Server est désactivée par défaut

`mlx_lm.server` démarre un serveur HTTP compatible OpenAI sur le port `8080`. Lancez-le et il accepte les requêtes de quiconque peut atteindre le port — sans identifiant requis :

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

MLX-LM Server ne fournit pas de couche d'authentification. Sa [propre documentation](https://github.com/ml-explore/mlx-lm/blob/main/mlx_lm/SERVER.md) note que le serveur n'est pas recommandé pour un usage en production sans un proxy inverse devant lui. C'est correct pour un usage local uniquement, mais cela signifie qu'exposer le port au-delà du loopback — via `--host 0.0.0.0`, le transfert de port ou un tunnel — donne un accès API non authentifié à quiconque peut l'atteindre.

> [!NOTE]
>
> Ce n'est pas un coup contre MLX-LM Server — c'est un serveur d'inférence natif Apple Silicon léger, et laisser l'auth à un proxy externe garde le serveur simple. Tokios est conçu spécialement pour un problème différent : transformer cet endpoint local en une API authentifiée que vous pouvez appeler de n'importe où, sans ouvrir de port entrant ni bricoler du TLS.

## The outbound-only way

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

MLX-LM Server nécessite un Mac Apple Silicon (M1 ou ultérieur) avec macOS 14.0 (Sonoma) ou ultérieur. Installez le package et démarrez le serveur :

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

Le serveur télécharge le modèle depuis [mlx-community](https://huggingface.co/mlx-community) lors de la première utilisation et écoute sur `http://127.0.0.1:8080`. Laissez-le sur le `127.0.0.1` par défaut — ne passez pas `--host 0.0.0.0`.

> [!TIP]
>
> **Choosing a quantization.** Les modèles sur mlx-community sont livrés en variantes 4-bit (par défaut, le plus petit), 8-bit et BF16 (pleine précision). Un modèle 70B en 4-bit a besoin d'environ 35 Go de mémoire unifiée ; en 8-bit environ 70 Go ; en BF16 environ 140 Go. Choisissez la quantification qui correspond à la mémoire de votre Mac.

**2. Pair the Tokios connector**

Connectez-vous sur [tokios.com/console](https://tokios.com/console), ouvrez l'onglet **Setup** et cliquez sur **Start pairing**. Tokios affiche un **code d'appairage** à usage unique comme `TKS-XXXX-XXXX`, valable environ 15 minutes.

Sur le Mac qui exécute MLX-LM Server, exécutez le one-liner d'installation macOS :

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

Vous avez déjà `tokios-connector` installé ? Passez le code directement à la place :

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

De retour dans la console, **approve**z l'appareil dans l'onglet **Setup** ou **Connectors**. Le token du connecteur est délivré par le tunnel une fois approuvé — vous ne le voyez jamais à l'écran et ne le collez pas dans un fichier.

**3. Point the connector at MLX-LM Server's /v1 API**

MLX-LM Server parle déjà le surface Chat Completions OpenAI que Tokios attend. Pour le chemin basique à modèle unique, l'assistant Setup de la console utilise `http://127.0.0.1:8080/v1` comme upstream automatiquement. Si vous servez plusieurs modèles via un fichier de configuration `tokios-connector.json`, définissez l'`BaseUrl` upstream explicitement :

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

Consultez [Connector config](/fr/reference/connector-config.md) pour le format de fichier complet multi-modèles.

**4. Register a deployment**

Dans l'onglet [Models](https://tokios.com/console/models), enregistrez le modèle MLX-LM et choisissez un **nom public** — par exemple, `mlx-qwen-tunnel`. C'est ce nom public, et non l'id de modèle HuggingFace, que les clients envoient dans le champ `model`.

**5. Create an API key**

Dans l'onglet [Keys](https://tokios.com/console/keys), cliquez sur **Create key**. Optionnellement, limitez-la à des déploiements spécifiques avec des motifs de nom de modèle (globs séparés par des virgules, `*` pour tous). Copiez la clé `sk-tok-...` maintenant — elle n'est affichée qu'une seule fois.

## Utilisez-le depuis n'importe où

Une fois que vous avez un nom de déploiement et une clé API, tout client compatible OpenAI ou Anthropic peut atteindre votre modèle MLX-LM — depuis une autre machine, le portable d'un coéquipier ou un agent hébergé.

```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]
>
> Le champ `model` est toujours votre nom de **déploiement** enregistré (`mlx-qwen-tunnel` ci-dessus), jamais l'id de modèle HuggingFace. Consultez [Use Claude Code](/fr/guides/claude-code.md) pour persister les variables d'environnement entre les sessions.

## Référence de configuration du serveur

MLX-LM Server expose plusieurs flags pour ajuster l'inférence. Les plus utiles :

| Flag | Default | Purpose |
| - | - | - |
| `--model` | (required) | HuggingFace model id or local path |
| `--host` | `127.0.0.1` | Bind address — keep on `127.0.0.1` for Tokios |
| `--port` | `8080` | Listen port |
| `--adapter-path` | — | Path to a LoRA adapter for serving fine-tuned models |
| `--max-tokens` | `512` | Default maximum tokens per generation |
| `--temp` | `0.0` | Sampling temperature |
| `--top-p` | `1.0` | Top-p (nucleus) sampling |
| `--top-k` | `0` | Top-k sampling (0 = disabled) |
| `--kv-bits` | — | KV cache quantization bits (reduces memory) |
| `--kv-group-size` | `64` | Group size for KV cache quantization |
| `--prefill-step-size` | `2048` | Prefill chunk size for long contexts |
| `--draft-model` | — | Model for speculative decoding |
| `--num-draft-tokens` | `3` | Draft tokens per speculative decoding step |
| `--prompt-cache-size` | `10` | Number of prompts to cache |
| `--decode-concurrency` | `32` | Maximum concurrent decode operations |
| `--prompt-concurrency` | `8` | Maximum concurrent prompt operations |
| `--trust-remote-code` | `false` | Trust remote code from HuggingFace repos |

Le serveur expose ces endpoints :

| Endpoint | Purpose |
| - | - |
| `/v1/chat/completions` | Chat Completions (OpenAI-compatible) |
| `/v1/completions` | Text Completions (OpenAI-compatible) |
| `/v1/models` | List loaded models |
| `/health` | Health check |

> [!TIP]
>
> **Speculative decoding** peut accélérer la génération de 2-3x pour les grands modèles. Passez `--draft-model` avec un modèle plus petit de la même famille — par exemple, utilisez un modèle 4B comme brouillon pour un modèle 32B. MLX-LM Server vérifie les jetons brouillon en parallèle et ne recalcule que les non-correspondances.

## FAQ

> **What are the prerequisites for MLX-LM Server?**
>
> Vous avez besoin d'un Mac Apple Silicon (M1, M2, M3, M4 ou M5) avec macOS 14.0 (Sonoma) ou ultérieur, Python 3.9 ou ultérieur, et `pip` ou `conda`. Installez avec `pip install mlx-lm`. Le framework MLX utilise Metal pour l'accélération GPU et la mémoire unifiée pour les poids du modèle — pas de pilotes GPU séparés ni de toolkit CUDA nécessaire.

> **How do I install MLX-LM Server?**
>
> Installez le package Python avec `pip install mlx-lm` (ou `conda install -c conda-forge mlx-lm`). Puis démarrez le serveur avec `mlx_lm.server --model <model-id>`. Le modèle est téléchargé depuis HuggingFace lors de la première utilisation. Les modèles de l'organisation [mlx-community](https://huggingface.co/mlx-community) sont pré-convertis au format MLX et prêts à l'emploi.

> **What port does MLX-LM Server use?**
>
> MLX-LM Server écoute sur le port **8080** par défaut, lié à `127.0.0.1` (localhost uniquement). Changez le port avec `--port` et l'adresse de liaison avec `--host`. Pour Tokios, gardez les valeurs par défaut — le connecteur atteint le serveur sur `http://127.0.0.1:8080/v1`.

> **Does MLX-LM Server support streaming?**
>
> Oui. Définissez `"stream": true` dans le corps de la requête et le serveur retourne des server-sent events (SSE) standard. Via Tokios, le streaming fonctionne de bout en bout — définissez `"stream": true` et Tokios retourne des SSE au format OpenAI ou Anthropic, selon la surface API que vous avez appelée.

> **Does MLX-LM Server support tool calling?**
>
> Oui. MLX-LM Server supporte le tool calling structuré. Utilisez un modèle qui supporte les chat templates avec des définitions d'outils — les modèles de la [mlx-community](https://huggingface.co/mlx-community) comme Qwen 3.5 et Llama 3 incluent les chat templates nécessaires. Passez les outils dans le champ `tools` compatible OpenAI de la requête.

> **Can I use LoRA adapters with MLX-LM Server?**
>
> Oui. Passez `--adapter-path` en pointant vers un répertoire contenant les poids de l'adaptateur LoRA. Fine-tunez les adaptateurs avec `mlx_lm.lora` (inclus dans le même package) puis servez le modèle de base avec l'adaptateur superposé. Enregistrez l'adaptateur comme son propre déploiement Tokios avec son propre nom public.

> **How does MLX-LM Server compare to llama.cpp on Apple Silicon?**
>
> Les deux utilisent la mémoire unifiée sur Apple Silicon. MLX-LM Server est le chemin natif Apple — il utilise directement l'accélération GPU Metal et, sur les puces M5, tire parti des Neural Accelerators pour un traitement des prompts jusqu'à 4x plus rapide. llama.cpp est multiplateforme et supporte une plus large gamme de formats de quantification (variantes GGUF). Pour la performance pure Apple Silicon, MLX-LM Server est compétitif avec ou légèrement en avance sur llama.cpp sur les puces série M.

> **Can I serve more than one model?**
>
> Oui. Exécutez plusieurs processus `mlx_lm.server` sur des ports différents, ou enregistrez des déploiements supplémentaires dans l'onglet [Models](https://tokios.com/console/models). Utilisez un fichier de configuration `tokios-connector.json` pour définir plusieurs upstreams et routes pour un seul connecteur. Consultez [Connector config](/fr/reference/connector-config.md) pour le format de fichier complet multi-modèles.

> **Can I share access with teammates without exposing MLX-LM Server directly?**
>
> Oui. Créez une clé `sk-tok-...` séparée par coéquipier dans l'onglet [Keys](https://tokios.com/console/keys), et limitez chaque clé aux déploiements dont ils ont besoin. Révoquer une clé arrête immédiatement son authentification, donc vous pouvez couper l'accès sans toucher à MLX-LM Server ni au connecteur.

> **What models work with MLX-LM Server?**
>
> Tout modèle sur HuggingFace qui a été converti au format MLX. L'organisation [mlx-community](https://huggingface.co/mlx-community) maintient des versions pré-converties de modèles populaires — Llama, Qwen, Mistral, Gemma, Phi et plus — en quantifications 4-bit, 8-bit et BF16. Vous pouvez aussi convertir vos modèles avec `mlx_lm.convert`.

## Votre modèle ne quitte jamais votre machine — votre endpoint fonctionne partout

MLX-LM Server continue de faire exactement ce qu'il fait aujourd'hui, sur localhost, sans ports entrants ni API exposée. Le connecteur ne fait que des appels sortants. Tout ce qui vient après — auth, routage, streaming — est un endpoint que vous pouvez appeler depuis n'importe quelle machine, coéquipier ou agent à qui vous choisissez de donner une clé.

> **[Quickstart](/fr/quickstart.md)**
>
> Associez un connecteur et enregistrez votre premier modèle de bout en bout.

> **[API keys](/fr/setup/api-keys.md)**
>
> Créez, limitez et faites tourner des clés `sk-tok-...` pour les coéquipiers et les agents.

> **[Mac Studio setup](/fr/use-cases/mac-studio.md)**
>
> Transformez un Mac Studio en boîte d'inférence headless avec mémoire unifiée pour des modèles 70B+.

## Sources

* [ml-explore/mlx-lm](https://github.com/ml-explore/mlx-lm) — official repository for the MLX-LM Python package and server
* [MLX-LM Server documentation (SERVER.md)](https://github.com/ml-explore/mlx-lm/blob/main/mlx_lm/SERVER.md) — server API reference and supported endpoints
* [MLX framework](https://github.com/ml-explore/mlx) — the underlying array framework for Apple Silicon
* [mlx-framework.org](https://mlx-framework.org/) — MLX framework overview and ecosystem links
* [mlx-community on HuggingFace](https://huggingface.co/mlx-community) — pre-converted MLX models ready for serving
* [Exploring LLMs with MLX and the Neural Accelerators in M5](https://machinelearning.apple.com/research/exploring-llms-mlx-m5) — Apple Machine Learning Research on M5 ANE performance
* [Run local agentic AI on the Mac using MLX (WWDC26)](https://developer.apple.com/videos/play/wwdc2026/232/) — Apple session on MLX-LM Server, continuous batching, and distributed inference


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