Haystack-KI-Framework

Deploye Haystack von deepset auf Clore.ai — baue produktionsreife RAG-Pipelines, semantische Suche und LLM-Agenten-Workflows auf günstiger GPU-Infrastruktur.

Haystack ist deepsets quelloffenes KI-Orchestrierungsframework zum Erstellen produktionsreifer LLM-Anwendungen. Mit über 18.000 GitHub-Sternen bietet es eine flexible pipelinebasierte Architektur die Dokumentenspeicher, Retriever, Reader, Generatoren und Agents miteinander verbindet — alles in sauberem, komponierbarem Python. Egal, ob Sie RAG über private Dokumente, semantische Suche oder mehrstufige Agenten-Workflows benötigen, Haystack übernimmt die ganze Infrastruktur, damit Sie sich auf die Anwendungslogik konzentrieren können.

Auf Clore.ai glänzt Haystack, wenn Sie eine GPU für die lokale Modellinferenz über Hugging Face Transformers oder sentence-transformers benötigen. Wenn Sie sich ausschließlich auf externe APIs (OpenAI, Anthropic) verlassen, können Sie es auf reinen CPU-Instanzen betreiben — aber für die Erzeugung von Embeddings und lokale LLMs senkt eine GPU die Latenz drastisch.

Alle Beispiele laufen auf GPU-Servern, die über die CLORE.AI-Marktplatz.

Dieser Leitfaden behandelt Haystack v2.x (haystack-ai Paket). Die v2-API unterscheidet sich erheblich von v1 (farm-haystack). Wenn Sie bestehende v1-Pipelines haben, sehen Sie sich den Migrationsleitfaden.

Überblick

Eigenschaft	Details
Projekt	deepset-ai/haystack
Lizenz	Apache 2.0
GitHub-Sterne	18K+
Version	v2.x (haystack-ai)
Primärer Anwendungsfall	RAG, semantische Suche, Dokumenten-QA, Agenten-Workflows
GPU-Unterstützung	Optional — erforderlich für lokale Embeddings / lokale LLMs
Schwierigkeitsgrad	Mittel
API-Bereitstellung	Hayhooks (auf FastAPI-Basis, REST)
Wichtige Integrationen	Ollama, OpenAI, Anthropic, HuggingFace, Elasticsearch, Pinecone, Weaviate, Qdrant

Was Sie bauen können

• RAG-Pipelines — Dokumente einlesen, Embeddings erzeugen, Kontext abrufen, Fragen beantworten

• Semantische Suche — Dokumente nach Bedeutung statt nach Schlüsselwörtern abfragen

• Dokumentenverarbeitung — PDFs, HTML, Word-Dokumente analysieren; Inhalte aufteilen, bereinigen und indizieren

• Agenten-Workflows — mehrstufiges Schlussfolgern mit Tool-Nutzung (Websuche, Rechner, APIs)

• REST-API-Dienste — jede Haystack-Pipeline über Hayhooks als Endpunkt bereitstellen

Anforderungen

Hardware-Anforderungen

Anwendungsfall	GPU	VRAM	RAM	Festplatte	Clore.ai-Preis
Nur API-Modus (OpenAI/Anthropic)	Keine / CPU	—	4 GB	20 GB	~0,01–0,05 $/h
Lokale Embeddings (sentence-transformers)	RTX 3060	8 GB	16 GB	30 GB	0,03–0,07 $/Std.
Lokale Embeddings + kleines LLM (7B)	RTX 3090	24 GB	16 GB	50 GB	ca. 0,07–0,21 $/h
Lokales LLM (13B–34B)	RTX 4090	24 GB	32 GB	80 GB	ca. 0,14–0,42 $/h
Großes lokales LLM (70B, quantisiert)	A100 80GB	80 GB	64 GB	150 GB	Bare Metal

Für die meisten RAG-Anwendungsfälle ist eine RTX 3090 für 0,07–0,21 $/h der ideale Mittelweg — 24 GB VRAM bewältigen sentence-transformer-Embeddings + ein lokales 7B–13B-LLM gleichzeitig.

Software-Anforderungen

• Docker (vorinstalliert auf Clore.ai-Servern)

• NVIDIA-Treiber + CUDA (vorinstalliert auf Clore.ai-GPU-Servern)

• Python 3.10+ (im Container)

