Pipeline RAG con Python y LangChain — procesamiento de documentos con IA

RAG con Python y LangChain: construye un chatbot con tus propios documentos

8 min read

Prerrequisitos: Python 3.9+, conocimientos básicos de Python, cuenta en OpenAI (con créditos disponibles). No necesitas experiencia previa con LLMs ni LangChain.

Imagina esto: tienes un LLM integrado en tu app, un usuario pregunta algo sobre tu documentación interna, y el modelo responde con total seguridad... pero inventando. Eso es una alucinación, y en producción es inaceptable. RAG (Retrieval Augmented Generation) resuelve esto: en lugar de esperar que el modelo recuerde lo que nunca aprendió, le entregamos los documentos relevantes en cada llamada. El resultado es un chatbot que cita fuentes reales. En este tutorial construimos el pipeline completo desde cero: carga de PDFs, embeddings, vectorstore FAISS y una cadena de Q&A con código ejecutable que puedes adaptar hoy mismo.

Regla práctica: si el problema es 'el modelo no sabe X', usa RAG. Si es 'el modelo no responde con el tono que quiero', considera fine-tuning. RAG es más rápido, más barato y no requiere datos etiquetados.

Sin RAG el LLM opera solo con su entrenamiento. Con RAG recibe contexto real de tus documentos antes de responder

Pipeline RAG completo: desde los documentos crudos hasta la respuesta final con fuentes citadas

Deberías ver: LangChain 0.3.x instalado. Si ves un error de importación, asegúrate de tener activado el entorno virtual (.venv).

Deberías ver al ejecutar python3 ingest.py: 'Cargadas X páginas', 'Generados Y chunks', 'Vectorstore guardado'. Si ves un error de autenticación, verifica tu OPENAI_API_KEY en el .env.

El chunk_overlap es el parámetro que más impacta la calidad de respuestas. Con documentos de frases largas o tablas, sube el overlap a 300-400. Con FAQs o listas cortas, puedes bajarlo a 100. No hay valor universal — experimenta con tus datos.

temperature=0 es deliberado. Para Q&A factual sobre documentos necesitas respuestas deterministas y precisas. Si subes la temperatura, el modelo 'creará' variaciones de la respuesta que pueden no estar en tus documentos.

El costo de embeddings con text-embedding-3-small es mínimo ($0.02/M tokens). El costo que escala es la generación con el LLM. Para proyectos con preguntas repetitivas, implementa caché de respuestas — incluso un diccionario en memoria reduce los costos significativamente.

Lo que aprendiste: • RAG amplía el conocimiento del LLM sin reentrenarlo • chunk_overlap controla la continuidad entre fragmentos • El prompt template es la guardia que evita alucinaciones • return_source_documents hace el sistema auditable

Siguiente paso: exponer la cadena como API REST con FastAPI, o conectarla a un frontend con el Vercel AI SDK. Ambas integraciones son directas una vez que el pipeline es estable en local.

Tutoriales cada dos semanas

Sin spam. Solo artículos técnicos cuando salen.

Paso 3: la cadena RAG — retriever + prompt + LLM#

Aquí está la pieza más importante. Antes de ver el código, pregúntate: ¿qué pasaría si no le dices explícitamente al LLM que responda solo con el contexto? Combinaría el contexto con su entrenamiento y volverías al punto de partida. El prompt template es lo que impide eso.

Python

# main.py
from langchain_openai import OpenAIEmbeddings, ChatOpenAI
from langchain_community.vectorstores import FAISS
from langchain.chains import RetrievalQA
from langchain.prompts import PromptTemplate
from dotenv import load_dotenv

load_dotenv()

# Prompt que fuerza respuestas basadas SOLO en el contexto
PROMPT_TEMPLATE = """Usa únicamente el siguiente contexto para responder.
Si la información no está en el contexto, responde exactamente:
'No tengo información suficiente para responder eso.'

Contexto: {context}
Pregunta: {question}
Respuesta:"""

def cargar_cadena_rag() -> RetrievalQA:
    embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
    vectorstore = FAISS.load_local(
        "./vectorstore", embeddings,
        allow_dangerous_deserialization=True  # solo con vectorstores propios
    )

    # k=4: recupera los 4 chunks más relevantes por consulta
    retriever = vectorstore.as_retriever(
        search_type="similarity",
        search_kwargs={"k": 4}
    )

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

    return RetrievalQA.from_chain_type(
        llm=llm,
        chain_type="stuff",
        retriever=retriever,
        chain_type_kwargs={"prompt": PromptTemplate(
            template=PROMPT_TEMPLATE,
            input_variables=["context", "question"]
        )},
        return_source_documents=True  # muestra las fuentes al usuario
    )

if __name__ == "__main__":
    cadena = cargar_cadena_rag()
    while True:
        pregunta = input("\n❓ Pregunta (o 'salir'): ").strip()
        if pregunta.lower() == "salir":
            break
        resultado = cadena.invoke({"query": pregunta})
        print(f"\n🤖 {resultado['result']}")
        for doc in resultado["source_documents"]:
            print(f"   📄 {doc.metadata.get('source')} — pág. {doc.metadata.get('page', '?')}")

RAG con Python y LangChain: construye un chatbot con tus propios documentos

Tutoriales cada dos semanas

También te puede interesar

Hablemos

El problema: qué hace un LLM sin contexto#

Cómo funciona RAG por dentro: el pipeline completo#

Resumen: lo que construiste#

Paso 1: instalación y estructura del proyecto#

Paso 2: cargar y vectorizar tus documentos#

Paso 3: la cadena RAG — retriever + prompt + LLM#

Paso 4: optimizaciones antes de pasar a producción#