Esta guía es para administradores de sistemas, ingenieros de DevOps y equipos técnicos que despliegan una infraestructura de IA privada para documentos corporativos confidenciales. Da por hecho que te manejas con la línea de comandos, Docker y redes básicas. Si no eres perfil técnico y quieres empezar rápido, mira la guía complementaria: Cómo ejecutar un asistente de IA privado en Windows sin experiencia técnica.

Lo que sigue cubre la pila de producción completa: inferencia acelerada por GPU con LocalAI, recuperación semántica de documentos mediante LocalRecall, flujos de agentes autónomos con LocalAGI y compatibilidad de API directa, de forma que tus herramientas actuales no necesitan reescribirse.

Por qué LocalAI frente a alternativas más simples a este nivel

Ollama y AnythingLLM son excelentes para personas y equipos pequeños. A nivel de empresa, las ventajas de LocalAI se vuelven decisivas:

  • Compatibilidad total con las API de OpenAI y Anthropic — cambia la URL base en cualquier herramienta que ya tengas y funciona. Sin tocar el SDK, sin bibliotecas envoltorio.
  • LocalRecall — una capa de memoria semántica persistente e integrada. Los documentos se trocean, se vectorizan en local y se guardan en una base de datos vectorial. Las consultas recuperan los fragmentos relevantes antes de la inferencia, manteniendo el contexto preciso en miles de documentos.
  • LocalAGI — marco de agentes autónomos para flujos programados o disparados por eventos: resumir contratos al subirlos, extraer datos estructurados de facturas, señalar riesgos de cumplimiento contra un conjunto de reglas propio.
  • Soporte multimodal — modelos de visión, transcripción de audio y generación de imágenes pasan todos por el mismo punto de acceso de la API.
  • Con licencia MIT — sin ataduras a un proveedor, sin tarifas por uso, con el código auditable por completo.

Recomendaciones de hardware según la carga

Workload CPU RAM GPU Storage
Preguntas ligeras, modelos de 7B Cualquier procesador moderno de 8 núcleos 16 GB Ninguna (inferencia por CPU) 40 GB SSD
Inteligencia documental estándar, modelos de 13B 12 núcleos o más (Ryzen 7 / Core i7 o superior) 32 GB RTX 3090 / 4080 100 GB NVMe
Análisis pesado, modelos de 70B Estación de trabajo de 16 núcleos o más 64–128 GB RTX 4090 / A6000 (24 GB VRAM) 200 GB NVMe
Multi-user server Server-grade CPU 128 GB+ Dual A100 / H100 RAID NVMe

Para la mayoría de los despliegues corporativos (revisión de contratos, análisis de documentos financieros, consultas sobre normativa interna), un modelo cuantizado de 13B en una sola RTX 4080 o 4090 ofrece una calidad cercana a GPT-4 con generación de tokens por debajo del segundo.

Windows: instalación completa con aceleración por GPU

Prerequisites

Comprueba que Docker ve tu GPU antes de seguir:

docker run --rm --gpus all nvidia/cuda:12.0-base-ubuntu22.04 nvidia-smi

Deberías ver tu GPU en la lista. Si da error, reinstala el NVIDIA Container Toolkit y reinicia Docker Desktop.

Instalar LocalAI con soporte de GPU

Descarga y ejecuta la imagen con CUDA:

docker run -d `
  --gpus all `
  -p 8080:8080 `
  -v C:\localai\models:/build/models `
  -v C:\localai\config:/build/config `
  --name localai `
  localai/localai:latest-aio-gpu-nvidia-cuda-12

Esto monta dos directorios locales — C:\localai\models para los archivos de modelo y C:\localai\config para la configuración. Créalos primero:

mkdir C:\localai\models
mkdir C:\localai\config

La imagen aio (todo en uno) incluye una galería de modelos seleccionada, LocalRecall y los backends habituales. Una vez en marcha, la API está disponible en http://localhost:8080/v1.

Descargar modelos de producción

Entra en http://localhost:8080 y usa la galería de modelos, o descárgalos con la línea de comandos de LocalAI:

# Strong reasoning model — good for contract analysis, financial Q&A
docker exec localai local-ai run llama-3.1-8b-instruct:q4_k_m

# Maximum quality for complex multi-document tasks (requires 24 GB VRAM)
docker exec localai local-ai run llama-3.1-70b-instruct:q4_k_m

# Embedding model for LocalRecall (required for RAG)
docker exec localai local-ai run nomic-embed-text

Configuración persistente

En producción, gestiona la configuración de los modelos con archivos YAML en C:\localai\config\. Ejemplo de configuración para un modelo de consultas corporativas:

