Tutorial: RAG básico con LangChain + ChromaDB

RAG con LangChain + ChromaDB — De Cero a Producción

RAG (Retrieval Augmented Generation) permite que un LLM responda preguntas basándose en tus documentos, no solo en su entrenamiento. Este tutorial construye un sistema RAG completo paso a paso.

Instalación

pip install langchain langchain-openai langchain-community chromadb tiktoken

Paso 1: Cargar documentos

from langchain_community.document_loaders import (
    DirectoryLoader, TextLoader, PyPDFLoader
)

# Cargar todos los .txt de una carpeta
loader = DirectoryLoader(
    './docs/',
    glob="**/*.txt",
    loader_cls=TextLoader,
    show_progress=True,
)
documents = loader.load()
print(f"Documentos cargados: {len(documents)}")

# O cargar un PDF
pdf_docs = PyPDFLoader("manual.pdf").load()

Paso 2: Dividir en chunks

from langchain.text_splitter import RecursiveCharacterTextSplitter

splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,       # Caracteres por chunk
    chunk_overlap=200,     # Overlap entre chunks para no perder contexto
    separators=["

", "
", ". ", " ", ""],
)
chunks = splitter.split_documents(documents)
print(f"Chunks generados: {len(chunks)}")

# Cada chunk tiene .page_content y .metadata
for chunk in chunks[:3]:
    print(f"  [{chunk.metadata['source']}] {chunk.page_content[:80]}...")

Paso 3: Crear embeddings y vector store

from langchain_openai import OpenAIEmbeddings
from langchain_community.vectorstores import Chroma

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

# Crear base de datos vectorial (persiste en disco)
vectorstore = Chroma.from_documents(
    documents=chunks,
    embedding=embeddings,
    persist_directory="./chroma_db",
    collection_name="mis_documentos",
)
print(f"Vectores almacenados: {vectorstore._collection.count()}")

Paso 4: Retrieval + LLM

from langchain_openai import ChatOpenAI
from langchain.chains import RetrievalQA
from langchain.prompts import PromptTemplate

llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)

template = """Usa el siguiente contexto para responder la pregunta.
Si no encuentras la respuesta en el contexto, di "No tengo información sobre eso."

Contexto:
{context}

Pregunta: {question}

Respuesta útil:"""

prompt = PromptTemplate(
    template=template,
    input_variables=["context", "question"],
)

qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",
    retriever=vectorstore.as_retriever(
        search_type="mmr",           # Diversidad en resultados
        search_kwargs={"k": 5},      # Top 5 chunks más relevantes
    ),
    chain_type_kwargs={"prompt": prompt},
    return_source_documents=True,
)

# Hacer una pregunta
result = qa_chain.invoke({"query": "¿Cómo configuro las credenciales?"})
print(result["result"])
for doc in result["source_documents"]:
    print(f"  Fuente: {doc.metadata['source']}")

Paso 5: API con FastAPI

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

# Cargar vectorstore existente al iniciar
vectorstore = Chroma(
    persist_directory="./chroma_db",
    embedding_function=OpenAIEmbeddings(model="text-embedding-3-small"),
    collection_name="mis_documentos",
)
qa_chain = RetrievalQA.from_chain_type(
    llm=ChatOpenAI(model="gpt-4o-mini", temperature=0),
    retriever=vectorstore.as_retriever(search_kwargs={"k": 5}),
    return_source_documents=True,
)

class Question(BaseModel):
    query: str

@app.post("/ask")
async def ask(q: Question):
    result = qa_chain.invoke({"query": q.query})
    return {
        "answer": result["result"],
        "sources": [d.metadata["source"] for d in result["source_documents"]],
    }

Tips de producción

• Chunk size: 500-1000 chars para documentos técnicos, 1000-2000 para narrativos
• Embedding model: text-embedding-3-small es 5x más barato que ada-002 y mejor calidad
• Costos: Embeddings ~$0.02 por 1M tokens. Un libro completo cuesta ~$0.01
• Actualizar docs: Recrea el vectorstore cuando cambien los documentos fuente
• Alternativa a ChromaDB: Supabase con pgvector para producción (más robusto)