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 flux de travail 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 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.

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. Pour une utilisation Langflow uniquement, tout serveur avec ≥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 — commande unique :

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 :

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

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

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

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 :

# 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

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

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

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 :

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

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

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

# 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

# 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

# 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

# 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

# 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

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 — Code source, issues, changelog

• Documentation Langflow — Docs officiels, référence des composants, docs API

• Discord 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 GPU — Choisissez le GPU Clore.ai adapté à votre charge de travail

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

• Docker Hub : langflowai/langflow — Tags d'images et versions disponibles