> 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/rag-and-vektordatenbanken/llamaindex.md).

# LlamaIndex

Erstelle LlamaIndex-Daten-zu-LLM-Pipelines und RAG-Anwendungen auf Clore.ai-GPUs

LlamaIndex (früher GPT Index) ist ein **Daten-Framework für LLM-Anwendungen** mit über **37.000 GitHub-Sternen**. Während LangChain sich auf das Verkettung von LLM-Aufrufen konzentriert, ist LlamaIndex hervorragend bei **Datenaufnahme, Indexierung und strukturierter Abfrage** — und ist damit die erste Wahl, wenn Ihre Anwendung über große, heterogene Dokumentensammlungen hinweg Schlussfolgerungen ziehen muss.

LlamaIndex bietet erstklassige Unterstützung für komplexe Datenstrukturen (Datenbanken, APIs, PDFs, Notion-Seiten, GitHub-Repos) und ausgefeilte Abrufstrategien. Der Betrieb auf Clore.ai-GPU-Servern mit lokalen LLMs eliminiert API-Kosten und hält Ihre Daten privat.

Wichtige Stärken:

* 📊 **Daten-Konnektoren** — über 160 Integrationen (PDF, SQL, Notion, Slack, GitHub usw.)
* 🗂️ **Mehrere Index-Typen** — Vektor, Baum, Liste, Schlüsselwort, Wissensgraph
* 🔍 **Erweiterte Abfrage** — Zerlegung in Unterfragen, rekursive Abfrage, hybride Suche
* 🤖 **Abfrage-Engines** — SQL, strukturiert und natürlichsprachlich über jede Datenquelle hinweg
* 🧩 **Multimodal** — Bilder, Audio und Video neben Text
* 💾 **Persistenz** — integrierte Unterstützung für ChromaDB, Pinecone, Weaviate usw.
* ⚡ **Async-first** — für Produktionsdurchsatz entwickelt
* 🔗 **Kompatibel mit LangChain** — beide Frameworks zusammen verwenden

