Langchain-Chatchat y Docker Compose: Construyendo un sistema de preguntas y respuestas local para entornos empresariales

El rápido avance de la inteligencia artificial plantea un desafío concreto: integrar modelos de lenguaje extensos (LLM) en operaciones reales. Si bien los servicios en la nube ofrecen capacidades potentes, industrias como la financiera, salud o legal, donde la privacidad de los datos es crucial, no pueden depender de APIs públicas. Esto ha impulsado la adopción de despliegues locales con enriquecimiento de conocimiento privado.

Langchain-Chatchat surge como una solución clave, permitiendo a las organizaciones construir asistentes de IA especializados sin necesidad de conectividad externa. Su combinación con Docker Compose simplifica la orquestación de servicios, convirtiendo un sistema complejo en una operación de "un solo comando", eliminando así barreras técnicas significativas.

Este enfoque refleja una evolución en la ingeniería: en lugar de desarrollar cada componente desde cero, se prioriza la integración modular para validar rápidamente el valor y facilitar itearciones continuas.

Adaptación al chino en sistemas RAG: La filosofía de Langchain-Chatchat

Aunque se basa en LangChain, Langchain-Chatchat va más allá de un simple envoltorio. Su aporte principal radica en la adaptación profunda al idioma chino y el diseño de flujos completos para contextos empresariales.

A diferencia de los sistemas RAG tradicionales, que a menudo requieren intervención manual para procesar documentos y actualizar índices, Langchain-Chatchat ofrece una interfaz web intuitiva. Los usuarios pueden subir archivos PDF o Word directamente, y el sistema ejecuta automáticamente los siguientes pasos:

1. Extracción de texto mediante herramientas como Unstructured.
2. Fragmentación del contenido mediante divisores de texto recursivos (con parámetros configurables como tamaño de bloque y superposición).
3. Generación de vectores usando modelos de incrustación para chino, como m3e-base o bge-small-zh.
4. Almacenamiento en bases de datos vectoriales como Chroma o FAISS.
5. Proporcionación de una interfaz de administración para gestionar las bases de conocimiento.

Este proceso automatizado permite a usuarios no técnicos integrar documentación de manera efectiva.

from langchain_community.document_loaders import DirectoryLoader
from langchain_text_splitters import CharacterTextSplitter
from langchain_community.embeddings import SentenceTransformerEmbeddings
from langchain_community.vectorstores import FAISS

# Carga y fragmentación de documentos
document_loader = DirectoryLoader("./documentos/", glob="**/*.pdf")
raw_documents = document_loader.load()

splitter = CharacterTextSplitter(chunk_size=600, chunk_overlap=80)
fragments = splitter.split_documents(raw_documents)

# Incrustación y persistencia en FAISS
embedding_model = SentenceTransformerEmbeddings(model_name="uer/sbert-base-chinese-nli")
vector_db = FAISS.from_documents(
    documents=fragments,
    embedding=embedding_model
)
vector_db.save_local("./faiss_index")

# Consulta de prueba
retriever_engine = vector_db.as_retriever(search_type="similarity", search_kwargs={"k": 4})
related_chunks = retriever_engine.get_relevant_documents("¿Cuál es el procedimiento para licencias?")
for doc in related_chunks:
    print(doc.page_content)

Este fragmento representa la esencia del sistema. Modelos como uer/sbert-base-chinese-nli están optimizados para la semántica en chino, ofreciendo una precisión superior a los enfoques basados en traducción. La lógica mostrada ya está encapsulada en módulos como api/knowledge_base, permitiendo a los usuarios finales operar sin escribir código.

La containerización como requisito indispensable

Los entornos de desarrollo en proyectos de IA frecuentemente sufren de inconsistencias: conflictos de versiones de bibliotecas, dependencias faltantes o configuraciones de GPU problemáticas. Para aplicaciones con arquitectura de múltiples servicios como Langchain-Chatchat, Docker Compose se vuelve esencial.

Sus ventajas desde una perspectiva de ingeniería incluyen:

• Consistencia ambiental: Elimina la famosa frase "en mi máquina funciona".
• Aislamiento de dependencias: Cada servicio (FastAPI, Streamlit, vLLM) opera en su propio contenedor.
• Control de recursos: Especificaciones de hardware (CPU, memoria, GPU) definidas explícitamente.
• Persistencia de datos: Los volúmenes enlazan directorios del host para conservar modelos y bases de conocimiento.

Ejemplo de configuración docker-compose.yml:

version: '3.9'

services:
  servicio-api:
    imagen: chatchat/backend:v2
    nombre_contenedor: api_chatchat
    puertos:
      - "7860:7860"
    volumenes:
      - ./configuraciones:/aplicacion/configuraciones
      - ./datos_conocimiento:/aplicacion/datos
      - ./modelos:/aplicacion/modelos
    variables_entorno:
      - NIVEL_LOG=WARN
    depende_de:
      - servicio_modelo
    redes:
      - red_chatchat

  servicio-web:
    imagen: chatchat/frontend:v2
    nombre_contenedor: interfaz_chatchat
    puertos:
      - "8500:8500"
    depende_de:
      - servicio-api
    redes:
      - red_chatchat

  servicio_modelo:
    imagen: localai/qwen2-7b-chat-cuda:latest
    nombre_contenedor: motor_llm
    puertos:
      - "8000:8000"
    despliegue:
      recursos:
        reservas:
          dispositivos:
            - controlador: nvidia
              cantidad: 1
              capacidades: [gpu]
    variables_entorno:
      - CUDA_VISIBLE_DEVICES=all
    redes:
      - red_chatchat

