> 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-fr/rag-et-bases-de-donnees-vectorielles/weaviate.md).

# Weaviate

{% hint style="info" %}
**Weaviate** est une base de données vectorielle open-source native pour l'IA, conçue pour la recherche sémantique, la recherche hybride et les applications RAG (Retrieval-Augmented Generation). Elle stocke à la fois des objets et leurs embeddings vectoriels et prend en charge l'intégration de modèles ML intégrés.
{% endhint %}

## Aperçu

Weaviate va au-delà des bases de données vectorielles traditionnelles en intégrant nativement des modèles ML pour la vectorisation automatique lors de l'importation et au moment des requêtes. Il prend en charge plusieurs types de données (texte, images, vidéo, audio), une recherche hybride intégrée combinant BM25 et similarité vectorielle, et des déploiements multi-locataires. Weaviate est prêt pour la production, cloud-native, et conçu pour évoluer des prototypes à des milliards de vecteurs.

| Propriété        | Valeur                                                    |
| ---------------- | --------------------------------------------------------- |
| **Catégorie**    | Base de données vectorielle / infrastructure RAG          |
| **Développeur**  | Weaviate B.V.                                             |
| **Licence**      | BSD 3-Clause                                              |
| **GitHub**       | [weaviate/weaviate](https://github.com/weaviate/weaviate) |
| **Étoiles**      | 12K+                                                      |
| **Image Docker** | `cr.weaviate.io/semitechnologies/weaviate`                |
| **Ports**        | 22 (SSH), 8080 (API HTTP / GraphQL)                       |

***

## Fonctionnalités clés

* **Recherche hybride vecteur + mots-clés** — combiner BM25 full-text avec la similarité vectorielle dans une seule requête
* **Vectoriseurs intégrés** — vectoriser automatiquement les données à l'import avec OpenAI, Cohere, HuggingFace ou des modèles locaux
* **Multi-modal** — stocker et rechercher texte, images, vidéo, audio dans une seule base de données
* **API GraphQL** — langage de requête expressif pour des requêtes sémantiques complexes
* **API REST** — opérations CRUD complètes et gestion du schéma
* **Multi-locataires** — isoler les données par locataire avec une infrastructure partagée
* **Indexation HNSW** — recherche approximative de plus proches voisins rapide
* **Recherche filtrée** — combiner la recherche vectorielle avec des filtres de métadonnées traditionnels
* **Recherche générative** — RAG intégré avec intégration de LLM
* **Mise à l'échelle horizontale** — fragmenter et répliquer sur plusieurs nœuds
* **Système de modules** — brancher des vectoriseurs, lecteurs, générateurs

***

## Configuration Clore.ai

### Étape 1 — Choisir le matériel

| Cas d’utilisation                    | Recommandé   | RAM    | Stockage |
| ------------------------------------ | ------------ | ------ | -------- |
| Développement / prototypage          | Instance CPU | 8 Go   | 20 Go    |
| Petite production (< 1M de vecteurs) | Instance CPU | 16 Go  | 50 Go    |
| Grande échelle (10M+ vecteurs)       | Instance GPU | 32 Go+ | 200 Go+  |
| Vectorisation accélérée par GPU      | RTX 4090     | 24 Go  | 100 Go   |

{% hint style="info" %}
Weaviate lui-même fonctionne sur CPU. Utilisez des instances GPU sur Clore.ai lorsque vous avez besoin **de modèle d'embedding local** d'inférence (par ex., `text2vec-transformers` avec un modèle local) pour une vectorisation rapide au moment de l'importation.
{% endhint %}

### Étape 2 — Louer un serveur sur Clore.ai

1. Aller à [clore.ai](https://clore.ai) → **Place de marché**
2. Pour une recherche vectorielle pure : instances CPU avec **≥ 16 Go de RAM**
3. Pour des embeddings accélérés par GPU : **RTX 3090 ou 4090**
4. Ports ouverts : **22** et **8080**
5. Assurez-vous **≥ 50 Go de disque** pour le stockage vectoriel

### Étape 3 — Déployer avec Docker

**Déploiement minimal (sans vectoriseur) :**

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

**Avec le vectoriseur OpenAI :**

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

**Avec le vectoriseur HuggingFace local (accéléré GPU) :**

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

Démarrer :

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

***

## Accéder à l'API

### API HTTP/REST

```
http://<server-ip>:8080
```

### Point d'accès GraphQL

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

### Vérification de l'état

```bash
curl http://<server-ip>:8080/v1/.well-known/ready
# Renvoie : {}  (HTTP 200 = sain)
```

### Via SSH

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

***

## Client Python

### Installation

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

### Se connecter

```python
import weaviate
import weaviate.classes as wvc

# Se connecter à votre instance Clore.ai
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 si sain
```

***

## Schéma & Collections

### Créer une 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,
)

# Créer une collection (appelée « class » en v3)
client.collections.create(
    name="Article",
    vectorizer_config=Configure.Vectorizer.none(),  # Nous fournirons nos propres vecteurs
    # Ou : Configure.Vectorizer.text2vec_openai() pour la vectorisation automatique
    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' créée")
```

***

## Importer des données

### Import par lot avec vecteurs pré-calculés

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

# Charger le modèle d'embeddings
encoder = SentenceTransformer("all-MiniLM-L6-v2")

# Articles d'exemple
articles = [
    {"title": "Introduction to RAG", "content": "RAG combines retrieval with generation..."},
    {"title": "Vector Databases Explained", "content": "Vector databases store high-dimensional embeddings..."},
    {"title": "Weaviate Best Practices", "content": "For production Weaviate deployments, consider..."},
    {"title": "GPU Cloud Computing", "content": "Clore.ai provides decentralized GPU access..."},
]

# Import par lot avec vecteurs
collection = client.collections.get("Article")

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

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

print(f"Importé {len(articles)} articles")
```

### Vectoriser automatiquement avec OpenAI (à l'import)

```python
# Lorsque la collection utilise le vectoriseur text2vec-openai,
# il suffit d'insérer les données — aucun vecteur requis
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"],
            }
            # Pas de vecteur = Weaviate vectorise automatiquement via OpenAI
        )
```

***

## Requêtes

### Recherche sémantique (vectorielle)

```python
# Trouver des articles sémantiquement similaires à une requête
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"Titre : {obj.properties['title']}")
    print(f"Distance : {obj.metadata.distance:.4f}")
    print()
```

### Recherche hybride (Vecteur + BM25)

```python
# Combiner recherche sémantique et par mots-clés
results = collection.query.hybrid(
    query="RAG retrieval augmented generation",
    alpha=0.5,  # 0.0 = BM25 pur, 1.0 = vecteur pur, 0.5 = équilibré
    limit=5,
    return_properties=["title", "content"],
    return_metadata=wvc.query.MetadataQuery(score=True),
)

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

### Recherche par mot-clé (BM25)

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

### Recherche filtrée

```python
from weaviate.classes.query import Filter

# Combiner la recherche vectorielle avec un filtre de métadonnées
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"],
)
```

### Requête GraphQL

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

***

## Recherche générative (RAG)

```python
from weaviate.classes.generate import GenerateOptions

# Configurer la collection avec le module génératif (OpenAI)
# Nécessite ENABLE_MODULES=generative-openai

results = collection.generate.near_text(
    query="how to build a RAG system",
    limit=3,
    grouped_task="Summarize these articles and explain the key steps to build a RAG system.",
    grouped_properties=["title", "content"],
)

print("Réponse RAG :")
print(results.generated)
print("\nArticles sources :")
for obj in results.objects:
    print(f"  - {obj.properties['title']}")
```

***

## Multi-locataires

```python
from weaviate.classes.config import Configure

# Créer une collection multi-locataire
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),
    ],
)

