Base de données vectorielle

Une base de données vectorielle est un système de base de données spécialement conçu pour stocker, indexer et récupérer des données vectorielles à haute dimension.

Vous pouvez le concevoir ainsi : stocker ensemble les choses ayant des significations similaires, et trouver rapidement celles qui sont les plus similaires à un élément donné.

Contrairement aux bases de données traditionnelles, qui interrogent par correspondance exacte (WHERE name = 'Alice'), les bases de données vectorielles interrogent par similarité (trouver les 10 images les plus similaires à cette image).

Une analogie intuitive

Imaginez un scénario de bibliothèque :

Type de base de donnéesMéthode de récupérationAnalogie
Base de données traditionnelleRecherche exacte par numéro de livre et titreTrouver un livre avec un numéro spécifié
Base de données vectorielleRecherche par pertinence de contenuTrouver « tous les romans de science-fiction similaires en style à The Three-Body Problem »

Cette similarité sémantique est précisément le problème central que résolvent les bases de données vectorielles.


Pourquoi avons-nous besoin d'une base de données vectorielle ?

Avant de plonger dans les détails techniques, commençons par comprendre quels problèmes les bases de données vectorielles résolvent.

Limites des bases de données traditionnelles

Les bases de données relationnelles traditionnelles (MySQL, PostgreSQL) sont très efficaces pour gérer des données structurées, mais elles montrent leurs limites face aux exigences suivantes :

  • Recherche d’images (trouver des images visuellement similaires)
  • Recherche sémantique (lorsqu’un utilisateur recherche « Apple phone », elle peut trouver du contenu associé à « iPhone »)
  • Systèmes de recommandation (trouver « des chansons au style similaire à celles que vous aimez »)
  • Détection d’anomalies (trouver « les journaux qui diffèrent le plus du comportement normal »)

La caractéristique commune de ces problèmes est la nécessité de comprendre le « sens » du contenu, plutôt que d’effectuer une correspondance littérale.

Problèmes des approches traditionnelles

用 LIKE '%苹果%' 搜索 → 找不到 "iPhone"、"Apple"
用全文索引搜索     → 找不到语义相关但用词不同的内容

Schéma comparatif

Le diagramme ci-dessous montre intuitivement les différences fondamentales entre les méthodes d’interrogation des bases de données traditionnelles et des bases de données vectorielles.

Traditional database vs. vector database: comparison of query methods Traditional database (exact match) SELECT * WHERE name = 'Apple phone' Match results: √ Apple phone Pro 128GB x iPhone 15 (no match) x Apple mobile phone (no match) x smartphone iOS (no match) Vector database (semantic similarity) search(embed("iPhone"), top_k=4) Similar results (with similarity scores): √ Apple phone Pro 128GB 0.98 √ iPhone 15 0.95 √ Apple mobile phone 0.93 √ smartphone iOS 0.87

Concepts clés : vecteurs et embeddings

Comprendre les vecteurs et les embeddings est la première étape pour maîtriser les bases de données vectorielles.

Qu'est-ce qu'un vecteur ?

En mathématiques, un vecteur est un ensemble ordonné de nombres.

[0.12, -0.54, 0.87, 0.03, ..., 0.61]   ← 这就是一个向量

En apprentissage automatique, cet ensemble de nombres représente les caractéristiques sémantiques d'un objet, avec généralement des dimensions allant de 128 à 4096.

Qu'est-ce qu'un plongement ?

Le plongement est le processus et le résultat de la conversion d'objets du monde réel (texte, images, audio, etc.) en vecteurs.

Cette conversion est effectuée par un modèle de plongement, dont l'idée centrale est : des objets ayant une sémantique similaire ont des vecteurs plus proches dans l'espace.