redes:
  red_chatchat:
    controlador: bridge

La configuración define tres servicios fundamentales:

• servicio-api: Núcleo central que maneja procesamiento documental, búsqueda vectorial e integración con LLMs.
• servicio-web: Interfaz gráfica basada en Streamlit, accesible en el puerto 8500.
• servicio_modelo: Ejecuta un modelo LLM cuantizado, aprovechando aceleración por GPU.

El despliegue se realiza mediante un único comando:

docker compose up -d

Para detener todos los servicios:

docker compose down

Este método abstrae completamente las complejidades del sistema operativo, controladores y dependencias.

Arquitectura típica y flujo de trabajo

El siguiente diagraam ilustra la arquitectura desplegada con Docker Compose:

+------------------+     +-------------------+
|    Navegador     |<--->|  Interfaz Web     |
+------------------+     +-------------------+
                              ↑ HTTP
                              ↓
                       +------------------+
                       |   Servidor API   |
                       | (FastAPI+LangChain)|
                       +------------------+
                        ↗           ↖
              Procesamiento      Búsqueda
              de documentos      vectorial
                    ↓               ↑
           +----------------+   +-------------+
           | Almacenamiento |   | Base Vectorial|
           | de documentos  |   | (Chroma/FAISS)|
           +----------------+   +-------------+
                              ↑
                              | API de Incrustación
                       +------------------+
                       | Modelo de Embedding|
                       | (m3e/bge/etc.)   |
                       +------------------+

                              ↑
                              | Inferencia LLM
                       +------------------+
                       | Servicio LLM local|
                       | (ChatGLM/Qwen)   |
                       +------------------+

Todo el procesamiento ocurre dentro de la red local, garantizando la confidencialidad de los datos.

Flujo operativo detallado:

1. Preparación e instalación: Clonar el repositorio, colocar los archivos de modelo necesarios en el directorio modelos/ y ejecutar docker compose up.
2. Construcción de la base de conocimiento: Desde la interfaz web, subir documentos internos. El sistema automáticamente extrae texto, lo fragmenta, genera vectores y los almacena.
3. Interacción de preguntas y respuestas: El usuario formula una consulta. El sistema la convierte en un vector, recupera fragmentos relevantes, construye un prompt y obtiene una respuesta del LLM local.
4. Actualización continua: Al modificarse políticas o documentos, basta con subir la nueva versión y reconstruir el índice. Se pueden configurar tareas programadas para sincronizar fuentes de datos.

Recomendaciones para una implementación exitosa

Especificaciones de hardware recomendadas

• Memoria RAM: Mínimo 16GB, idealmente 32GB o más. La inferencia de LLMs, la búsqueda vectorial y los servicios web compiten por recursos.
• GPU: Una tarjeta NVIDIA con al menos 8GB de VRAM es aconsejable para lograr tiempos de respuesta aceptables (<3 segundos) con modelos cuantizados.
• Almacenamiento: SSD altamente recomendado, especialmente con bases de conocimiento superiores a 10GB, donde la velocidad de I/O afecta directamente la latencia de búsqueda.

Selección de modelos basada en experiencia práctica

Nota: Modelos de 7B a 13B parámetros suelen ofrecer un equilibrio óptimo entre calidad de respuesta y costo computacional para la mayoría de aplicaciones empresariales.

Prácticas de seguridad y mantenimiento

• Autenticación: Si el sistema se expone a redes, implementar autenticación en la capa de proxy inverso (Nginx, Traefik).
• Copias de seguridad: Programar respaldos periódicos de los directorios ./datos_conocimiento y ./faiss_index.
• Procesamiento asíncrono: Para importaciones masivas de documentos, considerar el uso de una cola de mensajes como Celery.
• Monitoreo de registros: Establecer un nivel de log detallado (DEBUG) durante la implementación inicial para facilitar la depuración.

Ajustes para mejorar el rendimiento

• Tamaño de fragmentación: Un rango de 350 a 550 caracteres suele proporcionar buenos resultados. Fragmentos muy pequeños pierden contexto; los grandes introducen ruido.
• Número de resultados recuperados (Top-K): Configurar entre 3 y 5. Valores más altos pueden degradar la calidad de generación, valores bajos pueden omitir información relevante.
• Ingeniería de prompts: Diseñar plantillas que instruyan explícitamente al LLM a basarse únicamente en el contexto proporcionado para minimizar alucinaciones.

Impacto y perspectiva del enfoque

La combinación Langchain-Chatchat y Docker Compose no representa una innovación tecnológica radical, pero resuelve eficazmente una necesidad apremiante: democratizar el acceso a asistentes de IA especializados sin requerir un equipo de ingeniería dedicado.

Su valor reside en:

• Empaquetar un stack tecnológico complejo en un producto desplegable.
• Utilizar Docker Compose para abstraer la complejidad operativa.
• Ofrecer una interfaz visual que involucra a usuarios del negocio en la gestión del conocimiento.
• Mantener un código abierto con documentación activa y comunidad de soporte.

Para pequeñas y medianas empresas, esto significa tener un asistente inteligente para RRHH, soporte TI o atención al cliente en menos de una semana. Los desarrolladores obtienen una base extensible para integrar con sistemas existentes como plataformas de mensajería corporativa o CRM.

La evolución hacia modelos más ligeros y técnicas de recuperación avanzadas continuará mejorando estos sistemas. La decisión de implementar hoy sienta las bases para una estrategia de IA sólida, centrada en datos, eficiente y segura a largo plazo.