> 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/chromadb.md).

# ChromaDB

Stelle die Open-Source-Vektordatenbank ChromaDB für KI-Anwendungen auf Clore.ai-GPUs bereit

ChromaDB ist die **führende Open-Source-Vektordatenbank** speziell für KI-Anwendungen entwickelt. Sie bietet eine einfache, intuitive API zum Speichern, Abfragen und Verwalten hochdimensionaler Embeddings — das Rückgrat moderner RAG-Systeme, semantischer Suche, Empfehlungssysteme und des LLM-Gedächtnisses.

ChromaDB abstrahiert die Komplexität der Vektorsimiliarsuche und ermöglicht es Ihnen, sich auf die Entwicklung von KI-Anwendungen zu konzentrieren. Es unterstützt sowohl den In-Memory-Modus für die Entwicklung als auch einen persistenten Servermodus für Produktionsbereitstellungen, mit Docker-Unterstützung für eine einfache Bereitstellung auf Clore.ai-GPU-Servern.

Wichtige Funktionen:

* 🚀 **Einfache Python/JavaScript-API** — in Minuten loslegen
* 💾 **Persistenter Speicher** — Daten überstehen Container-Neustarts
* 🔍 **Mehrere Distanzmetriken** — Kosinus, L2, Skalarprodukt
* 📦 **Integrierte Embeddings** — integrierte Unterstützung für OpenAI, Cohere, sentence-transformers
* 🏗️ **Mandantenfähig** — Sammlungen zum Organisieren verschiedener Datensätze
* 🔌 **REST-API** — sprachunabhängige HTTP-Schnittstelle
* ⚡ **Schnell** — HNSW-Index für die approximative Suche nach den nächsten Nachbarn
* 🔗 **Nativer Support für LangChain/LlamaIndex** — erstklassige Integration

