Base de datos vectorial (Vector Database)

Una base de datos vectorial (Vector Database) es un sistema de base de datos especializado en almacenar, indexar y recuperar datos vectoriales de alta dimensionalidad.

Puedes entenderlo así: guarda las cosas con significados similares juntas y permite encontrar rápidamente las que más se parecen a una consulta.

A diferencia de las bases de datos tradicionales, que consultan mediante coincidencia exacta (WHERE name = 'Alice'), la base de datos vectorial consulta mediante similitud (encontrar las 10 imágenes más similares a esta imagen).

Una analogía intuitiva

Imagina el escenario de una biblioteca:

Tipo de base de datosMétodo de búsquedaAnalogía
Base de datos tradicionalBúsqueda exacta por número de libro, títuloEncontrar un libro con un código específico
Base de datos vectorialBúsqueda por relevancia del contenidoEncontrar "todas las novelas de ciencia ficción de estilo similar a 'El problema de los tres cuerpos'"

Esta similitud semántica es el problema central que resuelven las bases de datos vectoriales.


Por qué se necesita una base de datos vectorial

Antes de profundizar en los detalles técnicos, primero entendamos qué problema resuelve la base de datos vectorial.

Limitaciones de las bases de datos tradicionales

Las bases de datos relacionales tradicionales (MySQL, PostgreSQL) son muy buenas manejando datos estructurados, pero se quedan cortas ante las siguientes necesidades:

  • Búsqueda de imágenes (encontrar imágenes visualmente similares)
  • Búsqueda semántica (cuando el usuario busca "móvil Apple", puede encontrar contenido relacionado con "iPhone")
  • Sistemas de recomendación (encontrar "canciones de estilo similar a las que te gustan")
  • Detección de anomalías (encontrar "los registros con mayor diferencia respecto al comportamiento normal")

La característica común de estos problemas es que se necesita comprender el "significado" del contenido, no hacer una coincidencia literal.

Problemas de las soluciones tradicionales

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

Diagrama comparativo

El siguiente gráfico muestra de forma intuitiva la diferencia fundamental entre las bases de datos tradicionales y las vectoriales en cuanto al método de consulta.

Base de datos tradicional vs base de datos vectorial: comparación de métodos de consulta Base de datos tradicional (coincidencia exacta) SELECT * WHERE name = 'teléfono Apple' Resultados de coincidencia: √ Teléfono Apple Pro 128GB x iPhone 15 (sin coincidencia) x Apple Teléfono (sin coincidencia) x Smartphone iOS (sin coincidencia) Base de datos vectorial (similitud semántica) search(embed("teléfono Apple"), top_k=4) Resultados de similitud (con similitud): √ Teléfono Apple Pro 128GB 0.98 √ iPhone 15 0.95 √ Apple Teléfono 0.93 √ Smartphone iOS 0.87

Conceptos fundamentales: vectores y embeddings

Entender los vectores y los embeddings es el primer paso para dominar las bases de datos vectoriales.

Qué es un vector (Vector)

En matemáticas, un vector es un conjunto ordenado de números.

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

En aprendizaje automático, este conjunto de números representa las características semánticas de un objeto, con dimensiones típicamente entre 128 y 4096.

Qué es un embedding (Embedding)

Un embedding es el proceso y el resultado de convertir objetos del mundo real (texto, imágenes, audio, etc.) en vectores.

Esta conversión la realiza un modelo de embedding, cuya idea central es: los objetos con semántica similar tienen vectores más cercanos en el espacio.

Diagrama del proceso de embedding Texto "Hoy hace muy buen día" Imagen Una foto de un gato Audio Un fragmento de música Modelo de embedding Embedding Model text-embedding-3 CLIP / ResNet ... Vector de texto (1536 dimensiones): [0.12, -0.54, 0.87, 0.03, ...] Vector de imagen (512 dimensiones): [-0.33, 0.71, 0.22, 0.95, ...] Vector de audio (256 dimensiones): [0.66, -0.11, 0.48, -0.72, ...] Consejo: los objetos con semántica similar tienen vectores más cercanos en el espacio tras la conversión

Semántica cercana, vectores cercanos

Usemos un ejemplo simplificado en 2D para entenderlo (en realidad son cientos o miles de dimensiones):

