Langflow विज़ुअल एआई बिल्डर

Clore.ai पर Langflow तैनात करें — किफायती GPU क्लाउड इन्फ्रास्ट्रक्चर पर ड्रैग-एंड-ड्रॉप नो-कोड इंटरफ़ेस के साथ विज़ुअल एआई पाइपलाइनों, RAG सिस्टम और मल्टी-एजेंट वर्कफ़्लो बनाएं और चलाएँ।

अवलोकन

लैंगफ्लो यह एक ओपन-सोर्स, लो-कोड प्लेटफ़ॉर्म है जो विज़ुअल ड्रैग-एंड-ड्रॉप इंटरफ़ेस का उपयोग करके एआई अनुप्रयोग बनाने के लिए है। 55K+ GitHub स्टार्स और तेजी से बढ़ती समुदाय के साथ, यह जटिल बॉयलरप्लेट कोड लिखे बिना LLM-संचालित वर्कफ़्लो का प्रोटोटाइप और तैनाती करने के लिए लोकप्रिय टूल्स में से एक बन गया है।

लैंगफ्लो LangChain के ऊपर बनाया गया है और एक ग्राफिकल एडिटर प्रदान करता है जहाँ आप घटकों — LLMs, वेक्टर स्टोर्स, दस्तावेज़ लोडर्स, रिट्रीवर्स, एजेंट्स, टूल्स — को नोड्स के बीच लाइनें खींचकर जोड़ सकते हैं। resulting पाइपलाइन को एक API एंडपॉइंट के रूप में निर्यात किया जा सकता है, एक टेम्पलेट के रूप में साझा किया जा सकता है, या अपने अनुप्रयोग में एम्बेड किया जा सकता है।

मुख्य क्षमताएँ:

• दृश्यमान RAG बिल्डर — मिनटों में दस्तावेज़ लोडर्स → एम्बेडिंग्स → वेक्टर स्टोर्स → रिट्रीवर्स कनेक्ट करें

• मल्टी-एजेंट वर्कफ़्लो — मेमोरी, टूल्स और निर्णय लॉजिक के साथ कई AI एजेंट्स को चैन करें

• LangChain एकीकरण — UI नोड्स के माध्यम से पूरे LangChain इकोसिस्टम तक पहुँच

• कंपोनेंट मार्केटप्लेस — दर्जनों सेवाओं के लिए समुदाय-योगदान किए गए कंपोनेंट्स

• API-प्रथम — हर फ्लो अपने आप एक REST API एंडपॉइंट बनाता है

• मेमोरी और स्टेट — बिल्ट-इन वार्तालाप मेमोरी, सत्र प्रबंधन

Langflow के लिए Clore.ai क्यों?

Langflow की कम्प्यूट आवश्यकताएँ न्यूनतम हैं — यह वर्कफ़्लो ऑर्केस्ट्रेशन संभालने वाला एक Python वेब सर्वर है। हालांकि, Clore.ai शक्तिशाली उपयोग के मामले खोलता है:

• स्व-होस्टेड एम्बेडिंग्स — तेज़, मुफ्त वेक्टर जनरेशन के लिए GPU पर लोकल एम्बेडिंग मॉडल (nomic-embed, BGE) चलाएँ

• लोकल LLM बैकएंड — उसी सर्वर पर चल रहे Ollama या vLLM से Langflow कनेक्ट करें

• प्राइवेट डेटा पाइपलाइन्स — संवेदनशील दस्तावेज़ों को बाहरी APIs पर भेजे बिना प्रोसेस करें

• लागत अनुकूलन — महंगे OpenAI एम्बेडिंग कॉल्स को मुफ्त लोकल इंफरेंस से बदलें

• स्थायी वर्कफ़्लो — समर्पित सर्वरों पर लंबी अवधि के फ़्लो (अस्थायी क्लाउड फ़ंक्शन्स के बजाय)

---

आवश्यकताएँ

Langflow स्वयंपर प्रयाप्त हल्का और CPU-आधारित है। GPU वैकल्पिक है लेकिन मुफ्त लोकल LLM/एम्बेडिंग इंफरेंस सक्षम करता है।

कॉन्फ़िगरेशन	GPU	VRAM	RAM	स्टोरेज	अनुमानित मूल्य
केवल Langflow (API बैकएंड्स)	किसी की आवश्यकता नहीं	—	4 GB	10 GB	~$0.03–0.08/घंटा
+ लोकल एम्बेडिंग्स (nomic-embed)	RTX 3090	24 GB	8 GB	20 GB	~$0.20/घंटा
+ Ollama (Llama 3.1 8B)	RTX 3090	24 GB	16 GB	40 GB	~$0.20/घंटा
+ Ollama (Qwen2.5 32B)	RTX 4090	24 GB	32 GB	60 GB	~$0.35/घंटा
+ vLLM (production RAG)	A100 80GB	80 GB	64 GB	100 GB	~$1.10/घंटा

