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

# Weaviate

{% hint style="info" %}
**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.
{% endhint %}

## Ü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](https://github.com/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   |

{% hint style="info" %}
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.
{% endhint %}

### Schritt 2 — Mieten Sie einen Server auf Clore.ai

1. Gehe zu [clore.ai](https://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):**

```bash
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:**

```bash
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):**

```yaml
# 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:

```bash
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

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

### Per SSH

```bash
ssh root@<server-ip> -p 22
```

***

## Python-Client

### Installation

```bash
pip install weaviate-client
```

### Verbinden

```python
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

```python
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

```python
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)

```python
# 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

```python
# 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)

```python
# 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)

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

### Gefilterte Suche

```python
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

```python
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)

```python
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

```python
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

```bash
# 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

{% hint style="warning" %}
**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.
{% endhint %}

{% hint style="warning" %}
**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.
{% endhint %}

{% hint style="info" %}
**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.
{% endhint %}

{% hint style="info" %}
**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.
{% endhint %}

| 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](/guides/guides_v2-de/rag-and-vektordatenbanken/qdrant.md) — Rust-basierte Vektor-Datenbank mit Payload-Filtern
* [ChromaDB](/guides/guides_v2-de/rag-and-vektordatenbanken/chromadb.md) — leichtgewichtige Embeddings-Datenbank
* [Milvus](/guides/guides_v2-de/rag-and-vektordatenbanken/milvus.md) — 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](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/weaviate.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.