Constructeur d'agents IA Flowise

Déployez Flowise sur Clore.ai — créez et hébergez des chatbots LLM visuels, des agents IA et des pipelines RAG sur des serveurs cloud GPU abordables avec une interface no-code par glisser-déposer et des endpoints API instantanés.

Aperçu

Flowise est un outil open source en glisser-déposer pour créer des applications alimentées par des LLM sans écrire de code. Avec plus de 35K étoiles sur GitHub et plus de 5 millions de pulls Docker Hub, Flowise est devenu l’un des outils d’IA auto-hébergés les plus déployés de l’écosystème. Il permet aux équipes de créer des chatbots, des systèmes RAG, des agents IA et des workflows automatisés via une interface visuelle intuitive — et de les déployer en tant que points de terminaison d’API REST en quelques minutes.

Flowise est construit sur LangChain.js et fournit un canevas basé sur des nœuds où vous connectez des composants : LLM, bases de données vectorielles, chargeurs de documents, magasins de mémoire, outils et agents. Chaque flux génère automatiquement un widget de chat intégrable et un point de terminaison d’API que vous pouvez intégrer dans n’importe quelle application.

Fonctionnalités clés :

• Créateur de flux en glisser-déposer — Orchestration visuelle des LLM avec plus de 100 nœuds préconstruits

• Création de chatbot — Widgets de chat intégrables pour sites web et applications

• pipelines RAG — Connectez visuellement des chargeurs de documents, des embedders et des magasins vectoriels

• Prise en charge multi-agents — Créez des hiérarchies d’agents avec utilisation d’outils et délégation

• API instantanée — Chaque flux génère un /api/v1/prediction/<flowId> point de terminaison

• Nœuds LangChain — Accès complet à l’écosystème LangChain.js

• Gestionnaire d’identifiants — Gérez de manière centralisée les clés API, les connexions aux bases de données

Pourquoi Clore.ai pour Flowise ?

Flowise est un serveur Node.js léger — il gère l’orchestration, pas le calcul. L’associer à Clore.ai permet :

• Inférence locale de modèles — Exécutez Ollama ou vLLM sur le même serveur GPU, en éliminant les coûts d’API

• Traitement privé des documents — Des pipelines RAG qui n’envoient jamais de données à des services externes

• Déploiement persistant — Hébergement de chatbot et d’API toujours actifs aux prix d’un serveur GPU

• Rentable à grande échelle — Créez des plateformes de chatbot multi-locataires sans frais d’API par appel

• Hébergement IA full-stack — Flowise + Ollama + Qdrant/Chroma sur un seul serveur abordable

---

Exigences

Flowise est une application Node.js avec des besoins en ressources minimaux. Le GPU n’est nécessaire que si vous ajoutez un backend LLM local.

Configuration	GPU	VRAM	RAM	Stockage	Prix estimé
Flowise seul (API externes)	Aucune	—	2–4 Go	10 Go	~0,03–0,08 $/h
+ Ollama (Llama 3.1 8B)	RTX 3090	24 Go	16 Go	40 Go	0,07–0,21 $/h
+ Ollama (Mistral 7B + embeddings)	RTX 3090	24 Go	16 Go	30 Go	0,07–0,21 $/h
+ Ollama (Qwen2.5 32B)	RTX 4090	24 Go	32 Go	60 Go	0,14–0,42 $/h
+ vLLM (production)	A100 80 Go	80 Go	64 Go	100 Go	bare metal

Remarque : Flowise fonctionne confortablement sur n’importe quel serveur Clore.ai. Le GPU n’est nécessaire que si vous souhaitez une inférence locale gratuite. Voir les Guide de comparaison des GPU.

Exigences du serveur Clore.ai :

• Docker Engine (préinstallé sur toutes les images Clore.ai)

• NVIDIA Container Toolkit (pour GPU/Ollama uniquement)

