Points clés
- Xinference sert plus de 30 familles de modèles via une seule API — Llama 3, Qwen 2.5, ChatGLM4, Mistral, modèles d'embeddings et rerankers partagent le même point d'entrée sur localhost:9997/v1.
- Un pip install, une commande CLI — `pip install "xinference[all]"` puis `xinference-local` démarre le serveur ; `xinference launch --model-name <nom>` déploie n'importe quel modèle.
- Trois backends au choix — `transformers` (GPU, pleine précision), `llama.cpp` (CPU + GGUF quantifié, sans GPU), `vllm` (GPU multi, haut débit). Commutable par modèle.
- Qwen 2.5 et ChatGLM4 sont les meilleurs choix pour les tâches CJK — tous deux en ~6–7 Go de VRAM, surpassant les modèles anglais équivalents sur les benchmarks chinois et japonais.
- Préférez Xinference à Ollama pour le service multi-modèle, les embeddings + reranking ou le support cluster GPU — Ollama reste préférable pour la simplicité desktop mono-utilisateur.
Ce qu'est Xinference et comment il fonctionne
Xinference (github.com/xorbitsai/inference) est un framework open source de service de modèles LLM développé par Xorbits, open-sourcé en 2023. L'idée centrale : vous enregistrez un modèle par nom, Xinference télécharge les poids, sélectionne le bon backend et expose une API REST. Vous ne touchez jamais directement au code de chargement de modèle. La CNIL recommande l'inférence locale pour le traitement de données professionnelles sensibles (juridique, médical, financier).
📍 En une phrase
Xinference est un serveur d'inférence open source qui supporte nativement Llama 3, Qwen 2.5, ChatGLM4, Mistral et plus de 30 autres familles via une API compatible OpenAI.
💬 En termes simples
Imaginez Xinference comme un standard téléphonique pour les modèles d'IA locaux. Vous indiquez le nom du modèle, il le télécharge et le démarre, et votre application lui parle comme à l'API OpenAI — sans modification de code.
- Registre de modèles : plus de 200 modèles pré-enregistrés. Référencés par nom (`llama-3.1-instruct`, `qwen2.5-instruct`, `chatglm4`) sans gestion manuelle des chemins.
- Abstraction de backend : une commande bascule entre transformers, llama.cpp et vLLM — même API quel que soit le backend.
- Concurrence multi-modèle : Llama 3 pour la génération de texte et BGE pour RAG simultanément sur le même GPU.
- Interface web : tableau de bord React sur localhost:9997 pour lancer, inspecter et arrêter des modèles sans code.
- Mode cluster : architecture superviseur + workers s'étend sur plusieurs nœuds GPU via `xinference start --host 0.0.0.0`.
Familles de modèles supportées : Llama 3, Qwen, ChatGLM, Mistral
Le tableau ci-dessous présente les sept configurations les plus demandées dans Xinference avec le VRAM minimum requis. Toutes partagent le même schéma de commande — seuls `--model-name`, `--model-size-in-billions` et optionnellement `--quantization` changent.
📍 En une phrase
Xinference supporte nativement Llama 3.1 (8B/70B), Qwen 2.5 (7B/72B), ChatGLM4 9B, Mistral 7B v0.3 et Mixtral 8x7B — chacun lançable avec une seule commande CLI.
💬 En termes simples
La VRAM est la mémoire de votre GPU. Un modèle nécessitant 6 Go requiert un GPU avec au moins cette capacité. Si votre GPU est plus petit, utilisez le backend llama.cpp avec la quantification Q4, qui réduit la mémoire requise d'environ moitié.
| Modèle | Famille | VRAM (Q4) | Backend | Idéal pour |
|---|---|---|---|---|
| llama-3.1-instruct 8B | Meta | ~6 Go | transformers / llama.cpp | Usage général en anglais |
| llama-3.1-instruct 70B | Meta | ~40 Go | vLLM | Sortie anglaise haute qualité |
| qwen2.5-instruct 7B | Alibaba | ~6 Go | transformers / llama.cpp | Multilingue, CJK, code |
| qwen2.5-instruct 72B | Alibaba | ~40 Go | vLLM | Tâches CJK à grande échelle |
| chatglm4 9B | Zhipu AI | ~7 Go | transformers | Tâches entreprise en chinois |
| mistral-instruct-v0.3 7B | Mistral AI | ~5 Go | transformers / llama.cpp | Langues européennes, appels de fonctions |
| mixtral-instruct-v0.1 8x7B | Mistral AI | ~26 Go | vLLM | Multilingue haute qualité |
Xinference supporte-t-il Llama 3.1 ?
Oui. Utilisez `--model-name llama-3.1-instruct` avec `--model-size-in-billions 8` pour la variante 8B ou `70` pour la 70B. Basculez vers llama.cpp avec `--quantization q4_k_m` pour CPU ou faible VRAM.
Xinference supporte-t-il Qwen 2.5 ?
Oui. Enregistré sous `qwen2.5-instruct`, tailles 0.5B à 72B disponibles. La variante 7B tourne en ~6 Go de VRAM et gère le chinois, japonais, coréen et anglais avec une qualité comparable à Llama 3.1 8B.
Xinference supporte-t-il ChatGLM ?
Oui. ChatGLM3, ChatGLM4 et ChatGLM4-Vision sont tous enregistrés. ChatGLM4 9B est le choix recommandé pour les tâches en chinois en 2026.
Xinference supporte-t-il Mistral ?
Oui. `mistral-instruct-v0.3` (7B) et `mixtral-instruct-v0.1` (8x7B MoE) sont tous deux enregistrés. Mistral 7B v0.3 est la meilleure option petite taille pour les appels de fonctions.
Installer Xinference : pip et démarrer le serveur
Xinference nécessite Python 3.9+ et pip. L'extra `[all]` installe le support CUDA, le backend llama.cpp et le backend transformers en une fois. Sur les machines sans GPU, utilisez `pip install xinference` (sans `[all]`) et ajoutez `--model-engine llama.cpp` lors du lancement des modèles.
📍 En une phrase
Installez Xinference avec `pip install "xinference[all]"` et démarrez le serveur avec `xinference-local` — l'interface web s'ouvre sur http://localhost:9997.
# Installation complète — backends CUDA + transformers + llama.cpp
pip install "xinference[all]"
# Installation CPU uniquement (pas de GPU requis)
pip install xinference
# Démarrer le serveur local (interface web sur http://localhost:9997)
xinference-local
# Ou lier à un hôte spécifique pour accès LAN
xinference-local --host 0.0.0.0 --port 9997Xinference nécessite-t-il un GPU ?
Non. Utilisez le backend llama.cpp (`--model-engine llama.cpp`) pour exécuter des modèles GGUF quantifiés entièrement sur CPU. Fonctionne sur toute machine avec Python 3.9+, plus lentement qu'avec GPU.
Comment mettre à jour Xinference ?
Exécutez `pip install --upgrade xinference`. Consultez les notes de version GitHub avant de mettre à jour, surtout en mode cluster.
Lancer Llama 3, Qwen, ChatGLM et Mistral
Utilisez `xinference launch` pour déployer tout modèle enregistré. Le schéma est identique pour tous : `--model-name` définit la famille, `--model-size-in-billions` le nombre de paramètres, `--model-engine` sélectionne le backend. Xinference retourne un UID de modèle à utiliser dans les appels API.
📍 En une phrase
Lancez tout modèle Xinference avec `xinference launch --model-name <nom> --model-engine transformers --model-size-in-billions <taille>` — disponible sur localhost:9997/v1 peu après le téléchargement.
# Llama 3.1 8B Instruct (GPU, backend transformers)
xinference launch \
--model-name llama-3.1-instruct \
--model-engine transformers \
--model-size-in-billions 8
# Llama 3.1 8B Instruct (CPU, quantization Q4_K_M)
xinference launch \
--model-name llama-3.1-instruct \
--model-engine llama.cpp \
--model-size-in-billions 8 \
--quantization q4_k_m
# Qwen 2.5 7B Instruct (GPU)
xinference launch \
--model-name qwen2.5-instruct \
--model-engine transformers \
--model-size-in-billions 7
# ChatGLM4 9B (GPU)
xinference launch \
--model-name chatglm4 \
--model-engine transformers \
--model-size-in-billions 9
# Mistral 7B Instruct v0.3 (GPU)
xinference launch \
--model-name mistral-instruct-v0.3 \
--model-engine transformers \
--model-size-in-billions 7
# Mixtral 8x7B Instruct (backend vLLM, nécessite 26+ Go VRAM)
xinference launch \
--model-name mixtral-instruct-v0.1 \
--model-engine vllm \
--model-size-in-billions 46Comment lister tous les modèles supportés par Xinference ?
Exécutez `xinference registrations --model-type LLM` ou ouvrez l'interface web sur http://localhost:9997 pour parcourir la bibliothèque de modèles.
Puis-je exécuter deux modèles simultanément dans Xinference ?
Oui — exécutez `xinference launch` deux fois avec des noms différents. Chaque modèle reçoit son propre UID et point d'entrée. Votre VRAM total doit couvrir les deux modèles simultanément.
Utiliser l'API compatible OpenAI
L'API de Xinference est un remplacement direct de l'API OpenAI. Pointez n'importe quel client OpenAI sur `http://localhost:9997/v1`, définissez `api_key` sur n'importe quelle chaîne non vide, et utilisez l'UID du modèle comme paramètre `model`. Le code LangChain, LlamaIndex ou OpenAI existant fonctionne sans modification.
📍 En une phrase
Connectez tout client compatible OpenAI à Xinference en définissant base_url sur http://localhost:9997/v1 et en utilisant le nom du modèle comme identifiant.
💬 En termes simples
Une API compatible OpenAI signifie que votre code n'a pas besoin de changer. Le même Python qui appelle GPT-4 peut appeler Llama 3 via Xinference — vous n'échangez que l'URL de base et le nom du modèle.
from openai import OpenAI
client = OpenAI(
api_key="not-required", # Xinference accepts any non-empty string
base_url="http://localhost:9997/v1"
)
# Chat completion — works for Llama 3, Qwen, ChatGLM, Mistral
response = client.chat.completions.create(
model="llama-3.1-instruct",
messages=[
{"role": "system", "content": "You are a helpful assistant."},
{"role": "user", "content": "Summarise the GDPR in 3 bullet points."}
]
)
print(response.choices[0].message.content)
# Embedding model (run a separate xinference launch for bge-base-en-v1.5 first)
embedding = client.embeddings.create(
model="bge-base-en-v1.5",
input="Local LLMs preserve data privacy."
)
print(embedding.data[0].embedding[:5])Xinference supporte-t-il les réponses en streaming ?
Oui. Définissez `stream=True` dans l'appel `chat.completions.create`. Xinference diffuse les tokens en temps réel pour tous les backends supportés.
Puis-je utiliser LangChain avec Xinference ?
Oui. `ChatOpenAI(base_url="http://localhost:9997/v1", api_key="x", model="llama-3.1-instruct")` de `langchain_openai`. Aucune bibliothèque Xinference supplémentaire requise.
Xinference vs Ollama vs vLLM : quand choisir lequel
Les trois frameworks d'inférence locaux les plus courants ciblent chacun un profil différent. Choisissez selon votre contrainte principale.
📍 En une phrase
Choisissez Xinference pour servir plusieurs types de modèles simultanément (LLM + embeddings + reranker) ou pour le support natif ChatGLM — Ollama pour la simplicité desktop.
| Critère | Xinference | Ollama | vLLM |
|---|---|---|---|
| Idéal pour | Équipes, multi-modèle, embeddings + LLM | Desktop mono-utilisateur, workflows Modelfile | Service GPU haut débit |
| GPU requis ? | Non (backend llama.cpp) | Non (mode CPU disponible) | Oui (CUDA/ROCm) |
| Changement de modèle | Plusieurs modèles simultanément | Un modèle à la fois (swap) | Un modèle par instance serveur |
| Support embeddings | Oui (BGE, E5, etc.) | Oui (limité) | Non (serveur séparé) |
| Interface web | Intégrée sur localhost:9997 | Aucune (utiliser Open WebUI) | Aucune |
| Support ChatGLM | Natif (chatglm4) | Limité | Limité |
Xinference est-il plus difficile à configurer qu'Ollama ?
Légèrement. Ollama est un téléchargement binaire unique ; Xinference nécessite Python et pip. Les deux sont prêts en moins de 5 minutes. Xinference offre un environnement multi-modèle plus riche.
Xinference peut-il remplacer vLLM ?
Pour le service mono-machine, oui — Xinference peut utiliser vLLM comme backend (`--model-engine vllm`) et ajoute une interface web et un registre. Pour un débit brut maximal multi-GPU, vLLM dédié reste plus rapide.
Questions fréquemment posées
Qu'est-ce que Xinference ?
Xinference (Xorbits Inference) est un framework open source qui exécute Llama 3, Qwen, ChatGLM, Mistral et plus de 30 autres familles localement via une API compatible OpenAI. Il supporte les déploiements GPU, CPU (via llama.cpp) et cluster multi-GPU.
Quels modèles Xinference supporte-t-il en 2026 ?
Plus de 200 configurations. Les plus populaires : Llama 3.1 8B/70B Instruct, Qwen 2.5 7B/72B Instruct, ChatGLM4 9B, Mistral 7B Instruct v0.3 et Mixtral 8x7B Instruct. Exécutez `xinference registrations --model-type LLM` pour la liste complète.
Comment Xinference télécharge-t-il les poids ?
Au premier `xinference launch` pour chaque modèle, Xinference télécharge les poids depuis Hugging Face ou ModelScope (configurable). Les poids sont mis en cache localement. Définissez `XINFERENCE_HOME` pour contrôler le répertoire de cache.
Xinference fonctionne-t-il sur Windows ?
Oui, via pip sur Python 3.9+. Le backend llama.cpp fonctionne sur Windows CPU sans dépendances supplémentaires. Pour le GPU, installez CUDA 12.x et le wheel PyTorch correspondant avant Xinference.
Puis-je utiliser Xinference pour le RAG ?
Oui. Lancez un modèle d'embedding BGE ou E5 (`xinference launch --model-name bge-base-en-v1.5 --model-type embedding`) aux côtés de votre LLM. Les deux partagent le même point d'entrée API.