# Flowise — créer des applications LLM par glisser-déposer

Flowise : constructeur visuel d'applications LLM auto-hébergeable (chatbots, agents, RAG). Installation Docker, sécurité et licence Apache 2.0 détaillées.

URL canonique : https://www.osfria.fr/flowise.html

---

OSIALab · Automatiser

## Flowise — assembler des applications LLM par glisser-déposer

Flowise est un constructeur visuel d'**applications LLM**. On relie des nœuds — modèle, prompt, mémoire, base vectorielle, outils — pour bâtir un chatbot, un agent ou un pipeline RAG, sans écrire la tuyauterie à la main. Il s'auto-héberge et se branche aussi bien sur un modèle local que sur un provider cloud.

### Fiabilité & transparence

🟡 **Utilisable, avec points d'attention**

- **Maintenance** : v3.1.2 (14 avril 2026) ; rythme actif et suivi.
- **Adoption** : 53,4K étoiles GitHub, base utilisateurs importante pour le RAG/LLM.
- **Sécurité** : Takeover cross-workspace (mai 2026) + 6 vulnérabilités (CVSS moy. 7.1) ; correction en cours.
- **Verdict** : Constructeur LLM accessible et bien étoffé. Mettre à jour régulièrement, tester les Custom Tools en isolé, et sécuriser les credentials (clés API).

> Page informative, sans valeur de conseil. Téléchargez depuis la **source officielle**, vérifiez la **licence** (cœur Apache 2.0, mais une partie « enterprise » est sous licence commerciale — voir plus bas), et gardez en tête que certains nœuds **exécutent du code** et que vos agents peuvent **appeler des outils réels** : testez en isolé d'abord.

### À quoi ça sert

Flowise transforme la construction d'une chaîne LLM en **schéma de nœuds**. Chaque bloc a un rôle : un *Chat Model* (le modèle), un *Prompt*, une *Memory* (l'historique de conversation), un *Vector Store* (la base de connaissances), un *Retriever*, des *Tools* que l'agent peut déclencher. On câble ces blocs entre eux, on teste dans le chat intégré, puis on expose le résultat via une **API REST** ou un **widget** à intégrer dans un site.

Sous le capot, Flowise s'appuie sur l'écosystème **LangChain** (côté JavaScript / TypeScript) et LlamaIndex : le visuel n'est pas une couche fermée, c'est une façade lisible sur des briques largement adoptées. On obtient un prototype fonctionnel en minutes là où l'équivalent en code demanderait une stack à monter et à maintenir.

### Ce qui fait sa force