Agrupación semántica en el espacio vectorial (esquema bidimensional) x y Clase animal gato perro Conejo oso Clase tecnología Computadora Teléfono móvil Teclado Monitor Clase comida Pizza Hamburguesa Fideos Consulta: mascota El vector de la consulta "mascota" está más cerca de "gato" y "perro", pertenece al grupo de animales

Punto clave: dos vectores cercanos en el espacio vectorial implican que sus contenidos originales también son semánticamente similares. Esta es la base de todas las capacidades de las bases de datos vectoriales.


Métodos de cálculo de similitud

El núcleo para encontrar "los vectores más similares" es calcular la distancia o similitud entre dos vectores. Estos son los tres métodos más utilizados.

Similitud coseno (Cosine Similarity)

La similitud coseno mide el ángulo de dirección entre dos vectores, ignorando la magnitud. Es el método más común, especialmente adecuado para escenarios de texto.

Fórmula:

\[ \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}} \]

  • Rango de resultados: -1 a 1, cuanto mayor, más similar
  • Escenarios adecuados: búsqueda semántica de texto, similitud de documentos

Distancia euclidiana (Euclidean Distance)

La distancia euclidiana mide la distancia en línea recta entre dos puntos; cuanto menor es la distancia, más similares son.

Fórmula:

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

  • Rango de resultados: 0 a ∞, cuanto menor, más similar
  • Escenarios adecuados: recuperación de imágenes, aplicaciones relacionadas con geolocalización

Producto punto (Dot Product)

El producto punto es la suma de los productos de las componentes de dos vectores; combina información de dirección y magnitud.

Fórmula:

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

  • Escenarios adecuados: sistemas de recomendación (cuando los vectores están normalizados, equivale a la similitud coseno)

Comparación de los tres métodos

Comparación de los tres métodos de cálculo de similitud Método Principio Significado del resultado Escenario recomendado Similitud coseno Calcula el coseno del ángulo entre dos vectores Se centra en la dirección, ignora la magnitud [-1, 1], cuanto más cerca de 1, más similar Búsqueda de texto, primera opción en PLN Distancia euclidiana Distancia en línea recta entre dos puntos Se centra en la diferencia absoluta de posición [0, ∞), cuanto más cerca de 0, más similar Recuperación de imágenes, datos de coordenadas Producto punto Suma del producto de las componentes de los vectores Consideración combinada de dirección y longitud Cuanto mayor sea el valor, más similar (sin rango fijo) Sistemas de recomendación, escenarios de normalización

Ejemplo de código en Python

El siguiente ejemplo demuestra la implementación en Python de tres métodos de cálculo de similitud:

Ejemplo

import numpy as np

# Similitud coseno: mide la similitud de dirección
def cosine_similarity(a, b):
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))

# Distancia euclidiana: mide la diferencia de posición absoluta
def euclidean_distance(a, b):
    return np.linalg.norm(a - b)

# Producto punto: combina dirección y longitud
def dot_product(a, b):
    return np.dot(a, b)

# Vectores de ejemplo
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 similitud coseno: {cosine_similarity(v1, v2):.4f}")  # Aprox. 0.9997 (muy similar)
print(f"v1 vs v3 similitud coseno: {cosine_similarity(v1, v3):.4f}")  # Aprox. -0.55 (no similar)
v1 vs v2 余弦相似度: 0.9997
v1 vs v3 余弦相似度: -0.5512

Algoritmos de indexación vectorial

Cuando el volumen de datos es grande (millones, cientos de millones), calcular la similitud para cada registro (búsqueda por fuerza bruta) es demasiado lento. Las bases de datos vectoriales utilizan algoritmos de indexación especializados para acelerar las consultas.

Búsqueda exhaustiva (Flat / Brute-force)

La búsqueda por fuerza bruta recorre todos los vectores y calcula la similitud uno por uno.

AspectoDescripción
PrincipioRecorre todos los vectores y calcula la similitud uno a uno.
VentajasResultado 100% preciso
DesventajasExtremadamente lento con grandes volúmenes de datos, complejidad O(n)
AplicaciónVolumen de datos inferior a 100,000, requisitos extremadamente altos de precisión

IVF (Índice de archivos invertidos)

Principio del índice IVF: primero agrupar (clustering), luego buscar dentro de los buckets. Centro del clúster 1 Centro del clúster 2 Centro del clúster 3 Consulta lejos ¡Cerca! lejos Solo realiza una búsqueda exacta dentro del clúster 2 más cercano, reduciendo drásticamente el costo computacional.

