ChromaDB base de datos vectorial

Instalación y configuración de ChromaDB

ChromaDB representa un salto cualitativo respecto a FAISS en términos de persistencia y gestión de datos vectoriales. Mientras que FAISS requiere implementar manualmente la persistencia, ChromaDB ofrece almacenamiento automático y una arquitectura cliente-servidor que facilita el desarrollo de aplicaciones RAG robustas.

Instalación mediante Docker

La forma más eficiente de ejecutar ChromaDB es mediante Docker. Crea un archivo docker-compose.yml:

version: '3.8'
services:
  chroma:
    container_name: chroma
    image: chromadb/chroma:1.0.10
    ports:
      - "8000:8000"
    environment:
      - CHROMA_SERVER_HOST=0.0.0.0
      - CHROMA_SERVER_HTTP_PORT=8000
      - IS_PERSISTENT=TRUE
      - PERSIST_DIRECTORY=/chroma/chroma
    volumes:
      - chroma_data:/chroma/chroma

volumes:
  chroma_data:

Para iniciar el servicio:

docker-compose up -d

Instalación de dependencias Python

ChromaDB requiere paquetes específicos para integrarse correctamente con LangChain:

pip install chromadb langchain-chroma langchain-openai

Configuración básica del cliente

Una vez que el servidor ChromaDB esté ejecutándose, configura el cliente Python:

from langchain_chroma import Chroma
from langchain_openai import OpenAIEmbeddings
import chromadb

client = chromadb.HttpClient(host="localhost", port=8000)

embeddings = OpenAIEmbeddings(model="text-embedding-3-small")

vector_store = Chroma(
    client=client,
    collection_name="documentos_rag",
    embedding_function=embeddings,
)

Configuración de colecciones

ChromaDB organiza los datos en colecciones, que funcionan como espacios de nombres independientes:

vector_store_legal = Chroma(
    client=client,
    collection_name="documentos_legales",
    embedding_function=embeddings,
)

vector_store_tecnico = Chroma(
    client=client,
    collection_name="documentos_tecnicos", 
    embedding_function=embeddings,
)

Persistencia y colección de documentos

La persistencia automática de ChromaDB elimina la complejidad de gestionar manualmente el almacenamiento de vectores.

Almacenamiento de documentos

Para añadir documentos a una colección de ChromaDB:

from langchain_core.documents import Document

documentos = [
    Document(
        page_content="Python es un lenguaje de programación interpretado y de alto nivel.",
        metadata={"categoria": "programacion", "nivel": "basico", "fecha": "2025-01-15"}
    ),
    Document(
        page_content="FastAPI es un framework web moderno para construir APIs con Python.",
        metadata={"categoria": "web", "nivel": "intermedio", "fecha": "2025-01-16"}
    ),
    Document(
        page_content="Docker permite empaquetar aplicaciones en contenedores ligeros.",
        metadata={"categoria": "devops", "nivel": "intermedio", "fecha": "2025-01-17"}
    )
]

vector_store.add_documents(documentos)

Gestión de identificadores personalizados

Cuando necesites control sobre los identificadores de documentos:

documentos_con_ids = [
    Document(
        page_content="Machine Learning es una rama de la inteligencia artificial.",
        metadata={"categoria": "ia", "autor": "equipo_datos"}
    ),
    Document(
        page_content="Deep Learning utiliza redes neuronales profundas.",
        metadata={"categoria": "ia", "autor": "equipo_datos"}
    )
]

ids_personalizados = ["ml_intro_001", "dl_intro_002"]

vector_store.add_documents(
    documents=documentos_con_ids,
    ids=ids_personalizados
)

Búsqueda y recuperación de documentos

La búsqueda por similitud constituye la funcionalidad principal:

consulta = "¿Qué es el aprendizaje automático?"
documentos_similares = vector_store.similarity_search(
    query=consulta,
    k=3
)

for doc in documentos_similares:
    print(f"Contenido: {doc.page_content}")
    print(f"Metadatos: {doc.metadata}")

Búsqueda con puntuación de similitud

Para obtener información sobre la relevancia de los resultados:

