> 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 à l’IA, conçue pour la recherche sémantique, la recherche hybride et les applications RAG (génération augmentée par récupération). Elle stocke à la fois des objets et leurs embeddings vectoriels et prend en charge l’intégration native de modèles de ML.
{% endhint %}

## Aperçu

Weaviate va au-delà des bases de données vectorielles traditionnelles en intégrant nativement des modèles de ML pour la vectorisation automatique à l’importation et au moment de la requête. Il prend en charge plusieurs types de données (texte, images, vidéo, audio), la recherche hybride intégrée combinant BM25 et la similarité vectorielle, ainsi que les déploiements multi-locataires. Weaviate est prêt pour la production, natif du cloud, et conçu pour passer de 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)                       |

***

## Caractéristiques clés

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

***

## Configuration de 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 (< 1 M de vecteurs) | Instance CPU | 16 Go  | 50 Go    |
| Grande échelle (10 M+ de vecteurs)    | Instance GPU | 32 Go+ | 200 Go+  |
| Vectorisation accélérée par GPU       | RTX 4090     | 24 Go  | 100 Go   |

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

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

1. Accédez à [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. Ouvrir les ports : **22** et **8080**
5. Assurez-vous que **≥ 50 Go de disque** pour le stockage des vecteurs

### É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 local HuggingFace (accéléré par 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 de terminaison GraphQL

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

### Vérification d’état

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

### Via SSH

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

***

## Client Python

### Installation

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

### Connexion

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

# Connectez-vous à 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())  # Vrai si le service est sain
```

***

## Schéma et 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")
```

***

## Importation des données

### Importation par lots 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 à RAG", "content": "RAG combine la récupération avec la génération..."},
    {"title": "Explication des bases de données vectorielles", "content": "Les bases de données vectorielles stockent des embeddings de haute dimension..."},
    {"title": "Bonnes pratiques Weaviate", "content": "Pour les déploiements Weaviate en production, envisagez..."},
    {"title": "Informatique cloud GPU", "content": "Clore.ai fournit un accès décentralisé aux GPU..."},
]

# Importation par lots 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"{len(articles)} articles importés")
```

### Vectorisation automatique avec OpenAI (à l’import)

```python
# Lorsque la collection utilise le vectoriseur text2vec-openai,
# insérez simplement les données — aucun vecteur n’est nécessaire
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"],
            }
            # Aucun vecteur = Weaviate vectorise automatiquement via OpenAI
        )
```

***

## Interrogation

### Recherche sémantique (vectorielle)

```python
# Trouver des articles sémantiquement similaires à une requête
results = collection.query.near_text(
    query="comment stocker efficacement les embeddings",
    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
# Combinez la recherche sémantique et par mots-clés
results = collection.query.hybrid(
    query="RAG génération augmentée par récupération",
    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 mots-clés (BM25)

```python
results = collection.query.bm25(
    query="indexation de base de données vectorielle",
    limit=5,
    return_properties=["title"],
)
```

### Recherche filtrée

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

# Combinez la recherche vectorielle avec un filtre de métadonnées
results = collection.query.near_text(
    query="entraînement en apprentissage automatique",
    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: ["intelligence artificielle"]}
            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="comment construire un système RAG",
    limit=3,
    grouped_task="Résumez ces articles et expliquez les étapes clés pour construire un système RAG.",
    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-tenant

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

# Créer une collection multi-tenant
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": "Document privé d’Alice", "filename": "doc1.pdf"})

# Requête au sein du locataire
results = collection.with_tenant("user_alice").query.near_text(
    query="document privé",
    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": "Accès au cloud GPU",
            "description": "Place de marché GPU décentralisée",
            "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 santé
curl http://<server-ip>:8080/v1/.well-known/ready
```

***

## Dépannage

{% hint style="warning" %}
**Weaviate ne démarre pas** — Vérifiez 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 de Clore.ai.
{% endhint %}

{% hint style="warning" %}
**Importation lente** — Activez l’importation par lots (`collection.batch.dynamic()` ou `fixed_size()`). Évitez les imports objet par objet pour les grands jeux de données. Une taille de lot de 100 à 500 est optimale.
{% endhint %}

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

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

| Problème                    | Correctif                                                                                     |
| --------------------------- | --------------------------------------------------------------------------------------------- |
| `Connexion refusée`         | Attendez le démarrage (\~30 s), vérifiez `docker ps`, vérifiez les ports                      |
| `Le schéma existe déjà`     | Supprimez d’abord la collection : `client.collections.delete("Name")`                         |
| `Mémoire insuffisante`      | Augmentez la RAM ou réduisez les dimensions des vecteurs                                      |
| Recherche vectorielle lente | Ajoutez un index HNSW ou vérifiez la taille du jeu de données par rapport à la RAM disponible |

***

## Conseils de performance

1. **Utilisez des imports par lots** — 10 à 50 fois plus rapide que les insertions unitaires
2. **Choisissez le bon modèle d’embeddings** — `all-MiniLM-L6-v2` (384 dimensions) est rapide ; `text-embedding-3-large` (3072 dimensions) offre la meilleure qualité mais utilise 8 fois plus de RAM
3. **Alpha de la recherche hybride** — ajustez `alpha` pour votre cas d’usage : 0,25 pour les requêtes axées sur les mots-clés, 0,75 pour les requêtes sémantiques
4. **Paramètres HNSW** — `ef` et `efConstruction` contrôlent le compromis entre rappel et vitesse
5. **Isolation des locataires** — utilisez le multi-tenant pour les applications SaaS ; cela évolue beaucoup mieux que des collections séparées par utilisateur

***

## Outils associés

* [Qdrant](/guides/guides_v2-fr/rag-et-bases-de-donnees-vectorielles/qdrant.md) — base de données vectorielle basée sur Rust avec filtres de charge utile
* [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 à grande échelle

***

*Weaviate sur Clore.ai vous offre une base de données vectorielle de niveau production avec vectorisation accélérée par GPU — idéale pour créer 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 (24 Go) | 0,07–0,21 $/gpu/h        |
| Recherche vectorielle de production | RTX 3090 (24 Go) | 0,07–0,21 $/gpu/h        |
| Embeddings à haut débit             | RTX 4090 (24 Go) | 0,14–0,42 $/gpu/h        |

> 💡 Tous les exemples de ce guide peuvent être déployés sur [Clore.ai](https://clore.ai/marketplace) des serveurs GPU. Parcourez les GPU disponibles et louez à l'heure — sans engagement, 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, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-fr/rag-et-bases-de-donnees-vectorielles/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.