> 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/langflow.md).

# Constructeur visuel IA Langflow

Déployez Langflow sur Clore.ai — créez et exécutez des pipelines IA visuels, des systèmes RAG et des workflows multi-agents sur une infrastructure cloud GPU abordable avec une interface no-code par glisser-déposer.

## Aperçu

[Langflow](https://github.com/langflow-ai/langflow) est une plateforme open source, low-code, pour créer des applications IA à l’aide d’une interface visuelle de glisser-déposer. Avec plus de 55 k étoiles sur GitHub et une communauté en pleine croissance, elle est devenue l’un des outils de référence pour prototyper et déployer des workflows alimentés par des LLM sans écrire de code utilitaire complexe.

Langflow repose sur LangChain et fournit un éditeur graphique où vous pouvez connecter des composants — LLM, magasins vectoriels, chargeurs de documents, récupérateurs, agents, outils — en dessinant des lignes entre les nœuds. Le pipeline الناتant peut être exporté en tant que point de terminaison d’API, partagé comme modèle ou intégré dans votre application.

**Fonctionnalités clés :**

* **Générateur visuel de RAG** — Connectez des chargeurs de documents → des embeddings → des magasins vectoriels → des récupérateurs en quelques minutes
* **Workflows multi-agents** — Enchaînez plusieurs agents IA avec mémoire, outils et logique de décision
* **Intégration LangChain** — Accédez à l’ensemble de l’écosystème LangChain via des nœuds UI
* **Place de marché de composants** — Des composants apportés par la communauté pour des dizaines de services
* **Conçu pour l’API** — Chaque workflow génère automatiquement un point de terminaison d’API REST
* **Mémoire et état** — Mémoire de conversation intégrée, gestion des sessions

**Pourquoi Clore.ai pour Langflow ?**

Les besoins en calcul de Langflow sont minimes — c’est un serveur web Python qui gère l’orchestration des workflows. Cependant, Clore.ai ouvre la voie à des cas d’usage puissants :

* **Embeddings auto-hébergés** — Exécutez des modèles d’embeddings locaux (nomic-embed, BGE) sur GPU pour une génération vectorielle rapide et gratuite
* **Backends LLM locaux** — Connectez Langflow à Ollama ou vLLM exécutés sur le même serveur
* **Pipelines de données privés** — Traitez des documents sensibles sans envoyer de données vers des API externes
* **Optimisation des coûts** — Remplacez les appels d’embedding OpenAI coûteux par une inférence locale gratuite
* **Workflows persistants** — Des workflows de longue durée sur des serveurs dédiés (par opposition aux fonctions cloud éphémères)

***

## Exigences

Langflow lui-même est léger et basé sur le CPU. Le GPU est facultatif mais permet une inférence locale gratuite pour les LLM/embeddings.

| Configuration                          | GPU              | VRAM  | RAM   | Stockage | Prix estimé                               |
| -------------------------------------- | ---------------- | ----- | ----- | -------- | ----------------------------------------- |
| **Langflow uniquement (backends API)** | Aucun nécessaire | —     | 4 Go  | 10 Go    | \~0,03–0,08 $/h                           |
| **+ Embeddings locaux (nomic-embed)**  | RTX 3090         | 24 Go | 8 Go  | 20 Go    | 0,07–0,21 $/h                             |
| **+ Ollama (Llama 3.1 8B)**            | RTX 3090         | 24 Go | 16 Go | 40 Go    | 0,07–0,21 $/h                             |
| **+ Ollama (Qwen2.5 32B)**             | RTX 4090         | 24 Go | 32 Go | 60 Go    | 0,14–0,42 $/h                             |
| **+ vLLM (RAG de production)**         | A100 80 Go       | 80 Go | 64 Go | 100 Go   | [bare metal](https://clore.ai/bare-metal) |

> Pour une comparaison des options GPU sur Clore.ai, consultez le [Guide de comparaison des GPU](/guides/guides_v2-fr/premiers-pas/gpu-comparison.md).

**Exigences logicielles sur le serveur Clore.ai :**

* Docker Engine (préinstallé sur toutes les images Clore.ai)
* NVIDIA Container Toolkit (préinstallé sur les images GPU, requis uniquement pour les LLM locaux)
* 10 Go+ d’espace disque libre pour l’image Langflow et les données des workflows
* Accès Internet sortant (pour récupérer les images Docker et atteindre les API externes)

***

## Démarrage rapide

### Étape 1 : Connectez-vous à votre serveur Clore.ai

Réservez un serveur sur [la place de marché Clore.ai](https://clore.ai). Pour une utilisation de Langflow uniquement, tout serveur avec au moins 4 Go de RAM fonctionne. Connectez-vous via SSH :

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

### Étape 2 : Exécutez Langflow avec Docker

Le déploiement le plus simple — une seule commande :

```bash
docker run -d \
  --name langflow \
  --restart unless-stopped \
  -p 7860:7860 \
  langflowai/langflow:latest
```

Attendez environ 30 à 60 secondes le démarrage, puis accédez à `http://<server-ip>:7860`

### Étape 3 : Exposez le port 7860 sur Clore.ai

Dans le tableau de bord Clore.ai, allez dans votre serveur → section Ports → vérifiez que `7860` est mappé. Si vous utilisez un modèle personnalisé, ajoutez `7860:7860` à la configuration de votre port avant de démarrer le serveur.

### Étape 4 : Premier lancement

Lors de la première visite, Langflow va :

1. Afficher un écran d’accueil et demander de créer un compte (ou de passer cette étape)
2. Proposer un ensemble de modèles de départ (RAG, chatbot, agent)
3. Ouvrir l’éditeur visuel sur le canevas

Vous êtes prêt à créer votre premier workflow !

***

## Configuration

### Stockage persistant des données

Par défaut, Langflow stocke les workflows et les données à l’intérieur du conteneur. Montez un volume pour les conserver après les redémarrages :

```bash
mkdir -p /opt/langflow/data

docker run -d \
  --name langflow \
  --restart unless-stopped \
  -p 7860:7860 \
  -v /opt/langflow/data:/app/langflow \
  -e LANGFLOW_DATABASE_URL=sqlite:////app/langflow/langflow.db \
  langflowai/langflow:latest
```

### Référence des variables d’environnement

```bash
docker run -d \
  --name langflow \
  --restart unless-stopped \
  -p 7860:7860 \
  -v /opt/langflow/data:/app/langflow \
  -e LANGFLOW_HOST=0.0.0.0 \
  -e LANGFLOW_PORT=7860 \
  -e LANGFLOW_DATABASE_URL=sqlite:////app/langflow/langflow.db \
  -e LANGFLOW_SECRET_KEY=your-secret-key-here \
  -e LANGFLOW_AUTO_LOGIN=false \
  -e LANGFLOW_SUPERUSER=admin \
  -e LANGFLOW_SUPERUSER_PASSWORD=your-password \
  -e LANGFLOW_WORKERS=2 \
  -e LANGFLOW_LOG_LEVEL=info \
  langflowai/langflow:latest
```

| Variable                      | Description                                 | Par défaut        |
| ----------------------------- | ------------------------------------------- | ----------------- |
| `LANGFLOW_HOST`               | Adresse de liaison                          | `0.0.0.0`         |
| `LANGFLOW_PORT`               | Port du serveur web                         | `7860`            |
| `LANGFLOW_DATABASE_URL`       | Chaîne de connexion à la base de données    | SQLite en mémoire |
| `LANGFLOW_SECRET_KEY`         | Secret de session (à définir en production) | Aléatoire         |
| `LANGFLOW_AUTO_LOGIN`         | Ignorer l’écran de connexion                | `true`            |
| `LANGFLOW_SUPERUSER`          | Nom d’utilisateur administrateur            | `admin`           |
| `LANGFLOW_SUPERUSER_PASSWORD` | Mot de passe administrateur                 | —                 |
| `LANGFLOW_WORKERS`            | Nombre de workers API                       | `1`               |
| `LANGFLOW_LOG_LEVEL`          | Verbosité de journalisation                 | `critical`        |
| `OPENAI_API_KEY`              | Précharger la clé OpenAI                    | —                 |

### Utilisation de PostgreSQL (production)

Pour les déploiements multi-utilisateurs ou de production, utilisez PostgreSQL au lieu de SQLite :

```bash
# Démarrer PostgreSQL
docker run -d \
  --name langflow-db \
  --restart unless-stopped \
  -e POSTGRES_USER=langflow \
  -e POSTGRES_PASSWORD=langflow-secret \
  -e POSTGRES_DB=langflow \
  -v langflow-pgdata:/var/lib/postgresql/data \
  postgres:16-alpine

# Démarrer Langflow avec le backend PostgreSQL
docker run -d \
  --name langflow \
  --restart unless-stopped \
  --link langflow-db:db \
  -p 7860:7860 \
  -v /opt/langflow/data:/app/langflow \
  -e LANGFLOW_DATABASE_URL=postgresql://langflow:langflow-secret@db:5432/langflow \
  -e LANGFLOW_SECRET_KEY=$(openssl rand -hex 32) \
  -e LANGFLOW_AUTO_LOGIN=false \
  -e LANGFLOW_SUPERUSER=admin \
  -e LANGFLOW_SUPERUSER_PASSWORD=changeme \
  langflowai/langflow:latest
```

### Docker Compose (pile complète)

Pour une configuration complète avec PostgreSQL et un proxy inverse Nginx :

```yaml
# /opt/langflow/docker-compose.yml
version: "3.9"

services:
  langflow :
    image: langflowai/langflow:latest
    restart: unless-stopped
    ports:
      - "7860:7860"
    environment :
      - LANGFLOW_DATABASE_URL=postgresql://langflow:secret@db:5432/langflow
      - LANGFLOW_SECRET_KEY=${SECRET_KEY:-changeme}
      - LANGFLOW_AUTO_LOGIN=false
      - LANGFLOW_SUPERUSER=admin
      - LANGFLOW_SUPERUSER_PASSWORD=${ADMIN_PASSWORD:-changeme}
      - LANGFLOW_WORKERS=2
    volumes:
      - langflow-data:/app/langflow
    depends_on :
      db :
        condition: service_healthy

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

volumes:
  langflow-data :
  pgdata :
```

```bash
cd /opt/langflow
SECRET_KEY=$(openssl rand -hex 32) ADMIN_PASSWORD=yourpassword docker compose up -d
```

### Épinglage d’une version spécifique

Pour des déploiements reproductibles, épinglez une version spécifique :

```bash
# Liste des versions disponibles : https://hub.docker.com/r/langflowai/langflow/tags
docker run -d \
  --name langflow \
  -p 7860:7860 \
  langflowai/langflow:1.1.4
```

***

## Accélération GPU (intégration de modèles locaux)

Langflow lui-même fonctionne sur CPU, mais le fait de le connecter à des services locaux alimentés par GPU sur le même serveur Clore.ai permet une inférence gratuite et privée.

### Connecter Langflow à Ollama

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

# Étape 2 : Récupérer des modèles pour différents cas d’usage
docker exec ollama ollama pull llama3.1:8b          # Chat général
docker exec ollama ollama pull nomic-embed-text     # Embeddings pour RAG
docker exec ollama ollama pull qwen2.5-coder:7b    # Génération de code

# Étape 3 : Démarrer Langflow avec l’accès réseau à Ollama
docker run -d \
  --name langflow \
  --restart unless-stopped \
  -p 7860:7860 \
  -v /opt/langflow/data:/app/langflow \
  --add-host host.docker.internal:host-gateway \
  langflowai/langflow:latest
```

Dans l’interface Langflow, utilisez le **Ollama** composant avec :

* URL de base : `http://host.docker.internal:11434`
* Modèle : `llama3.1:8b`

Pour les embeddings, utilisez **OllamaEmbeddings** composant avec :

* URL de base : `http://host.docker.internal:11434`
* Modèle : `nomic-embed-text`

> Configuration complète d’Ollama : voir le [guide Ollama](/guides/guides_v2-fr/modeles-de-langage/ollama.md)

### Connecter Langflow à vLLM (compatible OpenAI)

```bash
# Démarrer vLLM avec une API compatible OpenAI
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 Langflow, utilisez le composant OpenAI avec une URL de base personnalisée :
# URL de base : http://host.docker.internal:8000/v1
# Clé API : (n’importe quelle valeur, par ex. "none")
# Modèle : mistralai/Mistral-7B-Instruct-v0.3
```

> Configuration complète de vLLM : voir le [guide vLLM](/guides/guides_v2-fr/modeles-de-langage/vllm.md)

### Créer un pipeline RAG local

Exemple de workflow RAG utilisant uniquement des modèles locaux (zéro coût API) :

1. **Chargeur de fichiers** nœud → Charger des documents PDF/texte
2. **Découpeur de texte** nœud → Découper les documents (taille : 512, chevauchement : 50)
3. **OllamaEmbeddings** nœud → Générer des embeddings (modèle : `nomic-embed-text`)
4. **Chroma** ou **FAISS** nœud → Stocker les vecteurs localement
5. **OllamaEmbeddings** nœud → Vectoriser la requête de l’utilisateur
6. **Récupérateur** nœud → Trouver les segments les plus similaires (top-k)
7. **Ollama** nœud → Générer une réponse (modèle : `llama3.1:8b`)
8. **Sortie du chat** nœud → Retourner la réponse

L’ensemble de ce pipeline s’exécute sur votre serveur Clore.ai sans aucun appel à une API externe.

***

## Conseils et bonnes pratiques

### 1. Exporter les workflows comme sauvegardes

Avant d’arrêter votre serveur Clore.ai, exportez vos workflows :

* Dans l’interface : Workflows → Tout sélectionner → Exporter → Télécharger le JSON
* Ou via l’API : `curl http://localhost:7860/api/v1/flows/`

Stockez-les dans un volume persistant ou téléchargez-les sur votre machine locale.

### 2. Utiliser l’API pour l’automatisation

Chaque workflow Langflow génère un point de terminaison d’API. Déclenchez les workflows par programme :

```bash
# Obtenez l’ID de votre workflow dans l’interface (affiché dans l’URL)
FLOW_ID="your-flow-id-here"

curl -X POST \
  "http://<server-ip>:7860/api/v1/run/$FLOW_ID" \
  -H "Content-Type: application/json" \
  -d '{
    "input_value": "Résume les derniers articles de recherche en IA",
    "input_type": "chat",
    "output_type": "chat"
  }'
```

### 3. Sécurisez votre instance

Pour tout usage au-delà des tests locaux :

```bash
# Définissez toujours l’authentification
-e LANGFLOW_AUTO_LOGIN=false \
-e LANGFLOW_SUPERUSER=admin \
-e LANGFLOW_SUPERUSER_PASSWORD=$(openssl rand -base64 16)

# Utilisez une clé secrète forte
-e LANGFLOW_SECRET_KEY=$(openssl rand -hex 32)
```

### 4. Surveiller l’utilisation mémoire

Langflow peut accumuler de la mémoire au fil du temps avec de nombreux workflows actifs :

```bash
docker stats langflow
# Si la mémoire augmente sans limite, redémarrez périodiquement :
docker restart langflow
```

### 5. Utiliser les modèles de départ

Langflow est livré avec des modèles prêts pour la production :

* **RAG de base** — Q\&R documentaire avec magasin vectoriel
* **Chatbot avec mémoire** — Agent conversationnel avec historique
* **Assistant de recherche** — Recherche web + synthèse LLM
* Accès via : Nouveau workflow → Projets de départ

### 6. Mise en cache des composants

Activez la mise en cache pour accélérer les exécutions répétées des workflows :

* Dans les paramètres du workflow : activez « Cache » sur les nœuds coûteux (embeddings, appels LLM)
* Particulièrement utile pour la récupération RAG pendant le développement

***

## Dépannage

### Le conteneur ne démarre pas

```bash
# Vérifiez les erreurs dans les journaux
docker logs langflow --tail 50

# Problème courant : le port est déjà utilisé
lsof -i :7860
# Arrêtez le processus en conflit ou changez le port :
docker run ... -p 7861:7860 ...
```

### L’interface se charge mais les workflows ne s’exécutent pas

```bash
# Vérifiez l’état du processus worker
docker exec langflow ps aux | grep langflow

# Vérifiez les erreurs liées aux paquets Python
docker logs langflow 2>&1 | grep -i error

# Redémarrez le conteneur
docker restart langflow
```

### Impossible de se connecter à Ollama

```bash
# Testez la connectivité depuis l’intérieur du conteneur Langflow
docker exec langflow curl http://host.docker.internal:11434/api/tags

# Si l’option --add-host est absente, recréez le conteneur avec :
--add-host host.docker.internal:host-gateway

# Vérifiez qu’Ollama est en cours d’exécution
docker ps | grep ollama
curl http://localhost:11434/api/tags
```

### Erreurs de base de données au redémarrage

```bash
# Si vous utilisez SQLite et obtenez des erreurs de verrouillage :
docker stop langflow
ls -la /opt/langflow/data/
# Vérifiez la présence de fichiers .lock orphelins
rm -f /opt/langflow/data/langflow.db-wal
rm -f /opt/langflow/data/langflow.db-shm
docker start langflow
```

### Exécution lente des workflows

```bash
# Augmentez le nombre de workers pour le traitement parallèle
-e LANGFLOW_WORKERS=4

# Pour les charges de travail fortement axées sur les embeddings, assurez-vous qu’Ollama utilise le GPU :
docker exec ollama nvidia-smi
# Devrait afficher l’utilisation du GPU lors de l’embedding
```

### Réinitialiser le mot de passe administrateur

```bash
docker exec -it langflow python -c "
from langflow.services.database.utils import initialize_db
from langflow.services.deps import get_settings_service
# Utilisez plutôt la CLI de Langflow :
"
# Utilisez la méthode CLI :
docker exec -it langflow langflow superuser --username admin --password newpassword
```

***

## Pour aller plus loin

* [Dépôt GitHub de Langflow](https://github.com/langflow-ai/langflow) — code source, problèmes, journal des modifications
* [Documentation de Langflow](https://docs.langflow.org) — documentation officielle, référence des composants, documentation de l’API
* [Discord de Langflow](https://discord.com/invite/EqksyE2EX9) — support communautaire et partage de flows
* [Ollama sur Clore.ai](/guides/guides_v2-fr/modeles-de-langage/ollama.md) — Configurez un backend LLM local pour Langflow
* [vLLM sur Clore.ai](/guides/guides_v2-fr/modeles-de-langage/vllm.md) — Service LLM à haut débit pour les flows de production
* [Guide de comparaison des GPU](/guides/guides_v2-fr/premiers-pas/gpu-comparison.md) — Choisissez le bon GPU Clore.ai pour votre charge de travail
* [Documentation de LangChain](https://python.langchain.com/docs/) — Référence du framework sous-jacent
* [Docker Hub : langflowai/langflow](https://hub.docker.com/r/langflowai/langflow) — Balises d’image et versions disponibles


---

# 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/langflow.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.