• Le port 3000 est accessible (ou mappé dans le tableau de bord Clore.ai)

• Minimum 2 Go de RAM libre, 10 Go d’espace disque

---

Démarrage rapide

Étape 1 : Réserver un serveur sur Clore.ai

Dans le Place de marché Clore.ai:

• Pour une utilisation uniquement via API : n’importe quel serveur, filtrez par RAM ≥ 4 Go

• Pour un LLM local : filtrez GPU ≥ 24 Go de VRAM

• Assurez-vous que Docker est activé dans le modèle

Connectez-vous via SSH :

ssh root@<server-ip> -p <ssh-port>

Étape 2 : Exécuter Flowise (commande unique)

docker run -d \
  --name flowise \
  --restart unless-stopped \\
  -p 3000:3000 \
  flowiseai/flowise

C’est tout. Flowise sera disponible à http://<server-ip>:3000 en 20 à 30 secondes.

Étape 3 : Vérifier qu’il fonctionne

# Vérifier l’état du conteneur
docker ps | grep flowise

# Vérifier les journaux
docker logs flowise --tail 20

# Tester l'API
curl http://localhost:3000/api/v1/chatflows

Étape 4 : Ouvrir l’interface

Accédez à http://<server-ip>:3000 dans votre navigateur.

Mappage des ports Clore.ai : Assurez-vous que le port 3000 est redirigé dans la configuration de votre serveur Clore.ai. Allez dans les détails de votre serveur → Ports → confirmez 3000:3000 qu’il est mappé. Certains modèles n’exposent SSH que par défaut.

---

Configuration

Stockage persistant

Montez des volumes pour que vos flux, identifiants et téléversements survivent aux redémarrages du conteneur :

mkdir -p /opt/flowise/{data,uploads,logs}

docker run -d \
  --name flowise \
  --restart unless-stopped \\
  -p 3000:3000 \
  -v /opt/flowise/data:/root/.flowise \
  -v /opt/flowise/uploads:/app/uploads \
  -e DATABASE_PATH=/root/.flowise \
  -e APIKEY_PATH=/root/.flowise \
  -e SECRETKEY_PATH=/root/.flowise \
  -e LOG_PATH=/root/.flowise/logs \
  flowiseai/flowise

Authentification

Protégez votre instance Flowise avec nom d’utilisateur/mot de passe :

docker run -d \
  --name flowise \
  --restart unless-stopped \\
  -p 3000:3000 \
  -v /opt/flowise/data:/root/.flowise \
  -e FLOWISE_USERNAME=admin \
  -e FLOWISE_PASSWORD=$(openssl rand -base64 16) \
  -e FLOWISE_SECRETKEY_OVERWRITE=$(openssl rand -hex 32) \
  flowiseai/flowise

Note de sécurité : Définissez toujours des identifiants lorsque vous exposez Flowise publiquement sur Clore.ai. Sans authentification, toute personne disposant de l’adresse IP de votre serveur peut accéder à vos flux et à vos clés API.

Référence complète des variables d’environnement

docker run -d \
  --name flowise \
  --restart unless-stopped \\
  -p 3000:3000 \
  -v /opt/flowise/data:/root/.flowise \
  -e PORT=3000 \
  -e FLOWISE_USERNAME=admin \
  -e FLOWISE_PASSWORD=votre-mot-de-passe-sécurisé \
  -e FLOWISE_SECRETKEY_OVERWRITE=votre-clé-secrète \
  -e DATABASE_TYPE=sqlite \
  -e DATABASE_PATH=/root/.flowise \
  -e APIKEY_PATH=/root/.flowise \
  -e SECRETKEY_PATH=/root/.flowise \
  -e LOG_PATH=/root/.flowise/logs \
  -e LOG_LEVEL=info \
  -e TOOL_FUNCTION_BUILTIN_DEP=crypto,fs \
  -e TOOL_FUNCTION_EXTERNAL_DEP=moment,lodash \
  -e CORS_ORIGINS=* \
  -e IFRAME_ORIGINS=* \
  flowiseai/flowise

