Weaviate

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.

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

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.

Étape 2 — Louer un serveur sur Clore.ai

1. Aller à 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) :

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 HuggingFace local (accéléré 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 d'accès GraphQL

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

Vérification de l'état

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

Via SSH

ssh root@<ip-serveur> -p 22

---

Client Python

Installation

pip install weaviate-client

Se connecter

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

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

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)

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

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

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

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

Recherche filtrée

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

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)

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

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

# 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

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.

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.

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.

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.

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 — base de données vectorielle en Rust avec filtres de payload

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

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