Exposer un LLM local avec FastChat
Mise à jour :
Les LLM ont révolutionné notre manière de travailler. Ces modèles, capables de comprendre et générer du texte de manière fluide, sont aujourd’hui accessibles via des API commerciales avec des limites d’utilisation. Dans le précédent guide, nous avions vu comment installer un LLM open-source localement avec juste du CPU. Cependant, une fois le modèle installé, il est essentiel de le rendre accessible via une API.
Il existe plusieurs solutions pour exposer un LLM localement via une API, mais celle que j’ai choisie est FastChat. FastChat est un framework open-source qui permet de déployer des modèles de langage en tant que services web. Il est conçu pour être simple à utiliser et offre une interface conviviale pour interagir avec les modèles.
Qu’est-ce que FastChat ?
FastChat est une projet open-source développée par lmsys.org ↗ pour exploiter facilement des LLM en local ou sur serveur, tout en offrant une interface web et une API compatible OpenAI. Il permet de servir des modèles comme Vicuna, LLaMA, Mistral ou encore Zephyr, via une architecture modulaire prête à l’emploi.
FastChat agit comme un pont entre le modèle et l’utilisateur final. Que vous souhaitiez interagir avec le modèle via un navigateur, une ligne de commande ou l’intégrer à un outil tiers comme Chainlit, il fournit tous les composants nécessaires : contrôleur, worker de modèle, interface web, serveur d’API.
Concrètement, il vous permet de :
- Lancer rapidement un chatbot localement avec interface web,
- Servir des modèles personnalisés (fine-tunés, quantifiés),
- Interagir via une API REST compatible avec les clients OpenAI existants,
- Superviser plusieurs workers sur une ou plusieurs machines.
Prérequis et environnements compatibles
Avant d’installer FastChat, il est important de s’assurer que votre machine répond aux exigences matérielles et logicielles. Le projet est conçu pour être flexible et peut fonctionner sur plusieurs architectures et systèmes d’exploitation, bien que certaines configurations offrent de meilleures performances.
Configuration matérielle minimale
-
Processeur (CPU) : requis pour l’exécution de base, mais fortement limité en performances sur les LLM.
-
Mémoire RAM : au moins 16 Go recommandés, 32 Go ou plus pour les modèles >7B.
-
Carte graphique (GPU) : (optionnelle) recommandée pour l’inférence rapide.
- Support des GPU NVIDIA avec CUDA pour les performances optimales.
- Mémoire GPU : 8 Go minimum, 16 Go ou plus pour des modèles plus grands (13B, 33B).
- Compatibilité partielle avec ROCm/AMD via des forks ou alternatives, mais non officiellement supportée.
- Possibilité de chargement CPU-only ou quantifié (int4/int8) pour contourner les limites matérielles.
Architectures supportées
-
x86_64 (amd64) : architecture principale supportée pour Linux, Windows et macOS.
-
ARM64 (aarch64) : supportée partiellement, notamment sur Apple Silicon (M1, M2) et serveurs ARM (Graviton).
- Certaines dépendances comme
transformers
,torch
oubitsandbytes
peuvent nécessiter des builds spécifiques.
- Certaines dépendances comme
Systèmes d’exploitation compatibles
- Linux (Ubuntu/Debian/Fedora…) : système de référence pour le développement et le déploiement.
- Windows 10/11 : supporté via Python et CUDA, mais certaines fonctionnalités avancées peuvent nécessiter WSL2.
- macOS (Intel & Apple Silicon) : possible via les versions CPU-only ou modèles quantifiés, sans support GPU natif.
Logiciels nécessaires
- Python 3.8 à 3.11 : FastChat nécessite une version récente de Python.
- pip : gestionnaire de paquets Python, à jour.
- Git : pour cloner les dépôts sources.
- CUDA Toolkit : requis si usage GPU avec NVIDIA (version dépendante de
torch
).
Ces prérequis permettent d’assurer une installation stable et des performances optimales pour l’exécution de modèles de langage via FastChat.
Installation de FastChat
L’installation de FastChat se fait facilement via pip
, mais il est
fortement recommandé de l’isoler dans un environnement virtuel. Cela évite
les conflits de dépendances et permet de tester différentes versions sans
impacter votre système.
Étape 1 : Installer les dépendances de base
Commencez par mettre à jour pip et installer git
si ce n’est pas déjà fait :
sudo apt install git pipx # sur Debian/Ubuntupip install --upgrade pip
Étape 2 : Créer un environnement virtuel
Commencez par créer un dossier pour votre projet FastChat, puis créez un environnement virtuel pour isoler les dépendances. Cela permet de garder votre installation propre et de ne pas polluer votre système global avec des paquets Python spécifiques à FastChat
mkdir ~/fschatcd ~/fschat
Vous pouvez utiliser venv (inclus dans Python) ou conda. Voici comment
faire avec venv
:
python3 -m venv fschat-envsource fschat-env/bin/activate # Linux/macOS.\fschat-env\Scripts\activate # Windows
Une fois activé, l’invite de commande change pour indiquer l’environnement actif.
Étape 3 : Installer FastChat et ses modules
Comme je l’ai mentionné précédemment, FastChat est distribué via un package Python. Pour une installation complète avec support de l’interface web et des modèles, utilisez :
pip install "fschat[model_worker,webui]"
Cela installe :
- le serveur,
- l’API,
- l’interface Gradio,
- les dépendances des workers.
Étape 4 : Vérifier l’installation
Vous pouvez tester que tout est bien en place en important le module Python :
python -c "import fastchat; print('FastChat prêt à l’emploi')"
Ou lancer simplement le contrôleur :
python3 -m fastchat.serve.controller
Si aucune erreur ne s’affiche, l’installation est terminée. Vous êtes maintenant prêt à lancer un worker et interagir avec un LLM. Mais avant cela, il faut que je vous explique l’architecture de FastChat.
Architecture de FastChat
FastChat est conçu autour d’une architecture modulaire qui sépare les différentes responsabilités. Voici les principaux composants :
- Contrôleur : Gère les requêtes entrantes et la communication entre les différents modules.
- Workers de modèle : Exécutent les inférences de modèle. Ils peuvent être déployés sur plusieurs machines pour la scalabilité.
- Interface web : Permet d’interagir avec le modèle via un navigateur.
- Serveur d’API : Expose une API REST pour les clients externes.
Cette architecture permet une grande flexibilité et facilite l’intégration avec d’autres outils et services.
Démarrer FastChat
Maintenant que vous avez compris l’architecture, voyons comment démarrer FastChat et interagir avec un modèle.
Lancer le contrôleur
Pour démarrer le contrôleur, exécutez la commande suivante dans votre terminal :
cd ~/fschatsource fschat-env/bin/activate # Linux/macOS
python3 -m fastchat.serve.controller
Cela lancera le contrôleur FastChat, qui gérera les requêtes et la communication entre les différents composants.
Interagir avec un modèle avec la CLI
Pour tester rapidement le modèle, vous pouvez utiliser l’interface en ligne de commande fournie par FastChat. Dans un nouveau terminal, exécutez :
cd ~/fschatsource fschat-env/bin/activate # Linux/macOSpython3 -m fastchat.serve.cli --model LiquidAI/LFM2-1.2B --device cpu
Cela lancera une session interactive où vous pouvez poser des questions au modèle. Par exemple, tapez :
Human: Bonjour, comment vas-tu ?Assistant: Je vais bien, merci! Et vous? Comment ça va aujourd'hui?
Pour quitter la session, faites un Ctrl + C
.
Modèles compatibles avec FastChat
FastChat supporte de nombreux modèles open-source, issus principalement de Hugging Face. Il est possible de :
- Charger un modèle localement depuis un dossier,
- Télécharger un modèle depuis
huggingface.co
, - Servir plusieurs modèles simultanément avec des workers séparés.
Parmi les modèles compatibles :
- LLaMA 2 (Meta),
- Mistral (Mistral AI),
- Vicuna (dérivé de LLaMA),
- Zephyr (HuggingFace),
- FastChat-T5 (LLM léger intégré au projet),
- Baichuan, ChatGLM, RWKV, etc.
FastChat supporte également les modèles quantifiés (int4
, int8
) pour
réduire la consommation mémoire et permettre leur exécution sur des GPU plus
modestes, ou même sur CPU.
Les chemins peuvent être locaux (répertoire contenant config.json
,
pytorch_model.bin
, etc.) ou des identifiants Hugging Face
(lmsys/vicuna-7b-v1.3
).
Lancer un worker avec un modèle
Pour lancer un worker de modèle, vous devez d’abord choisir le modèle que vous
souhaitez utiliser. Par exemple, nous allons utiliser le modèle
LiquidAI/LFM2-1.2B
qui est un modèle quantifié de 1,2 milliard de paramètres.
Dans un nouveau terminal, activez votre environnement virtuel et exécutez :
cd ~/fschatsource fschat-env/bin/activate # Linux/macOSpython3 -m fastchat.serve.model_worker --model-path LiquidAI/LFM2-1.2B --device cpu
Cela lancera un worker qui :
- téléchargera le modèle
LiquidAI/LFM2-1.2B
depuis Hugging Face, - le chargera en mémoire,
- se préparera à traiter les requêtes.
Vous devriez voir des logs indiquant que le worker est prêt à recevoir des requêtes.
Étape 3 : Interagir avec l’interface web
Pour interagir avec le modèle via une interface web, vous pouvez lancer l’interface Gradio fournie par FastChat. Dans un nouveau terminal, exécutez :
cd ~/fschatsource ~/fschat/fschat-env/bin/activate # Linux/macOSpython3 -m fastchat.serve.gradio_web_server
Cela démarrera un serveur web accessible par défaut à l’adresse http://localhost:7860 ↗. Vous pouvez y accéder via votre navigateur pour interagir avec le modèle.
Posez vos questions au modèle dans le champ de saisie et cliquez sur “Envoyer” pour obtenir des réponses. Vous pouvez également ajuster les paramètres comme la température et le nombre de tokens générés.
Étape 4 : Interagir via l’API
Un autre moyen d’interagir avec le modèle est d’utiliser l’API REST exposée par FastChat. Vous pouvez utiliser n’importe quel client HTTP pour envoyer des requêtes.
Pour lancer le serveur d’API, exécutez dans un nouveau terminal :
cd ~/fschatsource fschat-env/bin/activate # Linux/macOSpython3 -m fastchat.serve.openai_api_server --host 0.0.0.0 --port 8001
Vous pouvez maintenant envoyer des requêtes POST à l’API à l’adresse http://localhost:8001/ ↗. Cette API est compatible avec les clients OpenAI, ce qui facilite l’intégration avec des outils existants.
Voici un exemple avec curl
pour récupérer la liste des modèles disponibles :
curl -X GET "http://localhost:8001/v1/models" -H "Authorization: fake_token"
Vous devriez obtenir une réponse JSON contenant les modèles disponibles, y
compris LiquidAI/LFM2-1.2B
.
{ "object": "list", "data": [ { "id": "LFM2-1.2B", "object": "model", "created": 1753941325, "owned_by": "fastchat", "root": "LFM2-1.2B", "parent": null, "permission": [ { "id": "modelperm-V7grzvAwSrVRT8uGeUgSVg", "object": "model_permission", "created": 1753941325, "allow_create_engine": false, "allow_sampling": true, "allow_logprobs": true, "allow_search_indices": true, "allow_view": true, "allow_fine_tuning": false, "organization": "*", "group": null, "is_blocking": false } ] } ]}
Vous pouvez également envoyer des requêtes de génération de texte en utilisant
l’endpoint /v1/chat/completions
et en indiquant le modèle souhaité. Voici un
exemple de requête :
curl -X POST "http://localhost:8001/v1/chat/completions" \-H "Content-Type: application/json" \-d '{ "model": "LFM2-1.2B", "messages": [ { "role": "user", "content": "Bonjour, comment vas tu ?" } ]}'
Le modèle devrait répondre avec un message généré en fonction de l’entrée fournie. Vous pouvez ajuster les paramètres de la requête, tels que la température et le nombre de tokens, pour influencer le comportement du modèle.
{ "id": "chatcmpl-D53VYgmb9BBToJSonUMta2", "object": "chat.completion", "created": 1753941400, "model": "LFM2-1.2B", "choices": [ { "index": 0, "message": { "role": "assistant", "content": "Of course, how are you today?\n" }, "finish_reason": "stop" } ], "usage": { "prompt_tokens": 482, "total_tokens": 490, "completion_tokens": 8 }}
Un script de démarrage
Pour simplifier le lancement de FastChat avec vos paramètres préférés, vous
pouvez créer un script bash. Par exemple, créez un fichier start_fschat_ui.sh
:
#!/bin/bashsource ~/fschat/fschat-env/bin/activate # Active l'environnement virtuelpython3 -m fastchat.serve.controller & # Démarre le contrôleur en arrièrepython3 -m fastchat.serve.model_worker --model-path LiquidAI/LFM2-1.2B --device cpu & # Démarre le workerpython3 -m fastchat.serve.gradio_web_server # Démarre l'interface web
Un autre script pour lancer non pas l’UX mais l’API :
#!/bin/bashsource ~/fschat/fschat-env/bin/activate # Active l'environnement virtuelpython3 -m fastchat.serve.controller & # Démarre le contrôleur en arrièrepython3 -m fastchat.serve.model_worker --model-path LiquidAI/LFM2-1.2B --device cpu & # Démarre le workerpython3 -m fastchat.serve.openai_api_server --host 0.0.0.0 --port 8001
N’oubliez pas de rendre le script exécutable :
chmod +x start_fschat_ui.shchmod +x start_fschat_api.sh
Utilisation de modèles téléchargés avec la CLI Hugging Face
FastChat permet non seulement de charger un modèle depuis Hugging Face à la volée, mais aussi de travailler avec des modèles préalablement téléchargés. Cela est particulièrement utile si vous souhaitez :
- gagner du temps au démarrage (plus besoin de télécharger les poids à chaque fois),
- travailler hors ligne,
- gérer manuellement vos modèles (quantifiés, LoRA, adaptés localement).
Organisation recommandée
Organisez vos modèles dans un répertoire dédié, par exemple :
/opt/models/└── vicuna-7b-v1.5/ ├── config.json ├── tokenizer.model ├── pytorch_model-00001-of-00002.bin └── ...
Ensuite :
python3 -m fastchat.serve.model_worker --model-path /opt/models/vicuna-7b-v1.5
Télécharger un modèle manuellement
Utilisez la commande huggingface-cli
pour récupérer un modèle dans le cache
local :
source ~/fschat/fschat-env/bin/activate # Charger le venv pour accéder à `huggingface-cli`mkdir -p ~/models/vicuna-7b-v1.5hf auth login # Authentifiez-vous si nécessairehf download lmsys/vicuna-7b-v1.5 --cache-dir ~/models/vicuna-7b-v1.5
Spécifier un chemin local dans FastChat
Pour utiliser un modèle téléchargé localement dans FastChat, vous devez spécifier le chemin vers le dossier contenant :
config.json
tokenizer.model
outokenizer_config.json
pytorch_model-00001-of-00002.bin
, etc.generation_config.json
(facultatif)
Exemple :
python3 -m fastchat.serve.cli --model-path ~/models/vicuna-7b-v1.5 --device cpu
Paramètres de lancement et d’optimisation de FastChat
FastChat offre une multitude de paramètres configurables permettant d’adapter l’inférence selon le matériel disponible, les modèles utilisés, ou le contexte d’utilisation. Ces paramètres influencent la consommation mémoire, la vitesse de traitement et la qualité des réponses.
Choix du périphérique (--device
)
Le paramètre --device
permet de spécifier le périphérique sur lequel le modèle
sera exécuté. Les options disponibles sont :
cuda
: pour les GPU NVIDIA (recommandé pour les performances).cpu
: pour des tests sans GPU, mais lent et gourmand en RAM.mps
: pour GPU Apple Silicon (M1/M2) via Metal.xpu
: pour GPU Intel (Arc, Data Center) avec Intel Extension for PyTorch.npu
: pour NPU Huawei Ascend (via CANN).
Quantification mémoire (--load-8bit
, --load-4bit
)
Pour réduire la consommation mémoire, FastChat propose des options de quantification :
--load-8bit
: réduit de moitié la mémoire requise (compatibilité CPU/GPU).--load-4bit
: nécessite des bibliothèques tierces (ExLlama, GPTQ, AWQ).
Usage recommandé :
- RTX 3090/4080 : 13B avec
--load-8bit
- Apple M1 32 Go : 7B avec
--load-8bit
et--device mps
Compression et offloading
Pour optimiser l’utilisation de la mémoire, FastChat propose des options d’offloading et de compression :
-
--cpu-offloading
: déplace les poids excédentaires vers la RAM CPU.- Nécessite
--load-8bit
et Linux.
- Nécessite
-
Utilisé sur GPU faible pour permettre des modèles plus larges.
Précision numérique (--dtype
)
De meme que pour les modèles quantifiés, FastChat permet de choisir la
précision numérique des poids du modèle via le paramètre --dtype
:
-
float16
,bfloat16
,float32
:float16
recommandé sur GPU Ampere (RTX 30xx),bfloat16
utile sur TPU ou CPU AVX512,float32
pour compatibilité maximale, mais très gourmand.
Multi-GPU (--num-gpus
, --max-gpu-memory
)
Pour les configurations multi-GPU, FastChat permet de répartir la charge entre plusieurs cartes graphiques :
--num-gpus
: permet le model parallelism, répartissant le modèle sur plusieurs cartes.--max-gpu-memory
: contrôle la quantité de VRAM utilisée par GPU (ex.8GiB
).
Exemples
-
Exécution sur CPU uniquement avec 8-bit :
Terminal window python3 -m fastchat.serve.cli --model-path ... --device cpu --load-8bit -
GPU Apple Silicon :
Terminal window python3 -m fastchat.serve.cli --model-path ... --device mps --load-8bit -
Multi-GPU :
Terminal window python3 -m fastchat.serve.cli --model-path ... --num-gpus 2 --max-gpu-memory 10GiB
Ces paramètres permettent une adaptation fine à votre infrastructure, qu’il s’agisse d’un portable, d’un serveur multi-GPU ou d’un environnement cloud. Pour des déploiements fiables et performants, la bonne combinaison de ces options est essentielle.
Conclusion
Avec FastChat, vous disposez désormais d’une infrastructure complète pour héberger localement des LLM, interagir via une interface web, une API OpenAI-compatible, ou en ligne de commande.
Mais ce n’est qu’une première étape. Dans de futurs guides sur chainlit, nous verrons comment l’intégrer en mettant en place la persistance des conversations (stockage en base de données), la gestion de l’historique, de la configuration des prompts et la mise en place de Retriever pour améliorer les réponses du modèle avec des données contextuelles.
Vous apprendrez ainsi à transformer un modèle brut en véritable assistant intelligent, prêt pour des cas d’usage réels : support client, copilote technique, chatbot métier, etc.