Vous voulez ajouter à votre appli IA des fonctions de « recherche d'images par texte », « recherche sémantique » ou « recommandation par similarité » ? Votre premier réflexe, c'est quoi ? Chroma ? Pinecone ? Weaviate ?

Le projet open source que je vous présente aujourd'hui pourrait bien vous faire reconsidérer votre choix de base de données vectorielle. Il s'appelle Zvec — c'est une base de données vectorielle embarquée développée par le laboratoire Tongyi d'Alibaba. On la surnomme « le SQLite des bases de données vectorielles ».

Pas de serveur, pas de Docker, pas de fichier de config. Un simple pip install zvec et ça tourne directement dans votre processus Python. C'est aussi simple que ça.

Présentation du projet

Zvec est une base de données vectorielle légère et in-process, open source chez Alibaba. Sa philosophie de conception est identique à celle de SQLite — aucune dépendance externe, elle s'intègre directement dans votre application.

Caractéristique Description
GitHub Stars 10 400+ (trending GitHub en juin 2026)
Licence Apache 2.0
Langages Cœur en C++, SDK multi-langages (Python / Node.js / Go / Rust / Dart)
Dernière version v0.5.0 (2026-06-12)
Moteur sous le capot Proxima (moteur de recherche vectorielle utilisé en interne chez Alibaba)

Zvec vs bases de données vectorielles classiques

Caractéristique Zvec Chroma Pinecone Milvus
Déploiement In-process (embarqué) Service requis Cloud managé Déploiement complexe
Installation pip install zvec Docker nécessaire Création de compte Déploiement lourd
Empreinte mémoire Faible (index DiskANN sur disque) Moyenne N/A Élevée
Cas d'usage Apps locales, Edge, RAG petite/moyenne échelle Prototypage Service cloud en production Clusters à grande échelle

En une phrase : si vous voulez une base de données vectorielle « clé en main », sans vous prendre la tête avec des serveurs et de la config, Zvec est le choix le plus léger et le plus rapide.

Installation

Zvec est compatible avec plusieurs systèmes d'exploitation et langages de programmation. L'installation est ultra simple.

Python (recommandé)

BASH 
pip install zvec

Nécessite Python 3.10 - 3.14.

Node.js

BASH 
npm install @zvec/zvec

Go

BASH 
go get github.com/zvec-ai/zvec-go

Rust

TOML 
# Cargo.toml
[dependencies]
zvec = "0.5"

Configuration système requise

Plateforme Architecture
Linux x86_64, ARM64
macOS ARM64 (Apple Silicon)
Windows x86_64

Prise en main rapide

Votre première recherche vectorielle

En quelques lignes de code, vous créez une base de données vectorielle complète et lancez une recherche de similarité :

PYTHON 
import zvec

# 1. Définir la structure de la collection (Schema)
schema = zvec.CollectionSchema(
    name="my_collection",
    vectors=zvec.VectorSchema("embedding", zvec.DataType.VECTOR_FP32, 4),
)

# 2. Créer et ouvrir la collection (persistée automatiquement en local)
collection = zvec.create_and_open(path="./my_zvec_data", schema=schema)

# 3. Insérer des données vectorielles
collection.insert([
    zvec.Doc(id="doc_1", vectors={"embedding": [0.1, 0.2, 0.3, 0.4]}),
    zvec.Doc(id="doc_2", vectors={"embedding": [0.2, 0.3, 0.4, 0.1]}),
    zvec.Doc(id="doc_3", vectors={"embedding": [0.9, 0.1, 0.1, 0.2]}),
])

# 4. Exécuter une recherche de similarité vectorielle
results = collection.query(
    zvec.VectorQuery("embedding", vector=[0.2, 0.3, 0.3, 0.1]),
    topk=2
)

# Afficher les résultats
for r in results:
    print(f"ID: {r['id']}, Score de similarité: {r['score']:.4f}")

Résultat :

ID: doc_2, Score de similarité: 0.9899
ID: doc_1, Score de similarité: 0.9798

Construire une appli RAG simple

En combinant le modèle d'embedding d'OpenAI, vous pouvez monter rapidement un système de questions-réponses sur documents :

PYTHON 
import zvec
import openai