# Créer des locataires
collection = client.collections.get("UserDocuments")
collection.tenants.create([
    wvc.config.Tenant(name="user_alice"),
    wvc.config.Tenant(name="user_bob"),
])

# Insérer des données pour un locataire spécifique
tenant_collection = collection.with_tenant("user_alice")
tenant_collection.data.insert({"content": "Alice's private document", "filename": "doc1.pdf"})

# Requêter au sein du locataire
results = collection.with_tenant("user_alice").query.near_text(
    query="private document",
    limit=5,
)
```

***

## Exemples d'API REST

```bash
# Créer une classe de schéma
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"]}
        ]
    }'

# Ajouter un objet avec vecteur
curl -X POST http://<server-ip>:8080/v1/objects \
    -H "Content-Type: application/json" \
    -d '{
        "class": "Product",
        "properties": {
            "name": "GPU Cloud Access",
            "description": "Decentralized GPU marketplace",
            "price": 0.5
        },
        "vector": [0.1, 0.2, 0.3, ...]
    }'

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

# Vérification de l'état
curl http://<server-ip>:8080/v1/.well-known/ready
```

***

## Dépannage

{% hint style="warning" %}
**Weaviate ne démarre pas** — Vérifier l'espace disque (`df -h`). Weaviate a besoin d'un espace inscriptible au chemin des données. Vérifiez également que le port 8080 est ouvert dans les paramètres Clore.ai.
{% endhint %}

{% hint style="warning" %}
**Import lent** — Activer l'import par lot (`collection.batch.dynamic()` ou `fixed_size()`). Éviter les importations objet par objet pour les grands jeux de données. Une taille de lot de 100–500 est optimale.
{% endhint %}

{% hint style="info" %}
**Utilisation élevée de la mémoire** — Weaviate conserve l'index vectoriel en RAM pour une recherche rapide. Pour 1M de vecteurs 768-dim : \~6 Go de RAM. Prévoir en conséquence lors du choix de la taille d'instance Clore.ai.
{% endhint %}

{% hint style="info" %}
**Impossible de se connecter via le client Python** — Assurer que les ports 8080 (HTTP) et 50051 (gRPC) sont ouverts. Le client Python v4 utilise gRPC par défaut.
{% endhint %}

| Problème                    | Correction                                                                                    |
| --------------------------- | --------------------------------------------------------------------------------------------- |
| `Connexion refusée`         | Attendre le démarrage (\~30 s), vérifier `docker ps`, vérifier les ports                      |
| `Le schéma existe déjà`     | Supprimer la collection d'abord : `client.collections.delete("Name")`                         |
| `Mémoire insuffisante`      | Augmenter la RAM ou réduire la dimension des vecteurs                                         |
| Recherche vectorielle lente | Ajouter un index HNSW ou vérifier la taille du jeu de données par rapport à la RAM disponible |

***

## Conseils de performance

1. **Utiliser des imports par lot** — 10x–50x plus rapide que les insertions uniques
2. **Choisir le bon modèle d'embedding** — `all-MiniLM-L6-v2` (384 dims) est rapide; `text-embedding-3-large` (3072 dims) offre la meilleure qualité mais utilise 8x plus de RAM
3. **Alpha de la recherche hybride** — ajuster `alpha` pour votre cas d'utilisation : 0.25 pour des requêtes axées mots-clés, 0.75 pour des requêtes sémantiques
4. **Paramètres HNSW** — `ef` et `efConstruction` contrôler le compromis rappel vs. vitesse
5. **Isolement des locataires** — utiliser la multi-location pour les applications SaaS ; cela évolue beaucoup mieux que des collections séparées par utilisateur

***

## Outils connexes

* [Qdrant](/guides/guides_v2-fr/rag-et-bases-de-donnees-vectorielles/qdrant.md) — base de données vectorielle en Rust avec filtres de payload
* [ChromaDB](/guides/guides_v2-fr/rag-et-bases-de-donnees-vectorielles/chromadb.md) — base de données d'embeddings légère
* [Milvus](/guides/guides_v2-fr/rag-et-bases-de-donnees-vectorielles/milvus.md) — base de données vectorielle haute échelle

***

*Weaviate sur Clore.ai vous offre une base de données vectorielle prête pour la production avec vectorisation accélérée par GPU — idéale pour construire des systèmes RAG évolutifs et des applications de recherche sémantique.*

***

## Recommandations GPU Clore.ai

| Cas d’utilisation                   | GPU recommandé  | Coût estimé sur Clore.ai |
| ----------------------------------- | --------------- | ------------------------ |
| Développement/Test                  | RTX 3090 (24GB) | \~$0.12/gpu/hr           |
| Recherche vectorielle en production | RTX 3090 (24GB) | \~$0.12/gpu/hr           |
| Embeddings à haut débit             | RTX 4090 (24GB) | \~$0.70/gpu/hr           |

> 💡 Tous les exemples de ce guide peuvent être déployés sur [Clore.ai](https://clore.ai/marketplace) serveurs GPU. Parcourez les GPU disponibles et louez à l’heure — sans engagement, avec accès root complet.


---

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

```
GET https://docs.clore.ai/guides/guides_v2-fr/rag-et-bases-de-donnees-vectorielles/weaviate.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
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.