- **Du prototype à l'API, sans rupture.** Ce que vous assemblez visuellement est immédiatement appelable en REST ou intégrable en widget. Le passage de l'idée à l'intégration est court.
- **Agents outillés.** Flowise gère les agents capables d'appeler des *tools* — recherche web, calculatrice, appel d'API, fonction sur mesure. On construit un assistant qui agit, pas seulement qui répond.
- **Local ou cloud, au choix.** Les nœuds de modèle pointent sur [Ollama](https://www.osfria.fr/ollama.html) en local comme sur un provider distant. On garde les données sensibles sur sa machine et l'on n'externalise que ce qu'on accepte d'externaliser.
- **RAG accessible.** Chargement de documents, découpage, *embeddings*, base vectorielle et récupération se câblent visuellement. Monter un « chat sur vos documents » devient un exercice de quelques nœuds.
- **Adossé à un écosystème ouvert.** Vous ne dépendez pas d'une logique propriétaire opaque : les concepts et composants sont ceux de LangChain et LlamaIndex.

### Pour qui

Pour qui veut **prototyper vite une application LLM** sans écrire toute la chaîne : développeur pressé, intégrateur, équipe produit qui valide un concept. Il faut comprendre les notions de base — modèle, prompt, embedding, base vectorielle, agent — mais pas savoir coder une stack complète. Pour des automatisations métier plus larges (hors périmètre LLM), regardez [n8n](https://www.osfria.fr/n8n.html) ; pour une plateforme d'applications LLM plus intégrée et orientée production, [Dify](https://www.osfria.fr/dify.html).

### Installation

#### Démarrage express (Node.js)

Avec Node.js installé, une seule commande lance Flowise sur le port **3000** :

```
npx flowise start
```

Ouvrez ensuite **http://localhost:3000**.

#### Avec Docker (recommandé pour durer)

```
# Données persistées dans un volume nommé
docker run -d \
  --name flowise \
  -p 3000:3000 \
  -v flowise_data:/root/.flowise \
  flowiseai/flowise:latest
```

#### Protéger l'accès dès le départ

Flowise ne réclame pas d'identifiants si vous ne les configurez pas. Définissez une authentification **avant toute exposition** :

```
docker run -d \
  --name flowise \
  -p 3000:3000 \
  -e FLOWISE_USERNAME=admin \
  -e FLOWISE_PASSWORD=un_mot_de_passe_solide \
  -v flowise_data:/root/.flowise \
  flowiseai/flowise:latest
```

Depuis les versions 3.x, l'authentification repose sur Passport.js avec des jetons JWT en cookies sécurisés. Reste à ne jamais publier une instance sans cette couche.

### Aller plus loin : l'API et les nœuds qui exécutent du code

Chaque *chatflow* publié expose un point d'accès REST de type `/api/v1/prediction/<id>` : vous interrogez votre application LLM comme n'importe quelle API. C'est ce qui permet de l'intégrer dans un back-office, un site ou un autre outil.

Les nœuds **Custom Tool** et **Custom JS Function** permettent d'écrire du **JavaScript exécuté côté serveur** — pour appeler une API maison, transformer une sortie, déclencher une action. Pratique, mais c'est du code qui tourne sur votre instance : il mérite la même prudence qu'un script déployé en production. La documentation recommande de stocker les secrets dans les **variables Flowise** plutôt que de les coder en dur dans ces nœuds.

### Points de vigilance

Flowise est un **serveur web qui orchestre des modèles, des outils et du code**. Les points ci-dessous sont propres à ce qu'il est.

| Point d'attention | Niveau | Ce qu'il faut savoir |
| --- | --- | --- |
| Pas d'authentification par défaut | 🔴 si exposé sans config | Sans `FLOWISE_USERNAME` / `FLOWISE_PASSWORD`, l'interface et l'API sont ouvertes à quiconque atteint le port 3000. Configurez l'auth, placez Flowise derrière un reverse proxy HTTPS et restreignez l'accès réseau. |
| Nœuds Custom Tool / Custom Function (JS) | 🔴 selon la source du flow | Ces nœuds exécutent du JavaScript sur votre serveur. Un chatflow importé peut donc contenir du code qui s'exécute chez vous. N'importez pas un flow inconnu sans relire son code ; isolez l'instance. |
| Agents qui appellent des outils réels | 🟡 selon les outils accordés | Un agent peut déclencher des appels d'API, des recherches, des actions externes. Limitez les outils au strict nécessaire et supervisez les premières exécutions. |
| Clés API providers stockées dans l'instance | 🟡 réel | Les *credentials* (OpenAI, Anthropic, etc.) sont enregistrés côté Flowise. Évitez de les coder en dur dans les nœuds custom : passez par les variables Flowise. Protégez l'accès et le volume de données. |
| Licence : cœur Apache 2.0, mais pas tout | 🟡 avant usage commercial | Le cœur de Flowise est sous **Apache License 2.0**. En revanche, le code du dossier `enterprise/` (fonctions avancées, ex. gestion d'identité / SSO) relève d'une **licence commerciale** distincte. Vérifiez le périmètre que vous utilisez avant un déploiement pro. |
| Rachat par Workday (2025) | 🟡 à garder en tête | FlowiseAI a été racheté par **Workday** en 2025. Le projet reste open source à ce jour, mais un changement de propriétaire peut influer sur la feuille de route, la licence ou le rythme de maintenance. Suivez les annonces officielles si vous intégrez Flowise dans un projet durable. |

### Sécurité

- **Authentification obligatoire avant exposition.** Variables `FLOWISE_USERNAME` / `FLOWISE_PASSWORD`, puis reverse proxy HTTPS et restriction réseau.
- **Auditez les flows importés.** Inspectez tout nœud Custom Tool / Custom Function avant de l'exécuter.
- **Cadrez les agents.** N'accordez que les outils nécessaires ; surveillez les premiers passages en production.
- **Ne codez pas les secrets en dur.** Utilisez les variables Flowise pour les clés et identifiants ; sauvegardez le volume `~/.flowise`.
- **Pour les données confidentielles, restez local.** Pointez les modèles sur [Ollama](https://www.osfria.fr/ollama.html) plutôt que sur un provider cloud.

### Aller plus loin

- [Langflow](https://www.osfria.fr/langflow.html) — une alternative très proche, sous licence MIT.
- [Dify](https://www.osfria.fr/dify.html) — une plateforme d'applications LLM plus complète, orientée production.
- [Ollama](https://www.osfria.fr/ollama.html) — faire tourner le modèle en local sous Flowise.
- [OSIALab](https://www.osfria.fr/osialab.html) — comparer Flowise avec n8n, Langflow et Dify.

### Sources

- Site officiel : **flowiseai.com**
- Code source : [github.com/FlowiseAI/Flowise](https://github.com/FlowiseAI/Flowise)
- Documentation : [docs.flowiseai.com](https://docs.flowiseai.com)
- Licence : [Apache License 2.0](https://github.com/FlowiseAI/Flowise/blob/main/LICENSE.md) pour le cœur ; dossier `enterprise/` sous licence commerciale distincte.