Embedding process illustration Text "The weather is really nice today" Image A photo of a cat Audio A music clip Embedding model Embedding Model text-embedding-3 CLIP / ResNet ... Text vector (1536 dimensions): [0.12, -0.54, 0.87, 0.03, ...] Image vector (512 dimensions): [-0.33, 0.71, 0.22, 0.95, ...] Audio vector (256 dimensions): [0.66, -0.11, 0.48, -0.72, ...] Tip: Objects with similar semantics have vectors that are closer in space after conversion.

Une sémantique similaire signifie des vecteurs similaires

Utilisez un exemple simplifié en 2D pour comprendre (en réalité, il s'agit de centaines à milliers de dimensions) :

Semantic clustering in vector space (2D illustration) x y Animals cat dog Rabbit bear Technology Computer Phone Keyboard Monitor Food Pizza Hamburger Noodles Query: pet The vector for the query "pet" is closer to "cat" and "dog", belonging to the animal cluster.

Compréhension clé : deux vecteurs proches dans l'espace vectoriel ont également un contenu d'origine sémantiquement similaire. C'est le fondement de toutes les capacités des bases de données vectorielles.


Méthodes de calcul de similarité

Le cœur de la recherche du « vecteur le plus similaire » est de calculer la distance ou la similarité entre deux vecteurs. Voici les trois méthodes les plus couramment utilisées.

Similarité cosinus

La similarité cosinus mesure l'angle entre deux vecteurs, en ignorant leur magnitude. C'est la méthode la plus couramment utilisée, particulièrement adaptée aux scénarios textuels.

Formule :

\[ \text{CosineSimilarity}(A, B) = \frac{A \cdot B} {\|A\|\|B\|} = \frac{\sum_{i=1}^{n} A_i B_i} {\sqrt{\sum_{i=1}^{n} A_i^2}\sqrt{\sum_{i=1}^{n} B_i^2}} \]

  • Plage de résultats : -1 à 1, une valeur plus grande signifie une plus grande similarité
  • Scénarios applicables : recherche sémantique textuelle, similarité de documents

Distance euclidienne

La distance euclidienne mesure la distance en ligne droite entre deux points ; plus la distance est petite, plus ils sont similaires.

Formule :

\[ d(A,B) = \sqrt{\sum_{i=1}^{n}(A_i-B_i)^2} \]

  • Plage de résultats : 0 à ∞, une valeur plus petite signifie une plus grande similarité
  • Scénarios applicables : recherche d'images, applications liées à la localisation

Produit scalaire

Le produit scalaire est la somme des produits des composantes des vecteurs, combinant à la fois les informations de direction et de magnitude.

Formule :

\[ A \cdot B = \sum_{i=1}^{n} A_i B_i \]

  • Scénarios d'application : systèmes de recommandation (équivalent à la similarité cosinus lorsque les vecteurs sont normalisés)

Comparaison des trois méthodes

Comparison of three similarity calculation methods Method Principle Meaning of the result Recommended scenarios Cosine similarity Compute the cosine value of the angle between two vectors Focuses on direction, ignores magnitude [-1, 1], the closer to 1, the more similar Text search, first choice for NLP Euclidean distance The straight-line distance between two points Focuses on absolute position differences [0, ∞), the closer to 0, the more similar Image retrieval, coordinate system data Dot product Sum of the products of the vector components Comprehensive consideration of direction + magnitude The larger the value, the more similar (no fixed range) Recommender systems, normalized scenarios

Exemple de code Python

L'exemple suivant illustre des implémentations Python de trois méthodes de calcul de similarité :

Exemple

import numpy as np

# Similarité cosinus : mesure la similarité directionnelle
def cosine_similarity(a, b):
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))

# Distance euclidienne : mesure les différences de position absolues
def euclidean_distance(a, b):
    return np.linalg.norm(a - b)

# Produit scalaire : combine direction et norme
def dot_product(a, b):
    return np.dot(a, b)

# Vecteurs d'exemple
v1 = np.array([0.12, -0.54, 0.87, 0.03])
v2 = np.array([0.10, -0.50, 0.90, 0.05])
v3 = np.array([-0.80, 0.20, -0.30, 0.70])

