Weaviate

Weaviate ist eine KI-native, Open-Source-Vektordatenbank, die für semantische Suche, Hybridsuche und RAG-(Retrieval-Augmented Generation)-Anwendungen entwickelt wurde. Sie speichert sowohl Objekte als auch deren Vektor-Embeddings und unterstützt die integrierte ML-Modellintegration.

Überblick

Weaviate geht über traditionelle Vektordatenbanken hinaus, indem es ML-Modelle nativ für die automatische Vektorisierung beim Import und zur Abfragezeit integriert. Es unterstützt mehrere Datentypen (Text, Bilder, Video, Audio), integrierte Hybridsuche, die BM25 und Vektorähnlichkeit kombiniert, sowie Multi-Tenant-Bereitstellungen. Weaviate ist produktionsreif, cloud-nativ und darauf ausgelegt, von Prototypen bis zu Milliarden von Vektoren zu skalieren.

Eigenschaft	Wert
Kategorie	Vektordatenbank / RAG-Infrastruktur
Entwickler	Weaviate B.V.
Lizenz	BSD 3-Klausel
GitHub	weaviate/weaviate
Sterne	12K+
Docker-Image	cr.weaviate.io/semitechnologies/weaviate
Ports	22 (SSH), 8080 (HTTP-API / GraphQL)

---

Hauptfunktionen

• Vektor- und Schlüsselwort-Hybridsuche — kombiniert BM25-Volltext mit Vektorähnlichkeit in einer Abfrage

• Integrierte Vektorisierer — Daten beim Import automatisch mit OpenAI, Cohere, HuggingFace oder lokalen Modellen vektorisieren

• Multimodal — Text, Bilder, Video und Audio in einer Datenbank speichern und durchsuchen

• GraphQL-API — ausdrucksstarke Abfragesprache für komplexe semantische Abfragen

• REST-API — vollständige CRUD-Operationen und Schemaverwaltung

• Multi-Tenancy — Daten pro Mandant mit geteilter Infrastruktur isolieren

• HNSW-Indexierung — schnelle, approximative Suche nach den nächsten Nachbarn

• Gefilterte Suche — Vektorsuche mit traditionellen Metadatenfiltern kombinieren

• Generative Suche — integriertes RAG mit LLM-Integration

• Horizontale Skalierung — Shards über mehrere Knoten verteilen und replizieren

• Modulsystem — Vektorisierer, Reader und Generatoren einbinden

---

Clore.ai-Einrichtung

Schritt 1 — Hardware wählen

Anwendungsfall	Empfohlen	RAM	Speicher
Entwicklung / Prototyping	CPU-Instanz	8 GB	20 GB
Kleine Produktion (< 1 Mio. Vektoren)	CPU-Instanz	16 GB	50 GB
Große Skalierung (10 Mio.+ Vektoren)	GPU-Instanz	32 GB+	200 GB+
GPU-beschleunigte Vektorisierung	RTX 4090	24 GB	100 GB

Weaviate selbst läuft auf der CPU. Verwende GPU-Instanzen auf Clore.ai, wenn du ein lokales Embedding-Modell Inferenz (z. B. text2vec-transformers mit einem lokalen Modell) für schnelle Vektorisierung beim Import.

Schritt 2 — Mieten Sie einen Server auf Clore.ai

1. Gehe zu clore.ai → Marktplatz

2. Für reine Vektorsuche: CPU-Instanzen mit ≥ 16 GB RAM

3. Für GPU-beschleunigte Embeddings: RTX 3090 oder 4090

4. Ports öffnen: 22 und 8080

5. Stelle sicher >= 50 GB Festplattenspeicher für Vektorspeicherung

Schritt 3 — Mit Docker bereitstellen

Minimales Deployment (ohne Vektorisierer):

docker run -d \
    --name weaviate \\
    -p 8080:8080 \
    -p 50051:50051 \\
    -v /opt/weaviate/data:/var/lib/weaviate \\
    -e QUERY_DEFAULTS_LIMIT=20 \\
    -e AUTHENTICATION_ANONYMOUS_ACCESS_ENABLED=true \\
    -e PERSISTENCE_DATA_PATH=/var/lib/weaviate \\
    -e DEFAULT_VECTORIZER_MODULE=none \\
    -e ENABLE_MODULES="" \\
    -e CLUSTER_HOSTNAME=node1 \\
    cr.weaviate.io/semitechnologies/weaviate:latest