• CUDA 11.8 oder 12.x

Schnellstart

1. Mieten Sie einen Clore.ai-Server

Im Clore.ai-Marktplatz, filtern Sie nach:

• VRAM: ≥ 8 GB für Embedding-Workloads, ≥ 24 GB für lokale LLMs

• Docker: Aktiviert (standardmäßig bei den meisten Angeboten)

• Image: nvidia/cuda:12.8.1-devel-ubuntu22.04 oder pytorch/pytorch:2.11.0-cuda12.8-cudnn9-runtime

Notieren Sie die öffentliche IP-Adresse und den SSH-Port des Servers aus Meine Bestellungen.

2. Verbinden und GPU prüfen

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

# Prüfen, ob die GPU verfügbar ist
nvidia-smi

# Erwartete Ausgabe zeigt Ihre GPU, Treiberversion, CUDA-Version

3. Das Haystack-Docker-Image erstellen

Für Haystack v2 wird die Installation per pip empfohlen. Erstellen Sie ein benutzerdefiniertes Dockerfile:

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

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

# Interaktive Eingabeaufforderungen vermeiden
ENV DEBIAN_FRONTEND=noninteractive
ENV PYTHONUNBUFFERED=1

# Python und Systemabhängigkeiten installieren
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 als Standard festlegen
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 und Kernabhängigkeiten installieren
RUN pip install --no-cache-dir \
    haystack-ai \
    hayhooks \
    sentence-transformers \
    transformers \
    torch \
    accelerate \
    fastapi \
    uvicorn

# Optionale Integrationen installieren
RUN pip install --no-cache-dir \
    ollama-haystack \
    haystack-experimental

WORKDIR /app

# Standardport für Hayhooks
EXPOSE 1416

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

# Das Image bauen
docker build -t haystack-clore:latest .

4. Haystack mit Hayhooks ausführen

Hayhooks macht automatisch jede Haystack-Pipeline zu einer REST-API:

# Ein Verzeichnis für Ihre Pipelines erstellen
mkdir -p /workspace/haystack-pipelines

# Hayhooks mit GPU-Zugriff ausführen
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

# Prüfen, ob es läuft
curl http://localhost:1416/status

Erwartete Antwort:

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

5. Erstellen Sie Ihre erste RAG-Pipeline

Schreiben Sie eine Pipeline-YAML, die Hayhooks als Endpunkt bereitstellen wird:

cat > /workspace/haystack-pipelines/rag_pipeline.yml << 'EOF'
# RAG-Pipeline mit Ollama für das LLM + lokale Embeddings für die Suche
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: |
        Beantworten Sie die Frage anhand des folgenden Kontexts.
        Kontext: {% for doc in documents %}{{ doc.content }}{% endfor %}
        Frage: {{ 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 entdeckt und bereitgestellt diese Pipeline automatisch. Testen Sie sie:

# Bereitgestellte Pipelines auflisten
curl http://localhost:1416/pipelines

# Die RAG-Pipeline abfragen
curl -X POST http://localhost:1416/rag_pipeline/run \
  -H "Content-Type: application/json" \\
  -d '{"query": "What is Haystack?"}'

Konfiguration

Umgebungsvariablen

Variable	Beschreibung	Beispiel
OPENAI_API_KEY	OpenAI-API-Schlüssel für GPT-Modelle	sk-...
ANTHROPIC_API_KEY	Anthropic-API-Schlüssel für Claude	sk-ant-...
HF_TOKEN	Hugging-Face-Token für gesperrte Modelle	hf_...
HAYSTACK_TELEMETRY_ENABLED	Nutzungs-Telemetrie deaktivieren	false
CUDA_VISIBLE_DEVICES	Bestimmte GPU auswählen	0
TRANSFORMERS_CACHE	Cache-Pfad für HF-Modelle	/workspace/hf-cache

Mit vollständiger Konfiguration ausführen

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

Dokumenten-Ingestions-Pipeline

Erstellen Sie eine separate Indexierungs-Pipeline, um Dokumente einzulesen:

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

# Dokumentenspeicher initialisieren
document_store = InMemoryDocumentStore()

# Indexierungs-Pipeline erstellen
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))

# Komponenten verbinden
indexing_pipeline.connect("converter", "cleaner")
indexing_pipeline.connect("cleaner", "splitter")
indexing_pipeline.connect("splitter", "embedder")
indexing_pipeline.connect("embedder", "writer")