Variable	Description	Par défaut
PORT	Port du serveur web	3000
FLOWISE_USERNAME	Nom d’utilisateur admin (active l’authentification)	— (sans auth)
FLOWISE_PASSWORD	Mot de passe admin	—
FLOWISE_SECRETKEY_OVERWRITE	Clé de chiffrement pour les identifiants	Généré automatiquement
DATABASE_TYPE	sqlite ou mysql ou postgres	sqlite
DATABASE_PATH	Chemin de stockage SQLite	/root/.flowise
LOG_LEVEL	error, warn, info, debug	info
TOOL_FUNCTION_BUILTIN_DEP	Fonctions intégrées Node.js autorisées dans les nœuds de code	—
TOOL_FUNCTION_EXTERNAL_DEP	Packages npm autorisés dans les nœuds de code	—
CORS_ORIGINS	Origines CORS autorisées pour l’API	*
IFRAME_ORIGINS	Origines autorisées pour l’intégration dans un iframe	*

Docker Compose (recommandé)

Le dépôt officiel Flowise inclut une configuration Docker Compose. C’est l’approche recommandée pour Clore.ai :

# Télécharger le docker-compose.yml officiel
curl -o /opt/flowise/docker-compose.yml \
  https://raw.githubusercontent.com/FlowiseAI/Flowise/main/docker/docker-compose.yml

cd /opt/flowise

Ou créez le vôtre avec PostgreSQL :

# /opt/flowise/docker-compose.yml
version: "3.9"

services:
  flowise:
    image: flowiseai/flowise:latest
    restart: unless-stopped
    ports:
      - "3000:3000"
    environment :
      - PORT=3000
      - FLOWISE_USERNAME=${FLOWISE_USERNAME:-admin}
      - FLOWISE_PASSWORD=${FLOWISE_PASSWORD:-changeme}
      - FLOWISE_SECRETKEY_OVERWRITE=${SECRET_KEY}
      - DATABASE_TYPE=postgres
      - DATABASE_HOST=db
      - DATABASE_PORT=5432
      - DATABASE_USER=flowise
      - DATABASE_PASSWORD=flowise-secret
      - DATABASE_NAME=flowise
    volumes:
      - flowise-data:/root/.flowise
    depends_on:
      db:
        condition: service_healthy

  db:
    image: postgres:16-alpine
    restart: unless-stopped
    environment :
      - POSTGRES_USER=flowise
      - POSTGRES_PASSWORD=flowise-secret
      - POSTGRES_DB=flowise
    volumes:
      - pgdata:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U flowise"]
      interval: 10s
      timeout: 5s
      retries: 5

volumes:
  flowise-data:
  pgdata:

SECRET_KEY=$(openssl rand -hex 32) \
FLOWISE_PASSWORD=votre-mot-de-passe \
docker compose -f /opt/flowise/docker-compose.yml up -d

---

Accélération GPU (intégration LLM locale)

Flowise orchestre — le GPU fait le gros du travail dans les services connectés.

Flowise + Ollama (recommandé)

Exécutez Ollama sur le même serveur Clore.ai et connectez-y Flowise :

# Étape 1 : Démarrer Ollama avec accès GPU
docker run -d \
  --name ollama \\
  --gpus all \
  --restart unless-stopped \\
  -p 11434:11434 \
  -v ollama-models:/root/.ollama \
  ollama/ollama:latest

# Étape 2 : Télécharger les modèles
docker exec ollama ollama pull llama3.1:8b          # Modèle de chat/agent
docker exec ollama ollama pull nomic-embed-text     # Embeddings pour RAG
docker exec ollama ollama pull mistral:7b           # Modèle de chat alternatif