Mit OpenAI-Vektorisierer:

docker run -d \
    --name weaviate \\
    -p 8080:8080 \
    -v /opt/weaviate/data:/var/lib/weaviate \\
    -e QUERY_DEFAULTS_LIMIT=20 \\
    -e AUTHENTICATION_ANONYMOUS_ACCESS_ENABLED=true \\
    -e PERSISTENCE_DATA_PATH=/var/lib/weaviate \\
    -e DEFAULT_VECTORIZER_MODULE=text2vec-openai \\
    -e ENABLE_MODULES=text2vec-openai,generative-openai \\
    -e OPENAI_APIKEY=<dein-openai-schlüssel> \\
    -e CLUSTER_HOSTNAME=node1 \\
    cr.weaviate.io/semitechnologies/weaviate:latest

Mit lokalem HuggingFace-Vektorisierer (GPU-beschleunigt):

# docker-compose.yml
version: '3.4'

services:
  weaviate:
    image: cr.weaviate.io/semitechnologies/weaviate:latest
    restart: unless-stopped
    ports:
      - "8080:8080"
      - "50051:50051"
    volumes:
      - /opt/weaviate/data:/var/lib/weaviate
    environment:
      QUERY_DEFAULTS_LIMIT: 20
      AUTHENTICATION_ANONYMOUS_ACCESS_ENABLED: 'true'
      PERSISTENCE_DATA_PATH: '/var/lib/weaviate'
      DEFAULT_VECTORIZER_MODULE: text2vec-transformers
      ENABLE_MODULES: 'text2vec-transformers,generative-openai'
      TRANSFORMERS_INFERENCE_API: 'http://t2v-transformers:8080'
      CLUSTER_HOSTNAME: 'node1'

  t2v-transformers:
    image: cr.weaviate.io/semitechnologies/transformers-inference:sentence-transformers-multi-qa-MiniLM-L6-cos-v1
    environment:
      ENABLE_CUDA: '1'
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]

Starten:

mkdir -p /opt/weaviate/data
docker-compose up -d

---

Auf die API zugreifen

HTTP-/REST-API

http://<server-ip>:8080

GraphQL-Endpunkt

http://<server-ip>:8080/v1/graphql

Health-Check

curl http://<server-ip>:8080/v1/.well-known/ready
# Gibt zurück: {}  (HTTP 200 = gesund)

Per SSH

ssh root@<server-ip> -p 22

---

Python-Client

Installation

pip install weaviate-client

Verbinden

import weaviate
import weaviate.classes as wvc

# Verbinde dich mit deiner Clore.ai-Instanz
client = weaviate.connect_to_custom(
    http_host="<server-ip>",
    http_port=8080,
    http_secure=False,
    grpc_host="<server-ip>",
    grpc_port=50051,
    grpc_secure=False,
)

print(client.is_ready())  # True, wenn gesund

---

Schema & Sammlungen

Eine Sammlung erstellen

import weaviate
import weaviate.classes as wvc
from weaviate.classes.config import Configure, Property, DataType

client = weaviate.connect_to_custom(
    http_host="<server-ip>", http_port=8080,
    grpc_host="<server-ip>", grpc_port=50051,
    http_secure=False, grpc_secure=False,
)

# Erstelle eine Sammlung (in v3 „class“ genannt)
client.collections.create(
    name="Article",
    vectorizer_config=Configure.Vectorizer.none(),  # Wir stellen unsere eigenen Vektoren bereit
    # Oder: Configure.Vectorizer.text2vec_openai() für automatische Vektorisierung
    properties=[
        Property(name="title", data_type=DataType.TEXT),
        Property(name="content", data_type=DataType.TEXT),
        Property(name="author", data_type=DataType.TEXT),
        Property(name="published_date", data_type=DataType.DATE),
        Property(name="tags", data_type=DataType.TEXT_ARRAY),
        Property(name="view_count", data_type=DataType.INT),
    ],
)
print("Sammlung 'Article' erstellt")

---

Daten importieren

Batch-Import mit vorab berechneten Vektoren

import weaviate
import numpy as np
from sentence_transformers import SentenceTransformer

client = weaviate.connect_to_custom(
    http_host="<server-ip>", http_port=8080,
    grpc_host="<server-ip>", grpc_port=50051,
    http_secure=False, grpc_secure=False,
)

# Embedding-Modell laden
encoder = SentenceTransformer("all-MiniLM-L6-v2")