# Indexierung ausführen
from pathlib import Path
indexing_pipeline.run({"converter": {"sources": list(Path("/data/documents").glob("*.pdf"))}})

print(f"{document_store.count_documents()} Dokumentenfragmente indexiert")
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

Vektordatenbanken verwenden (Produktion)

Für Produktions-Workloads ersetzen Sie den In-Memory-Speicher durch eine persistente Vektordatenbank:

# Qdrant zusammen mit Haystack starten
docker network create haystack-net

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

# Qdrant-Integration im Haystack-Container installieren
# Zum Dockerfile hinzufügen:  RUN pip install qdrant-haystack
# Dann QdrantDocumentStore statt InMemoryDocumentStore verwenden

GPU-Beschleunigung

Haystack nutzt GPU-Beschleunigung in zwei Hauptszenarien:

1. Erzeugung von Embeddings (Sentence Transformers)

Eine GPU ist sehr vorteilhaft für das Einbetten großer Dokumentensammlungen:

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

# GPU-Verfügbarkeit prüfen
device = "cuda" if torch.cuda.is_available() else "cpu"
print(f"Verwendetes Gerät: {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 erstellen
embedder = SentenceTransformersDocumentEmbedder(
    model="BAAI/bge-base-en-v1.5"
)
embedder.warm_up()

# Benchmark
docs = [Document(content=f"Beispieldokument {i} mit etwas Textinhalt.") for i in range(100)]

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

print(f"100 Dokumente in {elapsed:.2f}s eingebettet ({100/elapsed:.0f} Dokumente/s)")
EOF

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

2. Lokale LLM-Inferenz (Hugging Face Transformers)

Zum direkten Ausführen von LLMs in Haystack ohne Ollama:

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

# Nutzt automatisch die GPU, wenn verfügbar
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="Beantworte diese Frage: {{ 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": "Was ist 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. Mit Ollama kombinieren (empfohlener Ansatz)

Für die beste Kombination aus Einfachheit und Leistung führen Sie Ollama für die LLM-Inferenz und Haystack für die Orchestrierung aus:

# Schritt 1: Ollama starten (siehe Ollama-Leitfaden)
docker run -d \
  --name ollama \
  --gpus all \
  -p 11434:11434 \
  -v /workspace/ollama:/root/.ollama \
  ollama/ollama

# Schritt 2: Ein Coding-/Chat-Modell herunterladen
docker exec ollama ollama pull llama3
docker exec ollama ollama pull nomic-embed-text  # Für Embeddings über Ollama

# Schritt 3: Haystack starten und auf Ollama verweisen
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

GPU-Auslastung in beiden Containern überwachen:

watch -n 2 nvidia-smi

Tipps & bewährte Praktiken

Das richtige Embedding-Modell auswählen

Modell	VRAM	Geschwindigkeit	Qualität	Am besten geeignet für
BAAI/bge-small-en-v1.5	~0,5 GB	Am schnellsten	Gut	Indexierung mit hohem Durchsatz
BAAI/bge-base-en-v1.5	~1 GB	Schnell	Besser	Allgemeines RAG
BAAI/bge-large-en-v1.5	~2 GB	Mittel	Am besten	Höchste Genauigkeit
nomic-ai/nomic-embed-text-v1	~1,5 GB	Schnell	Hervorragend	Lange Dokumente

Tipps für das Pipeline-Design

• Dokumente sinnvoll aufteilen — 200–400-Wort-Abschnitte mit 10–15 % Überlappung funktionieren für die meisten RAG-Anwendungsfälle gut

• Embeddings zwischenspeichern — speichern Sie Ihren Dokumentenspeicher auf der Festplatte; erneutes Einbetten ist teuer

• Verwende warm_up() — aufrufen component.warm_up() vor dem produktiven Einsatz, um Modelle in den GPU-Speicher zu laden

• Batch-Indexierung — Dokumente in Batches von 32–64 verarbeiten, um die GPU optimal auszulasten

• Mit Metadaten filtern — verwenden Sie die Metadatenfilterung von Haystack, um den Abruf einzugrenzen (z. B. nach Datum, Quelle, Kategorie)

Kostenoptimierung

# Nutzen Sie Spot-ähnliche Preise auf Clore.ai — wählen Sie Server mit niedrigerem $/h
# Für Entwicklung/Tests: RTX 3060 (0,03–0,07 $/h) reicht für Embeddings aus
# Für Produktions-Embeddings: RTX 3090 (0,07–0,21 $/h) — 24 GB bewältigen große Batches
# Für lokales LLM + Embedding: A100 40 GB ([Bare Metal](https://clore.ai/bare-metal)) — Spielraum für gleichzeitige Nutzer

# Ressourcennutzung überwachen
docker stats haystack
nvidia-smi dmon -s u -d 5  # GPU-Auslastung alle 5 Sekunden

Hayhooks für externen Zugriff absichern

# Option 1: SSH-Tunnel (am einfachsten, für den persönlichen Gebrauch)
# Von Ihrem lokalen Rechner aus:
ssh -L 1416:localhost:1416 root@<clore-ip> -p <clore-ssh-port>
# Dann lokal über http://localhost:1416 zugreifen

# Option 2: Basis-Authentifizierung über Nginx-Reverse-Proxy hinzufügen
docker run -d \
  --name nginx-proxy \
  -p 80:80 \
  -v /workspace/nginx.conf:/etc/nginx/conf.d/default.conf \
  nginx:alpine

Fehlerbehebung

Problem	Wahrscheinliche Ursache	Lösung
ModuleNotFoundError: haystack	Paket nicht installiert	Docker-Image neu erstellen; prüfen pip install haystack-ai erfolgreich
CUDA-Speicher erschöpft	Embedding-Modell zu groß	Verwende bge-small-en-v1.5 oder die Batch-Größe reduzieren
Hayhooks gibt für die Pipeline einen 404 zurück	YAML-Datei nicht gefunden	Prüfen Sie das Volume-Mount; die Pipeline-Datei muss sich in befinden /app/pipelines/
Langsames Embedding auf der CPU	GPU nicht erkannt	Überprüfen Sie --gpus all Flag; prüfen Sie torch.cuda.is_available()
Ollama-Verbindung abgelehnt	Falscher Hostname	Verwende --add-host=host.docker.internal:host-gateway; setzen Sie die URL auf http://host.docker.internal:11434
HuggingFace-Download schlägt fehl	Fehlendes Token oder Rate-Limit	Setze HF_TOKEN Umgebungsvariable; stellen Sie sicher, dass das Modell nicht eingeschränkt ist
YAML-Parsing-Fehler in der Pipeline	Ungültige Syntax	YAML validieren; verwenden Sie python3 -c "import yaml; yaml.safe_load(open('pipeline.yml'))"
Container beendet sich sofort	Startfehler	Prüfe docker logs haystack; stellen Sie sicher, dass das CMD im Dockerfile korrekt ist
Port 1416 ist extern nicht erreichbar	Firewall / Portweiterleitung	Stellen Sie den Port in den Bestell-Einstellungen von Clore.ai frei; prüfen Sie die offenen Ports des Servers

Debug-Befehle

# Container-Logs prüfen
docker logs haystack --tail 50 -f

# Hayhooks-API testen
curl http://localhost:1416/status
curl http://localhost:1416/pipelines

# Interaktive Python-Debug-Sitzung
docker exec -it haystack python3

# GPU im Container prüfen
docker exec haystack python3 -c "import torch; print(torch.cuda.is_available(), torch.cuda.get_device_name(0))"

# Installierte Pakete prüfen
docker exec haystack pip show haystack-ai hayhooks

Weiterführende Lektüre

• Haystack-Dokumentation — offizielle v2-Dokumentation

• Hayhooks-GitHub — Bereitstellung der REST-API für Pipelines

• Haystack-Kochbuch — End-to-End-Tutorials (RAG, Agenten, Suche)

• deepset-ai/haystack auf GitHub — Quellcode, Issues, Releases

• Haystack-Integrationen — vollständige Liste unterstützter Vektorspeicher, LLMs und Tools

• Ollama auf Clore.ai — Haystack mit Ollama für lokale LLM-Inferenz kombinieren

• vLLM auf Clore.ai — High-Throughput-Backend für die Bereitstellung von LLMs für Haystack

• GPU-Vergleichsleitfaden — Wählen Sie die richtige Clore.ai-GPU für Ihre Arbeitslast

• CLORE.AI-Marktplatz — GPU-Server mieten