name: business-assistant
backend: llama-cpp
model: llama-3.1-8b-instruct.Q4_K_M.gguf
context_size: 8192
gpu_layers: 40
parameters:
  temperature: 0.2
  top_p: 0.9
  repeat_penalty: 1.1

Una temperature baja (0,1–0,3) mejora la exactitud factual en tareas de recuperación documental — importante en contratos y cumplimiento, donde una alucinación es un pasivo.

Linux: instalación completa con aceleración por GPU

Linux es la plataforma preferida para despliegues en servidor por su mejor soporte de GPU en Docker, menos sobrecarga y acceso directo a los controladores de NVIDIA.

Prerequisites

Instala el NVIDIA Container Toolkit en Ubuntu:

curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg
curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list |   sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' |   sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list
sudo apt-get update && sudo apt-get install -y nvidia-container-toolkit
sudo nvidia-ctk runtime configure --runtime=docker
sudo systemctl restart docker

Install LocalAI

mkdir -p /opt/localai/{models,config}

docker run -d   --gpus all   --restart unless-stopped   -p 8080:8080   -v /opt/localai/models:/build/models   -v /opt/localai/config:/build/config   --name localai   localai/localai:latest-aio-gpu-nvidia-cuda-12

El parámetro --restart unless-stopped hace que LocalAI arranque solo al reiniciar — importante en despliegues de servidor que deben estar siempre activos.

Apple Silicon (ARM Linux y macOS)

Para Mac con chip de la serie M o servidores ARM con Linux:

docker run -d   --restart unless-stopped   -p 8080:8080   -v /opt/localai/models:/build/models   -v /opt/localai/config:/build/config   --name localai   localai/localai:latest-aio-cpu

En Apple Silicon, LocalAI usa la aceleración Metal automáticamente cuando se ejecuta de forma nativa (instalación por binario). La imagen de Docker usa inferencia por CPU — para soporte completo de Metal, usa la instalación por binario en macOS.

Despliegue solo con CPU (aislado o de bajo presupuesto)

Para entornos estrictamente aislados y sin GPU:

docker run -d   --restart unless-stopped   -p 8080:8080   -v /opt/localai/models:/build/models   -e THREADS=8   --name localai   localai/localai:latest-aio-cpu

Ajusta THREADS al número de núcleos físicos del procesador. Los modelos cuantizados de 7B a 13B (formato Q4_K_M) funcionan de forma aceptable en procesadores de 8 núcleos para consultas documentales con poca concurrencia.

Activar LocalRecall para inteligencia documental empresarial

LocalRecall es el sistema de memoria semántica y RAG de LocalAI. Vectoriza tus documentos en local, los guarda en una base de datos vectorial y recupera los fragmentos relevantes antes de cada llamada de inferencia — apoyando las respuestas en tu contenido real y no en los pesos del modelo.

Configuración

En tu directorio de configuración de LocalAI, crea localrecall.yaml:

localrecall:
  enabled: true
  embedding_model: nomic-embed-text
  vector_db: chromadb          # local ChromaDB instance, no external dependencies
  chunk_size: 512
  chunk_overlap: 64

Ingesting documents

LocalAI exposes a REST API for document management. Ingest a directory of files programmatically:

# Upload a single document
curl -X POST http://localhost:8080/v1/localrecall/documents   -F "file=@/path/to/contract.pdf"   -F "collection=legal-contracts"

# Query across a collection
curl -X POST http://localhost:8080/v1/localrecall/query   -H "Content-Type: application/json"   -d '{
    "collection": "legal-contracts",
    "query": "What are the termination clauses across all contracts?",
    "limit": 10
  }'

Las colecciones funcionan como espacios de nombres — usa una por categoría de documento (jurídico, finanzas, políticas de RR. HH.) para tener fronteras de recuperación limpias y control de acceso.

Integrar RAG en las respuestas de chat

Para inyectar automáticamente el contexto recuperado en las peticiones de chat, referencia la colección en tu instrucción de sistema o usa el punto de acceso de LocalAI que ya entiende RAG:

curl -X POST http://localhost:8080/v1/chat/completions   -H "Content-Type: application/json"   -d '{
    "model": "business-assistant",
    "localrecall_collection": "legal-contracts",
    "messages": [
      {"role": "user", "content": "Summarize indemnification clauses in the Acme and Bluebell contracts."}
    ]
  }'

LocalAI recupera de tu colección los fragmentos semánticamente más relevantes antes de enviarlos al modelo — sin llamadas a API externas y sin que ningún dato salga de la máquina.

Conectar las herramientas que ya usa tu empresa

La API compatible con OpenAI (http://localhost:8080/v1) significa cero reescrituras para las herramientas que ya se integran con ChatGPT.

Python / LangChain

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="business-assistant",
    base_url="http://localhost:8080/v1",
    api_key="not-needed",          # LocalAI doesn't require a real key
    temperature=0.2
)

