Weaviate

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.

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

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.

Étape 2 — Louer un serveur sur Clore.ai

1. Accédez à 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) :

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 :

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

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

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

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

Via SSH

ssh root@<server-ip> -p 22

---

Client Python

Installation

pip install weaviate-client

Connexion

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

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

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)

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

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

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

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

Recherche filtrée

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

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)

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

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

# 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

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.

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.

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.

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.

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 — base de données vectorielle basée sur Rust avec filtres de charge utile

• ChromaDB — base de données d’embeddings légère

• Milvus — 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 des serveurs GPU. Parcourez les GPU disponibles et louez à l'heure — sans engagement, accès root complet.