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

# Accès distant à Lemonade Server — NPU et GPU AMD

> Accédez à l'API de votre Lemonade Server depuis n'importe où — NPU AMD, Vulkan, ROCm, CUDA. Configurez un accès distant sécurisé avec le connecteur Tokios. Commencez à servir en 5 minutes.

Par défaut, Lemonade Server écoute sur `http://127.0.0.1:13305/v1` — il n'est pas accessible depuis une autre machine à moins de le lier plus largement ou de transférer le port. Lemonade Server ne fournit pas d'authentification intégrée pour l'accès à distance. Gardez-le sur localhost et exécutez le connecteur Tokios à côté : le connecteur compose vers `https://api.tokios.com`, et vos outils, coéquipiers ou agents appellent un seul point de terminaison authentifié depuis n'importe où.

> [!NOTE]
>
> **Dernière vérification : 2026-10-14.** Lemonade Server est en développement actif — consultez [lemonade-server.ai](https://lemonade-server.ai/) pour la dernière version.

> [!TIP]
>
> **Support NPU AMD.** Lemonade Server est le seul serveur LLM local qui accélère l'inférence sur les NPU AMD Ryzen AI (séries Ryzen AI 300/400). Il détecte aussi automatiquement les backends Vulkan, ROCm, CUDA et Metal, ce qui lui permet de fonctionner sur du matériel AMD, NVIDIA et Apple Silicon sans configuration manuelle.

## Qu'est-ce que Lemonade Server

Lemonade Server est un serveur LLM local open-source soutenu par AMD. Il expose une API compatible OpenAI à `http://localhost:13305/v1` et prend en charge plusieurs formats de modèles (GGUF, ONNX, FLM) sur plusieurs backends :

* **AMD Ryzen 7000/8000/200 series** — accélération GPU via Vulkan (backend llama.cpp)
* **AMD Ryzen AI MAX+ (Strix Halo)** — ROCm avec vLLM ou llama.cpp
* **AMD Ryzen AI 300/400 series** — accélération NPU via ONNX Runtime GenAI (exécution hybride NPU+iGPU)
* **NVIDIA GPUs** — accélération CUDA
* **Apple Silicon** — backend Metal

Lemonade Server détecte automatiquement votre matériel et sélectionne le meilleur backend. Vous pouvez aussi overrides le backend manuellement si nécessaire.

> **Why not just bind Lemonade Server to 0.0.0.0?**
>
> Lier Lemonade Server à toutes les interfaces (`0.0.0.0`) le rend accessible depuis votre réseau, mais Lemonade Server ne fournit pas d'authentification intégrée pour les appelants distants — quiconque peut atteindre le port `13305` peut appeler l'API. Si votre FAI utilise CGNAT, vous n'avez pas d'IP publique stable vers laquelle transférer. Tokios ajoute des clés API `sk-tok-…` à portée délimitée sans ouvrir de port entrant.

> **Why not use Tailscale or Cloudflare Tunnel?**
>
> Tailscale résout bien l'accès personnel — vos propres appareils rejoignent un réseau maillé privé et peuvent s'atteindre de manière sécurisée. Le problème survient pour tout usage au-delà du personnel : les coéquipiers ou clients SaaS qui doivent appeler votre modèle doivent d'abord rejoindre votre tailnet, ce qui ne correspond pas à un modèle de clé API publique. Cloudflare Tunnel achemine le trafic via le edge de Cloudflare sans port entrant nécessaire, mais par défaut Cloudflare met en tampon les réponses plutôt que de les diffuser sauf si la réponse porte un en-tête content-type `text/event-stream`, et les requêtes proxyées sont soumises aux timeouts du proxy de Cloudflare (environ 100 secondes sur le niveau gratuit) — les générations longues peuvent être coupées en cours de diffusion.

> [!NOTE]
>
> Rien de tout cela n'est un dénigrement de ces outils — ils résolvent un problème différent (réseau maillé d'appareils, proxy edge). Tokios est conçu spécialement pour une chose : transformer un point de terminaison de modèle local en une API authentifiée que vous pouvez appeler de n'importe où.

