Haystack AI फ़्रेमवर्क

Clore.ai पर deepset द्वारा Haystack डिप्लॉय करें — प्रोडक्शन RAG पाइपलाइन, सेमांटिक सर्च, और LLM एजेंट वर्कफ़्लो किफ़ायती GPU इंफ़्रास्ट्रक्चर पर बनाएँ।

Haystack, deepset का ओपन-सोर्स AI orchestration framework है, जो प्रोडक्शन-ग्रेड LLM applications बनाने के लिए है। GitHub पर 18K+ stars के साथ, यह एक लचीला pipeline-आधारित आर्किटेक्चर जो document stores, retrievers, readers, generators, और agents को एक साथ जोड़ता है — सब कुछ साफ़, composable Python में। चाहे आपको निजी दस्तावेज़ों पर RAG चाहिए, semantic search, या multi-step agent workflows, Haystack plumbing संभाल लेता है ताकि आप application logic पर ध्यान दे सकें.

Clore.ai पर, जब आपको Hugging Face Transformers या sentence-transformers के ज़रिए स्थानीय मॉडल inference के लिए GPU चाहिए, तब Haystack सबसे अच्छा काम करता है। यदि आप पूरी तरह बाहरी APIs (OpenAI, Anthropic) पर निर्भर हैं, तो आप इसे केवल-CPU instances पर चला सकते हैं — लेकिन embedding generation और local LLMs के लिए, GPU latency को बहुत कम कर देता है.

सभी उदाहरण GPU servers पर चलते हैं, जो से किराए पर लिए गए हैं CLORE.AI मार्केटप्लेस.

यह मार्गदर्शिका कवर करती है Haystack v2.x (haystack-ai पैकेज). v2 API, v1 (farm-haystack). यदि आपके पास मौजूदा v1 pipelines हैं, तो देखें माइग्रेशन गाइड.

अवलोकन

गुण

विवरण

परियोजना

deepset-ai/haystack

लाइसेंस

Apache 2.0

GitHub स्टार्स

18K+

संस्करण

v2.x (haystack-ai)

प्राथमिक उपयोग मामला

RAG, semantic search, document QA, agent workflows

GPU समर्थन

वैकल्पिक — local embeddings / local LLMs के लिए आवश्यक

कठिनाई

मध्यम

API सर्विंग

Hayhooks (FastAPI-आधारित, REST)

मुख्य इंटीग्रेशन

Ollama, OpenAI, Anthropic, HuggingFace, Elasticsearch, Pinecone, Weaviate, Qdrant

आप क्या बना सकते हैं

RAG पाइपलाइन — दस्तावेज़ ingest करें, embeddings बनाएं, संदर्भ पुनः प्राप्त करें, प्रश्नों के उत्तर दें
सिमेंटिक खोज — keywords के बजाय अर्थ के आधार पर दस्तावेज़ खोजें
दस्तावेज़ प्रोसेसिंग — PDFs, HTML, Word docs को parse करें; सामग्री को split, clean, और index करें
एजेंट वर्कफ़्लो — टूल उपयोग (web search, calculators, APIs) के साथ multi-step reasoning
REST API सेवाएँ — Hayhooks के माध्यम से किसी भी Haystack pipeline को endpoint के रूप में expose करें

आवश्यकताएँ

हार्डवेयर आवश्यकताएँ

उपयोग-प्रकरण

GPU

VRAM

RAM

डिस्क

Clore.ai मूल्य

केवल API मोड (OpenAI/Anthropic)

कोई नहीं / CPU

—

4 GB

20 GB

~$0.01–0.05/घं

स्थानीय embeddings (sentence-transformers)

RTX 3060

8 GB

16 GB

30 GB

$0.03–0.07/घंटा

स्थानीय embeddings + छोटा LLM (7B)

RTX 3090

24 GB

16 GB

50 GB

$0.07–0.21/hr

स्थानीय LLM (13B–34B)

RTX 4090

24 GB

32 GB

80 GB

$0.14–0.42/hr

बड़ा स्थानीय LLM (70B, quantized)

A100 80GB

80 GB

64 GB

150 GB

bare metal

