Cómo crear un asistente de inteligencia artificial en Linux utilizando modelos open source y agentes autónomos

Idea clave: un asistente de IA en Linux debe diseñarse como una plataforma segura: modelo local, interfaz, documentos autorizados, herramientas controladas, memoria, monitoreo y límites claros para los agentes.

Un asistente con agentes puede ayudar a:

• Responder preguntas sobre documentos internos.
• Resumir archivos, actas, informes o manuales.
• Generar reportes técnicos o ejecutivos.
• Crear borradores de correos, artículos o procedimientos.
• Automatizar tareas repetitivas con aprobación humana.
• Consultar una base de conocimiento local.
• Ayudar a programadores con código y documentación.
• Servir como asistente privado para una empresa o laboratorio.

sudo apt update
sudo apt upgrade -y
sudo apt install -y curl git python3 python3-venv python3-pip htop ufw ca-certificates

sudo ufw allow OpenSSH
sudo ufw enable
sudo ufw status verbose

Consejo: no expongas el asistente directamente a Internet durante las pruebas. Primero úsalo en red local, VPN o laboratorio.

curl -fsSL https://ollama.com/install.sh -o install-ollama.sh
less install-ollama.sh
sh install-ollama.sh
rm -f install-ollama.sh

ollama --version
sudo systemctl status ollama

ollama pull llama3.2:3b
ollama run llama3.2:3b

ollama run llama3.2:3b "Explica en español qué es un asistente de IA local en 5 líneas."

sudo apt install -y docker.io
sudo systemctl enable --now docker
sudo usermod -aG docker $USER

docker run -d \
  --name open-webui \
  --restart always \
  -p 3000:8080 \
  --add-host=host.docker.internal:host-gateway \
  -v open-webui:/app/backend/data \
  ghcr.io/open-webui/open-webui:main

http://localhost:3000

http://IP_DEL_SERVIDOR:3000

Precaución: no publiques Open WebUI ni la API de Ollama en Internet sin autenticación, HTTPS, firewall, VPN y revisión de logs.

Consejo: no empieces con el modelo más grande. Primero valida calidad, velocidad, memoria, consumo de CPU/GPU y resultados reales con tus propios documentos.

curl http://localhost:11434/api/generate -d '{
  "model": "llama3.2:3b",
  "prompt": "Actúa como asistente Linux y resume qué es un servicio systemd.",
  "stream": false
}'

Flujo RAG recomendado

1. Seleccionar documentos autorizados.
2. Extraer texto de PDF, Word, Markdown, HTML o TXT.
3. Dividir el contenido en fragmentos.
4. Crear embeddings.
5. Guardar los vectores en Chroma, Qdrant u otra base vectorial.
6. Recuperar fragmentos relevantes cuando el usuario pregunta.
7. Responder citando o resumiendo el contexto recuperado.

mkdir asistente-ia-linux
cd asistente-ia-linux
python3 -m venv .venv
source .venv/bin/activate
pip install -U langchain langchain-ollama langgraph

from langchain_ollama import ChatOllama
from langchain.agents import create_agent

def hora_servidor() -> str:
"""Devuelve una respuesta simple simulando una herramienta segura."""
from datetime import datetime
return f"Hora local del servidor: {datetime.now().isoformat(timespec='seconds')}"

modelo = ChatOllama(
model="llama3.2:3b",
temperature=0
)

agente = create_agent(
model=modelo,
tools=[hora_servidor],
system_prompt=(
"Eres un asistente de IA en Linux. "
"Responde en español, sé claro y usa herramientas solo cuando sean necesarias. "
"No ejecutes acciones fuera de las herramientas permitidas."
)
)

respuesta = agente.invoke({
"messages": [
{"role": "user", "content": "¿Qué hora tiene el servidor y para qué sirve esta herramienta?"}
]
})

print(respuesta["messages"][-1].content)

python agente_basico.py

Resultado: ya tienes un agente básico que usa un modelo local y una herramienta controlada. Desde aquí puedes agregar lectura de documentos, generación de reportes o integraciones internas.

python3 -m venv crew-env
source crew-env/bin/activate
pip install -U crewai

No hagas esto

