> 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-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.
{% endhint %}

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

{% hint style="info" %}
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.
{% 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. Ports öffnen: **22** und **8080**
5. Stelle sicher **>= 50 GB Festplattenspeicher** für Vektorspeicherung

### Schritt 3 — Mit Docker bereitstellen

**Minimales Deployment (ohne 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=<dein-openai-schlüssel> \\
    -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]
```

Starten:

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

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

# 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

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

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

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

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

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

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

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

### Gefilterte Suche

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

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

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

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

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

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

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

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

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

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