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

# Constructeur IA visuel Langflow

## Aperçu

[Langflow](https://github.com/langflow-ai/langflow) est une plateforme open-source et low-code pour créer des applications d'IA à l'aide d'une interface visuelle par glisser-déposer. Avec plus de 55K é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 flux de travail alimentés par des LLM sans écrire de code standard complexe.

Langflow est construit au-dessus de LangChain et fournit un éditeur graphique où vous pouvez connecter des composants — LLM, magasins de vecteurs, chargeurs de documents, récupérateurs, agents, outils — en traçant des lignes entre des nœuds. Le pipeline résultant peut être exporté en tant que point de terminaison API, partagé comme modèle ou intégré à votre application.

**Principales capacités :**

* **Constructeur visuel RAG** — Connectez chargeurs de documents → embeddings → magasins de vecteurs → récupérateurs en quelques minutes
* **Flux de travail multi-agents** — Chaînez plusieurs agents IA avec mémoire, outils et logique de décision
* **Intégration LangChain** — Accédez à l'écosystème complet LangChain via des nœuds UI
* **Place de marché de composants** — Composants fournis par la communauté pour des dizaines de services
* **API-first** — Chaque flow génère automatiquement un point de terminaison REST API
* **Mémoire et état** — Mémoire de conversation intégrée, gestion de session

**Pourquoi Clore.ai pour Langflow ?**

Les besoins en calcul de Langflow sont minimes — c'est un serveur web Python gérant l'orchestration des flux de travail. Cependant, Clore.ai ouvre des cas d'utilisation puissants :

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

***

## Exigences

Langflow lui-même est léger et basé sur le CPU. Le GPU est optionnel mais permet l'inférence locale gratuite des LLM/embeddings.

| Configuration                          | GPU          | VRAM  | RAM   | Stockage | Prix estimé     |
| -------------------------------------- | ------------ | ----- | ----- | -------- | --------------- |
| **Langflow uniquement (backends API)** | Aucun requis | —     | 4 Go  | 10 Go    | \~0,03–0,08 $/h |
| **+ Embeddings locaux (nomic-embed)**  | RTX 3090     | 24 Go | 8 Go  | 20 Go    | \~0,20 $/h      |
| **+ Ollama (Llama 3.1 8B)**            | RTX 3090     | 24 Go | 16 Go | 40 Go    | \~0,20 $/h      |
| **+ Ollama (Qwen2.5 32B)**             | RTX 4090     | 24 Go | 32 Go | 60 Go    | \~0,35 $/h      |
| **+ vLLM (RAG en production)**         | A100 80GB    | 80 Go | 64 Go | 100 Go   | \~1,10 $/h      |

> Pour une comparaison des options GPU sur Clore.ai, voir le [Guide de comparaison GPU](/guides/guides_v2-fr/prise-en-main/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 de flow
* 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 Langflow uniquement, tout serveur avec ≥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 — commande unique :

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

Attendez \~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, accédez à votre serveur → section Ports → assurez-vous que `7860` est mappé. Si vous utilisez un modèle personnalisé, ajoutez `7860:7860` à votre configuration de ports avant de démarrer le serveur.

### Étape 4 : Premier lancement

Lors de la première visite, Langflow :

1. Affichera un écran de bienvenue et proposera de créer un compte (ou de passer)
2. Proposera un ensemble de modèles de démarrage (RAG, chatbot, agent)
3. Ouvrira l'éditeur de canevas visuel

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

***

## Configuration

### Stockage de données persistant

Par défaut, Langflow stocke les flows et les données à l'intérieur du conteneur. Montez un volume pour persister entre 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 pour la production) | Aléatoire         |
| `LANGFLOW_AUTO_LOGIN`         | Passer 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é des logs                               | `critical`        |
| `OPENAI_API_KEY`              | Précharger la clé OpenAI                         | —                 |

### Utilisation de PostgreSQL (Production)

Pour des déploiements multi-utilisateurs ou en 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 un 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 (Full Stack)

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"]
      intervalle : 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
```

### Verrouillage sur une version spécifique

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

```bash
# Lister les 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 fonctionne lui-même sur CPU, mais le connecter à des services locaux accélérés par GPU sur le même serveur Clore.ai permet une inférence privée et gratuite.

### 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 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'UI de Langflow, utilisez le **composant Ollama** avec :

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

Pour les embeddings, utilisez le **OllamaEmbeddings** 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)

### Construire un pipeline RAG local

Exemple de flow RAG utilisant uniquement des modèles locaux (coût API nul) :

1. **Chargeur de fichiers** nœud → Charger des documents PDF/texte
2. **Fractionneur de texte** nœud → Découper les documents en segments (taille : 512, recouvrement : 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 → Calculer l'embedding de la requête de l'utilisateur
6. **Récupérateur** nœud → Trouver les k meilleurs segments similaires
7. **composant Ollama** nœud → Générer la réponse (modèle : `llama3.1:8b`)
8. **Sortie de chat** nœud → Retourner la réponse

Ce pipeline entier s'exécute sur votre serveur Clore.ai sans appels API externes.

***

## Conseils et bonnes pratiques

### 1. Exportez les flows comme sauvegardes

Avant d'arrêter votre serveur Clore.ai, exportez vos flows :

* Dans l'UI : Flows → Tout sélectionner → Exporter → Télécharger 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. Utilisez l'API pour l'automatisation

Chaque flow Langflow génère un point de terminaison API. Déclenchez les flows de manière programmatique :

```bash
# Obtenez l'ID de votre flow depuis l'UI (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ésumez 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 robuste
-e LANGFLOW_SECRET_KEY=$(openssl rand -hex 32)
```

### 4. Surveillez l'utilisation de la mémoire

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

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

### 5. Utilisez les modèles de démarrage

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

* **RAG basique** — Q\&R de documents avec magasin de vecteurs
* **Chatbot avec mémoire** — Agent conversationnel avec historique
* **Assistant de recherche** — Recherche web + synthèse par LLM
* Accès via : New Flow → Starter Projects

### 6. Mise en cache des composants

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

* Dans les paramètres du flow : Activez "Cache" sur les nœuds coûteux (embeddings, appels LLM)
* Particulièrement utile pour la recherche RAG pendant le développement

***

## Dépannage

### Le conteneur ne démarre pas

```bash
# Vérifiez les logs pour des erreurs
docker logs langflow --tail 50

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

### L'UI se charge mais les flows ne s'exécutent pas

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

# Vérifiez les erreurs de 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 manquante, 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 obsolètes
rm -f /opt/langflow/data/langflow.db-wal
rm -f /opt/langflow/data/langflow.db-shm
docker start langflow
```

### Exécution lente des flows

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

# Pour des charges lourdes en embeddings, assurez-vous qu'Ollama utilise le GPU :
docker exec ollama nvidia-smi
# Devrait afficher l'utilisation du GPU lors des embeddings
```

### 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 l'interface CLI de Langflow :
"
# Utilisez la méthode CLI :
docker exec -it langflow langflow superuser --username admin --password newpassword
```

***

## Lectures complémentaires

* [Répertoire GitHub de Langflow](https://github.com/langflow-ai/langflow) — Code source, issues, changelog
* [Documentation Langflow](https://docs.langflow.org) — Docs officiels, référence des composants, docs API
* [Discord 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 GPU](/guides/guides_v2-fr/prise-en-main/gpu-comparison.md) — Choisissez le GPU Clore.ai adapté à votre charge de travail
* [Documentation LangChain](https://python.langchain.com/docs/) — Référence du framework sous-jacent
* [Docker Hub : langflowai/langflow](https://hub.docker.com/r/langflowai/langflow) — Tags d'images 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:

```
GET https://docs.clore.ai/guides/guides_v2-fr/plateformes-et-agents-ia/langflow.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.