# Étape 3 : Démarrer Flowise avec l’accès au réseau de l’hôte
docker run -d \
  --name flowise \
  --restart unless-stopped \\
  -p 3000:3000 \
  -v /opt/flowise/data:/root/.flowise \
  --add-host host.docker.internal:host-gateway \
  -e FLOWISE_USERNAME=admin \
  -e FLOWISE_PASSWORD=changeme \
  flowiseai/flowise

Dans l’interface Flowise :

1. Créer un nouveau Chatflow

2. Ajoutez Ollama nœud (sous Modèles de chat)

   • URL de base : http://host.docker.internal:11434

   • Nom du modèle : llama3.1:8b

3. Ajoutez OllamaEmbeddings nœud (pour RAG)

   • URL de base : http://host.docker.internal:11434

   • Nom du modèle : nomic-embed-text

4. Connectez-vous à votre Vector Store (Chroma, FAISS, Qdrant)

Voir le guide complet d’Ollama pour le téléchargement du modèle et la configuration du GPU.

Flowise + vLLM (échelle production)

Pour un service compatible OpenAI à haut débit :

# Démarrer vLLM
docker run -d \
  --name vllm \\
  --gpus all \
  --restart unless-stopped \\
  -p 8000:8000 \
  --ipc=host \
  vllm/vllm-openai:latest \
  --model mistralai/Mistral-7B-Instruct-v0.3 \
  --gpu-memory-utilization 0.85

# Dans Flowise, utilisez le nœud ChatOpenAI avec une URL de base personnalisée :
# URL de base : http://host.docker.internal:8000/v1
# Clé API OpenAI : (n’importe quelle valeur)
# Nom du modèle : mistralai/Mistral-7B-Instruct-v0.3

Voir le guide vLLM pour la quantification et les configurations multi-GPU.

Créer un chatbot RAG local uniquement

Flux Flowise complet sans aucun appel à une API externe sur Clore.ai :

Nœud	Composant	Settings
1	Chargeur de fichier PDF	Téléverser le document
2	Séparateur récursif de texte	Segment : 1000, chevauchement : 200
3	Embeddings Ollama	Modèle : nomic-embed-text
4	Magasin vectoriel en mémoire	(ou Chroma pour la persistance)
5	Chat Ollama	Modèle : llama3.1:8b
6	QA de récupération conversationnelle	Type de chaîne : Stuff
7	Mémoire tampon	Mémoire basée sur la session

Exportez-le comme API et intégrez le widget de chat sur n’importe quel site web.

---

Conseils et bonnes pratiques

1. Exporter régulièrement les flux

Avant d’arrêter ou de changer de serveur Clore.ai :

# Exporter tous les flux via l’API
curl http://localhost:3000/api/v1/chatflows \
  -H "Authorization: Basic $(echo -n admin:password | base64)" \
  > /opt/flowise/backup-flows.json

# Ou utilisez l’interface : Chatflows → Exporter tout

2. Utiliser le widget d’intégration

Chaque chatflow Flowise génère un widget de chat prêt pour la production :

1. Ouvrez votre chatflow → Cliquez sur </> bouton (Intégrer)

2. Copiez l’extrait de script

3. Collez-le dans n’importe quelle page HTML — bot de support client instantané

3. Gérer les clés API en toute sécurité

Stockez toutes les clés API LLM dans le panneau Identifiants de Flowise (pas codées en dur dans les flux) :

• Menu → Identifiants → Ajouter un identifiant

• Les clés sont chiffrées avec FLOWISE_SECRETKEY_OVERWRITE

4. Limitation de débit

Pour les déploiements publics, ajoutez une limitation de débit via Nginx ou Caddy devant Flowise :

# Configuration simple du proxy inverse nginx
docker run -d \
  --name nginx \
  -p 80:80 \\
  -v /opt/flowise/nginx.conf:/etc/nginx/conf.d/default.conf:ro \
  --link flowise:flowise \
  nginx:alpine

5. Surveiller les performances

