> 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-ia-et-agents/flowise.md).

# 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](https://github.com/FlowiseAI/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](https://clore.ai/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](/guides/guides_v2-fr/premiers-pas/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)
* 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](https://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 :

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

### Étape 2 : Exécuter 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` en 20 à 30 secondes.

### Étape 3 : Vérifier qu’il fonctionne

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

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

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

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

```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"]
      interval: 10s
      timeout: 5s
      retries: 5

volumes:
  flowise-data:
  pgdata:
```

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

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

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

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

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

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

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

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

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

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

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

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

```bash
# 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](https://github.com/FlowiseAI/Flowise) — Code source, versions, 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) — Modèles de la communauté, partage de flux, assistance
* [Docker Hub : flowiseai/flowise](https://hub.docker.com/r/flowiseai/flowise) — Plus de 5 M de pulls, tags disponibles
* [Ollama sur Clore.ai](/guides/guides_v2-fr/modeles-de-langage/ollama.md) — Exécutez des LLM locaux pour une inférence Flowise gratuite
* [vLLM sur Clore.ai](/guides/guides_v2-fr/modeles-de-langage/vllm.md) — Service de LLM à l’échelle de la production pour Flowise
* [Guide de comparaison des GPU](/guides/guides_v2-fr/premiers-pas/gpu-comparison.md) — Sélectionnez le bon GPU pour votre pile
* [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, and the optional `goal` query parameter:

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

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.