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

Alle Beispiele können auf GPU-Servern ausgeführt werden, die gemietet wurden über CLORE.AI-Marktplatz.

---

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)

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.

---

Schnellbereitstellung auf CLORE.AI

1. Finden Sie einen geeigneten Server

Gehe zu CLORE.AI-Marktplatz 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:

#!/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

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

Schritt 2: Ollama installieren

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

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

# 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

# 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

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

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

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

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

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

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

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)

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

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)

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

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

# 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

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

Problem: Der Indexaufbau ist langsam

# 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

# 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

# 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

# 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 GPU-Servern. Durchsuchen Sie verfügbare GPUs und mieten Sie stundenweise — keine Verpflichtungen, voller Root-Zugriff.