Pasos de ejecución de IVF:

  1. Fase de entrenamiento: usar K-Means para agrupar todos los vectores en N clústeres y registrar el centro de cada clúster.
  2. Fase de consulta: primero encontrar los centros de los clústeres más cercanos y luego realizar una búsqueda exacta solo dentro de esos clústeres.

HNSW (Grafo de mundo pequeño navegable por capas)

HNSW es actualmente el algoritmo de indexación vectorial más utilizado, equilibrando velocidad y precisión.

Diagrama de la estructura jerárquica de HNSW Capa 2 (la más dispersa, saltos de largo alcance) A B Capa 1 (densidad media, saltos de alcance medio) C A D B E Capa 0 (la más densa, búsqueda exacta) F C A G D H B E I Al consultar, se realizan grandes saltos desde la capa superior para localizar la región y luego se refina capa por capa hasta encontrar exactamente el vecino más cercano.

Idea central de HNSW:

  • Construir una estructura de grafo multicapa: capas superiores dispersas, capas inferiores densas.
  • Al consultar, se comienza desde la entrada de la capa superior y se juega al "juego de saltos": en cada capa se salta codiciosamente a los nodos más cercanos y luego se desciende a la siguiente capa.
  • Reduce significativamente el número de nodos a comparar, con una complejidad temporal aproximada de O(log n).

Otros índices comunes

Tipo de índiceCaracterísticasEscenarios de aplicación
Flat (fuerza bruta)Preciso pero lentoConjuntos de datos pequeños, prioridad a la precisión
IVF_FlatBúsqueda exacta tras agrupamiento, rápidaEscala media-grande, memoria suficiente
IVF_PQCompresión por cuantización, ahorra memoriaEscala ultra grande, memoria limitada
HNSWRápido, preciso, alto uso de memoriaEl más utilizado, recomendado como primera opción
ScaNNCreado por Google, optimizado para rendimiento (throughput)Entornos de producción de alta concurrencia

Comparación de las principales bases de datos vectoriales

La siguiente es una comparación horizontal de las bases de datos vectoriales más populares actualmente, para ayudarte a elegir en diferentes escenarios.

Comparación horizontal de bases de datos vectoriales principales Base de datos Tipo Método de implementación Características Escenarios de aplicación Dificultad Chroma Código abierto y gratuito DB vectorial pura Local / Nube Prioridad integrada (embebida) API minimalista, nativa en Python La integración con LangChain es la más conveniente Prototipos RAG, desarrollo de aplicaciones de IA Principiante Qdrant Código abierto y gratuito DB vectorial pura Local / Docker Servicio en la nube Implementado en Rust, alto rendimiento Soporta filtrado + búsqueda híbrida vectorial Recomendado para producción, prioridad al rendimiento Intermedio Weaviate Código abierto y gratuito DB multimodal Local / Nube SaaS API GraphQL, vectorización integrada Multimodal (texto + imágenes) Búsqueda multimodal, grafos de conocimiento Intermedio Milvus Código abierto y gratuito DB vectorial pura Implementación distribuida Kubernetes Proyecto de la Fundación LF AI Distribuido a gran escala, funciones completas Datos a escala de cientos de millones, grandes empresas Avanzado Pinecone SaaS comercial DB vectorial administrada Solo nube Servicio totalmente administrado Cero operaciones, listo para usar Plan gratuito disponible Lanzamiento rápido, equipos sin capacidad de operaciones Principiante pgvector Complemento de código abierto Extensión PG PostgreSQL existente Usar directamente en el entorno Reutilizar la infraestructura PG existente Interfaz SQL, la más rápida de aprender Proyectos que ya usan PG, integración ligera Principiante

Recomendación para principiantes: comienza con Chroma o pgvector; el primero es adecuado para prototipos de aplicaciones de IA, el segundo para proyectos que ya usan PostgreSQL.


Inicio rápido: ejemplo en Python

A continuación, se utiliza Chroma (el más fácil de aprender) para demostrar el flujo completo de crear, leer, actualizar y eliminar (CRUD).

Instalación

Ejemplo

pip install chromadb openai

Ejemplo completo: construcción de un sistema de búsqueda semántica de documentos

El siguiente código demuestra de principio a fin cómo usar Chroma para construir un sistema de búsqueda de documentos basado en semántica.

Ejemplo

import chromadb
from chromadb.utils import embedding_functions