print(f"v1 vs v2 similarité cosinus : {cosine_similarity(v1, v2):.4f}")  # Environ 0.9997 (très similaires)
print(fv1 vs v3 similarité cosinus : {cosine_similarity(v1, v3):.4f})  # Environ -0.55 (pas similaires)
v1 vs v2 余弦相似度: 0.9997
v1 vs v3 余弦相似度: -0.5512

Algorithmes d'indexation vectorielle

Lorsque le volume de données est important (millions, milliards), calculer la similarité pour chaque donnée (recherche exhaustive) est trop lent. Les bases de données vectorielles utilisent des algorithmes d'indexation spécialisés pour accélérer les requêtes.

Recherche exhaustive (Flat / Brute-force)

La recherche exhaustive parcourt tous les vecteurs et calcule la similarité un par un.

DimensionDescription
PrincipeParcourir tous les vecteurs, calculer la similarité un par un
AvantagesRésultats exacts à 100%
InconvénientsExtrêmement lent avec de grands volumes de données, complexité O(n)
ApplicableVolume de données inférieur à 100k, exigences de précision extrêmement élevées

IVF (Index de fichier inversé)

IVF index principle: first cluster, then search within buckets Cluster 1 center Cluster 2 center Cluster 3 center Query far Close! far Perform exact search only within the nearest cluster 2, greatly reducing computation

Étapes d'exécution de l'IVF :

  1. Phase d'entraînement : Utiliser K-Means pour regrouper tous les vecteurs en N clusters, enregistrer le centre de chaque cluster
  2. Phase de requête : Trouver d'abord les centres des clusters les plus proches, puis effectuer une recherche exacte uniquement dans ces clusters

HNSW (graphe hiérarchique navigable de type petit monde)

HNSW est actuellement l'algorithme d'indexation vectorielle le plus répandu, alliant vitesse et précision.

HNSW hierarchical structure diagram Layer 2 (sparsest, long-range jumps) A B Layer 1 (medium density, medium-range jumps) C A D B E Layer 0 (densest, exact search) F C A G D H B E I At query time, start from the top layer with large jumps to locate the region, then refine layer by layer to precisely find the nearest neighbor

Idée centrale de HNSW :

  • Construire une structure de graphe multicouche, clairsemée en haut, dense en bas
  • Au moment de la requête, partir du point d'entrée de la couche supérieure et jouer à un « jeu de marelle » : sauter avidement vers les nœuds les plus proches à chaque couche, puis descendre à la couche suivante
  • Réduit considérablement le nombre de nœuds à comparer, complexité temporelle approximativement O(log n)

Autres index courants

Type d'indexFonctionnalitésScénarios applicables
Flat (force brute)Précis mais lentPetits ensembles de données, priorité à la précision
IVF_FlatRecherche exacte après regroupement, rapideÉchelle moyenne à grande, mémoire suffisante
IVF_PQCompression par quantification, économise de la mémoireTrès grande échelle, mémoire limitée
HNSWRapide, haute précision, utilisation élevée de la mémoireLe plus couramment utilisé, premier choix recommandé
ScaNNDéveloppé par Google, débit optimiséEnvironnements de production à forte concurrence

Comparaison des principales bases de données vectorielles

Ce qui suit est une comparaison horizontale des bases de données vectorielles les plus courantes actuellement disponibles, pour vous aider à faire des choix dans différents scénarios.