Clore.ai पर GPU विकल्पों की तुलना के लिए देखें GPU तुलना मार्गदर्शिका.

Clore.ai सर्वर पर सॉफ़्टवेयर आवश्यकताएँ:

• Docker Engine (सभी Clore.ai इमेजेस पर पहले से इंस्टॉल)

• NVIDIA Container Toolkit (GPU इमेजेस पर पहले से इंस्टॉल, केवल लोकल LLM के लिए आवश्यक)

• Langflow इमेज और फ्लो डेटा के लिए 10+ GB मुफ्त डिस्क स्पेस

• आउटबाउंड इंटरनेट एक्सेस (Docker इमेजेस खींचने और बाहरी APIs तक पहुँचने के लिए)

---

त्वरित प्रारम्भ

चरण 1: अपने Clore.ai सर्वर से कनेक्ट करें

पर एक सर्वर बुक करें Clore.ai मार्केटप्लेस। केवल Langflow उपयोग के लिए, किसी भी सर्वर में ≥4 GB RAM होना पर्याप्त है। SSH के माध्यम से कनेक्ट करें:

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

चरण 2: Docker के साथ Langflow चलाएँ

सर्वाधिक सरल तैनाती — एक ही कमांड:

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

स्टार्टअप के लिए ~30–60 सेकंड प्रतीक्षा करें, फिर पर पहुँचें http://<server-ip>:7860

चरण 3: Clore.ai पर पोर्ट 7860 एक्सपोज़ करें

Clore.ai डैशबोर्ड में, अपने सर्वर → पोर्ट्स सेक्शन पर जाएँ → सुनिश्चित करें कि 7860 मैप किया गया है। कस्टम टेम्पलेट का उपयोग कर रहे हैं तो सर्वर शुरू करने से पहले अपने पोर्ट कॉन्फ़िगरेशन में जोड़ें 7860:7860 ।

चरण 4: पहली लॉन्च

पहली बार विज़िट पर, Langflow करेगा:

1. एक स्वागत स्क्रीन दिखाएगा और खाता बनाने के लिए कहेगा (या छोड़ने का विकल्प देगा)

2. स्टार्टर टेम्पलेट्स का सेट ऑफर करेगा (RAG, चैटबोट, एजेंट)

3. विज़ुअल कैनवास एडिटर खोलेगा

आप अपना पहला फ्लो बनाने के लिए तैयार हैं!

---

कॉन्फ़िगरेशन

स्थायी डेटा स्टोरेज

डिफ़ॉल्ट रूप से, Langflow कंटेनर के अंदर फ्लो और डेटा स्टोर करता है। रिस्टार्ट के बीच बनाए रखने के लिए वॉल्यूम माउंट करें:

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

पर्यावरण चर संदर्भ

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

वैरिएबल	विवरण	डिफ़ॉल्ट
LANGFLOW_HOST	बाइंड पता	0.0.0.0
LANGFLOW_PORT	वेब सर्वर पोर्ट	7860
LANGFLOW_DATABASE_URL	डेटाबेस कनेक्शन स्ट्रिंग	इन-मैमोरी SQLite
LANGFLOW_SECRET_KEY	सेशन सीक्रेट (प्रोडक्शन के लिए सेट करें)	रैंडम
LANGFLOW_AUTO_LOGIN	लॉगिन स्क्रीन स्किप करें	true
LANGFLOW_SUPERUSER	एडमिन उपयोगकर्ता नाम	admin
LANGFLOW_SUPERUSER_PASSWORD	एडमिन पासवर्ड	—
LANGFLOW_WORKERS	API वर्कर्स की संख्या	1
LANGFLOW_LOG_LEVEL	लॉगिंग की वर्बोसिटी	critical
OPENAI_API_KEY	OpenAI कुंजी प्री-लोड करें	—

PostgreSQL का उपयोग करना (प्रोडक्शन)

मल्टी-यूज़र या प्रोडक्शन तैनातियों के लिए, SQLite के बजाय PostgreSQL का उपयोग करें:

# 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

# PostgreSQL बैकएंड के साथ Langflow शुरू करें
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 (फुल स्टैक)

PostgreSQL और 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

निश्चित संस्करण पिनिंग

पुनरुत्पादन योग्य तैनातियों के लिए, एक विशेष संस्करण पिन करें:

# उपलब्ध संस्करणों की सूची: https://hub.docker.com/r/langflowai/langflow/tags
docker run -d \
  --name langflow \
  -p 7860:7860 \
  langflowai/langflow:1.1.4

---

