> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-de/ki-plattformen-and-agenten/haystack.md).

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

{% hint style="success" %}
Alle Beispiele laufen auf GPU-Servern, die über die [CLORE.AI-Marktplatz](https://clore.ai/marketplace).
{% endhint %}

{% hint style="info" %}
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](https://docs.haystack.deepset.ai/docs/migration).
{% endhint %}

## Überblick

| Eigenschaft                 | Details                                                                           |
| --------------------------- | --------------------------------------------------------------------------------- |
| **Projekt**                 | [deepset-ai/haystack](https://github.com/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](https://clore.ai/bare-metal) |

{% hint style="info" %}
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.
{% endhint %}

### 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](https://clore.ai/marketplace), 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

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

```bash
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](https://github.com/deepset-ai/hayhooks) macht automatisch jede Haystack-Pipeline zu einer REST-API:

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

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

### 5. Erstellen Sie Ihre erste RAG-Pipeline

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

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

```bash
# 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

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

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

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

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

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

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

```bash
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

```bash
# 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

```bash
# 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

```bash
# 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](https://docs.haystack.deepset.ai/) — offizielle v2-Dokumentation
* [Hayhooks-GitHub](https://github.com/deepset-ai/hayhooks) — Bereitstellung der REST-API für Pipelines
* [Haystack-Kochbuch](https://haystack.deepset.ai/cookbook) — End-to-End-Tutorials (RAG, Agenten, Suche)
* [deepset-ai/haystack auf GitHub](https://github.com/deepset-ai/haystack) — Quellcode, Issues, Releases
* [Haystack-Integrationen](https://haystack.deepset.ai/integrations) — vollständige Liste unterstützter Vektorspeicher, LLMs und Tools
* [Ollama auf Clore.ai](/guides/guides_v2-de/sprachmodelle/ollama.md) — Haystack mit Ollama für lokale LLM-Inferenz kombinieren
* [vLLM auf Clore.ai](/guides/guides_v2-de/sprachmodelle/vllm.md) — High-Throughput-Backend für die Bereitstellung von LLMs für Haystack
* [GPU-Vergleichsleitfaden](/guides/guides_v2-de/erste-schritte/gpu-comparison.md) — Wählen Sie die richtige Clore.ai-GPU für Ihre Arbeitslast
* [CLORE.AI-Marktplatz](https://clore.ai/marketplace) — GPU-Server mieten


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-de/ki-plattformen-and-agenten/haystack.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.