अधिकांश RAG उपयोग मामलों के लिए, एक RTX 3090 $0.07–0.21/घं पर सबसे उपयुक्त है — 24 GB VRAM sentence-transformer embeddings + एक 7B–13B local LLM को एक साथ संभाल सकता है.

सॉफ़्टवेयर आवश्यकताएँ

Docker (Clore.ai servers पर पहले से इंस्टॉल)
NVIDIA drivers + CUDA (Clore.ai GPU servers पर पहले से इंस्टॉल)
Python 3.10+ (कंटेनर के अंदर)
CUDA 11.8 या 12.x

त्वरित शुरुआत

1. Clore.ai सर्वर किराए पर लें

में Clore.ai मार्केटप्लेस, इसके लिए फ़िल्टर करें:

VRAM: embedding workloads के लिए ≥ 8 GB, local LLMs के लिए ≥ 24 GB
Docker: सक्षम (अधिकांश listings पर डिफ़ॉल्ट)
इमेज: nvidia/cuda:12.8.1-devel-ubuntu22.04 या pytorch/pytorch:2.11.0-cuda12.8-cudnn9-runtime

सर्वर का सार्वजनिक IP और SSH पोर्ट यहाँ से नोट करें मेरे ऑर्डर.

2. कनेक्ट करें और GPU सत्यापित करें

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

# सत्यापित करें कि GPU उपलब्ध है
nvidia-smi

# अपेक्षित आउटपुट में आपका GPU, ड्राइवर संस्करण, CUDA संस्करण दिखता है

3. Haystack Docker इमेज बनाएं

Haystack v2 pip installation की अनुशंसा करता है। एक कस्टम Dockerfile बनाएँ:

mkdir -p /workspace/haystack-app && cd /workspace/haystack-app

cat > Dockerfile << 'EOF'
FROM nvidia/cuda:12.8.1-devel-ubuntu22.04

# इंटरैक्टिव प्रॉम्प्ट से बचें
ENV DEBIAN_FRONTEND=noninteractive
ENV PYTHONUNBUFFERED=1

