Dans cet article de blog, nous allons explorer différents logiciels libres qui, mis ensemble, permettent d'avoir un coffre à outil pour explorer l'intelligence artificielle générative avec des modèles de langage LLM entièrement hors-ligne.
Nous allons utiliser le déploiement par conteneurs avec Docker Compose pour ne pas modifier ton système d'exploitation.
🌘 Quels sont les avantages d'utiliser des LLM locaux par rapport aux services cloud ?
Pour préserver la confidentialité et respecter tes engangements professionnels, il faut éviter le plus possile de répandre des données sur des services disponibles gratuitement ou à peu de frais sur le web, avec des conditions d'utilisation difficiles à comprendre.
L'utilisation de logiciels libres localement ou sur des serveurs qu'on contrôle permet de simplifier l'atteinte de conformité réglementaire et de normes strictes en cybersécurité.
Travailler localement signifie que tu peux utiliser l'IA générative et le traitement du langage naturel tout en respectant des considérations éthiques et de vie privée grandissantes.
Un autre avantage qui n'est pas à négliger, c'est que tu ne dépends plus de la disponibilité du service, ni des limitations des forfaits gratuits des outils commerciaux.
Nous allons utiliser les logiciels suivants:
- Docker : https://www.docker.com/
- Ollama : https://ollama.ai/
- Open WebUI : https://github.com/open-webui/open-webui
- Flowise : https://github.com/FlowiseAI/Flowise
- PGVector : https://github.com/pgvector/pgvector
- Redis : https://redis.io/
Je vais t'expliquer leur rôle, comment les assembler avec la technologie Docker Compose et comment configurer les variables d'environnement nécessaires pour leur bon fonctionnement.
🌘 Présentation détaillée de chacun des logiciels
🌘 Docker
Docker est un logiciel qui utilise la technologie des conteneurs pour créer un réseau de mini-ordinateurs virtuels à l'intérieur de ton ordinateur. Ça permet d'installer et d'exécuter facilement plusieurs logiciels conçus pour des serveurs.
Docker ne fonctionne que sur Linux, mais l'applicatiom Docker Desktop permet d'installer tout ce qu'il faut dans la virtualisation de Windows ou de macOS de manière transparente. Docker est une application en ligne de commande, mais elle est disponible aussi graphiquement avec Docker Desktop ou les interfaces de développement comme Visual Studio Code ou IntelliJ.
Chaque logiciel est installé sur un système d'exploitation vierge. On peut donc configurer comme on le souhaite sans se soucier des dépendances ou des différences entre les systèmes d'exploitation.
Docker permet aussi de simuler un réseau informatique virtuel. Ça permet aux applications d'échanger des données entre elles à travers le protocole TCP/IP au travers de ports, sans avoir besoin d'infrastructure réseautique comme des routeurs, des cables ou des commutateurs.
🌘 Ollama
Ollama prend des modèles de langage et les prépare pour qu'ils soient faciles à utiliser sur ton ordinateur personnel. Ils sont disponibles sur une place de marché en ligne et peuvent être installés avec une seule ligne de code.
Ollama utilise les mêmes verbes que Git ou Docker, dont pull
, push
, run
... Ollama détecte automatiquement les processeurs graphiques et va pouvoir utiliser toute la puissance disponible de ton ordinateur.
🌘 Open WebUI
Open WebUI, c'est une interface web similaire à ChatGPT qui te permet de communiquer directement avec les modèles d'IA préparés par Ollama, ainsi que tout modèle en ligne compatible avec la syntaxe de l'API de OpenAI.
Ce logiciel tout-en-un permet d'utiliser des outils, des fonctions et des extensions pour interagir avec des modèles de langage et des bases de données vectorielles. C'est possible de faire du RAG avec des documents et d'appeler des services web avec Open WebUI, mais ça se fait avec le langage de programmation Python pour la plupart des fonctionnalités.
🌘 Flowise
Flowise est comme un jeu de construction pour l'IA générative et les RAG. Il te permet de créer des flux de travail et des agents IA en connectant différentes composantes ensemble. Par exemple, tu peux créer un système qui lit tes documents, comprend leur contenu, et répond à tes questions à leur sujet, le tout de manière automatisée.
Flowise utilise le concept de ChatFlow pour créer des flux de traitement. Ces flux sont composés de quelques dizaines de types différents de modules, qui permettent de créer de nombreuses applications basées sur des LLM locaux ou des API de services en ligne tels que OpenAI, AWS Bedrock ou DeepSeek.
C'est assez simple à utiliser et ça utilise le concept de classe en programmation orientée objet pour permettre de seulement relier les morceaux qui font du sens ensemble. Mais sans devoir programmer !
En arrière-plan, Flowise utilise LangChain et LlamaIndex, deux librairies de programmation avancées pour les modèles de langage.
🌘 PGVector
PGVector est une extension de la base de données PostgreSQL pour entreposer des vecteurs. Un vecteur, ça représente des concepts sous forme de nombres (qu'on appelle des vecteurs de plongements).
Ça permet à différents algorithmes basés sur l'algèbre matricielle de comparer rapidement des concepts complexes, un peu comme un gigantesque dictionnaire des synonymes et des antonymes.
Pour accéder facilement aux données d'une base de données, je conseille d'utiliser un éditeur de code tel que Visual Studio Code ou IntelliJ avec une extension pour les bases de données. Sinon, pour avoir un environnement complètement utilisable dans le navigateur, tu peux aussi utiliser Adminer (Site officiel, Docker).
🌘 Redis
Redis est comme la mémoire à court terme de ton système d'IA. Il stocke temporairement des informations pour que ton flux de traitement puisse y accéder très rapidement, un peu comme quand tu gardes une information importante en tête pour l'utiliser dans une conversation.
Ensemble, ces logiciels vont te permettre d'explorer l'IA générative. Ils travaillent ensemble pour te donner la possibilité de créer, d'interagir et d'expérimenter avec des modèles de langage sur ton ordinateur. Ça te permet de garder le contrôle sur tes données et de protéger la vie privée de ta clientèle
🌘 Le fichier Docker Compose
Je te présente ici un fichier Docker Compose qui permet de lancer tous ces services en même temps. Docker va créer un réseau virtuel et connecter chacun des composantes sur celui-ci.
services:
ollama:
image: ollama/ollama:latest
container_name: ollama
ports:
- "11434:11434"
volumes:
- ollama_volume:/root/.ollama
pull_policy: always
restart: always
pgvector:
image: 'pgvector/pgvector:pg17'
environment:
- 'POSTGRES_DB=${POSTGRES_DB}'
- 'POSTGRES_USER=${POSTGRES_USER}'
- 'POSTGRES_PASSWORD=${POSTGRES_PASSWORD}'
volumes:
- 'postgres_data:/var/lib/postgresql/data'
ports:
- '5432:5432'
open-webui:
image: 'ghcr.io/open-webui/open-webui:main'
ports:
- '3000:8080'
environment:
- 'OLLAMA_BASE_URL=${OLLAMA_BASE_URL}'
flowise:
image: flowiseai/flowise
ports:
- '3001:3001'
environment:
- 'PORT=${FLOWISE_PORT}'
- 'FLOWISE_USERNAME=${FLOWISE_USERNAME}'
- 'FLOWISE_PASSWORD=${FLOWISE_PASSWORD}'
- 'DATABASE_TYPE=${FLOWISE_DATABASE_TYPE}'
- 'DATABASE_HOST=${FLOWISE_DATABASE_HOST}'
- 'DATABASE_PORT=${FLOWISE_DATABASE_PORT}'
- 'DATABASE_USER=${FLOWISE_DATABASE_USER}'
- 'DATABASE_PASSWORD=${FLOWISE_DATABASE_PASSWORD}'
- 'DATABASE_NAME=${FLOWISE_DATABASE_NAME}'
depends_on:
- pgvector
- redis
volumes:
- 'flowise_data:/root/.flowise/'
redis:
image: 'redis:7'
ports:
- '6379:6379'
volumes:
- 'redis_data:/data'
volumes:
postgres_data: null
redis_data: null
flowise_data: null
ollama_volume: null
Avant de lancer le Docker Compose, par contre, tu dois préparer un fichier de variables d'environnement. Pour bien comprendre ce que tu dois faire, je t'invite à lire les deux sections suivantes.
🌘 Services Définis dans le Docker Compose
Je vais te présenter chacun des services présents dans le Docker Compose
🌘 Ollama
Image Docker: ollama/ollama:latest
Configuration:
- Ports: Le service est exposé sur le port 11434.
- Volumes: Les données persistantes sont stockées dans
ollama_volume
. - Redémarrage: Configuré pour redémarrer automatiquement en cas de problème.
🌘 PgVector
Image Docker: pgvector/pgvector:pg17
Configuration:
- Environnement: Les variables d'environnement pour la base de données PostgreSQL sont :
POSTGRES_DB
: : Nomde la base de données pour la base vectoriellePOSTGRES_USER
: Nom d'utilisateur pour la base vectoriellePOSTGRES_PASSWORD
: Mot de passe pour la base vectorielle
- Ports: Le service est exposé sur le port 5432.
- Volumes: Les données de la base de données sont stockées dans
postgres_data
.
🌘 Open Web UI
Image Docker: ghcr.io/open-webui/open-webui:main
Configuration:
- Ports: Le service est accessible via le port 3000.
- Environnement: La variable
OLLAMA_BASE_URL
doit être configurée pour pointer vers le service Ollama.
🌘 Flowise
Image Docker: flowiseai/flowise
Configuration:
- Ports: Le service est accessible via le port 3001.
- Environnement: Les variables d'environnement nécessaires sont :
PORT
: Le port sur lequel Flowise sera accessibleFLOWISE_USERNAME
: Nom d'utilisateur pour l'interface FlowiseFLOWISE_PASSWORD
: Mot de passe pour l'interface FlowiseDATABASE_TYPE
: Type de base de données utilisée (postgres dans ce cas)DATABASE_HOST
: Adresse du serveur de base de donnéesDATABASE_PORT
: Port de la base de donnéesDATABASE_USER
: Nom d'utilisateur pour la base de donnéesDATABASE_PASSWORD
: Mot de passe pour la base de donnéesDATABASE_NAME
: Nom de la base de données Flowise
- Dépendances: Ce service dépend de
pgvector
etredis
.
Attention, la base de données définie ici est différente de la base de données vectorielle. Nous allons utiliser la même instance de PostgreSQL pour les deux, mais avec deus bases de données distinctes.
🌘 Redis
Image Docker: redis:7
Configuration:
- Ports: Le service est exposé sur le port 6379.
- Environnement: Nous n'allons pas sécuriser Redis, donc il n'a pas besoin de configuration.
- Volumes: Les données sont stockées dans
redis_data
.
🌘 Configuration des Variables d'Environnement
Pour que ces services fonctionnent correctement, il faut configurer les variables d'environnement. Voici comment procéder :
-
Créer un fichier
.env
: Ce fichier doit être situé à la racine de ton projet et contiendra toutes les variables d'environnement nécessaires. -
Définir les Variables: Voici un exemple de ce que ton fichier
.env
pourrait contenir :POSTGRES_DB=your_database_name POSTGRES_USER=your_database_user POSTGRES_PASSWORD=your_database_password OLLAMA_BASE_URL=http://localhost:11434 FLOWISE_USERNAME=your_flowise_username FLOWISE_PASSWORD=your_flowise_password FLOWISE_PORT=3001 FLOWISE_DATABASE_TYPE=postgres FLOWISE_DATABASE_HOST=pgvector FLOWISE_DATABASE_PORT=5432 FLOWISE_DATABASE_USER=your_database_user FLOWISE_DATABASE_PASSWORD=your_database_password FLOWISE_DATABASE_NAME=your_database_name
-
Charger les Variables: Assure-toi que ton script de démarrage charge ces variables avant de lancer les services Docker. Ça peut être fait automatiquement par Docker Compose à travers la commande
docker compose up
.
🌘 Deux ateliers pour mettre en pratique !
Pour apprendre à utiliser ces outils, je te propose deux ateliers qui t'accompagnent pas à pas.
Le premier atelier permet de te familiariser avec Docker et Open Web UI, et le second se concentre sur les bases de données vectorielles et Flowise.
Tu peux te les procurer ici:
- 🤖 Atelier 1 - Utiliser des LLM localement et protéger ses données
- 🤖 Atelier 2 - Utiliser son contenu d’entreprise avec des LLM locaux
🌘 Conclusion
Nous avons combiné Ollama, Open WebUI, Flowise, PGVector et Redis à l'aide de Docker Compose. Tu as maintenant un environnement complet pour expérimenter avec l'IA générative et les modèles de langage LLM, tout en gardant le contrôle sur tes données.
Cette suite logicielle te permet de :
- Exécuter des modèles de langage localement avec Ollama
- Interagir avec ces modèles via une interface conviviale grâce à Open WebUI
- Créer des flux de traitement complexes sans coder avec Flowise
- Stocker et interroger efficacement des données vectorielles avec PGVector
- Gérer la mémoire à court terme de tes systèmes IA avec Redis
Le fichier Docker Compose et la configuration des variables d'environnement que nous avons vus simplifient grandement le déploiement de cet écosystème.
Tu peux maintenant explorer les possibilités de l'IA générative tout en respectant la confidentialité des données et en gardant le contrôle sur ton infrastructure.
🌘 Questions et réponses
🌘 Est-ce que je peux utiliser cette suite d'outils pour des projets commerciaux ?
Absolument ! Tous les logiciels présentés, à l'exception de Docker Desktop et Redis, n'ont aucune restriction commerciale. Pour les deux autres, le contrat de licence présente certaines conditions qui s'appliquent surtout aux grandes entreprises. En cas de doute, n'hésite pas à consulter un ou une juriste.
🌘 Quelles sont les exigences matérielles minimales pour exécuter ces logiciels ?
Je te conseille fortement d'avoir au moins 16 Go de mémoire vive (RAM). Si tu as un processeur GPU (Accélérateur graphique) ou NPU (Accélérateur pour réseaux de neurones), c'est encore mieux, car Ollama va l'utiliser pour exécuter tous les modèles qui entrent dans sa mémoire, et ils sont plusieurs dizaines de fois plus rapides que les CPU.
J'ai testé cette configuration sur 8 Go de RAM avec succès sans Open Web UI, mais avec, ça limite beaucoup les modèles disponibles qui peuvent entrer en mémoire. Si tu as des défis particuliers et que tu aimerais qu'on trouve des solutions ensemble, je te conseille de prendre une Consultation Express avec moi.