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 datos | Método de búsqueda | Analogía |
|---|---|---|
| Base de datos tradicional | Búsqueda exacta por número de libro, título | Encontrar un libro con un código específico |
| Base de datos vectorial | Búsqueda por relevancia del contenido | Encontrar "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.
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.
Semántica cercana, vectores cercanos
Usemos un ejemplo simplificado en 2D para entenderlo (en realidad son cientos o miles de dimensiones):
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
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
# 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.
| Aspecto | Descripción |
|---|---|
| Principio | Recorre todos los vectores y calcula la similitud uno a uno. |
| Ventajas | Resultado 100% preciso |
| Desventajas | Extremadamente lento con grandes volúmenes de datos, complejidad O(n) |
| Aplicación | Volumen de datos inferior a 100,000, requisitos extremadamente altos de precisión |
IVF (Índice de archivos invertidos)
Pasos de ejecución de IVF:
- Fase de entrenamiento: usar K-Means para agrupar todos los vectores en N clústeres y registrar el centro de cada clúster.
- 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.
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 índice | Características | Escenarios de aplicación |
|---|---|---|
| Flat (fuerza bruta) | Preciso pero lento | Conjuntos de datos pequeños, prioridad a la precisión |
| IVF_Flat | Búsqueda exacta tras agrupamiento, rápida | Escala media-grande, memoria suficiente |
| IVF_PQ | Compresión por cuantización, ahorra memoria | Escala ultra grande, memoria limitada |
| HNSW | Rápido, preciso, alto uso de memoria | El más utilizado, recomendado como primera opción |
| ScaNN | Creado 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.
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
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
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
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
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
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
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.
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:
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.
| Necesidad | Modelo 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 general | paraphrase-multilingual-MiniLM-L12-v2 |
| Multimodal imagen-texto | OpenAI CLIPSerie |
Consejos de optimización del rendimiento
1. Inserción por lotes: inserta varios registros a la vez, evita escrituras individuales frecuentes.
Ejemplo
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
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
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.
| Problema | Descripción | Solución |
|---|---|---|
| El modelo de embedding debe ser coherente | La inserción y la consulta deben usar el mismo modelo | Fija la versión del modelo en el archivo de configuración |
| Discrepancia de dimensiones | Se cambió el modelo pero no se reconstruyó la colección | Al cambiar de modelo, elimina y reconstruye la colección |
| Texto demasiado largo | La 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 inexacta | El texto no está dividido en bloques, la semántica se diluye | Divide el documento por párrafos o longitud fija |
| Arranque en frío lento | Con grandes volúmenes de datos, la primera carga del índice tarda mucho | Precalienta con antelación o usa índices persistentes |
Resumen
Repasemos los puntos clave de este tutorial:
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
- Primer paso: comprender los conceptos de vectores e incrustaciones, y ejecutar el ejemplo de Chroma de este artículo.
- Segundo paso: intentar construir un sistema simple de preguntas y respuestas sobre documentos usando LangChain + Chroma.
- Tercer paso: aprender algoritmos de indexación como HNSW y comprender el equilibrio entre precisión y velocidad.
- Cuarto paso: elegir la base de datos vectorial adecuada según las necesidades del proyecto real y desplegarla en el entorno de producción.