# ─── 1. Inicializar el cliente ───────────────────────────────────────────
# Persistencia local (recomendado)
client = chromadb.PersistentClient(path="./my_vector_db")

# Usar el modelo de embeddings de OpenAI (también se puede cambiar por un modelo local)
openai_ef = embedding_functions.OpenAIEmbeddingFunction(
    api_key="your-openai-api-key",       # Obligatorio: reemplaza con tu API Key
    model_name="text-embedding-3-small"   # 1536 dimensiones, buena relación costo-beneficio
)

# ─── 2. Crear una colección (similar a una "tabla" en bases de datos relacionales) ────────────────────────
collection = client.get_or_create_collection(
    name="my_documents",                   # Nombre de la colección
    embedding_function=openai_ef,          # Vincular la función de embeddings
    metadata={"hnsw:space": "cosine"}      # Usar similitud coseno
)

# ─── 3. Insertar documentos ──────────────────────────────────────────────
documents = [
    "Python es un lenguaje de programación interpretado y orientado a objetos, ampliamente utilizado en ciencia de datos y desarrollo de IA",
    "El aprendizaje automático es un subcampo de la inteligencia artificial que permite a las computadoras aprender patrones a partir de datos",
    "El aprendizaje profundo utiliza redes neuronales multicapa y destaca en tareas de reconocimiento de imágenes y PNL",
    "Las bases de datos vectoriales almacenan vectores de alta dimensión y admiten búsqueda por similitud semántica",
    "PostgreSQL es un potente sistema de gestión de bases de datos relacionales de código abierto",
    "Redis es una base de datos clave-valor de alto rendimiento basada en memoria, comúnmente utilizada para caché",
    "La tecnología de contenedores Docker permite que las aplicaciones se ejecuten de manera consistente en cualquier entorno",
    "Git es un sistema de control de versiones distribuido y una herramienta fundamental en el desarrollo de software moderno",
]

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

# Inserción por lotes (Chroma llama automáticamente al modelo de embeddings para convertir a vectores y luego los almacena)
collection.add(
    documents=documents,
    ids=ids,
    metadatas=[{"source": "tutorial", "index": i} for i in range(len(documents))]
)

print(f"Se insertaron {len(documents)} documentos")
已插入 8 条文档

Ejemplo

# ─── 4. Búsqueda semántica ──────────────────────────────────────────────
query = "Cómo hacer inteligencia artificial con Python"

results = collection.query(
    query_texts=[query],
    n_results=3,                # Devuelve los 3 más similares
    include=["documents", "distances", "metadatas"]
)

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

Ejemplo

# ─── 5. Búsqueda con filtros (filtrado por metadatos) ────────────────────────
results_filtered = collection.query(
    query_texts=["Tecnología de bases de datos"],
    n_results=2,
    where={"source": "tutorial"},        # Buscar solo en documentos con source=tutorial
    include=["documents", "distances"]
)

# ─── 6. Actualizar documentos ──────────────────────────────────────────────
collection.update(
    ids=["doc_0"],
    documents=[Python es actualmente el lenguaje de programación más popular, con amplia aplicación en IA, análisis de datos y desarrollo web.],
    metadatas=[{"source": "tutorial", "index": 0, "updated": True}]
)

# ─── 7. Eliminar documentos ──────────────────────────────────────────────
collection.delete(ids=["doc_7"])   # Eliminar documentos relacionados con Git

# ─── 8. Ver estadísticas de la colección ──────────────────────────────────────────
print(f"Número de documentos en la colección actual: {collection.count()}")

Sin usar API de embedding de terceros (100% local)

Si no quieres usar la API de OpenAI, puedes usar un modelo de embedding local para ejecutarlo completamente sin conexión.

Ejemplo

import chromadb
from sentence_transformers import SentenceTransformer

# Usar modelo de embedding local (sin API Key, completamente sin conexión)
model = SentenceTransformer("paraphrase-multilingual-MiniLM-L12-v2")  # Soporta chino

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

texts = ["Hoy hace buen tiempo", "Hace sol, ideal para salir", "El mercado de valores subió mucho", "Mañana puede llover"]

# Generar los vectores manualmente e insertarlos
embeddings = model.encode(texts).tolist()
collection.add(
    embeddings=embeddings,
    documents=texts,
    ids=[f"id_{i}" for i in range(len(texts))]
)