• No entregues al agente acceso root.
• No le permitas ejecutar cualquier comando del sistema.
• No conectes documentos confidenciales sin control de permisos.
• No publiques APIs internas sin autenticación.
• No permitas acciones irreversibles sin aprobación humana.
• No guardes tokens o contraseñas en texto plano.

Herramientas seguras para empezar

• Buscar en una carpeta autorizada de documentos.
• Leer archivos de solo lectura.
• Generar resúmenes en un directorio temporal.
• Consultar una base de conocimiento local.
• Calcular fechas, montos o métricas simples.
• Crear borradores que un humano revisa antes de enviar.
• Generar tickets, pero no cerrarlos automáticamente.
• Ejecutar acciones solo mediante una lista blanca.

Tipos de memoria

• Memoria corta: contexto dentro de una conversación.
• Memoria de tarea: estado de un flujo, pasos completados y pendientes.
• Memoria documental: conocimiento recuperado desde RAG.
• Memoria persistente: preferencias o datos guardados entre sesiones.

• Definir objetivo del asistente.
• Elegir distribución Linux.
• Instalar Ollama y probar un modelo pequeño.
• Instalar Open WebUI para una interfaz web.
• Limitar acceso por red local, VPN o firewall.
• Seleccionar documentos autorizados.
• Implementar RAG para respuestas basadas en conocimiento.
• Crear agentes con herramientas controladas.
• Evitar ejecución libre de comandos del sistema.
• Agregar aprobación humana para acciones sensibles.
• Monitorear logs, consumo de CPU, RAM, GPU y disco.
• Documentar modelos, versiones, datos y permisos.

Evita estos errores

• Conectar documentos sensibles sin control de permisos.
• Usar modelos grandes sin hardware suficiente.
• Confundir “local” con “automáticamente seguro”.
• Dar al agente permisos amplios sobre el sistema.
• No registrar acciones o respuestas importantes.
• No revisar licencias de modelos.
• No separar laboratorio de producción.
• No validar las respuestas antes de usarlas en decisiones importantes.
• No actualizar herramientas, contenedores o modelos.

¿Puedo crear un asistente de IA en Linux sin usar servicios propietarios?

Sí. Puedes usar Linux, Ollama, Open WebUI, modelos locales, RAG y frameworks de agentes como LangGraph o CrewAI. Aun así, debes revisar licencias, rendimiento y seguridad.

¿Necesito una GPU?

No siempre. Puedes empezar con modelos pequeños en CPU. Para varios usuarios, modelos grandes o respuestas rápidas, una GPU mejora mucho el rendimiento.

¿Qué diferencia hay entre un chatbot y un agente?

Un chatbot responde mensajes. Un agente puede decidir pasos, usar herramientas, consultar documentos, mantener estado y coordinar tareas dentro de límites definidos.

¿Open WebUI reemplaza a un framework de agentes?

No exactamente. Open WebUI sirve como interfaz y plataforma de uso. LangGraph, LangChain o CrewAI sirven para construir lógica de agentes, herramientas y flujos personalizados.

¿Qué es RAG?

RAG permite que el asistente consulte documentos o bases de conocimiento antes de responder. Es útil para reducir respuestas inventadas y adaptar la IA a información interna.

¿Un agente autónomo debe ejecutar comandos del sistema?

No como regla general. Lo más seguro es darle herramientas limitadas, listas blancas, permisos mínimos y aprobación humana para acciones sensibles.

¿Cuál es la ruta más simple para empezar?

Instala Linux, Ollama y Open WebUI. Luego agrega documentos con RAG. Después crea un agente pequeño con una o dos herramientas seguras. Escala solo cuando el caso de uso esté claro.

• Cómo construir un servidor de IA local utilizando Linux y modelos open source
• IA open source en Linux: cómo usar modelos locales sin depender completamente de servicios propietarios
• Cómo automatizar mis flujos de trabajo utilizando agentes de IA
• Cómo ejecutar modelos de inteligencia artificial localmente en Linux y Windows

Conclusión editorial

Linux y el software libre están convirtiendo la IA local en una opción real para empresas, docentes, desarrolladores y usuarios avanzados. El siguiente salto no será solo tener modelos locales, sino construir asistentes con agentes seguros, útiles y alineados con procesos reales.