# Beispielartikel
articles = [
    {"title": "Einführung in RAG", "content": "RAG kombiniert Retrieval mit Generierung..."},
    {"title": "Vektordatenbanken erklärt", "content": "Vektordatenbanken speichern hochdimensionale Embeddings..."},
    {"title": "Bewährte Methoden für Weaviate", "content": "Für produktive Weaviate-Bereitstellungen solltest du berücksichtigen..."},
    {"title": "GPU-Cloud-Computing", "content": "Clore.ai bietet dezentralen GPU-Zugriff..."},
]

# Batch-Import mit Vektoren
collection = client.collections.get("Article")

with collection.batch.dynamic() as batch:
    for article in articles:
        # Vektor berechnen
        vector = encoder.encode(article["content"]).tolist()

        batch.add_object(
            properties={
                "title": article["title"],
                "content": article["content"],
            },
            vector=vector,
        )

print(f"{len(articles)} Artikel importiert")

Mit OpenAI automatisch vektorisieren (beim Import)

# Wenn die Sammlung den text2vec-openai-Vektorisierer verwendet,
# einfach Daten einfügen — kein Vektor erforderlich
collection = client.collections.get("ArticleOpenAI")

with collection.batch.dynamic() as batch:
    for article in articles:
        batch.add_object(
            properties={
                "title": article["title"],
                "content": article["content"],
            }
            # Kein Vektor = Weaviate vektorisiert automatisch über OpenAI
        )

---

Abfragen

Semantische (Vektor-)Suche

# Finde Artikel, die einer Abfrage semantisch ähneln
results = collection.query.near_text(
    query="Wie speichert man Embeddings effizient",
    limit=5,
    return_properties=["title", "content"],
    return_metadata=wvc.query.MetadataQuery(distance=True),
)

for obj in results.objects:
    print(f"Titel: {obj.properties['title']}")
    print(f"Distanz: {obj.metadata.distance:.4f}")
    print()

Hybridsuche (Vektor + BM25)

# Semantische und Schlüsselwortsuche kombinieren
results = collection.query.hybrid(
    query="RAG Retrieval-erweiterte Generierung",
    alpha=0.5,  # 0.0 = nur BM25, 1.0 = nur Vektor, 0.5 = ausgewogen
    limit=5,
    return_properties=["title", "content"],
    return_metadata=wvc.query.MetadataQuery(score=True),
)

for obj in results.objects:
    print(f"Titel: {obj.properties['title']}")
    print(f"Hybrider Score: {obj.metadata.score:.4f}")

Schlüsselwortsuche (BM25)

results = collection.query.bm25(
    query="Indexierung von Vektordatenbanken",
    limit=5,
    return_properties=["title"],
)

Gefilterte Suche

from weaviate.classes.query import Filter

# Vektorsuche mit Metadatenfilter kombinieren
results = collection.query.near_text(
    query="Training für maschinelles Lernen",
    limit=10,
    filters=Filter.by_property("view_count").greater_than(1000),
    return_properties=["title", "view_count"],
)

GraphQL-Abfrage

import requests

query = """
{
    Get {
        Article(
            nearText: {concepts: ["künstliche Intelligenz"]}
            limit: 5
        ) {
            title
            content
            _additional {
                distance
                id
            }
        }
    }
}
"""

response = requests.post(
    "http://<server-ip>:8080/v1/graphql",
    json={"query": query},
)
data = response.json()
for article in data["data"]["Get"]["Article"]:
    print(article["title"])

---

Generative Suche (RAG)

from weaviate.classes.generate import GenerateOptions

# Sammlung mit generativem Modul einrichten (OpenAI)
# Erfordert ENABLE_MODULES=generative-openai

results = collection.generate.near_text(
    query="Wie baut man ein RAG-System",
    limit=3,
    grouped_task="Fasse diese Artikel zusammen und erkläre die wichtigsten Schritte zum Aufbau eines RAG-Systems.",
    grouped_properties=["title", "content"],
)

print("RAG-Antwort:")
print(results.generated)
print("\nQuellartikel:")
for obj in results.objects:
    print(f"  - {obj.properties['title']}")

---

Multi-Tenancy

from weaviate.classes.config import Configure

# Multi-Tenant-Sammlung erstellen
client.collections.create(
    name="UserDocuments",
    multi_tenancy_config=Configure.multi_tenancy(enabled=True),
    properties=[
        Property(name="content", data_type=DataType.TEXT),
        Property(name="filename", data_type=DataType.TEXT),
    ],
)