GPU त्वरण (लोकल मॉडल एकीकरण)

Langflow स्वयं CPU पर चलता है, लेकिन इसे उसी Clore.ai सर्वर पर लोकल GPU-समर्थित सेवाओं से जोड़ना मुफ्त, निजी इंफरेंस अनलॉक करता है।

Langflow को Ollama से कनेक्ट करें

# चरण 1: GPU के साथ Ollama शुरू करें
docker run -d \
  --name ollama \
  --gpus all \
  --restart unless-stopped \
  -p 11434:11434 \
  -v ollama-models:/root/.ollama \
  ollama/ollama:latest

# चरण 2: विभिन्न उपयोग मामलों के लिए मॉडल खींचें
docker exec ollama ollama pull llama3.1:8b          # सामान्य चैट
docker exec ollama ollama pull nomic-embed-text     # RAG के लिए एम्बेडिंग्स
docker exec ollama ollama pull qwen2.5-coder:7b    # कोड जेनरेशन

# चरण 3: Ollama नेटवर्क एक्सेस के साथ Langflow शुरू करें
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

Langflow UI में, उपयोग करें Ollama कंपोनेंट साथ:

• बेस URL: http://host.docker.internal:11434

• मॉडल: llama3.1:8b

एम्बेडिंग्स के लिए, उपयोग करें OllamaEmbeddings कंपोनेंट साथ:

• बेस URL: http://host.docker.internal:11434

• मॉडल: nomic-embed-text

पूर्ण Ollama कॉन्फ़िगरेशन के लिए देखें Ollama गाइड

Langflow को vLLM (OpenAI-संगत) से कनेक्ट करें

# OpenAI-संगत API के साथ vLLM शुरू करें
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

# Langflow में, कस्टम बेस URL के साथ OpenAI कंपोनेंट का उपयोग करें:
# बेस URL: http://host.docker.internal:8000/v1
# API की: (कोई भी मान, उदाहरण के लिए "none")
# मॉडल: mistralai/Mistral-7B-Instruct-v0.3

पूर्ण vLLM कॉन्फ़िगरेशन के लिए देखें vLLM गाइड

एक लोकल RAG पाइपलाइन बनाना

केवल लोकल मॉडलों का उपयोग करते हुए उदाहरण RAG फ्लो (शून्य API लागत):

1. फ़ाइल लोडर नोड → PDF/टेक्स्ट दस्तावेज़ लोड करें

2. टेक्स्ट स्प्लिटर नोड → दस्तावेज़ों को चंकों में बाँटें (आकार: 512, ओवरलैप: 50)

3. OllamaEmbeddings नोड → एम्बेडिंग्स जनरेट करें (मॉडल: nomic-embed-text)

4. Chroma या FAISS नोड → वेक्टर स्थानीय रूप से स्टोर करें

5. OllamaEmbeddings नोड → उपयोगकर्ता के प्रश्न का एम्बेड करें

6. रिट्रीवर नोड → टॉप-k समान चंक्स खोजें

7. Ollama नोड → उत्तर जनरेट करें (मॉडल: llama3.1:8b)

8. चैट आउटपुट नोड → प्रतिक्रिया लौटाएँ

यह संपूर्ण पाइपलाइन आपके Clore.ai सर्वर पर शून्य बाहरी API कॉल्स के साथ चलती है।

---

टिप्स और सर्वोत्तम प्रथाएँ

1. बैकअप के रूप में फ्लो निर्यात करें

अपने Clore.ai सर्वर को बंद करने से पहले, अपने फ्लो निर्यात करें:

• UI में: Flows → सभी चुनें → Export → JSON डाउनलोड करें

• या API के माध्यम से: curl http://localhost:7860/api/v1/flows/

उन्हें एक स्थायी वॉल्यूम में स्टोर करें या अपने लोकल मशीन पर डाउनलोड करें।

2. ऑटोमेशन के लिए API का उपयोग करें

हर Langflow फ्लो एक API एंडपॉइंट जनरेट करता है। प्रोग्रामेटिक रूप से फ्लो ट्रिगर करें:

# UI से अपना फ्लो ID प्राप्त करें (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": "Summarize the latest AI research papers",
    "input_type": "chat",
    "output_type": "chat"
  }'

3. अपने इंस्टेंस को सुरक्षित करें

लोकल परीक्षण से परे किसी भी चीज़ के लिए:

# हमेशा प्रामाणिकरण सेट करें
-e LANGFLOW_AUTO_LOGIN=false \
-e LANGFLOW_SUPERUSER=admin \
-e LANGFLOW_SUPERUSER_PASSWORD=$(openssl rand -base64 16)

# एक मजबूत सीक्रेट की का उपयोग करें
-e LANGFLOW_SECRET_KEY=$(openssl rand -hex 32)

