> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-fr/plateformes-et-agents-ia/flowise.md).

# Constructeur d’agents IA Flowise

## Aperçu

[Flowise](https://github.com/FlowiseAI/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](/guides/guides_v2-fr/prise-en-main/gpu-comparison.md).

**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](https://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 :

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

### Étape 2 : Lancez Flowise (commande unique)

```bash
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

```bash
# 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 :

```bash
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 :

```bash
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

```bash
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 :

```bash
# 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 :

```yaml
# /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 :
```

```bash
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 :

```bash
# É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](/guides/guides_v2-fr/modeles-de-langage/ollama.md) 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 :

```bash
# 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](/guides/guides_v2-fr/modeles-de-langage/vllm.md) 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 :

```bash
# 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 :

```bash
# 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

```bash
# 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

```bash
# 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

```bash
# 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 »

```bash
# 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

```bash
# 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

```bash
# 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

```bash
# 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

```bash
# 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](https://github.com/FlowiseAI/Flowise) — Code source, releases, docker-compose officiel
* [Documentation Flowise](https://docs.flowiseai.com) — Référence des nœuds, docs API, guides de déploiement
* [Discord Flowise](https://discord.gg/jn8n7yb9N) — Templates communautaires, partage de flux, support
* [Docker Hub : flowiseai/flowise](https://hub.docker.com/r/flowiseai/flowise) — 5M+ téléchargements, tags disponibles
* [Ollama sur Clore.ai](/guides/guides_v2-fr/modeles-de-langage/ollama.md) — Exécutez des LLM locaux pour l’inférence Flowise gratuite
* [vLLM sur Clore.ai](/guides/guides_v2-fr/modeles-de-langage/vllm.md) — Service de LLM à l’échelle production pour Flowise
* [Guide de comparaison GPU](/guides/guides_v2-fr/prise-en-main/gpu-comparison.md) — Sélectionnez le GPU approprié pour votre stack
* [Documentation LangChain.js](https://js.langchain.com/docs/) — Référence du framework sous-jacent


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-fr/plateformes-et-agents-ia/flowise.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.