# Initialiser le modèle d'embedding
client = openai.OpenAI(api_key="your-api-key")

def get_embedding(text: str) -> list[float]:
    response = client.embeddings.create(
        model="text-embedding-3-small",
        input=text
    )
    return response.data[0].embedding

# Créer la collection
schema = zvec.CollectionSchema(
    name="rag_docs",
    vectors=zvec.VectorSchema("embedding", zvec.DataType.VECTOR_FP32, 1536),
    fields=[
        zvec.FieldSchema("content", zvec.DataType.STRING),
        zvec.FieldSchema("source", zvec.DataType.STRING),
    ],
)

collection = zvec.create_and_open(path="./rag_data", schema=schema)

# Indexer les documents
documents = [
    ("Zvec est la base de données vectorielle légère open source d'Alibaba", "doc1.md"),
    ("Les bases de données vectorielles servent à stocker et récupérer des données vectorielles en haute dimension", "doc2.md"),
    ("La technologie RAG combine retrieval et génération, c'est l'approche dominante pour les apps LLM actuelles", "doc3.md"),
]

for content, source in documents:
    embedding = get_embedding(content)
    collection.insert([
        zvec.Doc(
            vectors={"embedding": embedding},
            fields={"content": content, "source": source},
        )
    ])

# Rechercher les documents les plus pertinents
question = "C'est quoi une base de données vectorielle ?"
query_embedding = get_embedding(question)

results = collection.query(
    zvec.VectorQuery("embedding", vector=query_embedding),
    topk=2
)

print("Documents pertinents :")
for r in results:
    print(f"- [{r['fields']['source']}] {r['fields']['content']}")
    print(f"  Similarité: {r['score']:.4f}\n")

Fonctionnalités avancées

Recherche en texte intégral (Full-Text Search)

La v0.5.0 introduit la recherche en texte intégral native, pas besoin d'ajouter Elasticsearch ou un autre moteur de recherche externe :

PYTHON 
import zvec

schema = zvec.CollectionSchema(
    name="ft_search",
    vectors=zvec.VectorSchema("embedding", zvec.DataType.VECTOR_FP32, 384),
    fields=[
        zvec.FieldSchema("title", zvec.DataType.STRING),
        zvec.FieldSchema("body", zvec.DataType.STRING),
    ],
)

collection = zvec.create_and_open(path="./fts_data", schema=schema)

# Créer un index de recherche en texte intégral sur le champ body
collection.create_fts_index("body_fts", field="body")

# Insérer des données
collection.insert([
    zvec.Doc(
        id="1",
        vectors={"embedding": [0.1] * 384},
        fields={"title": "Tutoriel Python", "body": "Python est un langage de programmation puissant, très utilisé en IA et en data science."},
    ),
    zvec.Doc(
        id="2",
        vectors={"embedding": [0.2] * 384},
        fields={"title": "Introduction à JavaScript", "body": "JavaScript est le langage incontournable du développement front-end, utilisé pour le Web, Node.js et bien plus."},
    ),
])

# Recherche en texte intégral
results = collection.query(
    zvec.FTSQuery("body_fts", "Python data science"),
    topk=5
)

for r in results:
    print(f"[{r['fields']['title']}] {r['fields']['body'][:30]}...")

L'un des points forts de Zvec : combiner recherche vectorielle, recherche en texte intégral et filtrage scalaire en une seule requête pour des résultats ultra précis :

PYTHON 
# Recherche hybride : vecteur + texte intégral + filtre scalaire
results = collection.query(
    zvec.MultiQuery([
        # Similarité vectorielle
        zvec.VectorQuery("embedding", vector=[0.15] * 384, weight=0.7),
        # Recherche en texte intégral
        zvec.FTSQuery("body_fts", "langage de programmation tutoriel", weight=0.3),
    ]),
    topk=3
)

for r in results:
    print(f"[{r['id']}] Score hybride: {r['score']:.4f}")

Index DiskANN sur disque

Quand vous avez beaucoup de données vectorielles, la mémoire peut vite devenir insuffisante. L'index DiskANN de Zvec stocke l'essentiel de l'index sur disque, ce qui réduit drastiquement l'empreinte mémoire :

