# Preparar Jarvis, un asistente de IA local con Debian, Proxmox y Ollama - Link: https://www.clhome.net/preparar-jarvis-asistente-local-debian-proxmox/ - Published: 2026-10-06T10:28:26+02:00 - Author: gerard **Resumen:** crearás una VM Debian en Proxmox dentro de la VLAN Jarvis, la fijarás en `192.168.100.10`, instalarás Docker y separarás Ollama, Jarvis, la voz y el avatar en carpetas independientes para poder ampliarlos sin rehacer la base. Esta guía explica cómo crear la máquina virtual Debian en el equipo donde está [Proxmox](https://www.clhome.net/instalar-proxmox-ve-desde-cero/), conectarla a la VLAN Jarvis y dejar operativo un asistente local con una estructura preparada para crecer. La red de ejemplo es `192.168.100.0/24` y Debian usará la IP fija `192.168.100.10`. ## 1. Diseña la red antes de crear la VM La VLAN Jarvis debe estar creada en el firewall y en UniFi antes de arrancar Debian( más detalles en la guía de [firewall con VLANs](https://www.clhome.net/configurar-firewall-vlans-homelab/)). En este ejemplo usamos: ```wp-block-code VLAN: Jarvis Red: 192.168.100.0/24 Gateway: 192.168.100.1 # ejemplo Debian VM: 192.168.100.10 DNS: 192.168.100.1 # ejemplo ``` Reserva `192.168.100.10` para Debian y deja fuera del DHCP las IPs fijas que vayas a utilizar. El gateway es orientativo: usa el que tenga configurado tu firewall. ## 2. Crea la máquina virtual en Proxmox En Proxmox selecciona **Create VM** y configura una VM independiente para Jarvis: ```wp-block-code Nombre: jarvis-debian ISO: Debian 12 netinst 64-bit CPU: 4 vCPU como punto de partida RAM: 8 GB; 16 GB si usarás modelos locales grandes Disco: 80 GB o más en almacenamiento SSD/NVMe Controlador: SCSI con SSD emulation si está disponible Red: VirtIO, bridge habitual y VLAN Tag: 100 ``` Activa QEMU Guest Agent si tu plantilla lo permite. La etiqueta VLAN debe coincidir con la VLAN Jarvis; no la confundas con la VLAN Docker ni con la red de gestión. ## 3. Instala Debian Arranca la VM desde la ISO y selecciona una instalación mínima. Crea un usuario normal, define un nombre de equipo como `jarvis-debian`, instala el servidor SSH cuando el instalador lo ofrezca y deja el entorno gráfico fuera si la VM funcionará como servidor. En el particionado, usa una partición raíz suficiente, activa swap según la RAM disponible y reserva espacio para los datos de Docker. No guardes los modelos dentro de la partición raíz si puedes dedicarles un disco o volumen separado. ## 4. Configura la IP fija de Debian Tras el primer arranque, identifica la interfaz con `ip link`. En Debian con NetworkManager puedes usar `nmcli`; con una instalación tradicional, configura la interfaz de red según el gestor activo. El objetivo es que Debian conserve siempre la IP `192.168.100.10`. ```wp-block-code ip addr ip route cat /etc/resolv.conf # Comprobaciones esperadas ping -c 3 192.168.100.1 ping -c 3 1.1.1.1 getent hosts deb.debian.org ``` Si tu gateway, DNS o nombre de interfaz son distintos, sustitúyelos. Comprueba primero que la VM tiene conectividad antes de continuar. ## 5. Actualiza Debian e instala las herramientas base Conéctate desde tu ordenador por SSH y actualiza el sistema: ```wp-block-code ssh usuario@192.168.100.10 sudo apt update sudo apt full-upgrade -y sudo apt install -y ca-certificates curl git vim htop unzip jq sudo reboot ``` Cuando vuelva a arrancar, reconecta por SSH. Mantén el usuario normal para trabajar y utiliza `sudo` solo para las tareas administrativas. ## 6. Protege el acceso SSH Usa una clave SSH desde tu equipo de administración y desactiva el acceso directo de root. Antes de cerrar tu sesión actual, abre una segunda sesión y comprueba que la clave funciona. ```wp-block-code # En tu ordenador de administración ssh-keygen -t ed25519 ssh-copy-id usuario@192.168.100.10 # En Debian, después de probar la clave sudo nano /etc/ssh/sshd_config # Revisa estas opciones PermitRootLogin no PubkeyAuthentication yes PasswordAuthentication no sudo systemctl restart ssh ``` No desactives las contraseñas hasta comprobar que la clave SSH funciona. Guarda una vía de recuperación local en Proxmox. ## 7. Instala Docker y Docker Compose Instala Docker usando el método oficial para Debian o los paquetes mantenidos por tu distribución. Después activa el servicio y permite que tu usuario lo use sin ` sudo`: ```wp-block-code sudo apt update sudo apt install -y docker.io docker-compose-plugin sudo systemctl enable --now docker sudo usermod -aG docker $USER newgrp docker docker version docker compose version docker run --rm hello-world ``` Si `docker-compose-plugin` no está disponible en tu versión, usa el repositorio oficial de Docker para Debian. Verifica siempre que la arquitectura de los contenedores sea compatible con el procesador del equipo. ## 8. Organiza Jarvis para que sea escalable Separa el motor de modelos, la interfaz y la configuración del asistente. Usa una carpeta por servicio y guarda cada Compose en su propia ubicación: ```wp-block-code /home/usuario/docker/ ├── ollama/ │ ├── compose.yaml │ └── data/ ├── jarvis/ │ ├── compose.yaml │ ├── data/ │ ├── config/ │ └── .env └── shared/ ├── prompts/ └── backups/ ``` ```wp-block-code mkdir -p /home/usuario/docker/ollama/data mkdir -p /home/usuario/docker/jarvis/{data,config} mkdir -p /home/usuario/docker/shared/{prompts,backups} chown -R usuario:usuario /home/usuario/docker ``` Esta separación permite actualizar Ollama, Jarvis o la configuración sin mezclar sus datos. Sustituye `usuario` por tu usuario real de Debian. ## 9. Despliega Ollama en su propia carpeta Ollama será el motor que descarga y sirve los modelos locales. Guarda este Compose en `/home/usuario/docker/ollama/compose.yaml`. La IP `192.168.100.20` es un ejemplo reservado dentro de la VLAN Jarvis: ```wp-block-code services: ollama: image: ollama/ollama:latest container_name: ollama restart: unless-stopped ports: - "11434:11434" volumes: - ./data:/root/.ollama networks: jarvis_internal: jarvis_vlan: ipv4_address: 192.168.100.20 networks: jarvis_internal: name: jarvis_internal jarvis_vlan: external: true ``` La red externa `jarvis_vlan` debe existir antes. Si todavía no usas una macvlan para esta VLAN (consulta la guía de [red macvlan](https://www.clhome.net/red-docker-macvlan-portainer/)), empieza con la red interna y publica el servicio solo en Debian. ```wp-block-code cd /home/usuario/docker/ollama docker compose up -d docker exec -it ollama ollama pull qwen2.5:3b docker exec -it ollama ollama list ``` El modelo depende de la RAM y la CPU disponibles. Empieza con un modelo pequeño y aumenta el tamaño solo después de comprobar el consumo. ## 10. Despliega la interfaz de Jarvis Para tener una interfaz operativa, usa Open WebUI conectado al servicio Ollama. Guarda este Compose en `/home/usuario/docker/jarvis/compose.yaml`: ```wp-block-code services: jarvis: image: ghcr.io/open-webui/open-webui:main container_name: jarvis restart: unless-stopped environment: - OLLAMA_BASE_URL=http://ollama:11434 - WEBUI_AUTH=true volumes: - ./data:/app/backend/data ports: - "3000:8080" networks: jarvis_internal: jarvis_vlan: ipv4_address: 192.168.100.21 depends_on: - ollama networks: jarvis_internal: external: true jarvis_vlan: external: true ``` Arranca desde su carpeta con `docker compose up -d` y entra en `http://192.168.100.21: 3000`. La primera cuenta creada queda como administradora. Usa una contraseña única y no la incluyas en esta documentación. ## 11. Comprueba que Jarvis está operativo Verifica primero los contenedores y después la comunicación entre servicios: ```wp-block-code cd /home/usuario/docker/ollama docker compose ps docker network inspect jarvis_internal curl http://127.0.0.1:11434/api/tags cd /home/usuario/docker/jarvis docker compose ps docker compose logs --tail=100 jarvis ``` Desde la interfaz de Jarvis selecciona Ollama, elige el modelo descargado y realiza una conversación de prueba. ## 12. Define firewall y acceso por VLAN Permite desde la VLAN de administración únicamente el acceso necesario a `192.168.100.21: 3000`. Mantén el puerto de Ollama `11434` accesible solo entre los contenedores o desde la propia VLAN Jarvis si necesitas administrarlo. No publiques Jarvis directamente en Internet. ```wp-block-code sudo apt install -y ufw sudo ufw default deny incoming sudo ufw default allow outgoing sudo ufw allow from 192.168.100.0/24 to any port 3000 proto tcp sudo ufw allow from RED_GESTION to any port 22 proto tcp sudo ufw enable sudo ufw status verbose ``` Sustituye `RED_GESTION` por el rango de tu VLAN de gestión. En el firewall principal documenta las reglas entre VLANs y conserva la separación respecto a las redes Home, IoT e Invitados. ## 13. Haz copias y actualizaciones controladas Los datos importantes están en `/home/usuario/docker/ollama/data`, `/home/usuario/ docker/jarvis/data`, los archivos Compose, el archivo `.env` y los prompts. Haz copias sin incluir contraseñas en texto plano. ```wp-block-code cd /home/usuario/docker docker compose -f ollama/compose.yaml pull docker compose -f jarvis/compose.yaml pull docker compose -f ollama/compose.yaml up -d docker compose -f jarvis/compose.yaml up -d ``` Actualiza primero en una ventana de mantenimiento, revisa los logs y conserva una copia de la versión anterior si el servicio es importante. ## 14. Añade voz y cara a Jarvis La voz y la cara deben ser capas separadas de la lógica. El flujo recomendado es: micrófono del cliente → reconocimiento de voz (STT) → Jarvis → Ollama → respuesta → síntesis de voz (TTS) y avatar visual. ```wp-block-code /home/usuario/docker/jarvis/ ├── compose.yaml ├── data/ ├── config/ ├── voice/ │ ├── stt/ │ └── tts/ └── face/ ├── assets/ └── frontend/ ``` **Voz:** empieza usando la entrada de micrófono de la interfaz de Jarvis. Para una instalación totalmente local, añade un servicio STT basado en Whisper para convertir audio en texto y un servicio TTS basado en Piper para convertir la respuesta en audio. Mantén ambos dentro de la carpeta `/home/usuario/docker/jarvis/voice` y conéctalos a Jarvis mediante una red interna, sin publicar sus puertos fuera de la VLAN. **Cara:** la cara pertenece al frontend, no al modelo. Crea una interfaz en `/home/ usuario/docker/jarvis/face/frontend` con un avatar SVG o 2D. Define estados como` idle`, `listening`, `thinking`, `speaking` y `error`, y cambia la animación según el estado de la conversación. Empieza con un SVG ligero y deja la puerta abierta a Live2D o WebGL cuando la base funcione. ```wp-block-code mkdir -p /home/usuario/docker/jarvis/voice/{stt,tts} mkdir -p /home/usuario/docker/jarvis/face/{assets,frontend} # Ejemplo de estados del avatar idle = espera listening = escuchando el micro thinking = procesando con Ollama speaking = reproduciendo la respuesta error = necesita atención ``` Prueba primero cada capa por separado: graba unos segundos y valida la transcripción, genera una respuesta de Ollama, reproduce el audio TTS y finalmente conecta el avatar. El navegador pedirá permiso para el micrófono; concédelo solo desde el equipo de confianza y mantén el acceso limitado a la VLAN Jarvis. **Privacidad:** evita enviar audio a servicios externos si quieres que Jarvis sea local. No guardes grabaciones de voz por defecto y documenta qué componentes procesan audio, texto y credenciales. ## Resultado esperado Proxmox ejecuta una VM Debian en `192.168.100.10`; Ollama mantiene los modelos en su propia carpeta; Jarvis usa una carpeta separada; ambos servicios se comunican por una red interna y la VLAN Jarvis queda documentada y controlada por el firewall.