resultados_con_score = vector_store.similarity_search_with_score(
    query="frameworks web para Python",
    k=2
)

for documento, score in resultados_con_score:
    print(f"Puntuación: {score:.4f}")
    print(f"Contenido: {documento.page_content}")

Filtrado por metadatos

ChromaDB permite filtrar resultados basándose en los metadatos almacenados:

documentos_programacion = vector_store.similarity_search(
    query="lenguajes de programación",
    k=5,
    filter={"categoria": "programacion"}
)

# Filtro más complejo con múltiples condiciones
filtro_avanzado = {
    "$and": [
        {"categoria": {"$in": ["programacion", "web"]}},
        {"nivel": "intermedio"}
    ]
}

documentos_filtrados = vector_store.similarity_search(
    query="desarrollo de aplicaciones",
    k=3,
    filter=filtro_avanzado
)

Eliminación de documentos

Para mantener las colecciones actualizadas:

ids_a_eliminar = ["ml_intro_001", "dl_intro_002"]
vector_store.delete(ids=ids_a_eliminar)

Uso como Retriever en cadenas LCEL

Una de las funcionalidades más potentes de ChromaDB en LangChain es su capacidad para actuar como retriever dentro de cadenas LCEL. Esto permite integrar la búsqueda vectorial directamente en flujos de procesamiento complejos:

from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_openai import ChatOpenAI

chat_model = ChatOpenAI(model="gpt-5.4")

prompt = ChatPromptTemplate.from_template(
    "Basándote en el siguiente contexto:\n{context}\n\nResponde a: {question}"
)

retriever = vector_store.as_retriever(
    search_type="similarity",
    search_kwargs={"k": 3}
)

chain = (
    {"context": retriever, "question": lambda x: x["question"]}
    | prompt
    | chat_model
    | StrOutputParser()
)

respuesta = chain.invoke({"question": "¿Qué tecnologías están relacionadas con IA?"})
print(respuesta)

El método as_retriever() transforma el vector store en un componente compatible con LCEL, aceptando parámetros como search_type para elegir entre búsqueda por similitud estándar o búsqueda con umbral de relevancia mediante similarity_score_threshold.

Gestión de colecciones y mantenimiento

En aplicaciones de producción, es habitual gestionar múltiples colecciones dentro del mismo servidor ChromaDB. Cada colección funciona como un espacio de nombres independiente con su propio índice vectorial:

# Listar colecciones existentes
colecciones = client.list_collections()
for col in colecciones:
    print(f"Colección: {col.name}, Documentos: {col.count()}")

# Eliminar una colección completa
client.delete_collection("documentos_obsoletos")

Actualización de documentos existentes

Cuando los documentos fuente cambian, puedes actualizar los embeddings almacenados sin necesidad de recrear toda la colección:

# Actualizar documentos existentes por ID
documentos_actualizados = [
    Document(
        page_content="Python 3.14 introduce nuevas características de tipado estático.",
        metadata={"categoria": "programacion", "version": "3.14"}
    )
]

vector_store.update_documents(
    ids=["ml_intro_001"],
    documents=documentos_actualizados
)

Monitorización del rendimiento

Para aplicaciones en producción, resulta conveniente monitorizar el estado del vector store:

# Verificar el número total de documentos
coleccion = client.get_collection("documentos_rag")
total_docs = coleccion.count()
print(f"Total de documentos indexados: {total_docs}")

# Comprobar la conexión con el servidor
heartbeat = client.heartbeat()
print(f"Servidor ChromaDB activo: latencia {heartbeat}ms")

ChromaDB proporciona una solución robusta para aplicaciones RAG que requieren persistencia y escalabilidad. Su arquitectura cliente-servidor, combinada con la persistencia automática y el soporte para filtros avanzados por metadatos, lo convierte en una opción excelente tanto para entornos de desarrollo como de producción. Además, su compatibilidad total con la interfaz estándar de LangChain facilita la migración a otras soluciones vectoriales en el futuro si las necesidades del proyecto lo requieren. En la siguiente lección exploraremos PGVector, que ofrece integración con PostgreSQL para entornos empresariales.