Weaviate

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

Übersicht

Weaviate geht über traditionelle Vektor-Datenbanken 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), eingebaute hybride Suche, die BM25 und Vektorähnlichkeit kombiniert, und Multi-Tenant-Deployments. Weaviate ist produktionsbereit, cloud-nativ und so konzipiert, dass es von Prototypen bis zu Milliarden von Vektoren skaliert.

Eigenschaft	Wert
Kategorie	Vektor-Datenbank / 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- + Schlüsselwort-hybride Suche — BM25-Volltext mit Vektorähnlichkeit in einer Abfrage kombinieren

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

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

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

• REST-API — vollständige CRUD-Operationen und Schema-Verwaltung

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

• HNSW-Indexierung — schnelle approximative k-nächste-Nachbarn-Suche

• Gefilterte Suche — Vektorsuche mit traditionellen Metadatenfiltern kombinieren

• Generative Suche — eingebaute RAG mit LLM-Integration

• Horizontale Skalierung — über mehrere Knoten sharden und replizieren

• Modul-System — Vektorisierer, Reader, Generatoren einstecken

---

Clore.ai Setup

Schritt 1 — Hardware auswählen

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

Weaviate selbst läuft auf der CPU. Verwenden Sie GPU-Instanzen auf Clore.ai, wenn Sie benötigen lokales Embedding-Modell Inference (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. Offene Ports: 22 und 8080

5. Stellen Sie sicher ≥ 50 GB Festplatte für Vektorspeicherung

Schritt 3 — Deployment mit Docker

Minimales Deployment (kein 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=<your-openai-key> \
    -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]

Start:

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

---

Zugriff auf die API

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

# Mit Ihrer Clore.ai-Instanz verbinden
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 & Collections

Erstellen einer Collection

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 Collection (wurde in v3 "class" genannt)
client.collections.create(
    name="Article",
    vectorizer_config=Configure.Vectorizer.none(),  # Wir liefern unsere eigenen Vektoren
    # 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("Collection '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")

# Beispiel-Artikel
articles = [
    {"title": "Introduction to RAG", "content": "RAG kombiniert Retrieval mit Generation..."},
    {"title": "Vector Databases Explained", "content": "Vektor-Datenbanken speichern hochdimensionale Embeddings..."},
    {"title": "Weaviate Best Practices", "content": "Für Weaviate-Produktions-Deployments sollten Sie in Betracht ziehen..."},
    {"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")

Automatische Vektorisierung mit OpenAI (beim Import)

# Wenn die Collection den text2vec-openai Vektorisierer verwendet,
# einfach Daten einfügen — kein Vektor nötig
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 via OpenAI
        )

---

Abfragen

Semantische (Vektor-)Suche

# Finde Artikel, die semantisch einer Abfrage ähnlich sind
results = collection.query.near_text(
    query="how to store embeddings efficiently",
    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()

Hybride Suche (Vektor + BM25)

# Semantische und Schlüsselwortsuche kombinieren
results = collection.query.hybrid(
    query="RAG retrieval augmented generation",
    alpha=0.5,  # 0.0 = reines BM25, 1.0 = reines Vektor, 0.5 = ausgeglichen
    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"Hybrid-Score: {obj.metadata.score:.4f}")

Schlüsselwortsuche (BM25)

results = collection.query.bm25(
    query="vector database indexing",
    limit=5,
    return_properties=["title"],
)

Gefilterte Suche

from weaviate.classes.query import Filter

# Vektorsuche mit Metadatenfilter kombinieren
results = collection.query.near_text(
    query="machine learning training",
    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: ["artificial intelligence"]}
            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

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

results = collection.generate.near_text(
    query="how to build a 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-Collection 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"})

# Abfrage innerhalb eines Mandanten
results = collection.with_tenant("user_alice").query.near_text(
    query="private document",
    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 Access",
            "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

# Health-Check
curl http://<server-ip>:8080/v1/.well-known/ready

---

Fehlerbehebung

Weaviate startet nicht — Festplattenplatz überprüfen (df -h). Weaviate benötigt schreibbaren Platz im Datenpfad. Prüfen Sie außerdem, ob Port 8080 in den Clore.ai-Einstellungen geöffnet ist.

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

Hoher Speicherverbrauch — Weaviate hält den Vektorindex im RAM für schnelle Suche. Für 1M 768-dim Vektoren: ~6 GB RAM. Planen Sie entsprechend bei der Auswahl der Clore.ai-Instanzgröße.

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

Problem	Lösung
Verbindung abgelehnt	Warten Sie auf den Start (~30 Sek.), prüfen Sie docker ps, überprüfen Sie die Ports
Schema existiert bereits	Collection zuerst löschen: client.collections.delete("Name")
Speicher erschöpft	RAM erhöhen oder Vektordimensionen reduzieren
Langsame Vektorsuche	HNSW-Index hinzufügen oder Dataset-Größe vs. verfügbarem RAM prüfen

---

Leistungs-Tipps

1. Batch-Imports verwenden — 10x–50x schneller als Einzelinserts

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

3. Hybrid-Search Alpha — abstimmen alpha für Ihren Anwendungsfall: 0.25 für keyword-lastige Abfragen, 0.75 für semantische Abfragen

4. HNSW-Parameter — ef und efConstruction steuern Recall vs. Geschwindigkeits-Kompromiss

5. Mandanten-Isolierung — Multi-Tenancy für SaaS-Apps verwenden; skaliert deutlich besser als separate Collections pro Benutzer

---

Verwandte Tools

• Qdrant — Rust-basierte Vektor-Datenbank mit Payload-Filtern

• ChromaDB — leichtgewichtige Embeddings-Datenbank

• Milvus — hochskalierbare Vektor-Datenbank

---

Weaviate auf Clore.ai bietet Ihnen eine produktionsreife Vektor-Datenbank mit GPU-beschleunigter Vektorisierung — ideal zum Aufbau skalierbarer RAG-Systeme und semantischer Suchanwendungen.

---

Clore.ai GPU-Empfehlungen

Anwendungsfall	Empfohlene GPU	Geschätzte Kosten auf Clore.ai
Entwicklung/Tests	RTX 3090 (24GB)	~$0.12/gpu/hr
Produktionsfähige Vektorsuche	RTX 3090 (24GB)	~$0.12/gpu/hr
Hochdurchsatz-Embedding	RTX 4090 (24GB)	~$0.70/gpu/hr

💡 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.