## Prérequis

Avant de commencer, assurez-vous d'avoir :

* **Lemonade Server installé** — consultez [Comment installer Lemonade Server](#how-to-install-lemonade-server) ci-dessous
* **Un modèle téléchargé** — utilisez `lemonade pull <model>` pour télécharger un modèle
* **Le connecteur Tokios** — vous l'installerez pendant la configuration

## Comment installer Lemonade Server

Lemonade Server fournit des installateurs pour Windows, Linux, macOS et Docker. Depuis la v10.1, la commande CLI est `lemonade` (l'ancienne CLI `lemonade-server` est obsolète).

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

Après l'installation, vérifiez que Lemonade Server fonctionne :

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

Vous devriez voir le statut du serveur et le backend détecté (Vulkan, ROCm, CUDA, Metal ou NPU).

## Comment servir un modèle avec Lemonade Server

Téléchargez et servez un modèle en 2 commandes :

```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 détecte automatiquement votre matériel et sélectionne le meilleur backend. Le modèle sert maintenant à `http://localhost:13305/v1`.

> [!TIP]
>
> **Accélération NPU sur AMD Ryzen AI.** Si vous avez un processeur AMD Ryzen AI série 300/400, Lemonade Server peut utiliser le NPU pour l'inférence. Téléchargez un modèle ONNX optimisé pour l'exécution NPU :
>
> ```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
> ```
>
> Les modèles NPU utilisent l'exécution hybride NPU+iGPU et sont identifiés par le suffixe `-NPU`.

### Commandes CLI courantes de Lemonade Server

| Commande | Description |
| - | - |
| `lemonade pull <model>` | Télécharger un modèle |
| `lemonade run <model>` | Servir un modèle |
| `lemonade run <model> --ctx-size 8192` | Servir avec une taille de contexte personnalisée |
| `lemonade list` | Lister les modèles disponibles |
| `lemonade list --downloaded` | Lister les modèles téléchargés |
| `lemonade status` | Vérifier le statut du serveur et le backend détecté |
| `lemonade status --json` | Vérifier le statut au format JSON |
| `lemonade bench <model>` | Benchmarker un modèle |

## La méthode uniquement sortante

**1. Run Lemonade Server locally, as usual**

Gardez Lemonade Server sur `127.0.0.1` — ne le liez pas plus largement que la boucle locale. Téléchargez et exécutez votre modèle :

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

Laissez-le écouter sur le `http://127.0.0.1:13305` par défaut.

**2. Pair the Tokios connector**

Connectez-vous à [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 la machine qui exécute Lemonade Server, exécutez l'installateur en une ligne pour votre OS :

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

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

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

De retour dans la console, **approve** l'appareil dans l'onglet **Setup** ou **Connectors**. Le token du connecteur est délivré via 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 Lemonade Server's /v1 API**

Lemonade Server expose une surface compatible OpenAI à `/v1`, et c'est ce à quoi Tokios se connecte. Pour le chemin de base mono-modèle, l'assistant Setup de la console utilise `http://127.0.0.1:13305/v1` comme upstream automatiquement. Si vous servez plusieurs modèles via un fichier de configuration `tokios-connector.json`, définissez explicitement le `BaseUrl` upstream :

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

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

**4. Register a deployment**

Dans l'onglet [Models](https://tokios.com/console/models), enregistrez le modèle Lemonade Server et choisissez un **nom public** — par exemple, `qwen3-tunnel`. Ce nom public, et non l'identifiant de modèle local de Lemonade, est ce 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**. Vous pouvez éventuellement la limiter à 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 de 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 Lemonade Server — depuis une autre machine, l'ordinateur 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": "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]
>
> Le champ `model` est toujours votre nom de **déploiement** enregistré (`qwen3-tunnel` ci-dessus), jamais l'identifiant de modèle local de Lemonade. Consultez [Utiliser Claude Code](/fr/guides/claude-code.md) pour persister les variables d'environnement entre les sessions.

## Qu'est-ce que le support NPU AMD

Les processeurs AMD Ryzen AI séries 300/400 incluent une Neural Processing Unit (NPU) dédiée pour les charges de travail IA. Lemonade Server est le seul serveur LLM local qui accélère l'inférence sur le NPU AMD en utilisant l'exécution hybride NPU+iGPU.

### Comment fonctionne l'accélération NPU

* **Format de modèle** : Les modèles optimisés NPU utilisent le format ONNX (identifiés par le suffixe `-NPU`, par exemple `Llama-3.2-1B-Instruct-NPU`)
* **Exécution** : Lemonade Server répartit l'inférence entre le NPU et l'iGPU en utilisant OnnxRuntime GenAI
* **Backend** : Le backend NPU est automatique — Lemonade Server détecte votre processeur Ryzen AI et sélectionne l'exécution NPU lorsque vous exécutez un modèle optimisé NPU
* **Performance** : L'accélération NPU décharge le travail du CPU et du GPU, réduisant la consommation d'énergie et libérant des ressources pour d'autres tâches

### Quels processeurs AMD prennent en charge l'inférence NPU

| Série de processeurs | Support NPU | Backend |
| - | - | - |
| AMD Ryzen AI 300 series (Strix Point) | Oui | NPU via ONNX |
| AMD Ryzen AI 400 series | Oui | NPU via ONNX |
| AMD Ryzen AI MAX+ (Strix Halo) | Pas de NPU, mais iGPU puissant | ROCm/vLLM ou Vulkan |
| AMD Ryzen 7000/8000 series | Pas de NPU | Vulkan (llama.cpp) |

> [!NOTE]
>
> Le support NPU nécessite les pilotes AMD Ryzen AI Software. Lemonade Server inclut le runtime nécessaire, mais assurez-vous que votre système dispose des derniers pilotes AMD Adrenalin installés.

## Lemonade Server vs autres backends

Lemonade Server est l'un des plusieurs backends que Tokios prend en charge. Voici comment il se compare :

| Fonctionnalité | Lemonade Server | Ollama | llama.cpp | vLLM |
| - | - | - | - | - |
| **Support NPU AMD** | Oui (Ryzen AI 300/400) | Non | Non | Non |
| **Détection auto du backend** | Oui (Vulkan/ROCm/CUDA/Metal) | Manuelle | Manuelle | Manuelle |
| **Complexité d'installation** | Faible (installateur) | Faible (une commande) | Moyenne (compilation) | Élevée (serveur GPU Python) |
| **Formats de modèles** | GGUF, ONNX, FLM | GGUF | GGUF | Hugging Face |
| **Idéal pour** | Matériel AMD ; multiplateforme | Débutants ; démarrage le plus rapide | Serving GGUF manuel | Serving GPU à haut débit |

> [!TIP]
>
> Lemonade Server est un excellent choix si vous avez du matériel AMD (en particulier Ryzen AI avec NPU) ou si vous voulez un serveur multiplateforme qui détecte automatiquement votre backend. Si vous voulez simplement le démarrage le plus rapide sur n'importe quel matériel, [Ollama](/fr/guides/ollama-remote-access.md) reste le plus simple.

## FAQ

> **What port does Lemonade Server use?**
>
> Lemonade Server écoute sur le port **13305** par défaut, lié à `127.0.0.1` (localhost uniquement). L'API compatible OpenAI est à `http://localhost:13305/v1`. Vous pouvez vérifier que Lemonade Server fonctionne avec `lemonade status` ou `curl http://localhost:13305/v1/models`.

> **How do I know which backend Lemonade Server is using?**
>
> Exécutez `lemonade status` pour voir le backend détecté (Vulkan, ROCm, CUDA, Metal ou NPU). Lemonade Server détecte automatiquement votre matériel et sélectionne le meilleur backend. Vous pouvez aussi utiliser `lemonade status --json` pour une sortie lisible par machine.

> **Does Lemonade Server support AMD NPU?**
>
> Oui. Lemonade Server est le seul serveur LLM local qui accélère l'inférence sur les NPU AMD Ryzen AI séries 300/400. Téléchargez un modèle optimisé NPU avec `lemonade pull <model>-NPU` et exécutez-le avec `lemonade run <model>-NPU`. Le backend NPU utilise l'exécution hybride NPU+iGPU via OnnxRuntime GenAI.

> **Can I use Lemonade Server with NVIDIA GPUs?**
>
> Oui. Lemonade Server détecte automatiquement les GPU NVIDIA et utilise le backend CUDA. Il fonctionne sur tout matériel qui prend en charge Vulkan, ROCm, CUDA ou Metal — AMD, NVIDIA et Apple Silicon sont tous pris en charge.

> **How do I expose Lemonade Server to my network?**
>
> N'exposez pas Lemonade Server directement — utilisez Tokios à la place. Tokios ajoute un accès à distance authentifié sans ouvrir de port entrant. Consultez [les étapes de configuration ci-dessus](#the-outbound-only-way) pour la procédure complète.

> **Does streaming work?**
>
> Oui. Définissez `"stream": true` et Tokios renvoie des server-sent events (SSE) standard au format OpenAI ou Anthropic, selon la surface API que vous avez appelée.

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

> **Can I expose more than 1 Lemonade Server model?**
>
> Oui. Enregistrez des déploiements supplémentaires dans l'onglet [Models](https://tokios.com/console/models), ou utilisez un fichier de configuration `tokios-connector.json` pour définir plusieurs upstreams et routes pour un seul connecteur. Consultez [Configuration du connecteur](/fr/reference/connector-config.md).

> **How do I update Lemonade Server?**
>
> Sur Linux, exécutez `sudo apt update && sudo apt upgrade lemonade-server` (APT) ou `sudo snap refresh lemonade-server` (Snap). Sur Windows, téléchargez le dernier installateur MSI depuis la [page des versions](https://github.com/lemonade-sdk/lemonade/releases).

> **What model architectures does the NPU support?**
>
> Le NPU prend en charge des architectures de modèles spécifiques optimisées pour l'exécution ONNX. Exécutez `lemonade list` pour voir les modèles NPU disponibles (identifiés par le suffixe `-NPU`). Tous les modèles ne sont pas compatibles NPU — les modèles GGUF s'exécutent sur le backend GPU/CPU à la place. Consultez la [FAQ Lemonade](https://lemonade-server.ai/docs/guide/faq/) pour la liste complète des architectures prises en charge par le NPU.

## Votre modèle ne quitte jamais votre machine — votre point de terminaison fonctionne partout

Lemonade Server continue de faire exactement ce qu'il fait aujourd'hui, sur localhost, sans ports entrants ni API exposée. Le connecteur compose uniquement vers l'extérieur. Tout ce qui vient après — authentification, routage, diffusion — est un seul point de terminaison que vous pouvez appeler depuis n'importe quelle machine, coéquipier ou agent à qui vous choisissez de donner une clé.

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

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

> **[Configuration Strix Halo](/fr/use-cases/strix-halo.md)**
>
> Transformez votre boîtier AMD Strix Halo en point de terminaison de modèle avec Lemonade Server.

> **[Backends pris en charge](/fr/setup/supported-backends.md)**
>
> Découvrez tous les backends que Tokios prend en charge — Ollama, llama.cpp, vLLM, LM Studio et plus.

## Sources

* [Dépôt GitHub Lemonade SDK](https://github.com/lemonade-sdk/lemonade)
* [Documentation officielle de Lemonade Server](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/)
* [Documentation CLI de Lemonade Server](https://lemonade-server.ai/docs/guide/cli/)


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