# Consulta
query_embedding = model.encode(["¿Cómo está el tiempo hoy?"]).tolist()
results = collection.query(query_embeddings=query_embedding, n_results=2)
print(results["documents"])
# Salida: [['Hoy hace buen tiempo', 'Hace sol, ideal para salir']]

Ejemplo con pgvector (para usuarios de PostgreSQL)

Si tu proyecto ya usa PostgreSQL, pgvector es la forma más ligera de integrarlo.

Ejemplo

-- Instalar la extensión
CREATE EXTENSION IF NOT EXISTS vector;

-- Crear tabla: almacenar títulos de artículos y sus vectores (1536 dimensiones)
CREATE TABLE articles (
    id       SERIAL PRIMARY KEY,
    title    TEXT NOT NULL,
    content  TEXT,
    embedding vector(1536)           -- Columna de vector, 1536 dimensiones
);

-- Crear índice HNSW para acelerar consultas
CREATE INDEX ON articles
USING hnsw (embedding vector_cosine_ops)
WITH (m = 16, ef_construction = 64);

-- Insertar datos (los vectores se generan en la capa de aplicación y luego se pasan)
INSERT INTO articles (title, embedding)
VALUES ('Guía de inicio de Python', '[0.12, -0.54, 0.87, ...]'::vector);

-- Búsqueda semántica: encontrar los 5 artículos más similares
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;

Nota: <=> es el operador de distancia vectorial proporcionado por pgvector, se usa para calcular la distancia coseno. Restar la distancia coseno de 1 da la similitud coseno.


Casos de uso típicos

Los casos de uso de las bases de datos vectoriales en la era de la IA son muy amplios. A continuación se presenta una visión general de los seis escenarios más típicos.

Casos de uso típicos de las bases de datos vectoriales RAG Preguntas y respuestas con base de conocimiento RAG Convertir documentos empresariales en vectores, recuperar fragmentos relevantes cuando el usuario pregunta y entregarlos al LLM para generar respuestas. Representantes: ChatPDF, NotionAI Asistente de base de conocimiento empresarial Recomendación Sistema de recomendación personalizado Convertir el comportamiento del usuario y la información de productos en vectores, buscar "qué les gusta a los usuarios con gustos similares" para hacer recomendaciones. Representante: recomendación de canciones de Spotify Recomendación de productos relacionados en comercio electrónico Imagen Búsqueda por imagen Codificar imágenes como vectores, y mediante búsqueda por similitud encontrar imágenes visualmente similares, sin necesidad de etiquetas. Representante: Búsqueda de imágenes de Google Taobao: buscar productos con foto Detección Detección de anomalías El comportamiento normal se mapea a regiones vectoriales agrupadas; los vectores de comportamiento anómalo se alejan de las regiones normales y así se detectan. Representante: detección de intrusos en redes Detección de fraude financiero Deduplicación Deduplicación de contenido / detección de derechos de autor Usar la similitud vectorial para determinar si dos fragmentos de contenido son altamente similares, e identificar plagio o contenido duplicado. Representante: sistema de verificación de similitud de tesis Detección de derechos de autor musicales Rostro Reconocimiento facial / biométrico Codificar el rostro como un vector de características, buscar en la base de datos vectorial los rostros conocidos más similares para completar el reconocimiento. Representante: sistema de control de acceso facial Desbloqueo facial en teléfonos móviles

Arquitectura RAG (Generación aumentada por recuperación)

RAG es actualmente uno de los casos de uso más importantes de las bases de datos vectoriales. A continuación se muestra su flujo de trabajo principal:

Flujo de trabajo del sistema RAG Step 1 El usuario pregunta "¿Cómo maneja Python las excepciones?" Step 2 Vectorización de la pregunta Modelo de embedding -> [0.12, -0.54, ...] Step 3 Búsqueda vectorial En la base de datos vectorial encontrar los documentos más similares Step 4 Generación con LLM Contenido recuperado + pregunta -> Prompt -> respuesta Step 5 Devolver la respuesta Basada en documentos, respuesta precisa y trazable La base de datos vectorial juega un papel central en el paso 3: encontrar los fragmentos de conocimiento más relevantes en milisegundos.

Recomendaciones de selección y mejores prácticas

Árbol de decisión para la selección

Según tu situación concreta, sigue el siguiente árbol de decisión para elegir la base de datos vectorial adecuada:

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

Elección del modelo de embedding