{% 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            | Beliebige NVIDIA-GPU (optional) | NVIDIA RTX 3080+ (für Embeddings)      |
| VRAM           | Für ChromaDB nicht erforderlich | 8–16 GB (für lokale Embedding-Modelle) |
| RAM            | 4 GB                            | 16–32 GB                               |
| CPU            | 2 Kerne                         | 8 Kerne                                |
| Festplatte     | 10 GB                           | 50–200 GB (für große Datensätze)       |
| Betriebssystem | Ubuntu 20.04+                   | Ubuntu 22.04                           |
| Docker         | Erforderlich                    | Docker + Docker Compose                |
| Ports          | 22, 8000                        | 22, 8000                               |

{% hint style="info" %}
ChromaDB selbst benötigt keine GPU — es läuft effizient auf der CPU. Allerdings, **das Erzeugen von Embeddings** (die Umwandlung von Text in Vektoren) profitiert erheblich von GPU-Beschleunigung. Wenn Sie planen, lokale Embedding-Modelle (sentence-transformers usw.) zu verwenden, wählen Sie einen Server mit GPU.
{% endhint %}

***

## Schnellbereitstellung auf CLORE.AI

### 1. Finden Sie einen geeigneten Server

Gehe zu [CLORE.AI-Marktplatz](https://clore.ai/marketplace) und wählen Sie:

* **Nur CPU** für ChromaDB-Server + API (vorberechnete Embeddings speichern)
* **GPU-Server** wenn Sie Embeddings auch lokal erzeugen möchten

### 2. Konfigurieren Sie Ihre Bereitstellung

**Docker-Image:**

```
chromadb/chroma:latest
```

**Port-Zuordnungen:**

```
22 → SSH-Zugriff
8000 → ChromaDB-HTTP-API
```

**Umgebungsvariablen:**

```
IS_PERSISTENT=TRUE
ANONYMIZED_TELEMETRY=FALSE
CHROMA_SERVER_AUTH_CREDENTIALS_FILE=/chroma/auth.txt
```

**Startbefehl:**

```bash
uvicorn chromadb.app:app --host 0.0.0.0 --port 8000
```

### 3. Bereitstellung testen

```bash
curl http://<server-ip>:8000/api/v1/heartbeat
# Erwartet: {"nanosecond heartbeat": <timestamp>}
```

***

## 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: Datenverzeichnis erstellen

```bash
mkdir -p /workspace/chromadb/data
mkdir -p /workspace/chromadb/config
```

### Schritt 3: ChromaDB-Container ausführen

```bash
docker run -d \
  --name chromadb \
  -p 8000:8000 \
  -v /workspace/chromadb/data:/chroma/chroma \
  -e IS_PERSISTENT=TRUE \
  -e ANONYMIZED_TELEMETRY=FALSE \
  -e CHROMA_SERVER_LOG_LEVEL=INFO \
  chromadb/chroma:latest
```

### Schritt 4: Überprüfen, ob er läuft

```bash
# Status prüfen
curl http://localhost:8000/api/v1/heartbeat

# Version prüfen
curl http://localhost:8000/api/v1/version

# Collections auflisten
curl http://localhost:8000/api/v1/collections
```

### Schritt 5: Python-Client installieren

```bash
pip install chromadb
pip install sentence-transformers  # Für lokale GPU-Embeddings
pip install openai                  # Für OpenAI-Embeddings
```

### Schritt 6: Konnektivität aus Python testen

```python
import chromadb

client = chromadb.HttpClient(host="<server-ip>", port=8000)
print(f"ChromaDB-Version: {client.get_version()}")
print(f"Heartbeat: {client.heartbeat()}")
```

### Schritt 7: (Optional) Authentifizierung aktivieren

```bash
# Authentifizierungsdaten erstellen
echo "admin:$2y$12$$(openssl rand -hex 16)" > /workspace/chromadb/auth.txt

# Mit aktivierter Authentifizierung ausführen
docker run -d \
  --name chromadb-auth \
  -p 8000:8000 \
  -v /workspace/chromadb/data:/chroma/chroma \
  -v /workspace/chromadb/auth.txt:/chroma/auth.txt \
  -e IS_PERSISTENT=TRUE \
  -e CHROMA_SERVER_AUTH_CREDENTIALS_FILE=/chroma/auth.txt \
  -e CHROMA_SERVER_AUTH_CREDENTIALS_PROVIDER=chromadb.auth.providers.HtpasswdFileServerAuthCredentialsProvider \
  -e CHROMA_SERVER_AUTH_PROVIDER=chromadb.auth.basic.BasicAuthServerProvider \
  chromadb/chroma:latest
```

***

## Anwendungsbeispiele

### Beispiel 1: Grundlegende Vektor-Store-Operationen

```python
import chromadb
from chromadb.utils import embedding_functions

# Mit ChromaDB auf dem Clore.ai-Server verbinden
client = chromadb.HttpClient(
    host="<your-clore-server-ip>",
    port=8000
)

# sentence-transformers für Embeddings verwenden (läuft bei Verfügbarkeit auf der GPU)
embedding_fn = embedding_functions.SentenceTransformerEmbeddingFunction(
    model_name="all-MiniLM-L6-v2"
)

# Eine Sammlung erstellen
collection = client.get_or_create_collection(
    name="clore_ai_docs",
    embedding_function=embedding_fn,
    metadata={"hnsw:space": "cosine"}  # Distanzmetrik
)

# Dokumente hinzufügen
documents = [
    "Clore.ai ist ein dezentraler GPU-Cloud-Marktplatz für KI-Workloads.",
    "Auf Clore.ai können Sie NVIDIA RTX 4090-, A100- und H100-GPUs mieten.",
    "Clore.ai unterstützt Docker-basierte Bereitstellungen für jedes KI-Framework.",
    "Die Preise auf Clore.ai sind im Vergleich zu AWS und GCP wettbewerbsfähig.",
    "Der Clore.ai-Marktplatz hat weltweit Tausende von GPU-Servern.",
    "Sie können PyTorch, TensorFlow, JAX und andere ML-Frameworks bereitstellen.",
    "Clore.ai bietet Spot-Preise für kosteneffizientes GPU-Computing.",
]

ids = [f"doc_{i}" for i in range(len(documents))]

collection.add(
    documents=documents,
    ids=ids,
    metadatas=[{"source": "docs", "index": i} for i in range(len(documents))]
)

print(f"{len(documents)} Dokumente zur Sammlung hinzugefügt")
print(f"Sammlungsgröße: {collection.count()} Dokumente")
```

***

### Beispiel 2: Semantische Suche

```python
import chromadb
from chromadb.utils import embedding_functions

client = chromadb.HttpClient(host="<server-ip>", port=8000)
embedding_fn = embedding_functions.SentenceTransformerEmbeddingFunction(
    model_name="all-MiniLM-L6-v2"
)

collection = client.get_collection(
    name="clore_ai_docs",
    embedding_function=embedding_fn
)

# Semantische Suchanfragen
queries = [
    "Wie viel kostet die GPU-Miete?",
    "Welche Machine-Learning-Tools sind verfügbar?",
    "Erzählen Sie mir von den GPU-Hardwareoptionen",
]

for query in queries:
    results = collection.query(
        query_texts=[query],
        n_results=3,
        include=["documents", "distances", "metadatas"]
    )

    print(f"\n🔍 Abfrage: {query}")
    for i, (doc, dist) in enumerate(zip(
        results["documents"][0],
        results["distances"][0]
    )):
        similarity = 1 - dist  # In Ähnlichkeit umrechnen
        print(f"  {i+1}. [{similarity:.3f}] {doc[:100]}...")
```

***

### Beispiel 3: RAG-Pipeline mit ChromaDB + OpenAI

```python
import chromadb
from chromadb.utils import embedding_functions
from openai import OpenAI

# Clients initialisieren
chroma_client = chromadb.HttpClient(host="<server-ip>", port=8000)
openai_client = OpenAI(api_key="your-openai-api-key")

# OpenAI-Embeddings verwenden
openai_ef = embedding_functions.OpenAIEmbeddingFunction(
    api_key="your-openai-api-key",
    model_name="text-embedding-3-small"
)

# Sammlung abrufen
collection = chroma_client.get_or_create_collection(
    name="knowledge_base",
    embedding_function=openai_ef
)

def add_to_knowledge_base(texts, ids=None, metadatas=None):
    """Dokumente zur ChromaDB-Wissensbasis hinzufügen."""
    if ids is None:
        ids = [f"doc_{i}" for i in range(len(texts))]
    collection.add(documents=texts, ids=ids, metadatas=metadatas or [{}]*len(texts))
    print(f"✓ {len(texts)} Dokumente hinzugefügt. Gesamt: {collection.count()}")

def rag_query(question, n_context=5):
    """Relevanten Kontext abrufen und mit GPT-4 eine Antwort generieren."""
    # 1. Relevante Dokumente abrufen
    results = collection.query(
        query_texts=[question],
        n_results=n_context,
        include=["documents", "distances"]
    )

    context_docs = results["documents"][0]
    distances = results["distances"][0]

    # 2. Kontext-String erstellen
    context = "\n\n".join([
        f"[Quelle {i+1} (Relevanz: {1-d:.2f})]: {doc}"
        for i, (doc, d) in enumerate(zip(context_docs, distances))
    ])

    # 3. Antwort mit LLM generieren
    messages = [
        {
            "role": "system",
            "content": "Sie sind ein hilfreicher Assistent. Beantworten Sie Fragen auf Grundlage des bereitgestellten Kontexts. Wenn die Antwort nicht im Kontext enthalten ist, sagen Sie das."
        },
        {
            "role": "user",
            "content": f"Kontext:\n{context}\n\nFrage: {question}"
        }
    ]

    response = openai_client.chat.completions.create(
        model="gpt-4-turbo",
        messages=messages,
        temperature=0.1
    )

    answer = response.choices[0].message.content

    return {
        "question": question,
        "answer": answer,
        "sources": context_docs,
        "relevance_scores": [1 - d for d in distances]
    }

# Beispielverwendung
knowledge = [
    "Clore.ai ist ein GPU-Cloud-Marktplatz mit über 45.000 Nutzern.",
    "Clore.ai unterstützt die Docker-basierte Bereitstellung von Workloads.",
    "GPU-Server auf Clore.ai reichen von GTX 1080 bis H100.",
    "Sie können KI-Anwendungen mit SSH-Zugriff und benutzerdefinierten Ports bereitstellen.",
]
add_to_knowledge_base(knowledge)

result = rag_query("Wie viele Nutzer hat Clore.ai?")
print(f"F: {result['question']}")
print(f"A: {result['answer']}")
```

***

### Beispiel 4: Dokumentenverwaltung mit mehreren Sammlungen

```python
import chromadb
from chromadb.utils import embedding_functions

client = chromadb.HttpClient(host="<server-ip>", port=8000)
embedding_fn = embedding_functions.SentenceTransformerEmbeddingFunction(
    model_name="all-mpnet-base-v2"  # Höherwertige Embeddings
)

# Separate Sammlungen für verschiedene Dokumenttypen erstellen
collections = {
    "technical_docs": client.get_or_create_collection("technical_docs", embedding_function=embedding_fn),
    "faq": client.get_or_create_collection("faq", embedding_function=embedding_fn),
    "blog_posts": client.get_or_create_collection("blog_posts", embedding_function=embedding_fn),
}

# Dokumente zu den jeweiligen Sammlungen hinzufügen
collections["technical_docs"].add(
    documents=["Docker-Bereitstellungsleitfaden für Clore.ai", "SSH-Konfiguration für GPU-Server"],
    ids=["tech_001", "tech_002"],
    metadatas=[{"type": "leitfaden", "version": "v2"}, {"type": "konfiguration"}]
)

collections["faq"].add(
    documents=["F: Wie bezahle ich? A: Per Kryptowährung.", "F: Welche GPUs? A: RTX bis H100."],
    ids=["faq_001", "faq_002"],
    metadatas=[{"category": "zahlung"}, {"category": "hardware"}]
)

# Über alle Sammlungen suchen
def search_all_collections(query, n_results=2):
    all_results = []
    for name, col in collections.items():
        results = col.query(query_texts=[query], n_results=n_results)
        for doc, dist in zip(results["documents"][0], results["distances"][0]):
            all_results.append({
                "collection": name,
                "document": doc,
                "similarity": 1 - dist
            })

    # Nach Relevanz sortieren
    all_results.sort(key=lambda x: x["similarity"], reverse=True)
    return all_results[:n_results * 2]

results = search_all_collections("Wie setze ich mit Docker bereit?")
for r in results:
    print(f"[{r['collection']}] ({r['similarity']:.3f}) {r['document'][:80]}...")
```

***

### Beispiel 5: Filterung und Metadatenabfragen

```python
import chromadb

client = chromadb.HttpClient(host="<server-ip>", port=8000)
collection = client.get_collection("technical_docs")

# Dokumente mit umfangreichen Metadaten hinzufügen
collection.add(
    documents=[
        "Leitfaden: PyTorch auf NVIDIA A100-GPU-Clustern ausführen",
        "Leitfaden: Verteiltes TensorFlow-Training auf RTX 4090",
        "Tutorial: LLM-Feinabstimmung mit LoRA auf GPU",
        "Referenz: Kompatibilitätsmatrix für CUDA 12.1",
        "Leitfaden: Docker-Netzwerk für Multi-GPU-Setups",
    ],
    ids=["d1", "d2", "d3", "d4", "d5"],
    metadatas=[
        {"type": "leitfaden", "gpu": "A100", "framework": "pytorch", "year": 2024},
        {"type": "leitfaden", "gpu": "RTX4090", "framework": "tensorflow", "year": 2024},
        {"type": "tutorial", "gpu": "beliebig", "framework": "transformers", "year": 2024},
        {"type": "referenz", "gpu": "beliebig", "framework": "cuda", "year": 2023},
        {"type": "leitfaden", "gpu": "mehrfach", "framework": "docker", "year": 2024},
    ]
)

# Mit Metadatenfilter abfragen
results = collection.query(
    query_texts=["GPU-Trainingsleitfaden"],
    n_results=3,
    where={"type": "leitfaden"},  # Nur Leitfäden zurückgeben
    include=["documents", "metadatas", "distances"]
)

print("Gefilterte Ergebnisse (type=leitfaden):")
for doc, meta, dist in zip(
    results["documents"][0],
    results["metadatas"][0],
    results["distances"][0]
):
    print(f"  [{1-dist:.3f}] {doc}")
    print(f"    Metadaten: {meta}")
```

***

## Konfiguration

### Docker Compose (Produktion)

```yaml
version: '3.8'

services:
  chromadb:
    image: chromadb/chroma:latest
    container_name: chromadb
    ports:
      - "8000:8000"
    volumes:
      - chromadb_data:/chroma/chroma
    environment:
      - IS_PERSISTENT=TRUE
      - ANONYMIZED_TELEMETRY=FALSE
      - CHROMA_SERVER_LOG_LEVEL=INFO
      - ALLOW_RESET=FALSE
      - CHROMA_SEGMENT_CACHE_POLICY=LRU
      - CHROMA_MEMORY_LIMIT_BYTES=2147483648  # 2 GB Cache
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8000/api/v1/heartbeat"]
      interval: 30s
      timeout: 10s
      retries: 3

volumes:
  chromadb_data:
    driver: local
```

### Referenz der Umgebungsvariablen

| Variable                      | Standard | Beschreibung                                       |
| ----------------------------- | -------- | -------------------------------------------------- |
| `IS_PERSISTENT`               | `FALSE`  | Permanenten Speicher aktivieren                    |
| `ANONYMIZED_TELEMETRY`        | `TRUE`   | Nutzungsverfolgung deaktivieren                    |
| `CHROMA_SERVER_LOG_LEVEL`     | `INFO`   | Protokollausführlichkeit                           |
| `CHROMA_MEMORY_LIMIT_BYTES`   | Keine    | Maximaler Speicher für den Segment-Cache           |
| `ALLOW_RESET`                 | `FALSE`  | Das Zurücksetzen aller Daten über die API zulassen |
| `CHROMA_SERVER_AUTH_PROVIDER` | Keine    | Klasse des Authentifizierungsanbieters             |

***

## Leistungstipps

### 1. Das richtige Embedding-Modell wählen

| Modell                   | Dimensionen | Geschwindigkeit | Qualität  | GPU erforderlich |
| ------------------------ | ----------- | --------------- | --------- | ---------------- |
| `all-MiniLM-L6-v2`       | 384         | Schnell         | Gut       | Nein             |
| `all-mpnet-base-v2`      | 768         | Mittel          | Besser    | Optional         |
| `text-embedding-3-small` | 1536        | Schnell         | Großartig | Nur API          |
| `BAAI/bge-large-en-v1.5` | 1024        | Mittel          | Am besten | Ja               |

### 2. Für Geschwindigkeit in Batches upserten

```python
# Für beste Leistung in Batches von 100–1000 hinzufügen
BATCH_SIZE = 500

for i in range(0, len(all_documents), BATCH_SIZE):
    batch = all_documents[i:i+BATCH_SIZE]
    collection.add(
        documents=[d["text"] for d in batch],
        ids=[d["id"] for d in batch],
        metadatas=[d["meta"] for d in batch]
    )
    print(f"Batch {i//BATCH_SIZE + 1} fertig")
```

### 3. HNSW-Index-Tuning

```python
collection = client.create_collection(
    name="optimized",
    metadata={
        "hnsw:space": "cosine",
        "hnsw:construction_ef": 200,  # Höher = bessere Indexqualität (langsamerer Aufbau)
        "hnsw:search_ef": 100,        # Höher = besserer Recall (langsamere Suche)
        "hnsw:M": 32,                 # Höher = besserer Recall (mehr Speicher)
    }
)
```

### 4. Persistenten Client für die lokale Verwendung

```python
# Für die Entwicklung direkt auf dem Clore.ai-Server
import chromadb

client = chromadb.PersistentClient(path="/workspace/chromadb/data")
# Kein Server nötig, schneller für die Verwendung in einem einzelnen Prozess
```

***

## Fehlerbehebung

### Problem: Keine Verbindung zu ChromaDB möglich

```bash
# Prüfen, ob der Container läuft
docker ps | grep chromadb

# Protokolle prüfen
docker logs chromadb --tail 20

# Von innerhalb des Containers testen
docker exec chromadb curl http://localhost:8000/api/v1/heartbeat
```

### Problem: Daten gehen beim Neustart des Containers verloren

```bash
# Sicherstellen, dass das Volume eingebunden ist
docker inspect chromadb | grep Mounts -A 10

# Mit explizitem Volume erneut ausführen
docker run -d -p 8000:8000 \
  -v /workspace/chromadb/data:/chroma/chroma \
  -e IS_PERSISTENT=TRUE \
  chromadb/chroma:latest
```

### Problem: Out-of-Memory-Fehler

```bash
# Speicher-Cache begrenzen
docker run -d -p 8000:8000 \
  -e CHROMA_MEMORY_LIMIT_BYTES=1073741824 \
  -v /workspace/chromadb/data:/chroma/chroma \
  chromadb/chroma:latest
```

### Problem: Langsame Embedding-Erzeugung

```bash
# Prüfen, ob die GPU für Embeddings verwendet wird
python3 -c "
import torch
from sentence_transformers import SentenceTransformer
model = SentenceTransformer('all-MiniLM-L6-v2', device='cuda')
print(f'Embedding-Modell auf: {model.device}')
"
```

### Problem: Sammlung nach Neustart nicht gefunden

```bash
# Überprüfen, dass die Persistenz aktiviert ist
curl http://localhost:8000/api/v1/collections
# Wenn leer, wurde IS_PERSISTENT nicht gesetzt oder das Volume wurde nicht eingehängt
```

***

## Links

* **GitHub**: <https://github.com/chroma-core/chroma>
* **Offizielle Dokumentation**: <https://docs.trychroma.com>
* **Docker Hub**: <https://hub.docker.com/r/chromadb/chroma>
* **PyPI**: <https://pypi.org/project/chromadb>
* **Discord**: <https://discord.gg/MMeYNTmh3x>
* **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/chromadb.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.