# Mandanten erstellen
collection = client.collections.get("UserDocuments")
collection.tenants.create([
    wvc.config.Tenant(name="user_alice"),
    wvc.config.Tenant(name="user_bob"),
])

# Daten für einen bestimmten Mandanten einfügen
tenant_collection = collection.with_tenant("user_alice")
tenant_collection.data.insert({"content": "Alices privates Dokument", "filename": "doc1.pdf"})

# Innerhalb des Mandanten abfragen
results = collection.with_tenant("user_alice").query.near_text(
    query="privates Dokument",
    limit=5,
)

---

REST-API-Beispiele

# Schema-Klasse erstellen
curl -X POST http://<server-ip>:8080/v1/schema \\
    -H "Content-Type: application/json" \\
    -d '{
        "class": "Product",
        "vectorizer": "none",
        "properties": [
            {"name": "name", "dataType": ["text"]},
            {"name": "description", "dataType": ["text"]},
            {"name": "price", "dataType": ["number"]}
        ]
    }'

# Objekt mit Vektor hinzufügen
curl -X POST http://<server-ip>:8080/v1/objects \\
    -H "Content-Type: application/json" \\
    -d '{
        "class": "Product",
        "properties": {
            "name": "GPU-Cloud-Zugang",
            "description": "Dezentraler GPU-Marktplatz",
            "price": 0.5
        },
        "vector": [0.1, 0.2, 0.3, ...]
    }'

# Vektorsuche
curl http://<server-ip>:8080/v1/objects?class=Product&limit=5

# Gesundheitsprüfung
curl http://<server-ip>:8080/v1/.well-known/ready

---

Fehlerbehebung

Weaviate startet nicht — Speicherplatz prüfen (df -h). Weaviate benötigt beschreibbaren Speicherplatz im Datenpfad. Prüfe außerdem, ob Port 8080 in den Clore.ai-Einstellungen geöffnet ist.

Langsamer Import — Batch-Import aktivieren (collection.batch.dynamic() oder fixed_size()). Vermeide Einzelobjekt-Importe für große Datensätze. Eine Batch-Größe von 100–500 ist optimal.

Hoher Speicherverbrauch — Weaviate hält den Vektorindex für schnelle Suche im RAM. Für 1 Mio. Vektoren mit 768 Dimensionen: ~6 GB RAM. Plane entsprechend bei der Wahl der Clore.ai-Instanzgröße.

Verbindung über Python-Client nicht möglich — Stelle sicher, dass sowohl Port 8080 (HTTP) als auch Port 50051 (gRPC) geöffnet sind. Der Python-Client v4 verwendet standardmäßig gRPC.

Problem	Fix
Verbindung abgelehnt	Auf den Start warten (~30 Sek.), prüfen docker ps, Ports überprüfen
Schema existiert bereits	Sammlung zuerst löschen: client.collections.delete("Name")
Nicht genügend Speicher	RAM erhöhen oder Vektordimensionen reduzieren
Langsame Vektorsuche	HNSW-Index hinzufügen oder Datensatzgröße mit verfügbarem RAM vergleichen

---

Leistungstipps

1. Batch-Importe verwenden — 10x–50x schneller als einzelne Einfügungen

2. Das richtige Embedding-Modell wählen — all-MiniLM-L6-v2 (384 Dimensionen) ist schnell; text-embedding-3-large (3072 Dimensionen) bietet die beste Qualität, benötigt aber 8x mehr RAM

3. Alpha der Hybridsuche — anpassen alpha für deinen Anwendungsfall: 0,25 für keywordlastige Abfragen, 0,75 für semantische Abfragen

4. HNSW-Parameter — ef und efConstruction steuern den Kompromiss zwischen Recall und Geschwindigkeit

5. Mandantenisolierung — verwende Multi-Tenancy für SaaS-Apps; sie skaliert viel besser als separate Sammlungen pro Benutzer

---

Verwandte Tools

• Qdrant — Rust-basierte Vektordatenbank mit Payload-Filtern

• ChromaDB — leichte Embeddings-Datenbank

• Milvus — Vektordatenbank für große Skalierung

---

Weaviate auf Clore.ai bietet dir eine produktionsreife Vektordatenbank mit GPU-beschleunigter Vektorisierung — ideal für den Aufbau skalierbarer RAG-Systeme und semantischer Suchanwendungen.

---

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
Produktions-Vektorsuche	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.