🔍 IA generativa y RAG en tu servidor casero: el poder del conocimiento local

⚡️ ¿Por qué me interesa?

¿Estás cansado de que tus modelos de IA generen alucinaciones o no sepan nada sobre tus propios documentos? ¿Te preocupa la privacidad cuando envías datos sensibles a la nube? ¡Tenemos la solución punk definitiva! Hoy vamos a montar un sistema RAG (Recuperación Aumentada por Recuperación) en tu propio servidor casero.

Con un sistema RAG local, tus modelos de IA podrán responder preguntas con precisión basándose en tu propia información, sin depender de lo que aprendieron durante su entrenamiento. Es como darle a tu IA un cerebro extra con tus propios conocimientos.

Si ya tienes Ollama instalado o has montado Docker siguiendo nuestra guía rápida para instalar Docker sin miedo, estás a medio camino de tener tu propio sistema RAG corriendo en casa.

1️⃣ ¿Qué es RAG y por qué mola tanto?

RAG (Retrieval-Augmented Generation) es una técnica que combina lo mejor de dos mundos: la potencia creativa de los modelos generativos y la precisión de la búsqueda de información. Funciona en dos pasos principales:

• Recuperación: El sistema busca y encuentra información relevante en tus documentos o bases de datos.
• Generación: La IA usa esa información como contexto para generar respuestas precisas y contextualizadas.

Es como si tu IA tuviera a mano un bibliotecario personal que le pasa la información exacta que necesita para responder tus preguntas.

2️⃣ Ventajas de montar RAG en tu servidor casero

• Privacidad total: Tus datos nunca salen de tu red local.
• Control absoluto: Decides qué modelos usar y qué documentos incluir.
• Sin costes por API: Una vez montado, no hay que pagar por uso.
• Acceso a información propia: Tus modelos pueden consultar documentación interna, proyectos personales o información privada.
• Actualizaciones fáciles: Puedes añadir nuevos documentos en cualquier momento para mantener tu sistema al día.
• Incrustación y recuperación más rápidas: Al estar todo local, los tiempos de respuesta son mejores.

3️⃣ Componentes necesarios para tu sistema RAG

Para montar un RAG casero necesitamos varios componentes claves:

• Un modelo de lenguaje (LLM): Usaremos Ollama con modelos como Llama 3 o Mixtral.
• Un modelo de embeddings: Para convertir texto en vectores (representaciones numéricas que capturan el significado).
• Una base de datos vectorial: Para almacenar y consultar rápidamente los vectores. Usaremos ChromaDB por su sencillez.
• Herramientas de procesamiento: Para cargar, dividir y preparar los documentos.
• Una interfaz para consultas: Para interactuar con tu sistema RAG.

4️⃣ Instalación paso a paso

Vamos a montar nuestro sistema RAG usando Python, Ollama, LangChain y ChromaDB. Esto es ideal para notebooks o servidores domésticos con Python instalado.

Paso 1: Instalar Ollama

Si no lo tienes ya, instala Ollama siguiendo las instrucciones de su página web o con este comando:

curl -fsSL https://ollama.com/install.sh | sh

Paso 2: Descargar modelos necesarios

Necesitarás un modelo para generar respuestas y otro para crear embeddings:

ollama pull llama3
ollama pull all-minilm

Paso 3: Instalar dependencias de Python

Instala las bibliotecas necesarias:

pip install langchain langchain-ollama langchain_community langchain_chroma langchainhub python-dotenv

Paso 4: Crea un script para tu sistema RAG

Crea un archivo rag_system.py con el siguiente código:

from langchain import hub
from langchain.vectorstores import Chroma
from langchain_community.document_loaders import PyPDFLoader, DirectoryLoader
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnablePassthrough
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_core.prompts.chat import ChatPromptTemplate
from langchain_ollama import ChatOllama, OllamaEmbeddings

# Configurar modelos
llm = ChatOllama(model="llama3")
embeddings = OllamaEmbeddings(model="all-minilm")

# Cargar documentos (reemplaza con tu ruta)
loader = DirectoryLoader("./documentos", glob="**/*.pdf")
documents = loader.load()

# Dividir documentos en fragmentos manejables
text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
splits = text_splitter.split_documents(documents)

# Crear base de datos vectorial
vectorstore = Chroma.from_documents(documents=splits, embedding=embeddings)

# Configurar el sistema RAG
retriever = vectorstore.as_retriever()

