Langflow विज़ुअल AI बिल्डर

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

अवलोकन

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

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

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

• विज़ुअल RAG बिल्डर — मिनटों में डॉक्यूमेंट लोडर्स → एम्बेडिंग्स → वेक्टर स्टोर्स → रिट्रीवर्स कनेक्ट करें

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

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

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

• API-first — हर फ्लो अपने-आप एक REST API endpoint जनरेट करता है

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

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

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

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

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

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

• लागत अनुकूलन — महंगे OpenAI एम्बेडिंग कॉल्स को मुफ़्त स्थानीय inference से बदलें

• स्थायी वर्कफ़्लोज़ — समर्पित सर्वरों पर लंबे समय तक चलने वाले फ्लोज़ (अस्थायी cloud functions के बजाय)

---

आवश्यकताएँ

Langflow स्वयं हल्का और CPU-आधारित है। GPU वैकल्पिक है, लेकिन यह मुफ़्त स्थानीय LLM/embedding inference सक्षम करता है।

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

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

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

• Docker Engine (सभी Clore.ai इमेजों में पूर्व-स्थापित)

• NVIDIA Container Toolkit (GPU इमेजों में पूर्व-स्थापित, केवल स्थानीय LLM के लिए आवश्यक)

• Langflow इमेज और फ्लो डेटा के लिए 10+ GB खाली डिस्क स्थान

• बाहरी इंटरनेट पहुँच (Docker images खींचने और बाहरी 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 डैशबोर्ड में, अपने सर्वर → Ports अनुभाग पर जाएँ → सुनिश्चित करें 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 workers की संख्या	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 reverse proxy के साथ पूर्ण सेटअप के लिए:

# /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-संचालित सेवाओं से इसे जोड़ने से मुफ़्त, निजी inference सक्षम होता है।

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 घटक का उपयोग करें:

• Base URL: http://host.docker.internal:11434

• Model: llama3.1:8b

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

• Base URL: http://host.docker.internal:11434

• Model: 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 में, OpenAI घटक का उपयोग कस्टम base URL के साथ करें:
# Base 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 endpoint जनरेट करता है। फ्लोज़ को प्रोग्रामेटिक रूप से ट्रिगर करें:

# UI से अपना flow 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": "नवीनतम AI शोध पत्रों का सारांश दें",
    "input_type": "chat",
    "output_type": "chat"
  }'

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

स्थानीय परीक्षण से आगे किसी भी उपयोग के लिए:

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

# एक मज़बूत secret key का उपयोग करें
-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 retrieval के लिए विशेष रूप से उपयोगी

---

समस्या निवारण

कंटेनर शुरू नहीं होता

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

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

UI लोड होता है लेकिन फ्लोज़ नहीं चलते

# worker process की स्थिति जाँचें
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 का उपयोग कर रहे हैं और lock errors मिल रहे हैं:
docker stop langflow
ls -la /opt/langflow/data/
# stale .lock फ़ाइलों की जाँच करें
rm -f /opt/langflow/data/langflow.db-wal
rm -f /opt/langflow/data/langflow.db-shm
docker start langflow

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

# समानांतर प्रोसेसिंग के लिए workers बढ़ाएँ
-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 — उपलब्ध इमेज टैग और संस्करण