# Surveillance des ressources en temps réel
watch -n 3 'docker stats flowise ollama --no-stream'

# Vérifier les journaux Flowise pour les erreurs
docker logs flowise --tail 50 -f

# Vérifier si les flux sont appelés
docker logs flowise 2>&1 | grep "Prediction"

6. Sauvegarder la base de données SQLite

# Créer une sauvegarde horodatée
cp /opt/flowise/data/database.sqlite \
   /opt/flowise/backup-$(date +%Y%m%d-%H%M%S).sqlite

# Ou automatiser avec cron
echo "0 */6 * * * cp /opt/flowise/data/database.sqlite /opt/flowise/backup-\$(date +\%Y\%m\%d-\%H\%M\%S).sqlite" | crontab -

---

Dépannage

Le conteneur se ferme immédiatement

# Vérifier la raison de la fermeture
docker logs flowise

# Causes courantes :
# 1. Le port 3000 est déjà utilisé
lsof -i :3000
# Correction : utiliser un autre port
docker run ... -p 3001:3000 ...

# 2. Erreur d’autorisation sur le volume
ls -la /opt/flowise/
chown -R 1000:1000 /opt/flowise/data

L’interface affiche « Connexion échouée »

# Vérifier que Flowise est bien en cours d’exécution
docker ps -a | grep flowise
docker stats flowise --no-stream

# Vérifier qu’il est lié à toutes les interfaces
docker logs flowise | grep "listening"
# Devrait afficher : Server is listening at port 3000

# Tester localement d’abord
curl -s http://localhost:3000/api/v1/chatflows | head -20

Les flux échouent avec des erreurs LLM

# Tester la connectivité Ollama depuis le conteneur Flowise
docker exec flowise wget -qO- http://host.docker.internal:11434/api/tags

# Si cela échoue, vérifiez que --add-host a été inclus :
docker inspect flowise | grep -A5 ExtraHosts

# Tester qu’Ollama fonctionne
curl http://localhost:11434/api/tags

Erreurs de migration de base de données lors de la mise à jour

# Lors de la mise à niveau de Flowise, faites d’abord une sauvegarde
cp -r /opt/flowise/data /opt/flowise/data-backup-$(date +%Y%m%d)

# Télécharger la nouvelle image
docker pull flowiseai/flowise:latest

# Redémarrer avec le même volume (les migrations s’exécutent automatiquement)
docker stop flowise && docker rm flowise
docker run -d --name flowise ... flowiseai/flowise:latest
docker logs flowise -f  # Surveiller la sortie de migration

Erreurs de déchiffrement des identifiants après redémarrage

# Si vous n’avez pas défini FLOWISE_SECRETKEY_OVERWRITE, une nouvelle clé est générée au redémarrage
# Définissez-la toujours explicitement :
-e FLOWISE_SECRETKEY_OVERWRITE=votre-secret-stable-de-32-caractères

# Pour récupérer : ressaisissez les identifiants dans l’interface après avoir défini une clé stable

Erreurs CORS du widget de chat

# Autoriser des origines spécifiques (remplacez * par votre domaine en production)
-e CORS_ORIGINS=https://votredomaine.com,http://localhost:3000
-e IFRAME_ORIGINS=https://votredomaine.com

---

Pour aller plus loin

• Dépôt GitHub Flowise — Code source, versions, docker-compose officiel

• Documentation Flowise — Référence des nœuds, docs API, guides de déploiement

• Discord Flowise — Modèles de la communauté, partage de flux, assistance

• Docker Hub : flowiseai/flowise — Plus de 5 M de pulls, tags disponibles

• Ollama sur Clore.ai — Exécutez des LLM locaux pour une inférence Flowise gratuite

• vLLM sur Clore.ai — Service de LLM à l’échelle de la production pour Flowise

• Guide de comparaison des GPU — Sélectionnez le bon GPU pour votre pile

• Documentation LangChain.js — Référence du framework sous-jacent