Horizontal comparison of mainstream vector databases Database Type Deployment method Features Applicable scenarios Difficulty Chroma Open source and free Pure vector DB Local / Cloud Embedded-first Minimalist API, Python-native Easiest to integrate with LangChain RAG prototyping, AI application development Beginner Qdrant Open source and free Pure vector DB Local / Docker Cloud service Rust implementation, high performance Supports hybrid filtering + vector search Production-grade recommendation, performance first Intermediate Weaviate Open source and free Multimodal DB Local / Cloud SaaS GraphQL API, built-in vectorization Multimodal (text + image) Multimodal retrieval, knowledge graph Intermediate Milvus Open source and free Pure vector DB Distributed deployment Kubernetes LF AI Foundation project Large-scale distributed, comprehensive features Hundreds of millions of data, enterprise scale Advanced Pinecone Commercial SaaS Managed vector DB Purely cloud-based Fully managed service Zero ops, out-of-the-box Free tier available Quick launch, for teams without ops capabilities Beginner pgvector Open source plugin PG extension Existing PostgreSQL Use directly in your environment Reuse existing PG infrastructure SQL interface, fastest to learn Projects already using PG, lightweight integration Beginner

Conseils pour débutants : commencez avec Chroma ou pgvector. Le premier convient aux prototypes d'applications d'IA, le second aux projets disposant déjà de PostgreSQL.


Démarrage rapide : exemples Python

Ci-dessous, nous utilisons Chroma (le plus simple pour démarrer) pour démontrer le flux de travail CRUD complet.

Installation

Exemple

pip install chromadb openai

Exemple complet : construction d'un système de recherche sémantique de documents

Le code suivant montre de bout en bout comment utiliser Chroma pour construire un système de recherche documentaire basé sur la sémantique.

Exemple

import chromadb
from chromadb.utils import embedding_functions

# ─── 1. Initialiser le client ───────────────────────────────────────────
# Persister localement (recommandé)
client = chromadb.PersistentClient(path="./my_vector_db")

# Utiliser le modèle d'embedding OpenAI (vous pouvez aussi passer à un modèle local)
openai_ef = embedding_functions.OpenAIEmbeddingFunction(
    api_key="your-openai-api-key",       # Obligatoire : remplacez par votre clé API
    model_name="text-embedding-3-small"   # 1536 dimensions, économique
)

# ─── 2. Créer une collection (comme une "table" dans les bases de données relationnelles)────────────────────────
collection = client.get_or_create_collection(
    name="my_documents",                   # Nom de la collection
    embedding_function=openai_ef,          # Lier la fonction d'embedding
    metadata={"hnsw:space": "cosine"}      # Utiliser la similarité cosinus
)

# ─── 3. Insérer des documents ──────────────────────────────────────────────
documents = [
    Python est un langage de programmation interprété orienté objet, largement utilisé en science des données et dans le développement de l'IA,
    L'apprentissage automatique est un sous-domaine de l'intelligence artificielle qui permet aux ordinateurs d'apprendre des motifs à partir des données,
    L'apprentissage profond utilise des réseaux de neurones multicouches et excelle dans la reconnaissance d'images et les tâches de NLP,
    Les bases de données vectorielles sont spécialement conçues pour stocker des vecteurs de grande dimension et prendre en charge la recherche de similarité sémantique,
    PostgreSQL est une puissante base de données relationnelle open source,
    Redis est une base de données clé-valeur en mémoire à hautes performances, souvent utilisée pour la mise en cache,
    La technologie de conteneurisation Docker permet aux applications de s'exécuter de manière cohérente dans n'importe quel environnement,
    Git est un système de gestion de versions distribué et un outil fondamental pour le développement logiciel moderne,
]

ids = [f"doc_{i}" for i in range(len(documents))]

# Insertion par lots (Chroma appelle automatiquement le modèle d'embedding pour convertir en vecteurs avant le stockage)
collection.add(
    documents=documents,
    ids=ids,
    metadatas=[{"source": "tutorial", "index": i} for i in range(len(documents))]
)

print(f{len(documents)} documents insérés)
已插入 8 条文档

Exemple

# ─── 4. Recherche sémantique ──────────────────────────────────────────────
query = Comment faire de l'intelligence artificielle avec Python

results = collection.query(
    query_texts=[query],
    n_results=3,                # Renvoyer les 3 plus similaires
    include=["documents", "distances", "metadatas"]
)

