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

Pour une comparaison des options GPU sur Clore.ai, consultez le Guide de comparaison des GPU.

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. Pour une utilisation de Langflow uniquement, tout serveur avec au moins 4 Go de RAM fonctionne. Connectez-vous via SSH :

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

Étape 2 : Exécutez Langflow avec Docker

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

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 :

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

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 :

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

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

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 :

# 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

# É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

Connecter Langflow à vLLM (compatible OpenAI)

# 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

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 :

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

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

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

# 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

# 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

# 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

# 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

# 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

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 — code source, problèmes, journal des modifications

• Documentation de Langflow — documentation officielle, référence des composants, documentation de l’API

• Discord de Langflow — support communautaire et partage de flows

• Ollama sur Clore.ai — Configurez un backend LLM local pour Langflow

• vLLM sur Clore.ai — Service LLM à haut débit pour les flows de production

• Guide de comparaison des GPU — Choisissez le bon GPU Clore.ai pour votre charge de travail

• Documentation de LangChain — Référence du framework sous-jacent

• Docker Hub : langflowai/langflow — Balises d’image et versions disponibles