Elegir un modelo de embedding adecuado es el primer paso clave en las aplicaciones de bases de datos vectoriales.

NecesidadModelo recomendado
Textos en chino e inglés (alta calidad)OpenAI text-embedding-3-small
Textos en chino (local sin conexión)BAAI/bge-large-zh-v1.5
Multilingüe generalparaphrase-multilingual-MiniLM-L12-v2
Multimodal imagen-textoOpenAI CLIPSerie

Consejos de optimización del rendimiento

1. Inserción por lotes: inserta varios registros a la vez, evita escrituras individuales frecuentes.

Ejemplo

# Recomendado: inserción por lotes
collection.add(documents=docs_list, ids=ids_list)

# No recomendado: bucle de inserción individual (reindexa cada vez, muy ineficiente)
# for doc, id in zip(docs_list, ids_list):
#     collection.add(documents=[doc], ids=[id])

2. Normalización de vectores: antes de usar la similitud coseno, normalizar los vectores de antemano puede acelerar el cálculo.

Ejemplo

import numpy as np

def normalize(v):
    """Normaliza el vector con L2 para que la norma sea 1"""
    return v / np.linalg.norm(v)

3. Configura n_results de forma razonable: no establezcas un top_k muy grande sin pensar; normalmente 3~10 resultados son suficientes en escenarios RAG.

4. Usa bien el filtrado por metadatos: combina condiciones where al buscar para reducir el alcance de la búsqueda.

Ejemplo

# Buscar solo en la categoría "documentación técnica" para reducir el alcance y mejorar la precisión
collection.query(
    query_texts=["Manejo de excepciones en Python"],
    where={"category": "tech_doc"},
    n_results=5
)

5. Reconstruye el índice periódicamente: cuando la cantidad de datos crezca, reconstruye el índice HNSW a su debido tiempo para mantener el rendimiento de las consultas.

Errores comunes

A continuación se presentan los problemas más comunes que enfrentan los principiantes al usar bases de datos vectoriales y sus soluciones.

ProblemaDescripciónSolución
El modelo de embedding debe ser coherenteLa inserción y la consulta deben usar el mismo modeloFija la versión del modelo en el archivo de configuración
Discrepancia de dimensionesSe cambió el modelo pero no se reconstruyó la colecciónAl cambiar de modelo, elimina y reconstruye la colección
Texto demasiado largoLa mayoría de los modelos tienen un límite de tokens (512~8192)Para textos muy largos, primero haz chunking (división en bloques)
Similitud inexactaEl texto no está dividido en bloques, la semántica se diluyeDivide el documento por párrafos o longitud fija
Arranque en frío lentoCon grandes volúmenes de datos, la primera carga del índice tarda muchoPrecalienta con antelación o usa índices persistentes

Resumen

Repasemos los puntos clave de este tutorial:

Repaso de los conceptos clave de Vector Database Vectores / embeddings Convertir objetos en vectores numéricos de alta dimensión la cercanía semántica implica cercanía en distancia es la base de todo Cálculo de similitud Similitud coseno Distancia euclidiana Producto punto Para texto, se prefiere coseno Algoritmos de indexación HNSW es el más utilizado IVF es adecuado para grandes escalas Flat es adecuado para datos pequeños Aproximación a cambio de velocidad Referencia de selección Para empezar: Chroma Producción: Qdrant Si ya tienes PG: pgvector Escala de cientos de millones: Milvus Aplicaciones principales Preguntas y respuestas con RAG Recomendaciones personalizadas Búsqueda por imagen Detección de anomalías

Las bases de datos vectoriales son una parte importante de la infraestructura en la era de la IA.

Resuelve el problema de búsqueda de similitud semántica que las bases de datos tradicionales no pueden manejar, y es un componente central para la construcción de sistemas RAG, sistemas de recomendación y búsqueda multimodal.

Sugerencias de ruta de aprendizaje

  1. Primer paso: comprender los conceptos de vectores e incrustaciones, y ejecutar el ejemplo de Chroma de este artículo.
  2. Segundo paso: intentar construir un sistema simple de preguntas y respuestas sobre documentos usando LangChain + Chroma.
  3. Tercer paso: aprender algoritmos de indexación como HNSW y comprender el equilibrio entre precisión y velocidad.
  4. Cuarto paso: elegir la base de datos vectorial adecuada según las necesidades del proyecto real y desplegarla en el entorno de producción.

Recursos de referencia

Otras extensiones