Las 4 capas de la IA Local: Evita errores comunes

Cuando un desarrollador decide meterse en el mundo de la IA local, lo primero que suele hacer es clonar tres repositorios distintos de GitHub, descargar un modelo desde Hugging Face y cruzar los dedos.

A los diez minutos, algo falla y escribe frustrado en un foro: "Ayuda, Hermes Agent no soporta archivos GGUF" o "¿Ollama es compatible con LangChain?".

Es un error clásico. Ocurre porque la industria avanza tan rápido que no nos ha dado tiempo a trazar un mapa conceptual de lo que estamos construyendo. Mezclar las capas de abstracción en tu servidor te llevará a diagnósticos erróneos y a un código insostenible. Puedes consultar nuestro post sobre cómo configurar oMLX en Mac para ver cómo operan de forma desacoplada las capas de inferencia y agente.

Hoy te quiero enseñar las 4 capas de la IA local que debes dominar para estructurar tus proyectos de forma profesional y entender qué herramienta hace qué en tu máquina.

El Mapa del Stack de IA Local

Para evitar dolores de cabeza, debes entender que un entorno de inteligencia artificial local se compone de cuatro capas independientes y bien delimitadas:

┌─────────────────────────────────────────┐
│ 1. AGENTE / ORQUESTADOR (Hermes Agent)  │  <-- Controla la lógica y flujo
└─────────────────────────────────────────┘
                     │  (Habla vía API HTTP / JSON)
                     ▼
┌─────────────────────────────────────────┐
│ 2. SERVIDOR DE INFERENCIA / SERVING     │  <-- Expone endpoints OpenAI/Anthropic
│    (oMLX, Ollama, llama.cpp, vLLM)       │
└─────────────────────────────────────────┘
                     │  (Compila y optimiza para el chip)
                     ▼
┌─────────────────────────────────────────┐
│ 3. RUNTIME ENGINE (MLX, TensorRT-LLM)   │  <-- Gestiona el hardware (GPU/Metal)
└─────────────────────────────────────────┘
                     │  (Lee los bytes binarios)
                     ▼
┌─────────────────────────────────────────┐
│ 4. FORMATO DE PESOS (GGUF, safetensors) │  <-- Los archivos del modelo (.bin)
└─────────────────────────────────────────┘

Capa 1: El Agente / Orquestador (El Cerebro Lógico)

Aquí es donde viven herramientas como Hermes Agent, LangChain o LlamaIndex. Esta capa no sabe matemáticas de tensores, no lee archivos de pesos binarios ni sabe qué es una GPU.

• Su función: Orquestar la conversación, manejar la persistencia de sesiones en SQLite, gestionar el historial de prompts y llamar a herramientas externas mediante MCP (Model Context Protocol).
• Cómo se comunica: Es 100% API-céntrico. Solo le importa hablar con un puerto web (como http://localhost:8000) que le devuelva texto en formato compatible con OpenAI o Anthropic.

Capa 2: El Servidor de Inferencia (El Gestor de Tráfico)

Aquí encontramos a oMLX, Ollama, LM Studio o vLLM. Su trabajo es actuar como puente entre el protocolo web del agente y los motores de bajo nivel del hardware.

• Su función: Exponer los endpoints HTTP compatibles (/v1/chat/completions), gestionar las colas de peticiones entrantes (continuous batching), optimizar el uso de memoria RAM y administrar las cachés de claves y valores (KV cache).

Capa 3: El Runtime Engine (El Acelerador de Hardware)

El motor de bajo nivel matemático. Aquí están MLX (el framework oficial de Apple), ONNX Runtime, TensorRT-LLM de Nvidia o la librería core de llama.cpp.

• Su función: Traducir las operaciones lógicas de la red neuronal a comandos nativos de tu hardware específico (núcleos CUDA de Nvidia o aceleración Metal en los chips Apple Silicon M1/M2/M3/M4).

Capa 4: El Formato de Pesos (Los Datos)

La capa más baja. Los archivos binarios reales descargados de Hugging Face en formatos como MLX, GGUF, safetensors u ONNX. Son simplemente las matrices de números y coeficientes del modelo (por ejemplo, Qwen 2.5 Coder o Llama 3).

Por qué esta distinción te salvará la vida

Cuando entiendes este mapa, te das cuenta de que la pregunta: "¿Hermes Agent soporta modelos GGUF?" no tiene sentido.

Hermes es formato-agnóstico a nivel de pesos. A Hermes no le importa si tu modelo es un archivo GGUF o una carpeta MLX. A Hermes solo le importa que el Servidor de Inferencia (como Ollama o oMLX) le exponga un puerto compatible. Si el servidor lee GGUF y responde HTTP, Hermes funcionará sin cambiar una línea de código.

Este enfoque modular y arquitectónico es clave para construir sistemas escalables. Es la filosofía que defendemos en el libro de SDD: Spec-Driven Development para estructurar el desarrollo antes de codificar, y la que aplicamos para conectar microservicios locales en el curso de Construye con IA y en el nuevo curso de Hermes Agent.

Conclusión: Diseña con desacoplamiento

No ates tu lógica agéntica a un formato de archivo o a un hardware concreto. Al separar el plano de control (Hermes) del plano de inferencia (oMLX/Ollama), puedes cambiar de modelo, escalar tu servidor a una máquina con GPU dedicada en Linux o correr localmente en tu Mac sin tener que reescribir una sola línea del comportamiento de tu agente de IA.

Si quieres debatir sobre la arquitectura óptima de IA local para tu equipo y resolver dudas de infraestructura, te espero en Dominicode Labs.

Preguntas Frecuentes (FAQ)

¿Por qué Hermes Agent no carga directamente los pesos del modelo?

Para mantener la eficiencia y el desacoplamiento. Cargar pesos de modelos de miles de millones de parámetros requiere optimizaciones extremas de memoria GPU a bajo nivel. Delegar esto a servidores dedicados (como oMLX o vLLM) permite que Hermes se concentre únicamente en la lógica de control, la orquestación de herramientas y el flujo de la conversación.

¿Qué formatos de pesos debo usar en Mac con Apple Silicon?

Para obtener el máximo rendimiento nativo en procesadores Apple Silicon, se recomienda utilizar el formato MLX servido por herramientas como oMLX. Si buscas portabilidad o usas hardware variado, el formato GGUF servido por Ollama o llama.cpp es la alternativa estándar.

¿Cómo se comunican el Agente y el Servidor de Inferencia?

Se comunican a través del protocolo HTTP utilizando formatos de petición y respuesta compatibles con la API de OpenAI o Anthropic. Esto significa que el agente simplemente envía un JSON con los mensajes y el servidor le devuelve el texto generado (habitualmente en modo streaming).

¿Puedo cambiar el servidor de inferencia sin alterar mi agente?

Sí. Al estar desacoplados mediante APIs estándar, puedes cambiar tu backend de inferencia local de oMLX en Mac a vLLM en un servidor Linux en la nube simplemente actualizar la URL base en el archivo de configuración del agente (config.yaml), sin alterar sus habilidades ni su lógica operativa.

Por Bezael Pérez — Developer senior con más de 15 años de experiencia y fundador de Dominicode.