Exposer un LLM local avec FastChat

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 ou bitsandbytes peuvent nécessiter des builds spécifiques.

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/Ubuntu
pip 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 ~/fschat
cd ~/fschat

Vous pouvez utiliser venv (inclus dans Python) ou conda. Voici comment faire avec venv :

python3 -m venv fschat-env
source 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 ~/fschat
source 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 ~/fschat
source fschat-env/bin/activate  # Linux/macOS
python3 -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 ~/fschat
source fschat-env/bin/activate  # Linux/macOS
python3 -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 ~/fschat
source ~/fschat/fschat-env/bin/activate  # Linux/macOS
python3 -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.

Interface web FastChat

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 ~/fschat
source fschat-env/bin/activate  # Linux/macOS
python3 -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/bash
source ~/fschat/fschat-env/bin/activate  # Active l'environnement virtuel
python3 -m fastchat.serve.controller &  # Démarre le contrôleur en arrière
python3 -m fastchat.serve.model_worker --model-path LiquidAI/LFM2-1.2B --device cpu &  # Démarre le worker
python3 -m fastchat.serve.gradio_web_server  # Démarre l'interface web

Un autre script pour lancer non pas l’UX mais l’API :

#!/bin/bash
source ~/fschat/fschat-env/bin/activate  # Active l'environnement virtuel
python3 -m fastchat.serve.controller &  # Démarre le contrôleur en arrière
python3 -m fastchat.serve.model_worker --model-path LiquidAI/LFM2-1.2B --device cpu &  # Démarre le worker
python3 -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.sh
chmod +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.5
hf auth login  # Authentifiez-vous si nécessaire
hf 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 ou tokenizer_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.
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 :

python3 -m fastchat.serve.cli --model-path ... --device cpu --load-8bit

GPU Apple Silicon :

python3 -m fastchat.serve.cli --model-path ... --device mps --load-8bit

Multi-GPU :

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.