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

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

---

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

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.

---

Schnellbereitstellung auf CLORE.AI

1. Finden Sie einen geeigneten Server

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

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

3. Bereitstellung testen

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

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

Schritt 2: Datenverzeichnis erstellen

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

Schritt 3: ChromaDB-Container ausführen

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

# 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

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

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

# 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

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

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

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

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

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)

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

# 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

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

# 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

# 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

# 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

# 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

# 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

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