print(f"\n"Requête : {query}")
print("-" * 50)
for i, (doc, dist) in enumerate(zip(
    results["documents"][0],
    results["distances"][0]
)):
    similarity = 1 - dist   # Convertir la distance cosinus en similarité
    print(fRang {i+1} (similarité {similarity:.4f}) :)
    print(f" {doc}")
    print()
查询:如何用 Python 做人工智能
--------------------------------------------------
第 1 名(相似度 0.9231):Python 是一种面向对象的解释型编程语言...
第 2 名(相似度 0.8874):机器学习是人工智能的子领域...
第 3 名(相似度 0.8612):深度学习使用多层神经网络...

Exemple

# ─── 5. Recherche avec filtres (filtrage des métadonnées) ───────────────────────
results_filtered = collection.query(
    query_texts=[Technologie des bases de données],
    n_results=2,
    where={"source": "tutorial"},        # Rechercher uniquement parmi les documents où source=tutorial
    include=["documents", "distances"]
)

# ─── 6. Mettre à jour les documents ──────────────────────────────────────────────
collection.update(
    ids=["doc_0"],
    documents=[Python est actuellement le langage de programmation le plus populaire, largement utilisé dans l'IA, l'analyse de données et le développement web],
    metadatas=[{"source": "tutorial", "index": 0, "updated": True}]
)

# ─── 7. Supprimer les documents ──────────────────────────────────────────────
collection.delete(ids=["doc_7"])   # Supprimer les documents liés à Git

# ─── 8. Afficher les statistiques de la collection ──────────────────────────────────────────
print(fNombre de documents dans la collection actuelle : {collection.count()})

Sans utiliser d'API d'embedding tierces (entièrement local)

Si vous ne voulez pas utiliser l'API OpenAI, vous pouvez fonctionner entièrement hors ligne avec des modèles d'embedding locaux.

Exemple

import chromadb
from sentence_transformers import SentenceTransformer

# Utiliser des modèles d'embedding locaux (aucune clé API requise, entièrement hors ligne)
model = SentenceTransformer("paraphrase-multilingual-MiniLM-L12-v2")  # Prend en charge le chinois

client = chromadb.Client()
collection = client.create_collection("local_demo")

texts = ["Le temps est agréable aujourd'hui", "Il fait beau et c'est parfait pour sortir", "Le marché boursier a bondi", "Il pourrait pleuvoir demain"]

# Générer manuellement les vecteurs avant l'insertion
embeddings = model.encode(texts).tolist()
collection.add(
    embeddings=embeddings,
    documents=texts,
    ids=[f"id_{i}" for i in range(len(texts))]
)

# Requête
query_embedding = model.encode(["Quel temps fait-il aujourd'hui ?"⟦⟧tolist]).tolist()
results = collection.query(query_embeddings=query_embedding, n_results=2)
print(results["documents"])
# Sortie : [['Le temps est agréable aujourd'hui', 'Il fait beau et c'est parfait pour sortir']]

exemple pgvector (pour les utilisateurs de PostgreSQL)

Si votre projet utilise déjà PostgreSQL, pgvector est le moyen le plus léger d'intégrer.

Exemple

-- Installer l'extension
CREATE EXTENSION IF NOT EXISTS vector;

-- Créer une table : stocker les titres d'articles et leurs vecteurs (1536 dimensions)
CREATE TABLE articles (
    id       SERIAL PRIMARY KEY,
    title    TEXT NOT NULL,
    content  TEXT,
    embedding vector(1536)           -- Colonne vectorielle, 1536 dimensions
);

-- Créer un index HNSW pour accélérer les requêtes
CREATE INDEX ON articles
USING hnsw (embedding vector_cosine_ops)
WITH (m = 16, ef_construction = 64);

-- Insérer des données (les vecteurs sont générés dans la couche applicative et passés en entrée)
INSERT INTO articles (title, embedding)
VALUES ('Guide du débutant Python', '[0.12, -0.54, 0.87, ...]'::vector);

-- Recherche sémantique : trouver les 5 articles les plus similaires
SELECT id, title,
       1 - (embedding <=> '[0.10, -0.50, 0.90, ...]'::vector) AS similarity
FROM articles
ORDER BY embedding <=> '[0.10, -0.50, 0.90, ...]'::vector
LIMIT 5;

Remarque : <=> est un opérateur de distance vectorielle fourni par pgvector, utilisé pour calculer la distance cosinus. Soustrayez la distance cosinus de 1 pour obtenir la similarité cosinus.


Scénarios d'application typiques

Les bases de données vectorielles ont un large éventail d'applications à l'ère de l'IA ; voici un aperçu des six scénarios les plus typiques.

Typical application scenarios of vector databases RAG RAG knowledge base Q&A Convert enterprise documents into vectors, When users ask questions, retrieve relevant fragments Hand over to LLM to generate answers. Examples: ChatPDF, NotionAI Enterprise knowledge base assistant Recommendation Personalized recommendation systems Convert user behavior and product information into vectors, find "users with similar tastes what they like" for recommendations. Examples: Spotify song recommendations E-commerce related product recommendations Image Search by image Encode images into vectors, Find visually similar images through similarity search, no labels needed. Examples: Google Image Search Taobao photo search for products Detection Anomaly detection Normal behavior is mapped to clustered Vector region, vector of abnormal behavior. Move away from the normal area to detect it. Representative: Network Intrusion Detection Financial Fraud Detection deduplication Content deduplication / copyright detection Determine two passages based on vector similarity. Identify whether the content is highly similar Plagiarized or duplicate content. Representative: Paper Plagiarism Detection System Music copyright detection face Face / biometric recognition Encode the face as a feature vector, Retrieve the most similar in the vector database Known face recognition completed. Representative: Face Access Control System Mobile face unlock

Architecture RAG (Retrieval-Augmented Generation)

RAG est actuellement l'un des principaux scénarios d'application des bases de données vectorielles. Voici son workflow principal :

RAG system workflow Step 1 User question "How does Python handle exceptions?" Step 2 Question vectorization. Embedding model -> [0.12, -0.54, ...] Step 3 Vector retrieval In vector DB Find most similar documents Step 4 LLM generation Retrieve content + question -> Prompt -> Answer Step 5 Return answer Document-based. Accurate, traceable answers The vector database plays a core role in step 3: finding the most relevant knowledge snippets in milliseconds.

Recommandations de sélection et bonnes pratiques

Arbre de décision de sélection

En fonction de votre situation spécifique, choisissez une base de données vectorielle appropriée selon l'arbre de décision suivant :

你的情况是什么?
│
├─── 已有 PostgreSQL,且数据量 < 500 万
│    └──> 用 pgvector,无缝集成,零额外运维
│
├─── 做 AI/LLM 应用原型,快速验证
│    └──> 用 Chroma,几行代码跑起来
│
├─── 需要生产级部署,性能优先,数据量 500 万 ~ 1 亿
│    └──> 用 Qdrant,Rust 实现,性能强
│
├─── 超大规模(> 1 亿),有 K8s 运维能力
│    └──> 用 Milvus,分布式,功能最全
│
└─── 团队没有运维能力,愿意付费
     └──> 用 Pinecone 云服务,开箱即用

Choisir un modèle d'embedding

Choisir un modèle d'embedding adapté est la première étape clé des applications de bases de données vectorielles.

ExigencesModèle recommandé
Texte en chinois et en anglais (haute qualité)OpenAI text-embedding-3-small
Texte chinois (local hors ligne)BAAI/bge-large-zh-v1.5
Multilingue universel.paraphrase-multilingual-MiniLM-L12-v2
Multimodal image-texte.OpenAI CLIPsérie

Conseils d'optimisation des performances

1. Insertion par lots : Insérer plusieurs entrées à la fois pour éviter les écritures fréquentes d'une seule entrée.

Exemple

# Recommandé : Insertion par lots
collection.add(documents=docs_list, ids=ids_list)

# Non recommandé : boucle un par un (réindexe à chaque fois, extrêmement inefficace)
# for doc, id in zip(docs_list, ids_list):
# collection.add(documents=[doc], ids=[id])

2. Normalisation vectorielle : avant d'utiliser la similarité cosinus, normaliser les vecteurs à l'avance peut accélérer le calcul.

Exemple

import numpy as np

def normalize(v):
    """Effectuer une normalisation L2 sur les vecteurs afin que la norme soit 1"""
    return v / np.linalg.norm(v)

3. Définissez n_results raisonnablement : ne définissez pas aveuglément un top_k très grand ; 3~10 résultats suffisent généralement pour les scénarios RAG.

4. Faites bon usage du filtrage des métadonnées : combinez avec les conditions where lors de la recherche pour restreindre le périmètre de recherche.

Exemple

# Rechercher uniquement dans la catégorie "documentation technique" pour réduire la portée et améliorer la précision
collection.query(
    query_texts=["Gestion des exceptions Python"],
    where={"category": "tech_doc"},
    n_results=5
)

5. Reconstruisez régulièrement les index : après que le volume de données augmente, reconstruisez l'index HNSW en temps voulu pour maintenir les performances des requêtes.

Pièges courants

Voici les problèmes les plus courants rencontrés par les débutants lors de l'utilisation de bases de données vectorielles, ainsi que leurs solutions.

ProblèmeDescriptionSolution
Le modèle d'embedding doit être cohérentLe même modèle doit être utilisé pour l'insertion et la requêteÉpingler la version du modèle dans le fichier de configuration
Incompatibilité de dimensionsModèle changé mais collection non reconstruiteSupprimez et reconstruisez la collection lors d'un changement de modèle
Texte trop longLa plupart des modèles ont des limites de tokens (512~8192)Découper d'abord les textes trop longs
Similarité impréciseLe texte n’est pas découpé, donc la sémantique est diluéeDécoupez les documents par paragraphe ou selon une longueur fixe
Démarrage à froid lentLorsque le volume de données est important, le chargement initial de l’index prend du tempsPréchauffez à l’avance, ou utilisez des index persistants

Résumé

Passons en revue les points de connaissance essentiels de ce tutoriel :

Vector Database Core Knowledge Review Vector / embedding Convert objects into high-dimensional numeric vectors semantically similar means close distance is the foundation of everything Similarity calculation Cosine similarity Euclidean distance Dot product Cosine is preferred for text Indexing algorithms HNSW is the most mainstream IVF suits large scale Flat suits small data Approximation for speed Selection reference Beginner: Chroma Production: Qdrant Existing PG: pgvector 100M+ scale: Milvus Core applications RAG knowledge QA Personalized recommendation Reverse image search Anomaly detection

Les bases de données vectorielles sont un élément crucial de l’infrastructure de l’ère de l’IA.

Il résout le problème de recherche de similarité sémantique que les bases de données traditionnelles ne peuvent pas gérer, et constitue un composant essentiel pour construire des systèmes RAG, des systèmes de recommandation et de recherche multimodale.

Recommandations de parcours d’apprentissage

  1. Étape 1 : Comprendre les concepts de vecteurs et d’embeddings, et exécuter l’exemple Chroma de cet article.
  2. Étape 2 : Essayez de créer un système simple de questions-réponses sur documents avec LangChain + Chroma.
  3. Étape 3 : Apprendre les algorithmes d’indexation tels que HNSW, et comprendre le compromis entre précision et vitesse.
  4. Étape 4 : En fonction des exigences réelles du projet, sélectionnez une base de données vectorielle appropriée et déployez-la dans un environnement de production.

Ressources de référence

Autres extensions