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 points de terminaison API instantanés.

Aperçu

Flowise est un outil open-source de type glisser-déposer pour créer des applications propulsées par des LLM sans écrire de code. Avec plus de 35K étoiles sur GitHub et plus de 5 millions de téléchargements sur 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 flux de travail automatisés via une interface visuelle intuitive — et de les déployer en tant que points de terminaison API REST en quelques minutes.

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

Principales capacités :

• Constructeur de flux par glisser-déposer — Orchestration visuelle de 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 embeddeurs et des stores vectoriels

• Prise en charge multi-agents — Construisez 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 centralement 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, éliminant les coûts d’API

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

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

• Rentable à grande échelle — Concevez des plateformes de chatbot multi-tenant sans frais API par appel

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

---

Exigences

Flowise lui-même est une application Node.js avec des exigences minimales en ressources. Le GPU n’est nécessaire que si vous ajoutez un backend LLM local.

Configuration	GPU	VRAM	RAM	Stockage	Prix estimé
Flowise uniquement (APIs 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,20 $/h
+ Ollama (Mistral 7B + embeddings)	RTX 3090	24 Go	16 Go	30 Go	~0,20 $/h
+ Ollama (Qwen2.5 32B)	RTX 4090	24 Go	32 Go	60 Go	~0,35 $/h
+ vLLM (production)	A100 80GB	80 Go	64 Go	100 Go	~1,10 $/h

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 le Guide de comparaison GPU.

exigences du serveur Clore.ai :

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

• NVIDIA Container Toolkit (pour GPU/Ollama uniquement)

• Port 3000 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éservez un serveur sur Clore.ai

Dans le la place de marché Clore.ai:

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

• Pour LLM local : filtrer GPU ≥ 24 Go de VRAM

• Assurez-vous que Docker est activé dans le template

Connectez-vous via SSH :

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

Étape 2 : Lancez 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 dans 20–30 secondes.

Étape 3 : Vérifiez qu’il fonctionne

# Vérifier le statut des conteneurs
docker ps | grep flowise

# Vérifiez les logs
docker logs flowise --tail 20

# Testez l’API
curl http://localhost:3000/api/v1/chatflows

Étape 4 : Ouvrez l’interface

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

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

---

Configuration

Stockage persistant

Montez des volumes afin que vos flux, identifiants et uploads 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 un 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 connaissant l’IP de votre serveur peut accéder à vos flux et 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=your-secure-password \
  -e FLOWISE_SECRETKEY_OVERWRITE=your-secret-key \
  -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)	— (pas d’authentification)
FLOWISE_PASSWORD	Mot de passe administrateur	—
FLOWISE_SECRETKEY_OVERWRITE	Clé de chiffrement pour les identifiants	Générée 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	Builtin Node.js autorisés 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 d’intégration iframe autorisées	*

Docker Compose (recommandé)

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

# Téléchargez 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"]
      intervalle : 10s
      timeout : 5s
      retries : 5

volumes :
  flowise-data :
  pgdata :

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

---

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

Flowise orchestre — le GPU effectue le travail intensif 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émarrez 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échargez 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émarrez Flowise avec accès réseau host
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éez un nouveau Chatflow

2. Ajoutez composant Ollama nœud (dans Chat Models)

   • 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 Ollama complet pour le téléchargement des modèles et la configuration GPU.

Flowise + vLLM (échelle production)

Pour un service compatible OpenAI à haut débit :

# Démarrez 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.

Construire un chatbot RAG uniquement local

Flux Flowise complet sans appels API externes sur Clore.ai :

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

Exportez ceci en tant qu’API et intégrez le widget de chat sur n’importe quel site web.

---

Conseils et bonnes pratiques

1. Exportez régulièrement les flux

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

# Exportez 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’UI : Chatflows → Export All

2. Utilisez 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 </> bouton (Embed)

2. Copiez le fragment de script

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

3. Gérez les clés API de manière sécurisée

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

• Menu → Credentials → Add Credential

• 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 de reverse proxy 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. Surveillez les performances

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

# Vérifiez les logs de Flowise pour les erreurs
docker logs flowise --tail 50 -f

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

6. Sauvegardez la base de données SQLite

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

# Ou automatisez 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érifiez la raison de l’arrêt
docker logs flowise

# Causes courantes :
# 1. Le port 3000 est déjà utilisé
lsof -i :3000
# Solution : utilisez un port différent
docker run ... -p 3001:3000 ...

# 2. Erreur de permission sur le volume
ls -la /opt/flowise/
chown -R 1000:1000 /opt/flowise/data

L’UI affiche « Connection Failed »

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

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

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

Les flux échouent avec des erreurs LLM

# Testez 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

# Testez 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, sauvegardez d’abord
cp -r /opt/flowise/data /opt/flowise/data-backup-$(date +%Y%m%d)

# Récupérez la nouvelle image
docker pull flowiseai/flowise:latest

# Redémarrez 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  # Surveillez la sortie des migrations

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=your-stable-32-char-secret

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

Erreurs CORS du widget de chat

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

---

Lectures complémentaires

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

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

• Discord Flowise — Templates communautaires, partage de flux, support

• Docker Hub : flowiseai/flowise — 5M+ téléchargements, tags disponibles

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

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

• Guide de comparaison GPU — Sélectionnez le GPU approprié pour votre stack

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