{% hint style="success" %}
Alle Beispiele können auf GPU-Servern ausgeführt werden, die gemietet wurden über [CLORE.AI-Marktplatz](https://clore.ai/marketplace).
{% endhint %}

***

## Serveranforderungen

| Parameter      | Minimum                 | Empfohlen                        |
| -------------- | ----------------------- | -------------------------------- |
| GPU            | NVIDIA RTX 3080 (10 GB) | NVIDIA RTX 4090 (24 GB)          |
| VRAM           | 8 GB (7B-Modell)        | 24 GB (13B–34B-Modelle)          |
| RAM            | 16 GB                   | 32–64 GB                         |
| CPU            | 4 Kerne                 | 16 Kerne                         |
| Festplatte     | 30 GB                   | 100+ GB (lokale Modelle + Daten) |
| Betriebssystem | Ubuntu 20.04+           | Ubuntu 22.04                     |
| CUDA           | 11.8+                   | 12.1+                            |
| Python         | 3.9+                    | 3.11                             |
| Ports          | 22, 8000                | 22, 8000, 11434 (Ollama)         |

{% hint style="info" %}
LlamaIndex ist eine Python-Bibliothek — GPU-Ressourcen werden vom zugrunde liegenden LLM und Embedding-Modell verbraucht. Für Produktionsbereitstellungen kombinieren Sie LlamaIndex mit Ollama (für lokale Inferenz) und ChromaDB (für Vektorspeicher), die beide auf Ihrem Clore.ai-GPU-Server laufen.
{% endhint %}

***

## Schnellbereitstellung auf CLORE.AI

### 1. Finden Sie einen geeigneten Server

Gehe zu [CLORE.AI-Marktplatz](https://clore.ai/marketplace) und wählen Sie basierend auf Ihrer LLM-Größe:

| Anwendungsfall      | GPU              | Hinweise                            |
| ------------------- | ---------------- | ----------------------------------- |
| Entwicklung / Tests | RTX 3080 (10 GB) | 7B-Modelle, kleine Dokumentensätze  |
| Produktion (klein)  | RTX 4090 (24 GB) | 13B-Modelle, mittelgroße Datensätze |
| Produktion (groß)   | A100 40G / 80G   | 34B–70B-Modelle, große Datensätze   |
| Unternehmen         | H100 (80 GB)     | Maximaler Durchsatz                 |

### 2. Konfigurieren Sie Ihre Bereitstellung

**Docker-Image (Basis):**

```
nvidia/cuda:12.8.1-cudnn-devel-ubuntu22.04
```

**Port-Zuordnungen:**

```
22    → SSH-Zugriff
8000  → LlamaIndex-API / Gradio-Oberfläche
11434 → Ollama-Inferenz-Engine
```

**Startskript:**

```bash
#!/bin/bash
# Ollama installieren
curl -fsSL https://ollama.ai/install.sh | sh
ollama serve &
sleep 5
ollama pull llama3:8b
ollama pull nomic-embed-text

# LlamaIndex installieren
pip install llama-index llama-index-llms-ollama llama-index-embeddings-ollama
pip install chromadb fastapi uvicorn

python /workspace/app.py
```

### 3. Zugriff auf die API

```
http://<your-clore-server-ip>:8000
```

***

## Schritt-für-Schritt-Einrichtung

### Schritt 1: Per SSH auf Ihren Server verbinden

```bash
ssh root@<your-clore-server-ip> -p <ssh-port>
```

### Schritt 2: Ollama installieren

```bash
curl -fsSL https://ollama.ai/install.sh | sh
ollama serve &
sleep 5

# Modelle abrufen
ollama pull llama3:8b              # LLM für die Generierung
ollama pull nomic-embed-text       # Embedding-Modell

# Prüfen
ollama list
```

### Schritt 3: Python-Umgebung einrichten

```bash
mkdir -p /workspace/llamaindex-app
cd /workspace/llamaindex-app

python3 -m venv venv
source venv/bin/activate
pip install --upgrade pip
```

### Schritt 4: LlamaIndex-Pakete installieren

```bash
# LlamaIndex-Kern
pip install llama-index

# LLM-Integrationen
pip install llama-index-llms-ollama
pip install llama-index-llms-openai     # Optional: OpenAI

# Embedding-Integrationen
pip install llama-index-embeddings-ollama
pip install llama-index-embeddings-huggingface

# Vektorspeicher-Integrationen
pip install llama-index-vector-stores-chroma

# Datenlader
pip install llama-index-readers-file
pip install llama-index-readers-web

# Optional: zusätzliche Reader
pip install pypdf docx2txt
```

### Schritt 5: Globale Einstellungen konfigurieren

```python
# settings.py
from llama_index.core import Settings
from llama_index.llms.ollama import Ollama
from llama_index.embeddings.ollama import OllamaEmbedding

# LLM konfigurieren
Settings.llm = Ollama(
    model="llama3:8b",
    base_url="http://localhost:11434",
    request_timeout=300.0,
    temperature=0.1,
)

# Embeddings konfigurieren
Settings.embed_model = OllamaEmbedding(
    model_name="nomic-embed-text",
    base_url="http://localhost:11434",
)

# Chunk-Einstellungen konfigurieren
Settings.chunk_size = 1024
Settings.chunk_overlap = 200
```

### Schritt 6: Ihren ersten Index erstellen

```python
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader

# Dokumente aus einem Verzeichnis laden
documents = SimpleDirectoryReader("/workspace/data/docs").load_data()
print(f"{len(documents)} Dokumente geladen")

# Vektorindex erstellen (automatisch einbetten und speichern)
index = VectorStoreIndex.from_documents(documents)

# Index auf der Festplatte speichern
index.storage_context.persist("/workspace/index_storage")
print("Index erstellt und gespeichert!")
```

### Schritt 7: Den Index abfragen

```python
from llama_index.core import load_index_from_storage, StorageContext

# Vorhandenen Index laden
storage_context = StorageContext.from_defaults(persist_dir="/workspace/index_storage")
index = load_index_from_storage(storage_context)

# Abfrage-Engine erstellen
query_engine = index.as_query_engine(similarity_top_k=5)

# Fragen stellen
response = query_engine.query("Welche GPU-Server sind auf Clore.ai verfügbar?")
print(f"Antwort: {response}")
print(f"\nQuellen: {len(response.source_nodes)} verwendete Knoten")
```

***

## Anwendungsbeispiele

### Beispiel 1: Einfache Dokumenten-Q\&A

```python
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader, Settings
from llama_index.llms.ollama import Ollama
from llama_index.embeddings.ollama import OllamaEmbedding
from pathlib import Path

# LlamaIndex mit lokalen Ollama-Modellen konfigurieren
Settings.llm = Ollama(model="llama3:8b", base_url="http://localhost:11434")
Settings.embed_model = OllamaEmbedding(
    model_name="nomic-embed-text",
    base_url="http://localhost:11434"
)

# Beispielverzeichnis für Dokumente erstellen
data_dir = Path("/workspace/data")
data_dir.mkdir(exist_ok=True)

# Beispieldokument erstellen
(data_dir / "clore_faq.txt").write_text("""
Clore.ai-FAQ

F: Was ist Clore.ai?
A: Clore.ai ist ein dezentraler GPU-Cloud-Marktplatz, der GPU-Besitzer mit KI-Forschern und Entwicklern verbindet, die Rechenleistung benötigen.

F: Welche GPUs sind verfügbar?
A: Clore.ai bietet GPUs von der NVIDIA GTX 1080 bis zur neuesten H100 80GB. Beliebte Optionen sind RTX 4090, A100 40G/80G und RTX 3090.

F: Wie funktioniert die Preisgestaltung?
A: Die Preise werden von den GPU-Anbietern festgelegt und variieren je nach GPU-Modell, VRAM und Verfügbarkeit. Im Allgemeinen 30–70 % günstiger als AWS/GCP.

F: Welche Software kann ich ausführen?
A: Jeder Docker-Container. Vorgefertigte Images für PyTorch, TensorFlow, ComfyUI, Stable Diffusion und mehr sind verfügbar.
""")

# Index erstellen
documents = SimpleDirectoryReader(str(data_dir)).load_data()
index = VectorStoreIndex.from_documents(documents, show_progress=True)

# Abfrage
query_engine = index.as_query_engine(similarity_top_k=3)

questions = [
    "Welche GPUs bietet Clore.ai an?",
    "Wie vergleicht sich die Preisgestaltung von Clore.ai mit AWS?",
    "Kann ich benutzerdefinierte Docker-Container ausführen?",
]

for q in questions:
    print(f"\n❓ {q}")
    response = query_engine.query(q)
    print(f"💬 {response}")
```

***

### Beispiel 2: Multi-Dokument-RAG mit ChromaDB

```python
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader, StorageContext, Settings
from llama_index.vector_stores.chroma import ChromaVectorStore
from llama_index.llms.ollama import Ollama
from llama_index.embeddings.ollama import OllamaEmbedding
import chromadb

# LLM und Embeddings konfigurieren
Settings.llm = Ollama(model="llama3:8b", base_url="http://localhost:11434")
Settings.embed_model = OllamaEmbedding(
    model_name="nomic-embed-text",
    base_url="http://localhost:11434"
)

# Mit ChromaDB verbinden (läuft auf demselben Clore.ai-Server)
chroma_client = chromadb.HttpClient(host="localhost", port=8001)
chroma_collection = chroma_client.get_or_create_collection("llamaindex_docs")

# ChromaDB-Vektorspeicher für LlamaIndex erstellen
vector_store = ChromaVectorStore(chroma_collection=chroma_collection)
storage_context = StorageContext.from_defaults(vector_store=vector_store)

# Dokumente aus mehreren Quellen laden
docs_dir = "/workspace/data/docs"
documents = SimpleDirectoryReader(
    docs_dir,
    recursive=True,              # Unterverzeichnisse einbeziehen
    required_exts=[".pdf", ".txt", ".md"],  # Nur diese Formate
    filename_as_id=True          # Dateiname als Dokumenten-ID verwenden
).load_data()

print(f"{len(documents)} Dokumente aus {docs_dir} geladen")

# Index erstellen (in ChromaDB speichern)
index = VectorStoreIndex.from_documents(
    documents,
    storage_context=storage_context,
    show_progress=True
)
print("Index erstellt und in ChromaDB persistiert!")

# Vorhandenen Index laden (zukünftige Sitzungen)
# index = VectorStoreIndex.from_vector_store(vector_store)

# Erweiterte Abfrage-Engine mit Metadatenfilterung
from llama_index.core.vector_stores import MetadataFilter, MetadataFilters

# Mit Metadatenfilter abfragen
filtered_engine = index.as_query_engine(
    similarity_top_k=5,
    filters=MetadataFilters(
        filters=[
            MetadataFilter(key="file_type", value=".pdf"),
        ]
    )
)

response = filtered_engine.query("Fassen Sie die wichtigsten technischen Konzepte in den Dokumenten zusammen.")
print(f"\nGefilterte Antwort: {response}")
```

***

### Beispiel 3: Zerlegung in Unterfragen

```python
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader, Settings
from llama_index.core.query_engine import SubQuestionQueryEngine
from llama_index.core.tools import QueryEngineTool, ToolMetadata
from llama_index.llms.ollama import Ollama
from llama_index.embeddings.ollama import OllamaEmbedding

Settings.llm = Ollama(model="llama3:8b", base_url="http://localhost:11434")
Settings.embed_model = OllamaEmbedding(model_name="nomic-embed-text", base_url="http://localhost:11434")

# Separate Indizes für verschiedene Wissensdomänen erstellen
def build_index(docs_path, index_name):
    docs = SimpleDirectoryReader(docs_path).load_data()
    index = VectorStoreIndex.from_documents(docs)
    return index

# Separate Wissensdatenbanken
pricing_index = build_index("/workspace/data/pricing", "pricing")
technical_index = build_index("/workspace/data/technical", "technical")
faq_index = build_index("/workspace/data/faq", "faq")

# Als Tools verpacken
tools = [
    QueryEngineTool(
        query_engine=pricing_index.as_query_engine(),
        metadata=ToolMetadata(
            name="pricing_docs",
            description="Enthält Preisinformationen, Kostenvergleiche und Abrechnungsdetails für Clore.ai."
        )
    ),
    QueryEngineTool(
        query_engine=technical_index.as_query_engine(),
        metadata=ToolMetadata(
            name="technical_docs",
            description="Enthält technische Dokumentation zu GPU-Spezifikationen, Docker-Bereitstellung und APIs."
        )
    ),
    QueryEngineTool(
        query_engine=faq_index.as_query_engine(),
        metadata=ToolMetadata(
            name="faq_docs",
            description="Enthält häufig gestellte Fragen und ihre Antworten."
        )
    ),
]

# Die Unterfrage-Engine zerlegt komplexe Abfragen
sub_question_engine = SubQuestionQueryEngine.from_defaults(
    query_engine_tools=tools,
    verbose=True
)

# Komplexe Frage mit mehreren Teilen
"""
Vergleichen Sie die Kosten für den Betrieb eines 7B-Parameter-LLM auf Clore.ai und AWS für 100 Stunden,
und erklären Sie das für jede Option erforderliche technische Setup.
"""

print(f"Frage: {complex_question}")
response = sub_question_engine.query(complex_question)
print(f"\nUmfassende Antwort:\n{response}")
```

***

### Beispiel 4: Wissensgraph-Index

```python
from llama_index.core import KnowledgeGraphIndex, SimpleDirectoryReader, Settings
from llama_index.llms.ollama import Ollama
from llama_index.embeddings.ollama import OllamaEmbedding

Settings.llm = Ollama(model="llama3:13b", base_url="http://localhost:11434")  # Größeres Modell für bessere Extraktion
Settings.embed_model = OllamaEmbedding(model_name="nomic-embed-text", base_url="http://localhost:11434")

# Dokumente laden
documents = SimpleDirectoryReader("/workspace/data/docs").load_data()

# Wissensgraph erstellen (extrahiert Entitäten und Beziehungen)
kg_index = KnowledgeGraphIndex.from_documents(
    documents,
    max_triplets_per_chunk=10,   # Bis zu 10 Tripel pro Chunk extrahieren
    include_embeddings=True,
    show_progress=True
)

# Den Graphen speichern
kg_index.storage_context.persist("/workspace/kg_storage")
print(f"Wissensgraph erstellt!")
print(f"Knoten: {len(kg_index.index_struct.table)}")

# Wissensgraph abfragen
kg_query_engine = kg_index.as_query_engine(
    include_text=True,            # Quelltext einschließen
    retriever_mode="keyword",     # Schlüsselwortbasierte Suche verwenden
    response_mode="tree_summarize"
)

questions = [
    "Welche Beziehungen bestehen zwischen GPU-Modellen und Anwendungsfällen?",
    "Wie hängen Preise und GPU-Spezifikationen zusammen?",
    "Welche Bereitstellungsmethoden verbinden sich mit welchen Diensten?",
]

for q in questions:
    print(f"\n🔍 {q}")
    response = kg_query_engine.query(q)
    print(f"📊 {response}")
```

***

### Beispiel 5: SQL-Abfrage-Engine über eine Datenbank

```python
from llama_index.core import SQLDatabase, Settings
from llama_index.core.query_engine import NLSQLTableQueryEngine
from llama_index.llms.ollama import Ollama
from sqlalchemy import create_engine, text
import pandas as pd

Settings.llm = Ollama(model="llama3:8b", base_url="http://localhost:11434")

# Beispieldatenbank mit GPU-Marktplatzdaten erstellen
engine = create_engine("sqlite:////workspace/clore_data.db")

# Tabellen erstellen und befüllen
with engine.connect() as conn:
    conn.execute(text("""
        CREATE TABLE IF NOT EXISTS gpu_servers (
            id INTEGER PRIMARY KEY,
            gpu_model TEXT,
            vram_gb INTEGER,
            price_per_hour REAL,
            location TEXT,
            available INTEGER
        )
    """))

    conn.execute(text("""
        INSERT OR REPLACE INTO gpu_servers VALUES
        (1, 'RTX 4090', 24, 0.65, 'US-East', 1),
        (2, 'RTX 4090', 24, 0.70, 'EU-West', 1),
        (3, 'A100 80G', 80, 2.50, 'US-West', 1),
        (4, 'H100 80G', 80, 4.20, 'US-East', 0),
        (5, 'RTX 3090', 24, 0.35, 'Asia-Pacific', 1),
        (6, 'RTX 3080', 10, 0.20, 'EU-East', 1),
        (7, 'A100 40G', 40, 1.50, 'US-East', 1)
    """))
    conn.commit()

# LlamaIndex-SQL-Datenbank-Wrapper erstellen
sql_database = SQLDatabase(engine, include_tables=["gpu_servers"])

# Abfrage-Engine von natürlicher Sprache zu SQL
query_engine = NLSQLTableQueryEngine(
    sql_database=sql_database,
    tables=["gpu_servers"],
)

# Die Datenbank in natürlicher Sprache abfragen
nl_queries = [
    "Was ist der günstigste verfügbare GPU-Server?",
    "Zeigen Sie mir alle GPU-Server mit mehr als 40 GB VRAM",
    "Wie hoch ist der durchschnittliche Preis pro Stunde für RTX-4090-Server?",
    "An welchen Standorten sind GPU-Server verfügbar?",
    "Listen Sie alle verfügbaren A100-Server nach Preis sortiert auf",
]

for query in nl_queries:
    print(f"\n💬 Natürliche Sprache: {query}")
    response = query_engine.query(query)
    print(f"📊 Antwort: {response}")
    if hasattr(response, 'metadata') and 'sql_query' in response.metadata:
        print(f"🔧 SQL: {response.metadata['sql_query']}")
```

***

## Konfiguration

### Docker Compose (vollständiger LlamaIndex-Stack)

```yaml
version: '3.8'

services:
  ollama:
    image: ollama/ollama:latest
    container_name: ollama
    runtime: nvidia
    ports:
      - "11434:11434"
    volumes:
      - ollama_models:/root/.ollama
    environment:
      - NVIDIA_VISIBLE_DEVICES=all
    restart: unless-stopped

  chromadb:
    image: chromadb/chroma:latest
    container_name: chromadb
    ports:
      - "8001:8000"
    volumes:
      - chroma_data:/chroma/chroma
    environment:
      - IS_PERSISTENT=TRUE
      - ANONYMIZED_TELEMETRY=FALSE
    restart: unless-stopped

  llamaindex-api:
    build:
      context: .
      dockerfile: Dockerfile
    container_name: llamaindex-api
    ports:
      - "8000:8000"
    volumes:
      - ./data:/workspace/data
      - ./indices:/workspace/indices
    environment:
      - OLLAMA_BASE_URL=http://ollama:11434
      - CHROMA_HOST=chromadb
      - CHROMA_PORT=8000
      - LLM_MODEL=llama3:8b
      - EMBED_MODEL=nomic-embed-text
    depends_on:
      - ollama
      - chromadb
    restart: unless-stopped

volumes:
  ollama_models:
  chroma_data:
```

### Wichtige Konfigurationsvariablen

| Einstellung               | Standard       | Beschreibung                       |
| ------------------------- | -------------- | ---------------------------------- |
| `Settings.llm`            | OpenAI GPT-3.5 | LLM zur Generierung                |
| `Settings.embed_model`    | OpenAI Ada     | Embedding-Modell                   |
| `Settings.chunk_size`     | 1024           | Text-Chunk-Größe in Tokens         |
| `Settings.chunk_overlap`  | 200            | Überlappung zwischen Chunks        |
| `Settings.num_output`     | 256            | Maximale Tokens in der LLM-Antwort |
| `Settings.context_window` | 4096           | Größe des LLM-Kontextfensters      |

***

## Leistungstipps

### 1. Async-Abfragen für höheren Durchsatz

```python
import asyncio
from llama_index.core import VectorStoreIndex

query_engine = index.as_query_engine(use_async=True)

async def batch_query(questions):
    tasks = [query_engine.aquery(q) for q in questions]
    return await asyncio.gather(*tasks)

questions = ["Q1?", "Q2?", "Q3?", "Q4?", "Q5?"]
answers = asyncio.run(batch_query(questions))
```

### 2. Hybride Suche (Schlüsselwort + Semantik)

```python
from llama_index.core import VectorStoreIndex
from llama_index.core.retrievers import VectorIndexRetriever, KeywordTableSimpleRetriever
from llama_index.core.query_engine import RetrieverQueryEngine
from llama_index.core.retrievers import QueryFusionRetriever

# Vektor- und Schlüsselwortsuche kombinieren
retriever = QueryFusionRetriever(
    [
        index.as_retriever(similarity_top_k=5),  # Vektorabfrage
        index.as_retriever(retriever_mode="keyword"),  # Schlüsselwortabfrage
    ],
    similarity_top_k=5,
    num_queries=3,  # Mehrere Abfragevarianten generieren
    use_async=True,
    verbose=True,
)

query_engine = RetrieverQueryEngine(retriever=retriever)
```

### 3. Re-Ranking für Qualität

```python
from llama_index.core.postprocessor import SentenceTransformerRerank

# Re-Ranking-Schritt nach der Abfrage hinzufügen
reranker = SentenceTransformerRerank(
    model="cross-encoder/ms-marco-MiniLM-L-2-v2",
    top_n=3
)

query_engine = index.as_query_engine(
    similarity_top_k=10,  # Mehr Kandidaten abrufen
    node_postprocessors=[reranker]  # Auf die Top 3 neu ranken
)
```

### 4. Streaming für reaktionsschnelle UIs

```python
# Tokens streamen, während sie generiert werden
streaming_engine = index.as_query_engine(streaming=True)
response = streaming_engine.query("Erklären Sie, wie Clore.ai funktioniert")

for token in response.response_gen:
    print(token, end="", flush=True)
```

***

## Fehlerbehebung

### Problem: Embedding-Modell verbindet sich nicht mit Ollama

```bash
# Ollama-Embeddings direkt testen
curl http://localhost:11434/api/embeddings -d '{
  "model": "nomic-embed-text",
  "prompt": "Testtext"
}'
```

### Problem: Der Indexaufbau ist langsam

```bash
# GPU-Nutzung während des Embeddings überwachen
watch -n1 nvidia-smi

# Kleinere Batch-Größen verwenden
from llama_index.core import VectorStoreIndex
index = VectorStoreIndex.from_documents(
    docs,
    show_progress=True,
    # In kleineren Batches einfügen
)
```

### Problem: ModuleNotFoundError für Integrationen

```bash
# LlamaIndex verwendet in v0.10+ eine Plugin-Architektur
pip install llama-index-llms-ollama
pip install llama-index-embeddings-ollama
pip install llama-index-vector-stores-chroma

# Installierte Pakete prüfen
pip list | grep llama
```

### Problem: Kontextfenster überschritten

```python
# Chunk-Größe reduzieren
Settings.chunk_size = 512
Settings.chunk_overlap = 50

# Oder ein Modell mit größerem Kontext verwenden
Settings.llm = Ollama(
    model="llama3:8b",
    context_window=8192  # Kontextfenster erweitern
)
```

### Problem: Abfragen liefern irrelevante Ergebnisse

```python
# similarity top-k erhöhen
query_engine = index.as_query_engine(similarity_top_k=10)

# Oder ein besseres Embedding-Modell verwenden
from llama_index.embeddings.huggingface import HuggingFaceEmbedding
Settings.embed_model = HuggingFaceEmbedding(
    model_name="BAAI/bge-large-en-v1.5"
)
```

***

## Links

* **GitHub**: <https://github.com/run-llama/llama_index>
* **Offizielle Dokumentation**: <https://docs.llamaindex.ai>
* **PyPI**: <https://pypi.org/project/llama-index>
* **Integrationen**: <https://llamahub.ai>
* **Discord**: <https://discord.gg/dGcwcsnxhU>
* **Blog**: <https://www.llamaindex.ai/blog>
* **CLORE.AI-Marktplatz**: <https://clore.ai/marketplace>

***

## GPU-Empfehlungen für Clore.ai

| Anwendungsfall                | Empfohlene GPU   | Geschätzte Kosten bei Clore.ai |
| ----------------------------- | ---------------- | ------------------------------ |
| Entwicklung/Testen            | RTX 3090 (24 GB) | 0,07–0,21 $/GPU/Stunde         |
| RAG in der Produktion         | RTX 3090 (24 GB) | 0,07–0,21 $/GPU/Stunde         |
| Embedding mit hohem Durchsatz | RTX 4090 (24 GB) | 0,14–0,42 $/GPU/Stunde         |

> 💡 Alle Beispiele in diesem Leitfaden können bereitgestellt werden auf [Clore.ai](https://clore.ai/marketplace) GPU-Servern. Durchsuchen Sie verfügbare GPUs und mieten Sie stundenweise — keine Verpflichtungen, voller Root-Zugriff.


---

# 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/rag-and-vektordatenbanken/llamaindex.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.