# Python और सिस्टम डिपेंडेंसीज़ इंस्टॉल करें
RUN apt-get update && apt-get install -y \\
    python3.11 \\
    python3-pip \\
    python3.11-dev \\
    git \\
    curl \\
    && rm -rf /var/lib/apt/lists/*

# python3.11 को डिफ़ॉल्ट के रूप में सेट करें
RUN update-alternatives --install /usr/bin/python3 python3 /usr/bin/python3.11 1
RUN update-alternatives --install /usr/bin/python python python3.11 1

# Haystack v2 और मुख्य डिपेंडेंसीज़ इंस्टॉल करें
RUN pip install --no-cache-dir \
    haystack-ai \
    hayhooks \
    sentence-transformers \
    transformers \\
    torch \\
    accelerate \\
    fastapi \\
    uvicorn

# वैकल्पिक इंटीग्रेशन इंस्टॉल करें
RUN pip install --no-cache-dir \
    ollama-haystack \
    haystack-experimental

WORKDIR /app

# Hayhooks के लिए डिफ़ॉल्ट पोर्ट
EXPOSE 1416

CMD ["hayhooks", "run", "--host", "0.0.0.0", "--port", "1416"]
EOF

# इमेज बनाएँ
docker build -t haystack-clore:latest .

4. Hayhooks के साथ Haystack चलाएँ

Hayhooks किसी भी Haystack pipeline को स्वतः REST API में बदल देता है:

# अपनी pipelines के लिए एक directory बनाएँ
mkdir -p /workspace/haystack-pipelines

# GPU access के साथ Hayhooks चलाएँ
docker run -d \\
  --name haystack \
  --gpus all \\
  -p 1416:1416 \
  -v /workspace/haystack-pipelines:/app/pipelines \
  -e OPENAI_API_KEY=${OPENAI_API_KEY:-""} \
  -e HF_TOKEN=${HF_TOKEN:-""} \
  haystack-clore:latest

# जाँचें कि यह चल रहा है
curl http://localhost:1416/status

अपेक्षित प्रतिक्रिया:

{"status": "ok", "pipelines": []}

5. अपनी पहली RAG pipeline बनाएँ

एक pipeline YAML लिखें जिसे Hayhooks endpoint के रूप में सर्व करेगा:

cat > /workspace/haystack-pipelines/rag_pipeline.yml << 'EOF'
# LLM के लिए Ollama और retrieval के लिए local embeddings का उपयोग करने वाली RAG pipeline
components:
  embedder:
    type: haystack.components.embedders.SentenceTransformersTextEmbedder
    init_parameters:
      model: BAAI/bge-small-en-v1.5

  retriever:
    type: haystack.components.retrievers.in_memory.InMemoryEmbeddingRetriever
    init_parameters:
      document_store:
        type: haystack_integrations.document_stores.in_memory.InMemoryDocumentStore

  prompt_builder:
    type: haystack.components.builders.PromptBuilder
    init_parameters:
      template: |
        नीचे दिए गए संदर्भ के आधार पर प्रश्न का उत्तर दें.
        संदर्भ: {% for doc in documents %}{{ doc.content }}{% endfor %}
        प्रश्न: {{ question }}

  llm:
    type: haystack_integrations.components.generators.ollama.OllamaGenerator
    init_parameters:
      model: llama3
      url: http://host.docker.internal:11434

connections:
  - sender: embedder.embedding
    receiver: retriever.query_embedding
  - sender: retriever.documents
    receiver: prompt_builder.documents
  - sender: prompt_builder.prompt
    receiver: llm.prompt

inputs:
  query:
    - embedder.text
    - prompt_builder.question

outputs:
  answer: llm.replies
EOF

Hayhooks स्वतः इस pipeline को खोजता है और सर्व करता है। इसे परीक्षण करें:

# डिप्लॉय की गई pipelines की सूची देखें
curl http://localhost:1416/pipelines

# RAG pipeline को query करें
curl -X POST http://localhost:1416/rag_pipeline/run \
  -H "Content-Type: application/json" \
  -d '{"query": "Haystack क्या है?"}'

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

पर्यावरण चर

वेरिएबल

विवरण

उदाहरण

OPENAI_API_KEY

GPT models के लिए OpenAI API key

sk-...

ANTHROPIC_API_KEY

Claude के लिए Anthropic API key

sk-ant-...

HF_TOKEN

gated models के लिए Hugging Face token

hf_...

HAYSTACK_TELEMETRY_ENABLED

उपयोग टेलीमेट्री अक्षम करें

false

CUDA_VISIBLE_DEVICES

विशिष्ट GPU चुनें

0

TRANSFORMERS_CACHE

HF models के लिए कैश पथ

/workspace/hf-cache

पूर्ण कॉन्फ़िगरेशन के साथ चलाएँ

docker run -d \\
  --name haystack \
  --gpus '"device=0"' \
  -p 1416:1416 \
  -v /workspace/haystack-pipelines:/app/pipelines \
  -v /workspace/hf-cache:/root/.cache/huggingface \
  -e OPENAI_API_KEY="your-key-here" \
  -e HF_TOKEN="your-hf-token" \
  -e HAYSTACK_TELEMETRY_ENABLED=false \
  -e CUDA_VISIBLE_DEVICES=0 \
  --restart unless-stopped \\
  haystack-clore:latest

दस्तावेज़ अंतर्ग्रहण पाइपलाइन

दस्तावेज़ों को ingest करने के लिए एक अलग indexing pipeline बनाएं:

cat > /workspace/index_documents.py << 'EOF'
import haystack
from haystack import Pipeline
from haystack.components.converters import PyPDFToDocument, TextFileToDocument
from haystack.components.preprocessors import DocumentSplitter, DocumentCleaner
from haystack.components.embedders import SentenceTransformersDocumentEmbedder
from haystack.components.writers import DocumentWriter
from haystack.document_stores.in_memory import InMemoryDocumentStore

# document store प्रारंभ करें
document_store = InMemoryDocumentStore()

# indexing pipeline बनाएँ
indexing_pipeline = Pipeline()
indexing_pipeline.add_component("converter", PyPDFToDocument())
indexing_pipeline.add_component("cleaner", DocumentCleaner())
indexing_pipeline.add_component("splitter", DocumentSplitter(
    split_by="word",
    split_length=200,
    split_overlap=20
))
indexing_pipeline.add_component("embedder", SentenceTransformersDocumentEmbedder(
    model="BAAI/bge-small-en-v1.5"
))
indexing_pipeline.add_component("writer", DocumentWriter(document_store=document_store))

# components को जोड़ें
indexing_pipeline.connect("converter", "cleaner")
indexing_pipeline.connect("cleaner", "splitter")
indexing_pipeline.connect("splitter", "embedder")
indexing_pipeline.connect("embedder", "writer")

# indexing चलाएँ
from pathlib import Path
indexing_pipeline.run({"converter": {"sources": list(Path("/data/documents").glob("*.pdf"))}})

print(f"इंडेक्स किए गए {document_store.count_documents()} दस्तावेज़ खंड")
EOF

docker run --rm \
  --gpus all \\
  -v /workspace:/workspace \
  -v /your/documents:/data/documents \
  -v /workspace/hf-cache:/root/.cache/huggingface \
  haystack-clore:latest \
  python3 /workspace/index_documents.py

वेक्टर डेटाबेस का उपयोग (प्रोडक्शन)

प्रोडक्शन workloads के लिए, in-memory store को एक persistent vector database से बदलें:

# Haystack के साथ Qdrant लॉन्च करें
docker network create haystack-net

docker run -d \\
  --name qdrant \
  --network haystack-net \
  -p 6333:6333 \
  -v /workspace/qdrant-data:/qdrant/storage \
  qdrant/qdrant

# Haystack container में Qdrant integration इंस्टॉल करें
# Dockerfile में जोड़ें:  RUN pip install qdrant-haystack
# फिर InMemoryDocumentStore की जगह QdrantDocumentStore का उपयोग करें

GPU त्वरण

Haystack दो मुख्य परिदृश्यों में GPU acceleration का उपयोग करता है:

1. Embedding जनरेशन (Sentence Transformers)

बड़े दस्तावेज़ संग्रहों को embed करने के लिए GPU बहुत लाभकारी है:

cat > /workspace/benchmark_embeddings.py << 'EOF'
import time
import torch
from haystack.components.embedders import SentenceTransformersDocumentEmbedder
from haystack import Document

# GPU उपलब्धता जाँचें
device = "cuda" if torch.cuda.is_available() else "cpu"
print(f"डिवाइस का उपयोग: {device}")
if device == "cuda":
    print(f"GPU: {torch.cuda.get_device_name(0)}")
    print(f"VRAM: {torch.cuda.get_device_properties(0).total_memory / 1e9:.1f} GB")

# embedder बनाएँ
embedder = SentenceTransformersDocumentEmbedder(
    model="BAAI/bge-base-en-v1.5"
)
embedder.warm_up()

# Benchmark करें
docs = [Document(content=f"नमूना दस्तावेज़ {i} जिसमें कुछ पाठ सामग्री है.") for i in range(100)]

start = time.time()
result = embedder.run(documents=docs)
elapsed = time.time() - start

print(f"100 दस्तावेज़ों को {elapsed:.2f}s में एम्बेड किया गया ({100/elapsed:.0f} docs/sec)")
EOF

docker run --rm --gpus all \
  -v /workspace:/workspace \
  haystack-clore:latest \
  python3 /workspace/benchmark_embeddings.py

2. स्थानीय LLM inference (Hugging Face Transformers)

Ollama के बिना सीधे Haystack में LLM चलाने के लिए:

cat > /workspace/local_llm_pipeline.py << 'EOF'
from haystack import Pipeline
from haystack.components.builders import PromptBuilder
from haystack.components.generators.hugging_face import HuggingFaceLocalGenerator

# उपलब्ध होने पर GPU का स्वतः उपयोग करता है
generator = HuggingFaceLocalGenerator(
    model="mistralai/Mistral-7B-Instruct-v0.2",
    task="text-generation",
    generation_kwargs={
        "max_new_tokens": 512,
        "temperature": 0.7,
        "do_sample": True,
    }
)

prompt_builder = PromptBuilder(template="इस प्रश्न का उत्तर दें: {{ question }}")

pipeline = Pipeline()
pipeline.add_component("prompt_builder", prompt_builder)
pipeline.add_component("llm", generator)
pipeline.connect("prompt_builder.prompt", "llm.prompt")

result = pipeline.run({"prompt_builder": {"question": "RAG क्या है?"}})
print(result["llm"]["replies"][0])
EOF

docker run --rm --gpus all \
  -v /workspace:/workspace \
  -e HF_TOKEN="your-hf-token" \
  haystack-clore:latest \
  python3 /workspace/local_llm_pipeline.py

3. Ollama के साथ संयोजन करें (अनुशंसित तरीका)

सुविधा और प्रदर्शन का सर्वोत्तम संयोजन पाने के लिए, LLM inference के लिए Ollama और orchestration के लिए Haystack चलाएँ:

# चरण 1: Ollama शुरू करें (Ollama guide देखें)
docker run -d \\
  --name ollama \
  --gpus all \\
  -p 11434:11434 \
  -v /workspace/ollama:/root/.ollama \
  ollama/ollama

# चरण 2: एक coding/chat model खींचें
docker exec ollama ollama pull llama3
docker exec ollama ollama pull nomic-embed-text  # Ollama के माध्यम से embeddings के लिए

# चरण 3: Ollama की ओर इंगित करते हुए Haystack शुरू करें
docker run -d \\
  --name haystack \
  --gpus '"device=0"' \
  -p 1416:1416 \
  --add-host=host.docker.internal:host-gateway \
  -v /workspace/haystack-pipelines:/app/pipelines \
  haystack-clore:latest

दोनों containers में GPU उपयोग की निगरानी करें:

watch -n 2 nvidia-smi

टिप्स और सर्वोत्तम अभ्यास

सही embedding model चुनें

मॉडल

VRAM

गति

गुणवत्ता

किसके लिए सर्वोत्तम

BAAI/bge-small-en-v1.5

~0.5 GB

सबसे तेज़

अच्छा

उच्च-थ्रूपुट indexing

BAAI/bge-base-en-v1.5

~1 GB

तेज़

बेहतर

सामान्य RAG

BAAI/bge-large-en-v1.5

~2 GB

मध्यम

सर्वोत्तम

सर्वोच्च सटीकता

nomic-ai/nomic-embed-text-v1

~1.5 GB

तेज़

उत्कृष्ट

लंबे दस्तावेज़

Pipeline डिज़ाइन सुझाव

दस्तावेज़ों को समझदारी से विभाजित करें — 200–400 शब्दों के chunks के साथ 10–15% overlap अधिकांश RAG use cases के लिए अच्छा काम करता है
Embeddings कैश करें — अपने document store को डिस्क पर persist करें; दोबारा embedding करना महँगा है
उपयोग करें warm_up() — कॉल करें component.warm_up() प्रोडक्शन उपयोग से पहले models को GPU memory में लोड करने के लिए
बैच indexing — इष्टतम GPU utilization के लिए दस्तावेज़ों को 32–64 के बैच में प्रोसेस करें
मेटाडेटा से फ़िल्टर करें — retrieval को सीमित करने के लिए Haystack के metadata filtering का उपयोग करें (उदा., तारीख, स्रोत, श्रेणी के अनुसार)

लागत अनुकूलन

# Clore.ai पर spot-style pricing का उपयोग करें — कम $/hr वाले सर्वर चुनें
# विकास/परीक्षण के लिए: RTX 3060 ($0.03–0.07/hr) embedding के लिए पर्याप्त है
# प्रोडक्शन embedding के लिए: RTX 3090 ($0.07–0.21/hr) — 24 GB बड़े बैच संभाल लेता है
# local LLM + embedding के लिए: A100 40GB ([bare metal](https://clore.ai/bare-metal)) — concurrent users के लिए अतिरिक्त क्षमता

# संसाधन उपयोग की निगरानी करें
docker stats haystack
nvidia-smi dmon -s u -d 5  # हर 5 सेकंड में GPU utilization

बाहरी पहुँच के लिए Hayhooks को सुरक्षित करें

# विकल्प 1: SSH tunnel (सबसे सरल, व्यक्तिगत उपयोग के लिए)
# अपनी स्थानीय मशीन से:
ssh -L 1416:localhost:1416 root@<clore-ip> -p <clore-ssh-port>
# फिर स्थानीय रूप से http://localhost:1416 एक्सेस करें

# विकल्प 2: nginx reverse proxy के माध्यम से basic auth जोड़ें
docker run -d \\
  --name nginx-proxy \
  -p 80:80 \
  -v /workspace/nginx.conf:/etc/nginx/conf.d/default.conf \
  nginx:alpine

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

समस्या

संभावित कारण

समाधान

ModuleNotFoundError: haystack

पैकेज इंस्टॉल नहीं है

Docker image को फिर से बनाएँ; जाँचें pip install haystack-ai सफल हुआ

CUDA out of memory

एम्बेडिंग मॉडल बहुत बड़ा है

उपयोग करें bge-small-en-v1.5 या बैच आकार कम करें

पाइपलाइन पर Hayhooks 404 लौटाता है

YAML फ़ाइल नहीं मिली

वॉल्यूम माउंट जांचें; पाइपलाइन फ़ाइल इसमें होनी चाहिए /app/pipelines/

CPU पर धीमा एम्बेडिंग

GPU का पता नहीं चला

सत्यापित करें --gpus all फ़्लैग; जांचें torch.cuda.is_available()

Ollama कनेक्शन अस्वीकृत

गलत होस्टनाम

उपयोग करें --add-host=host.docker.internal:host-gateway; URL को सेट करें http://host.docker.internal:11434

HuggingFace डाउनलोड विफल होता है

टोकन अनुपलब्ध है या दर सीमा पार हो गई है

सेट करें HF_TOKEN एनव वेरिएबल; सुनिश्चित करें कि मॉडल gated नहीं है

पाइपलाइन YAML पार्स त्रुटि

अमान्य सिंटैक्स

YAML को मान्य करें; उपयोग करें python3 -c "import yaml; yaml.safe_load(open('pipeline.yml'))"

कंटेनर तुरंत बाहर निकल जाता है

स्टार्टअप त्रुटि

जाँचें docker logs haystack; सुनिश्चित करें कि Dockerfile CMD सही है

पोर्ट 1416 बाहरी रूप से पहुँच योग्य नहीं है

फ़ायरवॉल / पोर्ट फ़ॉरवर्डिंग

Clore.ai ऑर्डर सेटिंग्स में पोर्ट एक्सपोज़ करें; सर्वर के खुले पोर्ट जांचें

डीबग कमांड

# कंटेनर लॉग जांचें
docker logs haystack --tail 50 -f

# Hayhooks API का परीक्षण करें
curl http://localhost:1416/status
curl http://localhost:1416/pipelines

# इंटरैक्टिव Python डीबग सत्र
docker exec -it haystack python3

# कंटेनर के अंदर GPU जांचें
docker exec haystack python3 -c "import torch; print(torch.cuda.is_available(), torch.cuda.get_device_name(0))"

# स्थापित पैकेजों की जाँच करें
docker exec haystack pip show haystack-ai hayhooks

अधिक पढ़ें

Haystack दस्तावेज़ीकरण — आधिकारिक v2 दस्तावेज़
Hayhooks GitHub — पाइपलाइनों के लिए REST API सर्विंग
Haystack कुकबुक — एंड-टू-एंड ट्यूटोरियल (RAG, एजेंट्स, खोज)
GitHub पर deepset-ai/haystack — स्रोत, समस्याएँ, रिलीज़
Haystack एकीकरण — समर्थित वेक्टर स्टोर, LLMs और टूल्स की पूरी सूची
Clore.ai पर Ollama — स्थानीय LLM इन्फ़रेंस के लिए Haystack को Ollama के साथ जोड़ें
Clore.ai पर vLLM — Haystack के लिए उच्च-थ्रूपुट LLM सर्विंग बैकएंड
GPU तुलना गाइड — अपने वर्कलोड के लिए सही Clore.ai GPU चुनें
CLORE.AI मार्केटप्लेस — GPU सर्वर किराए पर लें

पिछलाSWE-agent कोड फिक्सर

अगलाContinue.dev AI कोडिंग

अंतिम अपडेट 1 माह पहले

क्या यह उपयोगी था?