PYTHON 
schema = zvec.CollectionSchema(
    name="large_collection",
    vectors=zvec.VectorSchema("embedding", zvec.DataType.VECTOR_FP32, 768),
)

# Créer la collection avec un index DiskANN
collection = zvec.create_and_open(
    path="./diskann_data",
    schema=schema,
    index_options=zvec.IndexOptions(
        index_type=zvec.IndexType.DISKANN,  # Index sur disque
    )
)

# Insérer un gros volume de données (des millions, aucun problème)
for i in range(100000):
    collection.insert([zvec.Doc(
        id=f"doc_{i}",
        vectors={"embedding": [0.1 * (i % 768)] * 768},
    )])

Filtrage scalaire

Ajoutez des filtres sur des champs structurés en complément de la recherche vectorielle :

PYTHON 
results = collection.query(
    zvec.ScalarQuery("category = 'AI' AND published_year >= 2025"),
    topk=10
)

Persistance et concurrence

Zvec utilise le WAL (Write-Ahead Logging) pour garantir la persistance des données. Même en cas de crash ou de coupure de courant, rien n'est perdu. Il gère aussi la lecture simultanée par plusieurs processus sur la même collection (l'écriture reste exclusive) :

PYTHON 
# Processus A : écriture
collection_a = zvec.open("./shared_data", mode="write")
collection_a.insert([zvec.Doc(id="new_1", vectors={"embedding": [0.5] * 4})])
collection_a.flush()

# Processus B : lecture (en parallèle du processus A)
collection_b = zvec.open("./shared_data", mode="read")
results = collection_b.query(
    zvec.VectorQuery("embedding", vector=[0.5] * 4),
    topk=5
)

Performances

Selon les benchmarks officiels, Zvec se distingue sur plusieurs plans :

  • Latence de recherche : réponse en quelques millisecondes, même sur des datasets de milliards de vecteurs
  • Efficacité mémoire : l'index DiskANN économise plus de 10x de mémoire par rapport aux index classiques en mémoire
  • Débit : supporte les scénarios de requêtes à fort concurrency
  • Par rapport à la concurrence : à matériel égal, le QPS (requêtes par seconde) et la latence de Zvec surpassent Chroma et Milvus

Pour les données de benchmarks détaillées, consultez la documentation officielle des Benchmarks.

Outil de debug visuel : Zvec Studio

Si vous préférez ne pas coder pour debugger vos données vectorielles, l'équipe Zvec propose un outil visuel : Zvec Studio.

BASH 
git clone https://github.com/zvec-ai/zvec-studio
cd zvec-studio
npm install && npm run dev

Ouvrez votre navigateur et vous pouvez explorer les collections, debugger vos requêtes, inspecter l'état des index — zéro code requis.

Cas d'usage

Scénario Pourquoi Zvec est adapté
App RAG personnelle Pas de service externe à déployer, pip install et c'est parti
App IA de bureau Conception embarquée, pas de processus supplémentaire
Mobile / Edge Léger, faible empreinte mémoire
Prototypage rapide Zéro config, flux complet en 5 minutes
Production petite/moyenne échelle Persistance WAL + DiskANN pour la fiabilité
Projets multi-langages SDK Python / Node.js / Go / Rust / Dart

Conclusion

Zvec comble un vide important — entre les bases de données vectorielles comme Chroma qui nécessitent Docker, et les services cloud comme Pinecone, Zvec offre une alternative vraiment légère et vraiment embarquée.

Si vous êtes dans l'un de ces cas, Zvec mérite clairement 5 minutes de votre temps :

  • Vous voulez faire tourner une app RAG en local sans vous embêter avec Docker
  • Vous avez besoin d'une base de données vectorielle simple pour prototyper de la recherche sémantique
  • Vous développez une app IA desktop/mobile et besoin d'une solution embarquée légère
  • Vous en avez marre des configs complexes, vous voulez un truc qui marche avec pip install

Dépôt du projet : github.com/alibaba/zvec
Documentation officielle : zvec.org

Vous utilisez déjà Zvec ? N'hésitez pas à partager votre retour d'expérience en commentaire. Ou vous utilisez déjà une autre base de données vectorielle ? On peut en discuter et comparer avec Zvec.