response = llm.invoke("Summarize the key risks in the Q3 financial report.")
print(response.content)

LlamaIndex (document intelligence)

from llama_index.llms.openai import OpenAI
from llama_index.embeddings.openai import OpenAIEmbedding
from llama_index.core import Settings

Settings.llm = OpenAI(
    model="business-assistant",
    api_base="http://localhost:8080/v1",
    api_key="not-needed"
)
Settings.embed_model = OpenAIEmbedding(
    model="nomic-embed-text",
    api_base="http://localhost:8080/v1",
    api_key="not-needed"
)

Complementos de Microsoft Office y Word

Cualquier complemento de Word o alternativa a Copilot que acepte un punto de acceso propio de OpenAI puede apuntar a http://localhost:8080/v1. No hacen falta cambios de red ni VPN en despliegues en tus propios servidores.

Continue.dev (VS Code / JetBrains)

En .continue/config.json:

{
  "models": [{
    "title": "LocalAI — Business Assistant",
    "provider": "openai",
    "model": "business-assistant",
    "apiBase": "http://localhost:8080/v1",
    "apiKey": "not-needed"
  }]
}

Da a tu equipo de desarrollo asistencia de IA totalmente local sobre código propietario — nada sale de la máquina.

Flujos autónomos con LocalAGI

LocalAGI amplía LocalAI con un bucle de planificación y ejecución. Los agentes pueden vigilar directorios, llamar a herramientas externas y encadenar tareas de varios pasos sin intervención humana.

Ejemplo: resumir automáticamente los contratos nuevos

# localagi/agents/contract-monitor.yaml
name: contract-monitor
trigger:
  type: file-watch
  path: /opt/documents/incoming-contracts
  patterns: ["*.pdf", "*.docx"]
tasks:
  - name: summarize
    prompt: |
      You are a legal document analyst. Summarize the key terms of the uploaded contract,
      including: parties, duration, payment terms, termination clauses, and any unusual clauses.
      Output as structured JSON.
  - name: flag-risks
    prompt: |
      Review the summary and flag any clauses that deviate from standard terms.
      Reference the company playbook at /opt/documents/legal-playbook.pdf.
  - name: save-output
    action: write-file
    path: /opt/documents/processed/{filename}_summary.json

Example: weekly financial risk report

name: finance-weekly
trigger:
  type: schedule
  cron: "0 8 * * 1"    # Every Monday at 8 AM
tasks:
  - name: analyze
    collection: finance-reports
    prompt: |
      Analyze all financial documents from the past 7 days.
      Identify: cash flow risks, outstanding receivables over 90 days,
      budget variances greater than 10%, and any flagged compliance items.
  - name: email-report
    action: send-email
    to: "cfo@company.com"
    subject: "Weekly Financial Risk Summary — {date}"

Verifying your air-gap

Before processing any sensitive documents, confirm no external traffic is being generated.

Windows:

# Watch active connections while running a query
netstat -an | findstr "ESTABLISHED" | findstr /V "127.0.0.1"

No debería aparecer ninguna línea. Todas las conexiones deben ser de bucle local.

Linux:

# Monitor outbound traffic from the LocalAI container
sudo nsenter -t $(docker inspect -f '{{.State.Pid}}' localai) -n ss -tunp | grep ESTABLISHED | grep -v 127.0.0.1

De nuevo, no debería aparecer ninguna conexión externa durante la inferencia.

En entornos más estrictos, aplica una regla de iptables que bloquee todo el tráfico saliente del contenedor:

# Block all outbound from LocalAI except loopback
iptables -I DOCKER-USER -s $(docker inspect -f '{{.NetworkSettings.IPAddress}}' localai) -j DROP
iptables -I DOCKER-USER -s $(docker inspect -f '{{.NetworkSettings.IPAddress}}' localai) -d 127.0.0.0/8 -j ACCEPT

Lista de comprobación de producción

  • GPU visible to Docker — docker run --rm --gpus all nvidia/cuda:12.0-base-ubuntu22.04 nvidia-smi returns expected output
  • LocalAI API responding — curl http://localhost:8080/v1/models returns model list
  • Embedding model loaded — nomic-embed-text or equivalent appears in model list
  • LocalRecall activado y colección creada — pruébalo subiendo un documento de muestra y haciendo una consulta
  • No external network traffic during inference — confirmed via netstat or ss
  • --restart unless-stopped set on container (Linux) or Docker Desktop set to start on login (Windows)
  • El YAML de configuración del modelo guardado en el control de versiones para poder reproducirlo
  • Backup strategy for /opt/localai/models and vector DB data directory

Lecturas adicionales