Construire une stack IA open source auto-hébergée n’est plus réservé aux équipes de recherche. En 2026, une équipe ops peut faire tourner un LLM sur ses propres serveurs, offrir une interface de chat à ses collègues, brancher un RAG sur sa documentation, automatiser le triage d’alertes et tracer chaque appel, sans qu’aucune donnée ne quitte son infrastructure. Ce guide compare, couche par couche, les briques de cette infrastructure IA auto-hébergée.
La difficulté n’est plus de trouver des outils, mais de choisir parmi eux. Ollama, vLLM, llama.cpp, Open WebUI, LangChain, LlamaIndex, CrewAI, Dify, n8n, Langfuse, Phoenix : chaque projet a sa place, mais pas forcément dans votre contexte. Et chaque brique ajoutée est un service de plus à déployer, mettre à jour, sécuriser et superviser.
Ce guide pilier organise ces projets en cinq couches, compare leurs forces et leurs limites dans un tableau, puis propose des assemblages types. Chaque brique dispose d’un article dédié, en lien ci-dessous, avec un pas-à-pas et des conseils d’exploitation.
Les cinq couches d’une stack IA open source auto-hébergée
- Inférence : le serveur qui charge le modèle et répond aux requêtes (Ollama, vLLM, llama.cpp).
- Interface : l’application de chat pour les utilisateurs (Open WebUI).
- Frameworks : les bibliothèques pour construire RAG et agents (LangChain/LangGraph, LlamaIndex, CrewAI, AutoGen).
- Workflows : les plateformes visuelles pour orchestrer des traitements (Dify, n8n).
- Observabilité : la collecte et l’analyse des traces LLM (Langfuse, OpenLLMetry, Phoenix).
Le liant entre ces couches est double : l’API compatible OpenAI, que la plupart des serveurs d’inférence exposent et que la plupart des clients savent consommer, et OpenTelemetry, qui permet de suivre une requête d’une couche à l’autre.
Le tableau comparatif
| Brique | Couche | Points forts | Points d’attention | Article dédié |
|---|---|---|---|---|
| Ollama | Inférence | Installation en une commande, catalogue de modèles, API simple | Pensé pour le poste ou le petit serveur ; concurrence limitée | Ollama |
| vLLM | Inférence | Débit élevé sur GPU, API compatible OpenAI, métriques Prometheus | Exige des GPU et un réglage de la mémoire | vLLM |
| llama.cpp | Inférence | Léger, CPU ou GPU, format GGUF, quantification | Plus bas niveau ; à industrialiser soi-même | llama.cpp |
| Open WebUI | Interface | Interface de chat complète, multi-utilisateurs, RAG intégré | Licence propre au projet, à lire ; gestion des comptes à cadrer | Open WebUI |
| LangChain / LangGraph | Framework | Écosystème d’intégrations, graphes d’agents avec état | Abstractions nombreuses, évolutions fréquentes | LangChain et LangGraph |
| LlamaIndex | Framework | Ingestion, indexation et évaluation de RAG | Moins orienté orchestration d’agents complexes | LlamaIndex |
| CrewAI | Framework | Multi-agents par rôles et tâches, très lisible | Télémétrie d’usage activée par défaut | CrewAI et AutoGen |
| AutoGen | Framework | Agents conversationnels, traçage OpenTelemetry natif | En mode maintenance, successeur annoncé par Microsoft | CrewAI et AutoGen |
| Dify | Workflows | Applications LLM, RAG et agents en visuel, API par application | Licence Apache 2.0 modifiée, avec conditions | Dify et n8n |
| n8n | Workflows | Centaines de connecteurs, webhooks, nœuds IA | Licence « fair-code », restrictions commerciales | Dify et n8n |
| Langfuse | Observabilité | Traces LLM, prompts, coûts, évaluations ; réception OTLP | Plusieurs composants à opérer en auto-hébergement | Langfuse et OpenLLMetry |
| OpenLLMetry | Observabilité | Instrumentations OpenTelemetry pour LLM, bases vectorielles et frameworks | Conventions gen_ai.* encore en évolution |
Langfuse et OpenLLMetry |
| Phoenix | Observabilité | Traces et évaluations, basé sur OpenTelemetry et OpenInference | Licence Elastic License 2.0 | Observabilité de l’IA |
Ce tableau résume des tendances, pas des benchmarks : les performances dépendent du modèle, du matériel et de la charge. Mesurez dans votre contexte.
Infrastructure IA auto-hébergée : comment choisir la couche d’inférence ?
C’est la décision la plus structurante, car elle conditionne le matériel :
- Un poste, une petite équipe, des essais : Ollama, pour sa simplicité.
- Un service partagé sur GPU avec beaucoup d’utilisateurs simultanés : vLLM, conçu pour le débit et l’efficacité mémoire.
- Du matériel modeste, du CPU, de l’embarqué ou un environnement isolé : llama.cpp et son serveur intégré, avec des modèles quantifiés.
Comme les trois exposent une API compatible OpenAI (Ollama propose aussi la sienne), changer de serveur plus tard reste possible si les clients s’appuient sur cette API commune. Sur Kubernetes, pensez aux demandes de ressources : notre article sur les requêtes CPU effectives des pods rappelle à quel point l’écart entre déclaré et réel peut être grand, et les GPU sont encore moins partageables.
Frameworks ou plateforme de workflows ?
Les frameworks (LangChain, LlamaIndex, CrewAI, AutoGen) s’adressent aux développeurs : tout est code, testable et versionnable, mais il faut écrire et maintenir une application. Les plateformes de workflows (Dify, n8n) s’adressent à des profils plus larges : on assemble visuellement, on publie une API, mais on dépend de l’outil et de son modèle d’exécution.
Une règle simple : si le cœur du besoin est un traitement métier spécifique avec des tests, un framework ; si c’est l’intégration entre systèmes existants avec une étape IA, une plateforme de workflows. Les deux cohabitent souvent.
Pourquoi l’observabilité n’est pas une option
Une stack IA auto-hébergée cumule les risques d’un service classique (pannes, saturation, latence) et ceux propres aux LLM (réponses fausses, boucles d’agents, explosion des tokens, fuite de données dans les prompts). Il faut donc deux niveaux d’observation :
- Infrastructure et service : GPU, mémoire, files d’attente du serveur d’inférence, latence, erreurs, disponibilité de chaque brique ;
- Application LLM : traces des appels, documents récupérés, tokens, scores de qualité.
OpenLLMetry ou OpenInference produisent les traces, Langfuse ou Phoenix les analysent sous l’angle LLM, et un backend généraliste compatible OTLP relie le tout au reste du système. Notre pilier sur l’observabilité de l’IA détaille cette approche, et les exigences SRE des charges IA en précisent les contraintes.
En pratique : trois assemblages types
Étape 1 — Le kit de démarrage (une machine)
Ollama + Open WebUI, éventuellement avec le RAG intégré d’Open WebUI. Objectif : faire découvrir l’IA locale à l’équipe et collecter des cas d’usage. À superviser : disponibilité, mémoire, temps de réponse.
# exemple indicatif : vérifier que le serveur Ollama répond
curl http://localhost:11434/api/tags
Étape 2 — L’assistant ops (un serveur GPU)
vLLM pour l’inférence partagée, Open WebUI comme interface, un RAG LlamaIndex sur les runbooks exposé en API, n8n pour le triage d’alertes, et OpenLLMetry vers Langfuse. Objectif : un premier service interne avec un SLO de disponibilité et de latence.
Étape 3 — La plateforme IA interne (Kubernetes)
Plusieurs modèles servis par vLLM derrière une passerelle, Dify pour les équipes métier, LangGraph ou CrewAI pour les agents développés en interne, un OpenTelemetry Collector central qui envoie les traces vers Langfuse ou Phoenix et vers le backend d’observabilité de l’entreprise. Objectif : un produit de plateforme, avec catalogue, quotas et suivi des coûts. Voir aussi notre article sur les défis du platform engineering.
À chaque étape, ajoutez une brique seulement quand un besoin mesuré la justifie.
Bonnes pratiques
- Lisez les licences : plusieurs projets cités ne sont pas sous licence open source « classique » (Dify, n8n, Open WebUI, Phoenix).
- Standardisez sur l’API compatible OpenAI côté clients pour garder la liberté de changer de serveur.
- Instrumentez avec OpenTelemetry dès le prototype, et centralisez via un Collector.
- Fixez les versions des images et des modèles ; testez les mises à jour sur un jeu de cas de référence.
- Placez toutes les interfaces derrière une authentification d’entreprise et un reverse proxy TLS.
- Exposez les outils aux agents avec parcimonie, éventuellement via MCP, et en lecture seule par défaut.
- Suivez les coûts : GPU, stockage des traces et temps humain d’exploitation.
Questions fréquentes
Une stack IA auto-hébergée est-elle moins chère qu’une API cloud ?
Pas forcément. Elle devient intéressante avec un usage soutenu, des contraintes de confidentialité ou un besoin de fonctionnement hors ligne. Il faut compter le matériel, l’énergie et surtout le temps d’exploitation.
Quel modèle choisir pour démarrer ?
Un modèle généraliste de taille moyenne, distribué avec une licence compatible avec votre usage, et disponible dans le format de votre serveur d’inférence. Comparez ensuite quelques candidats sur vos propres questions plutôt que sur des classements publics.
Faut-il tout auto-héberger, y compris l’observabilité ?
Ce n’est pas obligatoire. Langfuse et Phoenix s’auto-hébergent, mais les traces peuvent aussi partir vers un service géré si les prompts sont masqués au Collector. L’essentiel est de décider consciemment où vont les données.
Conclusion
Une stack IA open source auto-hébergée se construit par couches : inférence, interface, frameworks, workflows et observabilité. Il n’existe pas de combinaison universelle, mais une démarche : commencer petit, standardiser sur des interfaces ouvertes (API compatible OpenAI, OpenTelemetry), mesurer, puis ajouter des briques quand le besoin est démontré. Les articles satellites de cette série détaillent chacune d’entre elles.
Pour approfondir chaque projet, référez-vous à sa documentation officielle, par exemple celle d’vLLM ou de Phoenix.
span.observer est un blog indépendant de la communauté, non affilié à Dynatrace LLC ni aux projets cités. Les marques citées appartiennent à leurs propriétaires. Les outils évoluent vite : vérifiez les commandes et options dans leur documentation officielle.
4 comments