Almacén vectorial con FAISS
En esta página
FAISS: búsqueda vectorial de alto rendimiento
Ya has calculado y guardado tus embeddings, pero una matriz de NumPy no es un motor de búsqueda: comparar una consulta con 100.000 vectores mediante un bucle en Python llevaría varios segundos por pregunta. FAISS (Facebook AI Similarity Search) resuelve exactamente este problema. Esta biblioteca de código abierto de Meta está diseñada para la búsqueda por similitud en grandes conjuntos de vectores; es rápida, eficiente en memoria y funciona igual de bien con unos pocos cientos de vectores que con millones. La instalación requiere un único comando. faiss-cpu es suficiente en la gran mayoría de los casos; faiss-gpu solo se justifica para volúmenes donde el cómputo se convierte en el cuello de botella.
# pip install faiss-cpu
# o faiss-gpu para aceleración por GPU
import faiss
import numpy as np
Crea tu primer índice
El índice más sencillo es IndexFlatL2, que realiza una búsqueda exhaustiva usando la distancia L2 (euclídea). «Exhaustiva» significa que compara realmente la consulta con cada vector almacenado: sin aproximaciones, por lo que no hay resultados perdidos. Lo inicializas con la dimensión del vector: 1024 para mistral-embed, un valor que lees directamente de la forma de la matriz en lugar de hardcodearlo. Convertir a float32 no es opcional: FAISS rechaza el float64 que NumPy produce por defecto, y olvidar este detalle es el primer error que comete todo principiante.
# Supongamos que nuestros embeddings son una matriz de NumPy
# embeddings.shape = (n_chunks, 1024)
# Crear el índice
dimension = embeddings.shape[1] # 1024 para mistral-embed
index = faiss.IndexFlatL2(dimension)
# Añadir los vectores
index.add(embeddings.astype(np.float32)) # FAISS requiere float32
print(f"Índice creado: {index.ntotal} vectores de dimensión {dimension}")
Elegir el tipo de índice adecuado
FAISS no ofrece un único índice, sino una familia de ellos, y la elección implica un compromiso entre precisión y velocidad. Los dos primeros, IndexFlatL2 e IndexFlatIP, son exactos: solo difieren en la métrica utilizada, distancia euclídea para uno, producto escalar para el otro. IndexIVFFlat cambia la lógica al particionar el espacio en clústeres y buscar solo en los más prometedores, lo que acelera significativamente la búsqueda a costa de una ligera pérdida de exhaustividad (recall), y requiere un entrenamiento previo con tus datos. Por último, IndexHNSWFlat construye un grafo de vecinos y resulta muy rápido durante las consultas; aquí el parámetro 32 establece el número de vecinos retenidos por nodo.
dimension = 1024
# 1. IndexFlatL2: Búsqueda exacta, distancia L2
# Más preciso, pero más lento para grandes volúmenes
index_flat_l2 = faiss.IndexFlatL2(dimension)
# 2. IndexFlatIP: Búsqueda exacta, producto escalar (producto interno)
# Usar con vectores normalizados para similitud del coseno
index_flat_ip = faiss.IndexFlatIP(dimension)
# 3. IndexIVFFlat: Búsqueda aproximada con particionamiento
# Más rápido para grandes volúmenes, ligera pérdida de precisión
nlist = 100 # Número de particiones (clústeres)
quantizer = faiss.IndexFlatL2(dimension)
index_ivf = faiss.IndexIVFFlat(quantizer, dimension, nlist)
# Requiere entrenamiento antes de usar:
# index_ivf.train(embeddings)
# index_ivf.add(embeddings)
# 4. IndexHNSWFlat: Grafo de vecinos (búsqueda muy rápida)
index_hnsw = faiss.IndexHNSWFlat(dimension, 32) # 32 = número de vecinos
Consultar el índice
La búsqueda ocurre en tres pasos. Primero, codifica la pregunta del usuario con el mismo modelo que el corpus: una consulta codificada por un modelo diferente produciría distancias sin sentido. FAISS devuelve entonces dos arrays paralelos: las distancias y los índices de los k vecinos más cercanos. Estos índices son posiciones en tu lista de fragmentos (chunks): aquí es donde la disciplina de la lección anterior da sus frutos, ya que la alineación entre la matriz y los metadatos es lo que te permite rastrear el texto y su fuente. La comprobación if idx >= 0 cubre el caso en que el índice contiene menos de k vectores, situación en la que FAISS rellena los huecos faltantes con -1.
from mistralai.client import Mistral
client = Mistral(api_key=api_key)
def search_index(query, index, chunks, k=5):
"""Buscar fragmentos más cercanos a una consulta."""
# 1. Codificar la consulta
response = client.embeddings.create(
model="mistral-embed",
inputs=[query],
)
query_vector = np.array([response.data[0].embedding], dtype=np.float32)
# 2. Buscar en FAISS
distances, indices = index.search(query_vector, k)
# 3. Formatear resultados
results = []
for i, (dist, idx) in enumerate(zip(distances[0], indices[0])):
if idx >= 0: # FAISS devuelve -1 si no hay suficientes resultados
results.append({
"rank": i + 1,
"distance": float(dist),
"text": chunks[idx]["text"],
"source": chunks[idx].get("source", ""),
})
return results
# Ejemplo de búsqueda
results = search_index("¿Cómo funciona RAG?", index, chunks)
for r in results:
print(f" #{r['rank']} (dist: {r['distance']:.4f}) [{r['source']}]")
print(f" {r['text'][:100]}...")
Cambiar a similitud del coseno
FAISS no ofrece un índice «coseno» explícito, pero el álgebra proporciona un equivalente gratuito: para vectores con norma 1, el producto escalar es el coseno. Simplemente divides cada vector por su norma y luego usas IndexFlatIP. Este cambio está lejos de ser teórico: la distancia L2 es sensible a la longitud del vector, por lo que un fragmento muy largo puede acabar artificialmente lejos de una consulta corta aunque sus temas coincidan. El coseno mide solo la orientación, es decir, el significado, y eso es generalmente lo que quieres comparar.
def create_cosine_index(embeddings):
"""Crear un índice FAISS con similitud del coseno."""
# Normalizar vectores (norma L2 = 1)
norms = np.linalg.norm(embeddings, axis=1, keepdims=True)
normalized = (embeddings / norms).astype(np.float32)
# Usar IndexFlatIP (producto escalar = coseno para vectores normalizados)
dimension = normalized.shape[1]
index = faiss.IndexFlatIP(dimension)
index.add(normalized)
return index
cosine_index = create_cosine_index(embeddings)
Al igual que con los embeddings, el índice persiste en disco. faiss.write_index produce un archivo binario que faiss.read_index recarga tal cual, incluidas las estructuras internas, lo cual es crucial para los índices entrenados, donde de otro modo habría que repetir la reconstrucción.
# Guardar
faiss.write_index(index, "rag_faiss.index")
print("Índice FAISS guardado")
# Cargar
index_loaded = faiss.read_index("rag_faiss.index")
print(f"Índice cargado: {index_loaded.ntotal} vectores")
Cuando el corpus se vuelve masivo
A partir de varios cientos de miles de vectores, la búsqueda exhaustiva se vuelve demasiado lenta y el índice IVF (archivo invertido) se vuelve necesario. Su ciclo de vida incluye un paso que los índices planos no tienen: el entrenamiento, que analiza la distribución de tus datos para colocar los centroides de las nlist particiones. A continuación viene la adición de los vectores y luego el ajuste de nprobe, el mando que decide cuántas particiones se explorarán por consulta. Aumentar nprobe mejora la exhaustividad (recall) y ralentiza la búsqueda; este es el parámetro que ajustarás midiendo, sobre un conjunto representativo de preguntas, el punto en el que los resultados dejan de mejorar.
def create_ivf_index(embeddings, nlist=100, nprobe=10):
"""Crear un índice IVF para grandes volúmenes."""
dimension = embeddings.shape[1]
data = embeddings.astype(np.float32)
# Crear el cuantificador y el índice IVF
quantizer = faiss.IndexFlatL2(dimension)
index = faiss.IndexIVFFlat(quantizer, dimension, nlist)
# Entrenar el índice (requerido para IVF)
print("Entrenando índice...")
index.train(data)
# Añadir los vectores
index.add(data)
# Número de particiones a explorar durante la búsqueda
index.nprobe = nprobe # Mayor = más preciso, más lento
print(f"Índice IVF creado: {index.ntotal} vectores, {nlist} particiones")
return index
# Para más de 100K vectores
# large_index = create_ivf_index(embeddings, nlist=256, nprobe=20)
Puntos clave
- FAISS es el estándar para la búsqueda vectorial rápida
IndexFlatL2para corpus pequeños (menos de 100K vectores), búsqueda exactaIndexIVFFlatpara corpus grandes, búsqueda aproximada pero rápida- Normaliza los vectores y usa
IndexFlatIPpara similitud del coseno - Guarda el índice en disco con
faiss.write_indexpara evitar reconstruirlo