4. मेमोरी उपयोग की निगरानी करें

कई सक्रिय फ्लोज़ के साथ Langflow समय के साथ मेमोरी जमा कर सकता है:

docker stats langflow
# यदि मेमोरी अनियंत्रित रूप से बढ़े, तो समय-समय पर पुनः आरंभ करें:
docker restart langflow

5. स्टार्टर टेम्पलेट्स का उपयोग करें

Langflow प्रोडक्शन-रेडी टेम्पलेट्स के साथ आता है:

• बेसिक RAG — वेक्टर स्टोर के साथ दस्तावेज़ Q&A

• मेमोरी चैटबॉट — इतिहास के साथ वार्तालापात्मक एजेंट

• रिसर्च असिस्टेंट — वेब सर्च + LLM संश्लेषण

• इसके द्वारा पहुँचें: New Flow → Starter Projects

6. कंपोनेंट कैशिंग

दोहराए गए फ्लो रन को तेज़ करने के लिए कैशिंग सक्षम करें:

• फ्लो सेटिंग्स में: महंगे नोड्स (एम्बेडिंग्स, LLM कॉल्स) पर "Cache" सक्षम करें

• विकास के दौरान RAG रिट्रीवल के लिए विशेष रूप से उपयोगी

---

समस्याओं का निवारण

कंटेनर स्टार्ट नहीं होता

# त्रुटियों के लिए लॉग्स जांचें
docker logs langflow --tail 50

# सामान्य समस्या: पोर्ट पहले से उपयोग में है
lsof -i :7860
# विरोधी प्रक्रिया को समाप्त करें या पोर्ट बदलें:
docker run ... -p 7861:7860 ...

UI लोड होती है पर फ्लोज़ नहीं चलते

# वर्कर प्रोसेस स्थिति जांचें
docker exec langflow ps aux | grep langflow

# Python पैकेज त्रुटियों की जाँच करें
docker logs langflow 2>&1 | grep -i error

# कंटेनर रीस्टार्ट करें
docker restart langflow

Ollama से कनेक्ट नहीं कर पा रहे

# Langflow कंटेनर के अंदर से कनेक्टिविटी का परीक्षण करें
docker exec langflow curl http://host.docker.internal:11434/api/tags

# यदि --add-host फ्लैग गायब है, तो कंटेनर को फिर से बनाएँ साथ में:
--add-host host.docker.internal:host-gateway

# सुनिश्चित करें कि Ollama चल रहा है
docker ps | grep ollama
curl http://localhost:11434/api/tags

रीस्टार्ट पर डेटाबेस त्रुटियाँ

# यदि SQLite का उपयोग करते समय लॉक त्रुटियाँ आ रही हैं:
docker stop langflow
ls -la /opt/langflow/data/
# पुराने .lock फ़ाइलों की जाँच करें
rm -f /opt/langflow/data/langflow.db-wal
rm -f /opt/langflow/data/langflow.db-shm
docker start langflow

फ्लो निष्पादन धीमा है

# समानांतर प्रोसेसिंग के लिए वर्कर्स बढ़ाएँ
-e LANGFLOW_WORKERS=4

# एम्बेडिंग-भारी वर्कलोड्स के लिए, सुनिश्चित करें कि Ollama द्वारा GPU उपयोग हो रहा है:
docker exec ollama nvidia-smi
# एम्बेडिंग के समय GPU उपयोग दिखना चाहिए

एडमिन पासवर्ड रीसेट करें

docker exec -it langflow python -c "
from langflow.services.database.utils import initialize_db
from langflow.services.deps import get_settings_service
# इसके बजाय Langflow CLI का उपयोग करें:
"
# CLI विधि का उपयोग करें:
docker exec -it langflow langflow superuser --username admin --password newpassword

---

अधिक पढ़ने के लिए

• Langflow GitHub रिपॉज़िटरी — स्रोत कोड, इश्यूज़, चेंजलॉग

• Langflow प्रलेखन — आधिकारिक डॉक्स, कंपोनेंट संदर्भ, API डॉक्स

• Langflow Discord — समुदाय समर्थन और फ्लो शेयरिंग

• Clore.ai पर Ollama — Langflow के लिए लोकल LLM बैकएंड सेट अप करें

• Clore.ai पर vLLM — प्रोडक्शन फ्लोज़ के लिए हाई-थ्रूपुट LLM सर्विंग

• GPU तुलना मार्गदर्शिका — अपने वर्कलोड के लिए सही Clore.ai GPU चुनें

• LangChain प्रलेखन — अंतर्निहित फ्रेमवर्क संदर्भ

• Docker Hub: langflowai/langflow — उपलब्ध इमेज टैग्स और संस्करण