template = """
Eres un asistente experto que responde preguntas basándose en la documentación proporcionada.
Usa sólo el contexto dado para responder. Si no encuentras la respuesta en el contexto, di que no lo sabes.

Contexto: {context}

Pregunta: {question}

Respuesta: 
"""

prompt = ChatPromptTemplate.from_template(template)

def format_docs(docs):
    return "\n\n".join(doc.page_content for doc in docs)

# Construir la cadena RAG
rag_chain = (
    {"context": retriever | format_docs, "question": RunnablePassthrough()}
    | prompt
    | llm
    | StrOutputParser()
)

# Interfaz simple para consultas
def consulta(pregunta):
    return rag_chain.invoke(pregunta)

if __name__ == "__main__":
    while True:
        pregunta = input("\nHaz una pregunta (o 'salir' para terminar): ")
        if pregunta.lower() == "salir":
            break
        print("\nBuscando respuesta...\n")
        respuesta = consulta(pregunta)
        print(respuesta)

5️⃣ Desplegar tu RAG en entornos más robustos

Si prefieres un despliegue más serio con Docker, puedes usar este enfoque:

1. Crear un archivo docker-compose.yml

version: '3'
services:
  ollama:
    image: ollama/ollama
    volumes:
      - ollama-data:/root/.ollama
    ports:
      - "11434:11434"
    restart: unless-stopped

  chromadb:
    image: chromadb/chroma
    volumes:
      - chroma-data:/chroma/data
    ports:
      - "8000:8000"
    restart: unless-stopped

  rag-app:
    build: .
    volumes:
      - ./documentos:/app/documentos
    ports:
      - "8080:8080"
    depends_on:
      - ollama
      - chromadb
    environment:
      - OLLAMA_HOST=http://ollama:11434
      - CHROMA_HOST=chromadb:8000

volumes:
  ollama-data:
  chroma-data:

2. Crear un Dockerfile

FROM python:3.10-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .

CMD ["python", "app.py"]

6️⃣ Casos de uso prácticos para tu RAG casero

• Asistente de documentación personal: Carga todos tus manuales, guías y documentación técnica para consultarlas con lenguaje natural.
• Chatbot para proyectos o hobbies: Un asistente que conoce tus proyectos personales, recetas, notas, etc.
• Búsqueda inteligente en biblioteca digital: Consulta tu colección de libros, papers o artículos con preguntas específicas.
• Asistente para estudios: Carga tus libros y apuntes para hacerle preguntas específicas.
• Análisis de documentos familiares: Organiza y consulta documentos familiares, históricos o personales.

7️⃣ Optimizando tu sistema RAG

• Ajusta el tamaño de los chunks: Prueba diferentes tamaños para dividir tus documentos (500-1500 caracteres suele funcionar bien).
• Elige el modelo adecuado: Para servidores modestos, prueba modelos como Phi-2 o Gemma. Para máquinas más potentes, Llama 3 o Mixtral.
• Mejora los prompts: Un buen prompt puede mejorar drásticamente las respuestas.
• Considera la memoria RAM: Los embeddings consumen memoria, así que dimensiona tu sistema según la cantidad de documentos.
• Implementa un sistema de caché: Para preguntas frecuentes y mejorar la velocidad de respuesta.

8️⃣ Integrando RAG con otras herramientas

Tu sistema RAG puede integrarse con otras herramientas que ya tengas en tu servidor:

• n8n: Automatiza flujos de trabajo con tu RAG usando nuestra guía de n8n.
• Home Assistant: Conecta tu RAG para responder preguntas sobre tu casa inteligente.
• Telegram/Discord: Crea un bot que responda consultas usando tu RAG.
• Watchtower: Mantén actualizados los contenedores de tu RAG usando nuestra guía de Watchtower.

🎸 Despedida punk

Montar tu propio sistema RAG es un paso gigante hacia la soberanía digital y el control de tu ecosistema de IA. Ya no dependes de servicios en la nube que pueden cambiar sus términos o dejar de funcionar en cualquier momento.

Con RAG local, tus modelos responderán basándose en TU información, con TUS reglas, en TU servidor. ¿Hay algo más punk que eso?

¿Ya has probado implementar un sistema RAG? ¿Qué documentos has cargado en tu base de conocimiento personal? Cuéntanos tu experiencia y sigue explorando el lado más DIY de la inteligencia artificial.

Recursos y enlaces útiles

• Comparativa de plataformas de automatización e IA
• Watchtower para Docker: olvídate de actualizar contenedores a mano
• Automatiza todo en tu servidor casero con n8n
• Repositorio de LangChain en GitHub
• Sitio oficial de Ollama
• Documentación de ChromaDB