Categoría: Inteligencia Artificial

Instalación de Ollama en Windows paso a paso

1. Introducción

En esta práctica vamos a instalar Ollama en un equipo con Windows para poder ejecutar modelos de inteligencia artificial de forma local.

Ollama permite descargar y ejecutar modelos como Llama, Qwen, Mistral u otros modelos compatibles directamente en nuestro ordenador, sin depender necesariamente de servicios externos.

Esto es especialmente interesante en clase porque nos permite trabajar conceptos como:

Inteligencia artificial local.
Modelos de lenguaje.
Uso de la terminal.
Consumo de CPU, RAM y GPU.
Servicios accesibles desde red local.
Integración con herramientas como Open WebUI, OpenCode o aplicaciones propias.

2. Requisitos previos

Para realizar esta práctica necesitaremos:

Un equipo con Windows 10 o Windows 11.
Conexión a Internet.
Permisos para instalar programas.
PowerShell o Terminal de Windows.
Espacio suficiente en disco para descargar modelos.

Según la página oficial de Ollama, la versión para Windows requiere Windows 10 o posterior.

3. ¿Qué vamos a instalar?

Vamos a instalar:

Ollama para Windows

Una vez instalado, podremos ejecutar comandos como:

ollama --version
ollama pull llama3.1:8b
ollama run llama3.1:8b

Paso 1. Descargar Ollama para Windows

Entramos en la página oficial de descarga de Ollama:

https://ollama.com/download/windows

En la página oficial aparece la opción de descarga para Windows y también una instalación mediante PowerShell.

Podemos instalarlo de dos formas:

Opción A: Instalación con instalador gráfico

Esta es la opción más sencilla para alumnos que empiezan.

Entramos en la web oficial de Ollama.
Seleccionamos la versión de Windows.
Descargamos el instalador.
Ejecutamos el archivo descargado.
Seguimos el asistente de instalación.

Cuando termine, Ollama debería quedar instalado en el sistema.

Opción B: Instalación desde PowerShell

También podemos instalar Ollama usando PowerShell.

Abrimos PowerShell y ejecutamos:

irm https://ollama.com/install.ps1 | iex

Este comando aparece actualmente en la página oficial de descarga de Ollama para Windows.

Paso 2. Comprobar que Ollama está instalado

Abrimos una terminal de PowerShell y ejecutamos:

ollama --version

Si todo está correcto, veremos una salida parecida a esta:

ollama version x.x.x

La versión puede cambiar según el momento en el que se instale.

Paso 3. Comprobar que el servicio responde

Ollama funciona como una aplicación/servicio local que escucha normalmente en el puerto:

Podemos comprobarlo con:

curl http://localhost:11434/api/tags

Si todavía no tenemos modelos instalados, puede aparecer una lista vacía o una respuesta JSON sin modelos.

Ejemplo aproximado:

{
  "models": []
}

Paso 4. Descargar un primer modelo

Ahora vamos a descargar un modelo pequeño o mediano para probar.

Para empezar podemos usar:

ollama pull llama3.1:8b

También podríamos usar un modelo orientado a programación, por ejemplo:

ollama pull qwen2.5-coder:7b

La descarga puede tardar varios minutos, dependiendo de la conexión a Internet y del tamaño del modelo.

Paso 5. Ejecutar un modelo

Una vez descargado el modelo, podemos ejecutarlo con:

ollama run llama3.1:8b

Aparecerá un prompt interactivo donde podremos escribir preguntas.

Por ejemplo:

>>> Explícame qué es una dirección IP como si fuera para un alumno de primero de ASIR.

Ollama responderá usando el modelo cargado en local.

Para salir del chat podemos escribir:

/bye

Paso 6. Ver los modelos instalados

Para ver qué modelos tenemos descargados:

ollama list

La salida será parecida a:

NAME              ID              SIZE      MODIFIED
llama3.1:8b       xxxxxxxx        4.7 GB    ...
qwen2.5-coder:7b  xxxxxxxx        4.7 GB    ...

Paso 7. Ver qué modelos están cargados en memoria

Este paso es importante, especialmente si el ordenador también se usa para jugar, editar vídeo o realizar tareas pesadas.

Ejecutamos:

ollama ps

Este comando muestra los modelos que están cargados en ese momento.

Ejemplo:

NAME              ID              SIZE      PROCESSOR    UNTIL
llama3.1:8b       xxxxxxxx        4.7 GB    100% GPU     4 minutes from now

Paso 8. Detener un modelo cargado

Si queremos liberar memoria, podemos detener un modelo con:

ollama stop llama3.1:8b

O, si estamos usando otro modelo:

ollama stop qwen2.5-coder:7b

Esto es útil para liberar RAM o VRAM de la tarjeta gráfica.

Paso 9. Borrar un modelo

Si queremos eliminar un modelo descargado para liberar espacio en disco:

ollama rm llama3.1:8b

Después podemos comprobar de nuevo:

ollama list

Paso 10. Probar Ollama desde el navegador

Podemos abrir en el navegador:

http://localhost:11434

También podemos probar directamente la API:

http://localhost:11434/api/tags

El endpoint /api/tags permite comprobar los modelos disponibles en la instalación local.

Paso 11. Crear una petición a la API de Ollama

Ollama no solo sirve para usar modelos desde terminal. También podemos hacer peticiones HTTP a su API local.

Ejemplo desde PowerShell:

curl http://localhost:11434/api/generate `
  -Method POST `
  -Body '{"model":"llama3.1:8b","prompt":"Explica qué es Linux en pocas palabras.","stream":false}' `
  -ContentType "application/json"

Esto nos devolverá una respuesta en formato JSON.

Paso 12. Configurar Ollama para acceder desde otro equipo de la red

Por defecto, Ollama suele estar pensado para usarse desde el propio equipo. Si queremos acceder desde otro ordenador de la red local, por ejemplo desde un portátil, podemos configurar la variable de entorno:

OLLAMA_HOST

La documentación oficial de Ollama indica que en Windows las variables de entorno se pueden configurar desde las opciones de entorno del usuario o del sistema. Para ello recomienda cerrar primero Ollama desde la barra de tareas, abrir la configuración de variables de entorno, crear o editar la variable correspondiente y volver a iniciar Ollama.

Configuración recomendada para red local

Creamos la variable:

OLLAMA_HOST

Con el valor:

0.0.0.0:11434

También se puede hacer desde PowerShell como administrador:

setx OLLAMA_HOST "0.0.0.0:11434" /M

Después debemos cerrar Ollama y volver a abrirlo, o reiniciar el equipo.

Paso 13. Abrir el puerto en el firewall de Windows

Si queremos acceder a Ollama desde otro ordenador de la misma red, puede ser necesario abrir el puerto 11434.

Abrimos PowerShell como administrador y ejecutamos:

New-NetFirewallRule `
  -DisplayName "Ollama 11434" `
  -Direction Inbound `
  -Protocol TCP `
  -LocalPort 11434 `
  -Action Allow

Paso 14. Averiguar la IP del equipo Windows

En el equipo donde está instalado Ollama ejecutamos:

ipconfig

Buscamos la dirección IPv4 de la tarjeta de red que estamos usando.

Ejemplo:

Dirección IPv4. . . . . . . . . . . . . . : 192.168.1.50

En este ejemplo, la IP del equipo sería:

192.168.1.50

Paso 15. Probar Ollama desde otro ordenador

Desde otro equipo de la misma red, por ejemplo un portátil, probamos:

curl http://192.168.1.50:11434/api/tags

Cambiando 192.168.1.50 por la IP real del equipo Windows.

Si todo está correcto, veremos la lista de modelos disponibles.

Paso 16. Conectar Open WebUI u otra herramienta

Si instalamos una interfaz web como Open WebUI, podremos conectarla a la dirección del servidor Ollama.

Si Open WebUI está en el mismo equipo:

http://localhost:11434

Si Open WebUI está en otro ordenador de la red:

http://192.168.1.50:11434

Paso 17. Recomendaciones de modelos para empezar

Para equipos normales:

ollama pull llama3.1:8b
ollama pull qwen2.5-coder:7b

Para equipos con buena GPU:

ollama pull qwen2.5-coder:14b
ollama pull qwen3:14b

Para programación:

ollama run qwen2.5-coder:7b

O, si el equipo tiene más potencia:

ollama run qwen2.5-coder:14b

Para uso general:

ollama run llama3.1:8b

Paso 18. Buenas prácticas si el equipo también se usa para jugar

Si el ordenador tiene una tarjeta gráfica potente y también se usa para jugar, conviene tener cuidado.

Ollama puede usar:

RAM.
CPU.
GPU.
VRAM de la tarjeta gráfica.
Disco.

Instalar Ollama no debería reducir el rendimiento de los juegos por sí solo. El problema aparece cuando tenemos un modelo cargado mientras jugamos.

Antes de jugar podemos comprobar:

ollama ps

Si aparece algún modelo cargado, podemos detenerlo:

ollama stop nombre_del_modelo

Por ejemplo:

ollama stop qwen2.5-coder:14b

También podemos cerrar Ollama desde el icono de la bandeja del sistema.

Paso 19. Seguridad básica

No debemos exponer Ollama directamente a Internet.

Una cosa es usarlo dentro de nuestra red local y otra muy distinta dejarlo accesible públicamente desde fuera.

Recomendaciones:

No abrir el puerto 11434 en el router.
No hacer redirección de puertos hacia Ollama.
Usarlo solo en red local.
Si se necesita acceso remoto, usar VPN o una solución segura.
No permitir que cualquier persona de la red use modelos grandes sin control.

Paso 20. Comandos principales de Ollama

Acción	Comando
Ver versión	`ollama --version`
Descargar modelo	`ollama pull nombre_modelo`
Ejecutar modelo	`ollama run nombre_modelo`
Ver modelos instalados	`ollama list`
Ver modelos cargados	`ollama ps`
Detener modelo	`ollama stop nombre_modelo`
Borrar modelo	`ollama rm nombre_modelo`
Probar API local	`curl http://localhost:11434/api/tags`

Actividad propuesta

Instalar Ollama en Windows, descargar un modelo, ejecutarlo y comprobar que funciona correctamente desde terminal y desde la API local.

Tareas

Instalar Ollama en Windows.
Comprobar la versión instalada.
Descargar un modelo.
Ejecutar el modelo desde terminal.
Hacerle al modelo una pregunta técnica.
Listar los modelos instalados.
Comprobar qué modelos están cargados.
Probar la API local con curl.
Documentar el proceso con capturas.
Explicar qué recursos del equipo consume Ollama.

Cargar modelos de ollama en el disco duro secundario

Importante:
Los modelos de Ollama pueden ocupar muchos gigabytes. En equipos con un disco principal pequeño, es recomendable guardar los modelos en un disco secundario usando la variable de entorno OLLAMA_MODELS. Así evitamos llenar la unidad C: y mantenemos el sistema operativo con espacio libre suficiente.

la forma correcta para Windows, que es mover la carpeta de modelos usando la variable OLLAMA_MODELS. También voy a incluir una alternativa con enlace simbólico, útil si ya tienes modelos descargados.Pensó durante 4s

Sí. En Windows tienes que cambiar la ubicación de los modelos con la variable de entorno OLLAMA_MODELS. Ollama indica oficialmente que esta variable sirve para elegir dónde se guardan los modelos descargados.

Por ejemplo, si quieres que los modelos estén en el disco D:, puedes crear esta carpeta:

D:\Ollama\Models

Opción recomendada: usar `OLLAMA_MODELS`

1. Crea la carpeta en el disco secundario

En PowerShell:

mkdir D:\Ollama\Models

Puedes cambiar D: por la letra real de tu disco.

2. Cierra Ollama

Antes de cambiar la ruta:

Ve al icono de Ollama en la bandeja del sistema, junto al reloj.
Clic derecho.
Pulsa Quit o Salir.

También puedes cerrar el proceso desde PowerShell:

taskkill /IM ollama.exe /F

3. Crea la variable de entorno

Abre PowerShell como administrador y ejecuta:

setx OLLAMA_MODELS "D:\Ollama\Models" /M

Esto crea la variable a nivel de sistema.

También podrías crearla solo para tu usuario:

setx OLLAMA_MODELS "D:\Ollama\Models"

Para un PC personal, yo usaría la opción con /M.

4. Reinicia Ollama

Después de crear la variable:

Cierra todas las terminales.
Vuelve a abrir PowerShell.
Abre Ollama de nuevo desde el menú de inicio.

Para ir a lo seguro, reinicia Windows.

5. Comprueba que la variable existe

En una nueva ventana de PowerShell:

echo $env:OLLAMA_MODELS

Debería aparecer:

D:\Ollama\Models

6. Descarga un modelo de prueba

Por ejemplo:

ollama pull llama3.1:8b

Después comprueba que se han creado archivos dentro de:

D:\Ollama\Models

Si ya tenías modelos descargados

Por defecto, Ollama suele guardar los modelos en la carpeta del usuario, dentro de:

C:\Users\TU_USUARIO\.ollama

La documentación oficial también indica que %HOMEPATH%\.ollama contiene modelos y configuración.

Puedes moverlos así:

1. Cierra Ollama

taskkill /IM ollama.exe /F

2. Copia la carpeta antigua al nuevo disco

Por ejemplo:

robocopy "$env:USERPROFILE\.ollama\models" "D:\Ollama\Models" /E

3. Crea la variable `OLLAMA_MODELS`

setx OLLAMA_MODELS "D:\Ollama\Models" /M

4. Reinicia Windows

Después prueba:

ollama list

Si los modelos aparecen correctamente, ya está usando la nueva ubicación.

mayo 23, 2026

Instalación y uso de OpenCode en Windows con WSL Ubuntu
1. Introducción

OpenCode es una herramienta de asistencia al desarrollo mediante inteligencia artificial. Permite trabajar con proyectos de programación desde la terminal, hacer preguntas sobre el código, pedir cambios, generar archivos, revisar errores y trabajar con diferentes proveedores de modelos de IA.

Aunque OpenCode puede instalarse de varias formas, en Windows la opción más recomendable para trabajar de manera seria es usarlo dentro de WSL, es decir, el Subsistema de Windows para Linux. De esta forma trabajaremos con un entorno Linux real dentro de Windows, algo muy útil para programación, servidores, automatización y administración de sistemas.

OpenCode está disponible como herramienta de terminal, aplicación de escritorio e incluso extensiones para editores como Visual Studio Code. La versión de escritorio está disponible en beta para Windows x64.

Objetivos de la práctica

Al finalizar esta práctica, el alumno será capaz de:
- Instalar WSL en Windows.
- Instalar Ubuntu dentro de WSL.
- Instalar OpenCode en el entorno Linux.
- Abrir un proyecto con Visual Studio Code usando Remote WSL.
- Ejecutar OpenCode desde la terminal del proyecto.
- Conectar OpenCode con un proveedor de IA.
- Comprender la diferencia entre usar OpenCode en terminal, escritorio o navegador.
Requisitos previos

Para realizar esta práctica necesitaremos:
- Un equipo con Windows 10 o Windows 11.
- Conexión a Internet.
- Permisos de administrador en Windows.
- Visual Studio Code instalado.
- Una cuenta o clave de acceso para algún proveedor de IA compatible, por ejemplo OpenAI, GitHub Copilot, OpenRouter, Anthropic, Google Gemini u otro proveedor compatible.
OpenCode necesita un proveedor de modelos de lenguaje para funcionar. La herramienta puede ser gratuita, pero el uso del modelo puede depender del proveedor elegido.

Paso 1. Instalar WSL en Windows

Abrimos PowerShell como administrador.

Para ello:
1. Pulsamos en el menú de inicio.
2. Escribimos PowerShell.
3. Hacemos clic derecho.
4. Seleccionamos Ejecutar como administrador.
Después ejecutamos:
```
wsl --install
```
Este comando instalará WSL y, normalmente, también una distribución Ubuntu por defecto.

Cuando finalice la instalación, reiniciamos el equipo si Windows lo solicita.

Paso 2. Comprobar que WSL funciona

Después del reinicio, abrimos una terminal de Ubuntu desde el menú de inicio.

Buscamos:
```
Ubuntu
```
Si no lo vemos, probamos lo siguiente:

Ejecuta:
```
wsl --list --online
```
Esto te mostrará las distribuciones disponibles.

Instala Ubuntu manualmente

Ejecuta:
```
wsl --install -d Ubuntu
```
Reinicia el ordenador si te lo pide.

Si al reinicar aun no aparece, vuelve a poner
```
wsl --install -d Ubuntu
```
Comprueba qué distribuciones tienes instaladas

Después abre PowerShell normal y ejecuta:
```
wsl -l -v
```
Deberías ver algo parecido a:
```
  NAME      STATE           VERSION
* Ubuntu    Stopped         2
```
Si aparece Ubuntu, puedes abrirlo con:
```
wsl
```
o también:

ubuntu

La primera vez que se abra, Ubuntu nos pedirá crear un usuario y una contraseña.

Por ejemplo:
```
Enter new UNIX username: alumno
New password:
Retype new password:
```
La contraseña no se verá mientras la escribimos. Esto es normal en Linux.

Paso 3. Actualizar Ubuntu

Dentro de la terminal de Ubuntu ejecutamos:
```
sudo apt update
sudo apt upgrade -y
```
Con esto actualizamos la lista de paquetes y los programas instalados.

Es importante hacer este paso antes de instalar herramientas de desarrollo.

Paso 4. Instalar herramientas básicas

Instalamos algunas herramientas útiles:
```
sudo apt install -y curl git unzip
```
Estas herramientas nos permitirán descargar archivos, trabajar con repositorios y preparar proyectos.

Paso 5. Instalar OpenCode dentro de WSL

La documentación oficial de OpenCode recomienda instalarlo en WSL para trabajar desde Windows. Una vez dentro de la terminal de Ubuntu, ejecutamos el instalador oficial:
```
curl -fsSL https://opencode.ai/install | bash
```
Cuando termine la instalación, cerramos y volvemos a abrir la terminal de Ubuntu.

Después comprobamos que OpenCode está instalado:
```
opencode --version
```
Si aparece una versión, la instalación ha funcionado correctamente.

Paso 6. Crear una carpeta de trabajo

Vamos a crear una carpeta para nuestros proyectos dentro del entorno Linux.
```
mkdir -p ~/proyectos
cd ~/proyectos
```
Ahora podemos crear un proyecto de prueba:
```
mkdir prueba-opencode
cd prueba-opencode
```
Creamos un archivo simple:
```
nano index.html
```
Pegamos este contenido:
```
<!DOCTYPE html>
<html lang="es">
<head>
    <meta charset="UTF-8">
    <title>Prueba OpenCode</title>
</head>
<body>
    <h1>Hola desde OpenCode</h1>
    <p>Este es mi primer proyecto usando OpenCode en WSL.</p>
</body>
</html>
```
Guardamos con:
```
CTRL + O
Enter
CTRL + X
```
Paso 7. Ejecutar OpenCode en el proyecto

Desde la carpeta del proyecto ejecutamos:
```
opencode
```
OpenCode se iniciará en la terminal.

La primera vez puede solicitar configuración o conexión con un proveedor de IA.

Dentro de OpenCode podemos usar comandos como:
```
/connect
```
Este comando permite conectar OpenCode con un proveedor de modelos de IA.

Dependiendo del proveedor elegido, puede pedir una clave API, iniciar sesión o configurar una cuenta.

Paso 8. Primeras pruebas con OpenCode

Una vez abierto OpenCode dentro del proyecto, podemos pedirle tareas sencillas.

Por ejemplo:
```
Explícame qué hace este proyecto.
```
También podemos pedirle mejoras:
```
Mejora el archivo index.html añadiendo una estructura básica con cabecera, contenido principal y pie de página.
```
O podemos pedirle que cree nuevos archivos:
```
Crea un archivo styles.css y enlázalo desde index.html.
```
OpenCode puede ayudar a escribir, modificar y revisar código, pero el alumno siempre debe revisar los cambios antes de aceptarlos. La IA puede equivocarse, generar código innecesario o modificar partes que no debería.

Paso 9. Instalar Visual Studio Code

Si no lo tenemos instalado, descargamos e instalamos Visual Studio Code desde su página oficial.

Una vez instalado, abrimos Visual Studio Code.

Paso 10. Instalar la extensión Remote WSL

En Visual Studio Code:
1. Vamos a la sección Extensions.
2. Buscamos:
```
WSL
```
1. Instalamos la extensión oficial de Microsoft llamada WSL.
Esta extensión permite abrir carpetas de Linux/WSL directamente desde Visual Studio Code.

Paso 11. Abrir el proyecto desde WSL en Visual Studio Code

Volvemos a la terminal de Ubuntu y nos situamos en nuestro proyecto:
```
cd ~/proyectos/prueba-opencode
```
Ejecutamos:
```
code .
```
La primera vez puede tardar un poco, porque Visual Studio Code instalará algunos componentes dentro de WSL.

Cuando se abra Visual Studio Code, veremos que estamos trabajando dentro del entorno WSL.

Esto es importante: aunque estamos usando una aplicación gráfica de Windows, el proyecto realmente está dentro de Ubuntu.

Paso 12. Abrir una terminal integrada en Visual Studio Code

Dentro de Visual Studio Code:
1. Vamos al menú Terminal.
2. Pulsamos New Terminal.
3. Comprobamos que la terminal abierta es de Ubuntu/WSL.
Podemos probarlo ejecutando:
```
pwd
```
Debería aparecer una ruta parecida a:
```
/home/alumno/proyectos/prueba-opencode
```
Ahora podemos lanzar OpenCode directamente desde la terminal integrada:
```
opencode
```
Esta forma de trabajar es muy cómoda porque tenemos:
- El editor Visual Studio Code.
- El proyecto abierto.
- La terminal Linux.
- OpenCode trabajando sobre la carpeta real del proyecto.
Paso 13. Acceder a proyectos de Windows desde WSL

Aunque es recomendable guardar los proyectos dentro de Linux, también podemos acceder a carpetas de Windows desde WSL.

Por ejemplo, el disco C: de Windows aparece en WSL como:
```
/mnt/c/
```
Ejemplo:
```
cd /mnt/c/Users/TuUsuario/Desktop
```
El disco D: aparecería como:
```
/mnt/d/
```
Y así sucesivamente.

La documentación oficial de OpenCode indica que desde WSL podemos navegar a proyectos de Windows usando rutas como /mnt/c/Users/YourName/project y ejecutar allí opencode.

Aun así, para proyectos de programación es mejor trabajar dentro de:
```
/home/usuario/proyectos
```
Suele dar menos problemas de permisos, rendimiento y compatibilidad.

Paso 14. Usar la versión web de OpenCode desde WSL

OpenCode también puede ejecutarse como interfaz web en el navegador. La documentación oficial recomienda que, en Windows, se ejecute desde WSL para mantener buen acceso al sistema de archivos y a la terminal.

Desde la carpeta del proyecto podemos ejecutar:
```
opencode web --hostname 0.0.0.0
```
OpenCode mostrará una dirección local en la terminal.

Después podremos abrirla desde el navegador de Windows.

Normalmente será algo parecido a:
```
http://localhost:PUERTO
```
donde PUERTO será el número que indique OpenCode.

Paso 15. Usar la aplicación de escritorio de OpenCode

OpenCode también tiene una aplicación de escritorio en beta para Windows x64.

La idea sería:
1. Instalar OpenCode Desktop para Windows.
2. Ejecutar el servidor de OpenCode dentro de WSL.
3. Conectar la aplicación de escritorio al servidor local.
Desde WSL podemos lanzar el servidor con:
```
opencode serve --hostname 0.0.0.0 --port 4096
```
Después, desde la aplicación de escritorio, nos conectaríamos a:
```
http://localhost:4096
```
Si localhost no funciona, podemos obtener la IP de WSL con:
```
hostname -I
```
Y conectarnos usando una dirección parecida a:
```
http://IP-DE-WSL:4096
```
La documentación oficial advierte que, si usamos --hostname 0.0.0.0, conviene proteger el servidor con contraseña mediante la variable OPENCODE_SERVER_PASSWORD.

Ejemplo:
```
OPENCODE_SERVER_PASSWORD=clave-segura opencode serve --hostname 0.0.0.0 --port 4096
```
Paso 16. Recomendación para clase

Para esta práctica vamos a trabajar principalmente de esta forma:
```
Windows + WSL Ubuntu + Visual Studio Code + OpenCode en terminal
```
Es decir:
1. Usamos Windows como sistema principal.
2. Usamos Ubuntu mediante WSL como entorno de desarrollo.
3. Abrimos los proyectos con Visual Studio Code usando Remote WSL.
4. Ejecutamos OpenCode desde la terminal del proyecto.
Esta forma de trabajo es muy parecida a un entorno profesional real, porque muchos servidores, herramientas de desarrollo y sistemas de despliegue funcionan sobre Linux.

Paso 17. Comandos resumen

Instalar WSL
```
wsl --install
```
Actualizar Ubuntu
```
sudo apt update
sudo apt upgrade -y
```
Instalar herramientas básicas
```
sudo apt install -y curl git unzip
```
Instalar OpenCode
```
curl -fsSL https://opencode.ai/install | bash
```
Comprobar versión
```
opencode --version
```
Crear proyecto
```
mkdir -p ~/proyectos/prueba-opencode
cd ~/proyectos/prueba-opencode
```
Abrir Visual Studio Code desde WSL
```
code .
```
Ejecutar OpenCode
```
opencode
```
Ejecutar OpenCode Web
```
opencode web --hostname 0.0.0.0
```
Ejecutar servidor para escritorio
```
opencode serve --hostname 0.0.0.0 --port 4096
```
Problemas frecuentes

El comando opencode no se reconoce

Cerramos y volvemos a abrir la terminal de Ubuntu.

También podemos probar:
```
source ~/.bashrc
```
Después:
```
opencode --version
```
El comando code . no funciona

Puede deberse a que Visual Studio Code no está instalado correctamente o no está disponible en el PATH.

Solución:
1. Abrir Visual Studio Code en Windows.
2. Instalar la extensión WSL.
3. Volver a abrir Ubuntu.
4. Probar de nuevo:
```
code .
```
OpenCode no puede conectarse al proveedor de IA

Revisamos:
- Que tenemos conexión a Internet.
- Que la clave API es correcta.
- Que hemos usado el comando /connect.
- Que el proveedor elegido está disponible.
- Que la cuenta tiene saldo, suscripción o permisos suficientes.
Estoy en PowerShell y no en Ubuntu

OpenCode para esta práctica debe ejecutarse dentro de Ubuntu/WSL.

Si estamos en PowerShell, veremos algo parecido a:
```
PS C:\Users\Alumno>
```
Si estamos en Ubuntu/WSL, veremos algo parecido a:
```
alumno@equipo:~$
```
Para entrar en Ubuntu, abrimos la aplicación Ubuntu desde el menú de inicio.

Actividad propuesta para el alumno

Crea un pequeño proyecto web con estos archivos:
```
index.html
styles.css
script.js
```
El proyecto debe tener:
- Una página principal con título.
- Un párrafo explicando qué es OpenCode.
- Un botón creado con HTML.
- Estilos básicos en CSS.
- Un pequeño mensaje en JavaScript al pulsar el botón.
Después abre OpenCode desde la carpeta del proyecto y pídele:
```
Revisa este proyecto y propón mejoras sencillas para un alumno que está empezando.
```
A continuación, el alumno deberá entregar:
- Captura de WSL funcionando.
- Captura de opencode --version.
- Captura de Visual Studio Code abierto con Remote WSL.
- Captura de OpenCode ejecutándose en la terminal del proyecto.
- Breve explicación de qué ventajas tiene trabajar con WSL en Windows.
Conclusión

OpenCode puede utilizarse directamente en Windows, pero para un entorno de clase y de desarrollo técnico es más recomendable utilizarlo dentro de WSL con Ubuntu.

De esta manera conseguimos un entorno más parecido al que encontraremos en servidores reales, con mejor integración con herramientas Linux y con una forma de trabajo muy útil para programación, administración de sistemas, ciberseguridad y automatización.

La combinación recomendada para el curso será:
```
Windows + WSL Ubuntu + Visual Studio Code Remote WSL + OpenCode
```
mayo 18, 2026
1. Moltbot: El Asistente con Garras que Nunca se Olvida del Token
INSTALACIÓN DE CLAWDBOT EN UBUNTU

Objetivo:
• Dejar Clawdbot instalado y funcional en Ubuntu.
• Elegir entre dos modos de operación:
1) IA externa mediante API.
2) IA local mediante Ollama (ya presente en el sistema).

Nivel de privilegio necesario: usuario normal con terminal y sudo.
1. ACTUALIZAR EL SISTEMA
Primera regla de supervivencia Linux: actualizar repos.

Abre terminal y ejecuta:
```
sudo apt update && sudo apt upgrade -y
```
Esto asegura que tu zoológico de paquetes no tenga criaturas desactualizadas.

2. INSTALAR NODE.JS 22 CON NVM

Aquí usamos NVM (Node Version Manager), porque permite instalar versiones específicas sin contaminar el sistema.

Instalación de NVM:
```
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash
```
Cierra terminal y ábrela de nuevo (o source ~/.bashrc si quieres ahorrar clicks mentales).

Instala Node.js 22:
```
nvm install 22
nvm use 22
```
Comprueba versión:
```
node -v
```
Si ves v22.x.x, perfecto.

3. INSTALAR CLAWDBOT EN UBUNTU

Clawdbot ofrece dos caminos: script o npm. Ambos llevan al mismo sitio.

Opción A — Instalar con script oficial:
```
curl -fsSL https://clawd.bot/install.sh | bash
```
Opción B — Instalar vía npm:
```
npm install -g clawdbot@latest
```
Verificar que existe:
```
clawdbot --version
```
Si devuelve una versión, el bot ya está en casa.

4. CONFIGURAR CLAWDBOT (ONBOARD)

El programa tiene un asistente interactivo para dejarlo listo.

Lánzalo:
```
clawdbot onboard --install-daemon
```
Durante este paso te preguntará por:

• Método de IA
• Tokens o claves (si usas proveedores externos)
• Integración con mensajería (opcional)
• Arranque como daemon (servicio en segundo plano)

Aquí se bifurcan nuestros caminos.

5. ESCENARIO A: USANDO IA EXTERNA

En este modo Clawdbot actuaría como un cerebro sin neuronas propias, pidiendo a proveedores externos que piensen por él.

Requisitos previos:

• Haber generado tokens API en servicios como OpenAI, Anthropic, etc.
• Tener anotada la clave (no la pierdas, equivale a la llave del laboratorio).

Durante el onboard, escoge:

→ “Proveedor externo”
→ Introduce el endpoint si lo pide
→ Introduce tu token API

Ejemplo típico con OpenAI (pseudointerfaz del asistente):
```
Select AI Provider:
1 - OpenAI
2 - Anthropic
3 - Others
Choice: 1

Enter API key: sk-********************************
```
(Ve al final del documento para ver el proceso paso a paso)

Una vez completado, Clawdbot usará internet para obtener las respuestas.

Prueba de funcionamiento:
```
clawdbot start
```
Si has integrado Telegram/Discord/CLI, deberías ver respuestas.

6. ESCENARIO B: USANDO OLLAMA LOCAL

En este modo Clawdbot usa el cerebro que ya existe en tu máquina, sin enviar nada fuera. Captura la idea de “computación autónoma”. Muy útil en ciberseguridad o en entornos sin internet.

Requisitos previos:

• Ollama ya instalado y funcionando.
• Un modelo instalado (ej: llama3).
• Servicio de Ollama escuchando en http://localhost:11434.

No explicamos cómo instalar Ollama porque ya está presente — solo necesitamos conectarlo.

Durante el onboard, selecciona:

→ “Ollama (local)”

El asistente preguntará por:

• URL del servidor (usar http://localhost:11434)
• Nombre del modelo (ej: llama3, mistral, etc.)

Ejemplo textual:
```
Select AI Provider:
1 - OpenAI
2 - Anthropic
3 - Ollama (local)
Choice: 3

Enter Ollama Endpoint [http://localhost:11434]: 
→ (dejar en blanco para usar el valor por defecto)

Enter Model Name: llama3
```
Tras eso, Clawdbot sabrá pedirle respuestas al servicio local de Ollama.

Prueba de funcionamiento:
```
clawdbot start
```
Si todo está en orden, al enviar una pregunta Clawdbot se la envía a Ollama y devuelve el resultado.

7. COMPROBACIONES ÚTILES

Ver si Clawdbot está funcionando como daemon:
```
systemctl --user status clawdbot
```
Ver logs para diagnosticar:
```
clawdbot logs
```
Ver si Ollama responde (solo en escenario B):
```
curl http://localhost:11434
```
Si responde JSON, Ollama está despierto.

8. USO COMPLEMENTARIO

Para integraciones con mensajería (Telegram, Discord, etc.) el asistente de onboard sirve de guía. Estas integraciones no influyen en si usas IA externa o IA local; son capas independientes del cerebro del bot.

INSTALACIÓN DE CLAWDBOT EN WINDOWS MEDIANTE WSL

Objetivo:
• Iniciar un entorno Linux dentro de Windows
• Instalar Node.js 22
• Instalar Clawdbot
• Configurar IA externa u Ollama
1. HABILITAR WSL2
Abrir PowerShell como Administrador y ejecutar:
```
wsl --install
```
Esto habilita los componentes necesarios (Subsistema Linux + máquina virtual liviana). Después quizá te pida reiniciar.

Tras el reinicio, aparecerá Ubuntu en tu lista de aplicaciones o se te mostrará un prompt para configurar usuario y contraseña.

2. ACTUALIZAR UBUNTU

Abrir Ubuntu desde el menú de Windows y ejecutar:
```
sudo apt update && sudo apt upgrade -y
```
Esto pone al día los paquetes internos del nuevo Linux doméstico.

3. INSTALAR NVM + NODE.JS 22

NVM es el truco para tener la versión exacta de Node.js sin ensuciar el sistema.

Instalar NVM:
```
sudo apt install curl -y
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash
```
Cerrar terminal y abrirla de nuevo (o source ~/.bashrc si tienes prisa).

Instalar Node.js 22:
```
nvm install 22
nvm use 22
```
Verificar con:
```
node -v
```
Si devuelve v22.x.x, vas bien.

4. INSTALAR CLAWDBOT

Aquí dos opciones, igual que en Linux nativo:

Opción A: Script oficial
```
curl -fsSL https://clawd.bot/install.sh | bash
```
Opción B: npm global
```
npm install -g clawdbot@latest
```
Verificar:
```
clawdbot --version
```
Si responde una versión, ya está dentro del laboratorio.

5. CONFIGURACIÓN INICIAL

Activar asistente interactivo:
```
clawdbot onboard --install-daemon
```
Este asistente pregunta por:
• proveedor de IA
• claves API para IA externa (si aplica)
• integraciones con mensajería
• arranque como daemon

(Ve al final del documento para ver el proceso paso a paso)

6. ESCENARIO A: USAR IA EXTERNA DESDE WSL

Este es el más sencillo. Sirve para OpenAI, Anthropic, etc.

Durante el onboard elegimos proveedor externo, metemos clave y listo. Después WSL puede salir a Internet sin problemas, así que Clawdbot obtiene las respuestas y las devuelve sin drama.

Prueba:
```
clawdbot start
```
7. ESCENARIO B: USAR OLLAMA DESDE WSL

Aquí hay un detalle curioso: Ollama debe correr en Windows nativo, no dentro de WSL, porque Ollama usa GPU y servicios del host. Actualmente Ollama no funciona bien dentro de WSL.

Por tanto, el flujo es:
1. Instalar Ollama en Windows
2. Lanzarlo (Windows abre un servicio en localhost:11434)
3. Desde WSL, Clawdbot le habla como si estuviera en la misma red
Comprobación desde WSL:
```
curl http://localhost:11434
```
Si devuelve JSON, la frontera entre Windows y Linux es porosa y amigable.

Durante el onboard, seleccionar:
→ “Ollama (local)”
→ Endpoint: http://localhost:11434
→ Modelo: por ejemplo llama3

Después:
```
clawdbot start
```
Clawdbot enviará las preguntas desde WSL al servicio de Ollama en Windows, y te contestará sin salir jamás a la nube.

8. DIAGNÓSTICO Y LOGS

Estado del daemon:
```
systemctl --user status clawdbot
```
Logs:
```
clawdbot logs
```
9. NOTA

Usar WSL es cómodo para desarrollo o pruebas, pero no siempre ideal para producción: si cierras la terminal o el portátil duerme, los servicios mueren. Para sistemas siempre despiertos, vale más montar esto en una máquina Linux real, un NAS, o un pequeño Proxmox.

10. RESUMEN

Para que quede en un tiro limpio:
1. wsl --install
2. Abrir Ubuntu
3. sudo apt update && sudo apt upgrade -y
4. Instalar NVM + Node.js 22
5. Instalar Clawdbot
6. clawdbot onboard --install-daemon
7. Elegir IA externa o conectarlo a Ollama de Windows
Esto deja un entorno funcional donde Clawdbot vive en WSL y la IA puede vivir en la nube o en Windows según filosofía del usuario.

INSTALACIÓN DE CLAWDBOT EN macOS

Objetivo:
• Instalar Clawdbot en macOS usando Terminal
• Permitir funcionamiento con:
(A) IA externa o
(B) Ollama local previamente instalado
1. PREPARAR EL ENTORNO
Aunque no es estrictamente obligatorio, tener Homebrew facilita la vida. Homebrew es un gestor de paquetes que convierte el Mac en una especie de «Linux con diseño bonito».

Comprobar si está instalado:
```
brew -v
```
Si no responde con una versión, instalarlo con:
```
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
```
Una vez instalado, cerrar y abrir Terminal.

2. INSTALAR NODE.JS 22

Puedes hacerlo de dos formas: Homebrew o NVM. La más limpia para versiones específicas es NVM, así que lo haremos con él.

Instalar NVM vía Homebrew:
```
brew install nvm
```
Crear directorio para NVM:
```
mkdir -p ~/.nvm
```
Añadir a tu ~/.zshrc (o ~/.bashrc, según shell) lo siguiente:
```
export NVM_DIR="$HOME/.nvm"
source "$(brew --prefix nvm)/nvm.sh"
```
Después recargar la shell:
```
source ~/.zshrc
```
Instalar Node.js 22:
```
nvm install 22
nvm use 22
```
Comprobar versión:
```
node -v
```
Si ves v22.x.x, ya tienes el cerebro JavaScript funcional.

3. INSTALAR CLAWDBOT

Dos caminos disponibles:

Opción A — Script oficial:
```
curl -fsSL https://clawd.bot/install.sh | bash
```
Opción B — NPM global:
```
npm install -g clawdbot@latest
```
Verificar instalación:
```
clawdbot --version
```
Si devuelve una versión, Clawdbot ya vive en tu Mac.

4. CONFIGURACIÓN INICIAL

Iniciar asistente interactivo:
```
clawdbot onboard --install-daemon
```
Este asistente te pedirá tres tipos de decisiones:
1. Qué IA usar
2. Integraciones con mensajería (opcional)
3. Si deseas ejecutar como daemon (servicio)
(Ve al final del documento para ver el proceso paso a paso)

5. ESCENARIO A: IA EXTERNA EN macOS

Este modo envía las peticiones a un proveedor externo como OpenAI o Anthropic. Es útil si quieres modelos grandes sin instalarlos localmente.

Requisitos: token API del proveedor.

Durante onboarding, elegir:
```
AI Provider: OpenAI / Anthropic / Otros
```
Introducir tu clave API cuando te la pida.

Probar funcionamiento:
```
clawdbot start
```
Si has configurado una integración (Telegram, Discord, etc.) deberías recibir respuestas desde esas plataformas.

6. ESCENARIO B: OLLAMA EN macOS

Aquí no explicamos la instalación de Ollama porque ya está instalada según tu petición. Solo nos interesa cómo conectar.

Comprobación rápida de que Ollama está vivo:
```
curl http://localhost:11434
```
Si devuelve JSON, el servidor está en pie.

Durante el onboard, seleccionar:
```
AI Provider: Ollama (local)
Endpoint: http://localhost:11434
Model Name: llama3
```
Puedes usar cualquier modelo que tengas descargado (alto secreto: macOS tira especialmente bien con Mistral y Llama3 por tema de optimización ARM).

Probar Clawdbot:
```
clawdbot start
```
Cuando envíes mensajes verás que Clawdbot se convierte en una especie de diplomático entre tu terminal y el modelo local.

7. VERIFICACIÓN Y LOGS

Comprobar si corre como daemon (usuario):
```
launchctl list | grep clawdbot
```
Observar logs de Clawdbot:
```
clawdbot logs
```
Ver si Ollama responde (solo escenario B):
```
curl http://localhost:11434
```
8. NOTAS OPERATIVAS MAC

– macOS es actualmente uno de los mejores sistemas para IA local gracias al hardware ARM.
– Clawdbot no requiere privilegios elevados para funcionar, solo permisos de usuario.
– Si quieres integraciones persistentes (Telegram, Discord) conviene activar el modo daemon en el onboard.

9. RESUMEN

El procedimiento queda así:
1. Instalar Homebrew (opcional pero útil)
2. Instalar NVM
3. Instalar Node.js 22
4. Instalar Clawdbot
5. Ejecutar clawdbot onboard --install-daemon
6. Elegir IA externa u Ollama
7. Verificar con clawdbot start
Esta combinación te da un asistente local que piensa con modelos externos (si quieres potencia cloud) o con cerebros locales (si quieres privacidad y autonomía).

PROCESO DE INSTALACIÓN CLOAWBOT

────────────────────────────────────────────
📷 Imagen: Inicio del onboarding de Clawdbot (modo QuickStart)
────────────────────────────────────────────

Descripción:
Se muestra el asistente de configuración inicial (onboard) en la terminal. La primera pregunta confirma que el usuario entiende la naturaleza del software (agente automatizado) y se le pide confirmar con Yes.

Elementos relevantes:
- Onboarding mode: QuickStart
- Configuración predeterminada del Gateway: Gateway port: 18789 Gateway bind: Loopback (127.0.0.1) Gateway auth: Token (default) Tailscale exposure: Off Direct to chat channels.
Significado operativo:
En este modo, Clawdbot se ejecuta de forma local, no expone el servicio en la red, y autentica mediante token. Es ideal para principiantes o entornos personales.

Acciones recomendadas para el usuario:
- Confirmar QuickStart en este punto si no requiere exposición de red.
- Solo usuarios avanzados deben usar otros modos de gateway.
────────────────────────────────────────────
📷 Imagen: Selección del proveedor de IA (Model/auth provider)
────────────────────────────────────────────

Descripción:
Aquí el asistente solicita elegir qué proveedor dará servicio de inferencia al bot. Esta es la decisión clave entre IA externa (nube) o IA local.

Opciones visibles en la captura:
- OpenAI
- Anthropic
- MiniMax
- Qwen
- Synthetic
- Venice AI
- Google
- Copilot
- OpenRouter
- Vercel AI Gateway
- Moonshot AI
- Z.AI
- OpenCode Zen
- Skip for now
Significado operativo:
Esto determina de dónde obtendrá Clawdbot sus respuestas. Si el usuario planea usar Ollama más adelante, puede elegir Skip for now y configurarlo posteriormente.

Acciones recomendadas para alumnos según escenario:
- IA externa: seleccionar OpenAI o similar e introducir clave.
- IA local con Ollama: seleccionar Skip for now y configurarlo después.
- Entornos de prueba: también Skip for now si solo se quiere ver el panel.
────────────────────────────────────────────
📷 Imagen: Selección del canal de comunicación (QuickStart)
────────────────────────────────────────────

Descripción:
El asistente ahora pide elegir a través de qué canal responderá el bot. Aparecen múltiples integraciones, algunas por API y otras por aplicaciones intermedias.

Opciones visibles en la captura:
- Telegram
- WhatsApp
- Discord
- Google Chat
- Slack
- Signal
- iMessage
- Microsoft Teams
- Nextcloud Talk
- Matrix
- BlueBubbles
- LINE
- Zalo
- TLon (Urbit)
- Skip for now
Significado operativo:
Cada integración requiere pasos adicionales (tokens, claves, o conectores). Para configurar primero el backend del bot, se puede usar Skip for now.

Acción recomendada para alumnos en laboratorio:
- Seleccionar Skip for now la primera vez.
- Más adelante añadir canales con: clawdbot channels add
────────────────────────────────────────────
📷 Imagen: Estado de habilidades (Skills Status) + Hooks
────────────────────────────────────────────

Descripción:
Aquí se muestra la comprobación de habilidades del agente y la posibilidad de configurar Hooks.

Contenido clave:
- Skills status:
  - Eligible: 7
  - Missing requirements: 42
  - Blocked by allowlist: 0
- Configure skills now? → No
- Hooks explicados con descripción funcional.
Significado operativo:
Las habilidades son módulos que permiten a Clawdbot ejecutar acciones: leer archivos, ejecutar comandos, manipular memoria del agente, etc. Los Hooks permiten automatizar acciones en eventos internos.

Acciones recomendadas:
- Para instalaciones iniciales:
  Configure skills now? → No
  Enable hooks? → Skip for now
- Para uso avanzado, activar por ejemplo:
  - boot-md para ejecutar comandos al iniciar
  - command-logger para auditoría
  - session-memory para retención de contexto
────────────────────────────────────────────
📷 Imagen: Panel web de Clawdbot (Gateway Dashboard)
────────────────────────────────────────────

Descripción:
Es la interfaz web del gateway de Clawdbot. Permite gestionar chat directo, sesiones, logs, habilidades, nodos y configuración del agente.

Elementos visibles en la captura:
- Sección izquierda de navegación:
  - Chat
  - Overview
  - Channels
  - Sessions
  - Cron Jobs
  - Skills
  - Nodes
  - Config
  - Debug
  - Logs
  - Docs
- Área principal mostrando ejecución de comandos:
  - read ~/clawd/SOUL.md
  - read ~/clawd/USER.md
  - exec date
  - memory_search
  - etc.
Significado operativo:
El panel confirma que el gateway está funcional, el agente responde a comandos, y el estado del sistema es saludable (Health OK).

Acciones recomendadas:
- Usar esta interfaz para verificar que el bot está funcionando.
- Confirmar que la IA está generando respuestas en el panel (Hey, I'm online.).
- Configurar canales o IA desde sección Config si se omitió al inicio.
enero 26, 2026

[Reto] – Aletheia un Sistema de Auditoría y Análisis Forense Automatizado

El término aletheia proviene del griego antiguo αλήθεια y significa «verdad», pero con un matiz profundo que va más allá de una simple correspondencia con la realidad; se refiere al «desocultamiento del ser» o al proceso de hacer evidente lo que estaba oculto.

En entornos profesionales de administración de sistemas, auditoría y ciberseguridad, el análisis de evidencias no se realiza en el equipo personal del analista.
Los datos —logs, resultados de auditoría, informes técnicos o documentación sensible— se envían a servidores dedicados, diseñados para procesar información de forma controlada, trazable y reproducible.

El proyecto Aletheia plantea la construcción de uno de estos servidores.

Aletheia es una máquina independiente dentro de la red cuya función no es almacenar información ni ofrecer servicios al usuario final, sino transformar evidencias técnicas en conocimiento estructurado.
Para ello, integra un motor de inteligencia artificial local, accesible únicamente desde el propio servidor, que actúa como sistema de análisis y apoyo a la toma de decisiones.

A diferencia de soluciones basadas en la nube, este servidor:

no envía información a terceros,
no depende de conectividad externa,
y permite mantener control total sobre los datos analizados.

Durante el desarrollo del proyecto, el alumnado diseñará y desplegará un servicio capaz de:

recibir archivos y evidencias técnicas,
procesarlos de forma segura y estática,
analizarlos desde una perspectiva de auditoría o forense,
y generar informes claros, coherentes y reutilizables.

El objetivo no es “usar IA”, sino integrarla como parte de una arquitectura real de sistemas, entendiendo su papel como herramienta de análisis, no como sustituto del criterio técnico.

Este proyecto reproduce un escenario habitual en organizaciones reales, donde la inteligencia no reside en el usuario final, sino en la infraestructura que da soporte al análisis.

Fase 1 — Puesta a punto del servidor

Requisitos mínimos de la VM

Crea una VM en VirtualBox:
- Ubuntu Server 22.04/24.04 (64-bit)
- 4 vCPU
- 8 GB RAM
- 40 GB disco
- Red: Adaptador puente

Instala Ubuntu Server y crea un usuario (no root), por ejemplo: alumno.

1) Actualiza el sistema

sudo apt update && sudo apt -y upgrade
sudo reboot

2) Instala herramientas base

Instalar utilidades básicas:

curl
unzip
jq
python3

sudo apt -y install curl unzip jq ca-certificates gnupg python3 python3-venv python3-pip

3) Configura hostname (opcional pero recomendado)

sudo hostnamectl set-hostname forense-ai

Comprueba:

hostnamectl

4) Comprueba IP del servidor

ip a

Fase 2 — Instalar y probar Ollama

5) Instala Ollama

curl -fsSL https://ollama.com/install.sh | sh

6) Comprueba que el servicio está activo

sudo systemctl status ollama --no-pager

7) Descarga un modelo ligero (recomendado para VM)

ollama pull phi3

8) Prueba que responde

ollama run phi3 "Resume en 5 líneas qué es una auditoría de sistemas."

Si esto funciona, ya tienes “motor IA” listo.

Fase 3 — Instalar Apache + PHP (interfaz web)

9) Instala Apache y PHP

sudo apt -y install apache2 php libapache2-mod-php

10) Habilita y arranca Apache

sudo systemctl enable --now apache2

11) Abre el firewall (solo si lo estás usando)

Si tienes UFW activo:

sudo ufw allow 'Apache'
sudo ufw status

12) Comprueba acceso web

Desde tu PC (host), abre:

http://IP_DEL_SERVIDOR/

Debes ver la página por defecto de Apache.

Fase 4 — Crear la estructura del servicio “Forense-AI”

13) Crea carpetas del proyecto

sudo mkdir -p /var/www/forense-ai/{uploads,results,scripts,logs}
sudo chown -R www-data:www-data /var/www/forense-ai
sudo chmod -R 750 /var/www/forense-ai

14) Crea un VirtualHost

sudo nano /etc/apache2/sites-available/forense-ai.conf

Pega esto:

<VirtualHost *:80>
    ServerName forense-ai.local
    DocumentRoot /var/www/forense-ai

    <Directory /var/www/forense-ai>
        Options -Indexes
        AllowOverride All
        Require all granted
    </Directory>

    ErrorLog ${APACHE_LOG_DIR}/forense-ai_error.log
    CustomLog ${APACHE_LOG_DIR}/forense-ai_access.log combined
</VirtualHost>

Activa el sitio:

sudo a2ensite forense-ai
sudo a2dissite 000-default
sudo systemctl reload apache2

Fase 5 — Servicio web: formulario de subida + análisis

15) Instala herramientas para extraer texto de PDF

sudo apt -y install poppler-utils

(trae pdftotext)

16) Crea el formulario web `index.php`

sudo nano /var/www/forense-ai/index.php

Contenido:

<?php
$maxSize = 8 * 1024 * 1024; // 8 MB
$allowed = ['txt','log','pdf'];

function safe_name($name) {
  $name = preg_replace('/[^a-zA-Z0-9._-]/', '_', $name);
  return $name;
}

?>
<!doctype html>
<html>
<head>
  <meta charset="utf-8">
  <title>Forense-AI</title>
  <style>
    body { font-family: Arial, sans-serif; margin: 40px; max-width: 900px; }
    .box { padding: 16px; border: 1px solid #ccc; border-radius: 8px; }
    input, textarea, select { width: 100%; padding: 8px; margin-top: 8px; }
    button { padding: 10px 14px; margin-top: 12px; }
    .small { color: #555; font-size: 0.9em; }
  </style>
</head>
<body>
  <h1>Forense-AI — Analizador de evidencias</h1>
  <div class="box">
    <form action="process.php" method="post" enctype="multipart/form-data">
      <label>Evidencia (TXT/LOG/PDF, máx 8 MB)</label>
      <input type="file" name="evidence" required>

      <label>Tipo de análisis</label>
      <select name="mode">
        <option value="audit">Auditoría (hallazgos y riesgos)</option>
        <option value="forensic">Forense (línea temporal y eventos)</option>
        <option value="summary">Resumen ejecutivo</option>
      </select>

      <label>Contexto (opcional)</label>
      <textarea name="context" rows="4" placeholder="Ej: Esto es un auth.log de un servidor SSH expuesto a Internet..."></textarea>

      <button type="submit">Subir y analizar</button>
      <p class="small">El análisis se realiza localmente en el servidor (Ollama). No se envía nada a Internet.</p>
    </form>
  </div>
</body>
</html>

17) Crea el script de procesamiento `process.php`

sudo nano /var/www/forense-ai/process.php

Contenido:

<?php
$uploadDir = __DIR__ . "/uploads/";
$resultDir = __DIR__ . "/results/";
$logDir    = __DIR__ . "/logs/";

$maxSize = 8 * 1024 * 1024;
$allowed = ['txt','log','pdf'];

function safe_name($name) {
  return preg_replace('/[^a-zA-Z0-9._-]/', '_', $name);
}

function ext($name) {
  $p = pathinfo($name);
  return strtolower($p['extension'] ?? '');
}

function run_cmd($cmd) {
  $output = [];
  $ret = 0;
  exec($cmd . " 2>&1", $output, $ret);
  return [$ret, implode("\n", $output)];
}

if (!isset($_FILES['evidence'])) {
  http_response_code(400);
  exit("No file uploaded");
}

$f = $_FILES['evidence'];
if ($f['error'] !== UPLOAD_ERR_OK) {
  http_response_code(400);
  exit("Upload error");
}

if ($f['size'] > $maxSize) {
  http_response_code(400);
  exit("File too large");
}

$original = $f['name'];
$extension = ext($original);

if (!in_array($extension, $allowed, true)) {
  http_response_code(400);
  exit("Invalid extension");
}

$mode = $_POST['mode'] ?? 'audit';
$context = trim($_POST['context'] ?? '');

$base = date("Ymd_His") . "_" . safe_name($original);
$dest = $uploadDir . $base;

if (!move_uploaded_file($f['tmp_name'], $dest)) {
  http_response_code(500);
  exit("Failed to save upload");
}

// Extraer texto
$textFile = $dest . ".txt";
if ($extension === 'pdf') {
  // pdftotext
  [$ret, $out] = run_cmd("pdftotext " . escapeshellarg($dest) . " " . escapeshellarg($textFile));
  if ($ret !== 0) {
    http_response_code(500);
    exit("pdftotext failed:\n" . htmlspecialchars($out));
  }
} else {
  // Copiar tal cual
  copy($dest, $textFile);
}

// Leer texto (limitamos por tamaño para no petar memoria)
$raw = file_get_contents($textFile);
if ($raw === false) {
  http_response_code(500);
  exit("Cannot read extracted text");
}
$raw = substr($raw, 0, 50000); // 50k chars (suficiente para práctica)

$promptBase = "Eres un analista de ciberseguridad. Responde en español con formato claro.\n";
if ($mode === 'audit') {
  $task = "Analiza la evidencia como auditoría. Devuelve: 1) Resumen, 2) Hallazgos (con evidencias), 3) Riesgos, 4) Recomendaciones priorizadas.";
} elseif ($mode === 'forensic') {
  $task = "Analiza la evidencia con enfoque forense. Devuelve: 1) Resumen, 2) Línea temporal aproximada, 3) Eventos relevantes, 4) Hipótesis, 5) Próximos pasos.";
} else {
  $task = "Resume la evidencia para un responsable no técnico. Devuelve un resumen ejecutivo y 5 puntos clave.";
}

$contextPart = $context ? "\nContexto aportado por el usuario:\n" . $context . "\n" : "";

$prompt = $promptBase . $task . $contextPart . "\nEVIDENCIA (texto):\n" . $raw . "\n";

// Llamar a Ollama
$model = "phi3";
$cmd = "ollama run " . escapeshellarg($model) . " " . escapeshellarg($prompt);

[$ret, $analysis] = run_cmd($cmd);
if ($ret !== 0) {
  http_response_code(500);
  exit("Ollama failed:\n" . htmlspecialchars($analysis));
}

$reportName = basename($dest) . "_informe.md";
$reportPath = $resultDir . $reportName;

$report = "# Informe Forense-AI\n\n"
        . "- Archivo: **" . htmlspecialchars($original) . "**\n"
        . "- Fecha: **" . date("Y-m-d H:i:s") . "**\n"
        . "- Modo: **" . htmlspecialchars($mode) . "**\n\n"
        . "---\n\n"
        . $analysis . "\n";

file_put_contents($reportPath, $report);

// Log básico
file_put_contents($logDir . "activity.log",
  date("c") . " file=" . $base . " mode=" . $mode . " ip=" . ($_SERVER['REMOTE_ADDR'] ?? 'unknown') . "\n",
  FILE_APPEND
);

header("Location: result.php?f=" . urlencode($reportName));

18) Crea la página de resultados `result.php`

sudo nano /var/www/forense-ai/result.php

Contenido:

<?php
$resultDir = __DIR__ . "/results/";
$f = $_GET['f'] ?? '';
$f = basename($f); // evita traversal
$path = $resultDir . $f;

if (!$f || !file_exists($path)) {
  http_response_code(404);
  exit("Report not found");
}

$txt = file_get_contents($path);
?>
<!doctype html>
<html>
<head>
  <meta charset="utf-8">
  <title>Resultado — Forense-AI</title>
  <style>
    body { font-family: Arial, sans-serif; margin: 40px; max-width: 900px; }
    pre { white-space: pre-wrap; border: 1px solid #ccc; padding: 16px; border-radius: 8px; }
    a { display:inline-block; margin-top: 12px; }
  </style>
</head>
<body>
  <h1>Informe generado</h1>
  <a href="download.php?f=<?php echo urlencode($f); ?>">Descargar informe</a>
  <pre><?php echo htmlspecialchars($txt); ?></pre>
  <a href="index.php">⬅ Volver</a>
</body>
</html>

19) Crea el descargador `download.php`

sudo nano /var/www/forense-ai/download.php

Contenido:

<?php
$resultDir = __DIR__ . "/results/";
$f = $_GET['f'] ?? '';
$f = basename($f);
$path = $resultDir . $f;

if (!$f || !file_exists($path)) {
  http_response_code(404);
  exit("Not found");
}

header('Content-Type: text/markdown; charset=utf-8');
header('Content-Disposition: attachment; filename="' . $f . '"');
readfile($path);

Fase 6 — Permisos y seguridad mínima del servicio

20) Permisos finales (muy importante)

sudo chown -R www-data:www-data /var/www/forense-ai
sudo find /var/www/forense-ai -type d -exec chmod 750 {} \;
sudo find /var/www/forense-ai -type f -exec chmod 640 {} \;
sudo systemctl reload apache2

21) Importante: Ollama solo local

Comprueba que Ollama no está expuesto:

El servicio web llama a ollama run localmente.
No hace falta abrir puertos de Ollama.

Fase 7 — Pruebas obligatorias (para entregar)

22) Caso de prueba A (Auditoría)

Sube un auth.log (o un ejemplo creado por vosotros)
Modo: Auditoría
Debe devolver hallazgos y recomendaciones

23) Caso de prueba B (Forense)

Sube una salida de nmap guardada como TXT
Modo: Forense
Debe generar hipótesis y próximos pasos

24) Caso de prueba C (PDF)

Sube un PDF técnico (manual, informe)
Modo: Resumen ejecutivo
Debe resumir y extraer puntos clave

enero 6, 2026

Herramientas IA en la Web (I)

🖼️ IA de IMAGEN (generación / edición)

Herramienta	Enlace	Uso principal	Coste
Rendernet	https://rendernet.ai/	Imágenes y vídeo con personajes consistentes	Freemium / Suscripción
Krea AI	https://www.krea.ai/home	Imagen creativa en tiempo real, estilos	Freemium / Suscripción
Grok Image / Imagine	https://grok.com/imagine	Generación de imágenes por prompt	Freemium (limitado)
Adobe Firefly	https://firefly.adobe.com/upload/inpaint	Edición IA (inpaint, estilos)	Freemium / Suscripción Adobe
Reve / Reve AI	https://app.reve.com/	Generación artística de imágenes	Freemium
Lovart AI	https://www.lovart.ai/	Ilustración, arte conceptual	Freemium / Suscripción
PixVerse	https://app.pixverse.ai/	Imagen + vídeo creativo	Freemium / Suscripción

🎥 IA de VÍDEO (texto → vídeo / imagen → vídeo)

Herramienta	Enlace	Uso principal	Coste
LivePortrait	https://liveportrait.github.io/	Animar retratos (imagen → vídeo)	Gratuito / Open Source
HuggingFace Demo (KwaiVGI)	https://huggingface.co/spaces/KwaiVGI	Demo online de LivePortrait	Gratuito
Wan	https://wan.video/	Generación de vídeo con IA	Freemium / Suscripción
Wan 2.2	https://wan.video/	Versión avanzada del modelo Wan	Freemium / Suscripción
MindVideo	https://www.mindvideo.ai/es/	Texto → vídeo	Freemium / Suscripción
CapCut AI Video	https://www.capcut.com/my-edit	Edición y vídeo con IA	Freemium / Pro
Symphony (TikTok)	https://ads.tiktok.com/creative	Vídeos publicitarios automáticos	Gratuito
Veo 3.1 (Flow)	https://labs.google/fx/es/tools/flow	Vídeo generativo experimental (Google)	Acceso limitado / Experimental
Hedra	https://www.hedra.com/	Creación audiovisual con IA	Freemium / Suscripción

🔊 IA de VOZ / AUDIO

Herramienta	Enlace	Uso principal	Coste
ElevenLabs	https://try.elevenlabs.io/shmdm7umt6gg	Texto → voz realista, clonación	Freemium / Suscripción

💬 IA de CHAT / LLMs

Herramienta	Enlace	Uso principal	Coste
Meta AI	https://www.meta.ai/	Asistente IA general	Gratuito
Qwen	https://qwen.ai/	LLM general (Alibaba)	Gratuito
Chat Qwen (mini campus)	https://chat.qwen.ai/s/deploy/…	Chat personalizado desplegado	Gratuito
Ernie	https://ernie.baidu.com/	LLM de Baidu	Gratuito
Chat Z	https://chat.z.ai/	Chat IA general	Gratuito
ChatGLM	https://chatglm.cn	LLM técnico	Gratuito
LMArena	https://lmarena.ai/	Comparador de modelos LLM	Gratuito

🧠 PROMPTS / EXPERIMENTOS IA

Herramienta	Enlace	Uso principal	Coste
Generador de prompts (Gemini)	https://gemini.google.com/gem/…	Creación de prompts optimizados	Gratuito
Pomelli (Google Labs)	https://labs.google.com/pomelli/about/	Experimentos creativos IA	Gratuito / Experimental

🤖 AGENTES / AUTOMATIZACIÓN

Herramienta	Enlace	Uso principal	Coste
RoboNeo	https://www.roboneo.com/	Agentes IA y automatización	Freemium / Suscripción

🔐 PRIVACIDAD / VPN (extra, no IA)

Herramienta	Enlace	Uso principal	Coste
NordVPN	https://nordvpn.com/alejavi	VPN profesional	Suscripción
Hide.me (extensión Chrome)	Chrome Web Store	VPN básica navegador	Gratuita

🧩 RESUMEN

🟢 Gratis / Open: LivePortrait, HuggingFace, Meta AI, Qwen, ChatGLM, LMArena
🟡 Freemium : ElevenLabs, Krea, CapCut, Wan, PixVerse
🔵 Profesional / Pro: Rendernet, Adobe Firefly, NordVPN

diciembre 22, 2025

TGPT desde la terminal (Windows · Linux · macOS)
Manual de instalación y uso de tgpt

1. ¿Qué es tgpt y para qué sirve?

tgpt es un cliente no oficial que permite interactuar con modelos tipo ChatGPT directamente desde la terminal, sin navegador y sin iniciar sesión en OpenAI.

Se usa mucho para:
- Resolver dudas técnicas rápidas
- Explicar comandos Linux
- Generar scripts
- Pedir ejemplos de código
- Documentar procesos
- Automatizar consultas desde scripts
No sustituye el razonamiento humano. Es un copiloto, no el piloto.

2. Instalación en Windows

Instalar Node.js
1. Descargar desde: https://nodejs.org
2. Instalar la versión LTS
3. Verificar desde PowerShell o CMD:
```
node -v
npm -v
```
Si aparecen versiones, todo va bien.

Instalar tgpt

En PowerShell o CMD:
```
npm install -g tgpt
```
Comprobar instalación:
```
tgpt --help
```
Primer uso en Windows

Ejemplo simple:
```
tgpt "¿Qué es un firewall?"
```
Ejemplo técnico:
```
tgpt "Explícame el comando netstat en Windows con ejemplos"
```
3. Instalación en Linux (Ubuntu, Debian, Kali, Parrot…)
```
curl -sSL https://raw.githubusercontent.com/aandrew-me/tgpt/main/install | bash -s /usr/local/bin
```
Comprobar:
```
tgpt --help
```
Primer uso en Linux

Ejemplo OSINT:
```
tgpt "¿Qué es OSINT y qué tipos de fuentes existen?"
```
Ejemplo Linux:
```
tgpt "Explícame el comando grep con ejemplos reales"
```
Ejemplo scripting:
```
tgpt "Hazme un script bash para comprobar si un host responde a ping"
```
4. Instalación en macOS

5.1 Instalar Homebrew (si no está instalado)

En Terminal:
```
brew install tgpt
```
Verificar:
```
tgpt --help
```
Ejemplo programación:
```
tgpt "Dame un ejemplo sencillo de una API REST"
```
Ejemplo sistemas:
```
tgpt "Diferencias entre TCP y UDP explicadas para principiantes"
```
5. Uso básico de tgpt

Consulta directa
```
tgpt "Explícame qué es un hash"
```
Respuestas más técnicas
```
tgpt "Explícame qué es SHA-256 con un ejemplo práctico"
```
Modo conversación
```
tgpt -c
```
Permite hacer varias preguntas seguidas manteniendo contexto.

Salida sin colores (útil para logs o scripts)
```
tgpt --no-color "Qué es un IDS"
```
6. Buenas prácticas
- No copiar y pegar sin entender
- Verificar comandos antes de ejecutarlos
- Usar tgpt como ayuda, no como sustituto del aprendizaje
- Contrastar respuestas técnicas
- Documentar qué pregunta se hizo y por qué
7. Ejemplos

Ejemplo 1 – Linux
```
tgpt "Explícame paso a paso cómo funciona chmod"
```
Ejemplo 2 – Ciberseguridad
```
tgpt "Diferencias entre IDS y IPS con ejemplos"
```
Ejemplo 3 – OSINT
```
tgpt "Herramientas OSINT que se pueden usar desde terminal"
```
Ejemplo 4 – Programación
```
tgpt "Ejemplo de conexión a MySQL en PHP usando PDO"
```
8. Problemas comunes
- command not found → tgpt no está en el PATH
- Permisos npm → usar sudo en Linux
- Node muy antiguo → actualizar Node.js
- Respuestas erróneas → recordar que la IA puede equivocarse
Opciones y flags con ejemplos reales

Uso básico (sin flags)
```
tgpt "¿Qué es un IDS?"
```
Esto lanza una consulta directa y devuelve una respuesta estándar, con colores y formato amigable.

Es el modo “háblame como a un humano”.

-m → Elegir modelo (cuando está disponible)

El flag -m permite indicar el modelo que se quiere usar.
No siempre todos los modelos están activos, pero el concepto es clave didácticamente.
```
tgpt -m gpt-3.5-turbo "Explícame qué es OSINT"
```
Ejemplo técnico:
```
tgpt -m gpt-3.5-turbo "Dame un ejemplo de escaneo pasivo"
```
Prueba a comparar la misma pregunta con y sin -m y analizar diferencias de detalle, precisión o estilo.

-s → Modo shell / respuesta corta y directa

Este flag es oro para Linux.

-s (shell mode) intenta responder como si fuera una ayuda de terminal: más conciso, menos charla.
```
tgpt -s "comando para listar puertos abiertos en linux"
```
Salida típica: comandos directos, sin narrativa larga.

Ejemplo muy útil:
```
tgpt -s "como ver mi ip publica en linux"
```
-c → Modo conversación (contexto persistente)

Activa un modo interactivo.
tgpt recuerda lo que se ha dicho en esa sesión.
```
tgpt -c
```
Luego:
```
¿qué es nmap?
¿y en qué se diferencia de masscan?
ponme un ejemplo práctico
```
Esto es perfecto para:
- razonamiento progresivo
- tutoría guiada
- simulación de mentor técnico
El contexto se pierde al salir del programa.

--no-color → Sin colores (scripts, logs, redirecciones)

Cuando la salida se va a:
- un archivo
- un pipe
- un script bash
Los colores estorban.
```
tgpt --no-color "qué es un hash" > hash.txt
```
O encadenado:
```
tgpt --no-color -s "comando para ver procesos" | less
```
-q → Modo silencioso (solo respuesta)

El flag -q elimina encabezados y texto adicional.
```
tgpt -q "comando para ver usuarios conectados"
```
Muy útil cuando:
- quieres solo la respuesta
- estás comparando resultados
- lo usas como apoyo rápido
Combinando flags (aquí está la magia)

Ejemplo 1 – Linux puro
```
tgpt -s -q "ver uso de disco en linux"
```
Respuesta directa, corta, sin ruido.

Ejemplo 2 – OSINT
```
tgpt -s "herramientas osint que funcionen desde terminal"
```
Ejemplo 3 – Para scripting
```
tgpt --no-color -s "script bash para comprobar si un host responde a ping"
```
Ejemplo 4 – Clase de ciberseguridad
```
tgpt -c -s
```
Y dentro:
```
que es un firewall
diferencia entre firewall y waf
ejemplo en entorno real
```
Ver todas las opciones disponibles

Siempre recordar a los alumnos:
```
tgpt --help
```
Esto refuerza un hábito clave: leer la ayuda antes de preguntar.

Ejercicios
1. Ejecuta la misma pregunta de 3 formas:
  - sin flags
  - con -s
  - con -s -q
2. Pregunta:
  - ¿Cuál es más útil para terminal?
  - ¿Cuál para aprender?
  - ¿Cuál para automatizar?
Ejemplo de pregunta base:
```
"comando para ver conexiones activas en linux"
```
Chuleta rápida de tgpt

Chuleta Tgpt Descarga

tgpt no es ChatGPT, es una interfaz.
Lo interesante no es la IA, sino cómo la integras en tu flujo de trabajo Linux:
diciembre 14, 2025

Ollama – Chatbot IA Local en 5 Minutos

¿cuándo usar tgpt y cuándo usar Ollama?

En el ecosistema actual de IA aplicada a terminal y ciberseguridad aparecen dos enfoques muy distintos:

tgpt → un cliente que conecta con modelos en la nube
Ollama → un motor local que ejecuta modelos en tu propio sistema

Ambos usan IA. Pero resuelven problemas distintos.

1. Qué es tgpt (en una frase honesta)

tgpt es un puente entre tu terminal y modelos en la nube.

No ejecuta IA local
Envía tus prompts a un servicio externo
Devuelve la respuesta en texto, integrada en la terminal

Mentalmente:

“Un ChatGPT sin navegador, pegado a la shell.”

2. Qué es Ollama (en una frase honesta)

Ollama es una plataforma para ejecutar modelos de IA localmente.

Los modelos están en tu disco
El razonamiento ocurre en tu máquina
No depende de Internet
Tú controlas datos, logs y flujos

Mentalmente:

“Un motor de IA como si fuera un servicio más del sistema.”

3. Comparativa

Aspecto	tgpt	Ollama
Tipo	Cliente	Motor local
Dónde se ejecuta la IA	Nube	Tu servidor
Requiere Internet	Sí	No
Privacidad	Baja–media	Alta
Consumo de recursos locales	Muy bajo	Medio–alto
Facilidad de uso	Muy alta	Media
Control del sistema	Nulo	Total
Ideal para	Consultas rápidas	Integración técnica
Uso en producción	No	Sí
Valor educativo en ciber	Conceptual	Arquitectónico

4. Cuándo es mejor usar tgpt

Usa tgpt cuando:

Quieres rapidez
Estás aprendiendo conceptos
Necesitas ayuda puntual con:
- comandos
- sintaxis
- explicaciones
No te importa que el contenido viaje a la nube
Estás en un equipo con pocos recursos

Ejemplos reales:

“Explícame este error de Bash”
“¿Qué hace este comando?”
“Dame una idea rápida”

tgpt es ideal como calculadora mental avanzada.

5. Cuándo es mejor usar Ollama

Usa Ollama cuando:

Trabajas con:
- logs reales
- datos sensibles
- salidas de herramientas de ciber
Quieres offline
Necesitas:
- automatización
- integración con scripts
- auditoría y control
Estás enseñando arquitectura y seguridad
No quieres depender de terceros

Ejemplos reales:

Analizar auth.log
Resumir resultados de nmap
Asistir en scripting
Crear un copiloto de terminal seguro
Laboratorios en red aislada

Requisitos mínimos Ollama (realistas)

Antes de tocar nada, conviene saber qué espera Ollama del hierro:

Ubuntu Server 24.04 LTS (OK)
Arquitectura x86_64
CPU decente (funciona sin GPU, pero paciencia)
RAM recomendada:
- 8 GB → modelos pequeños (phi, tinyllama)
- 16 GB o más → llama3, mistral, etc.
Acceso a internet

Comprueba lo básico:

lsb_release -a
uname -m
free -h

Instalación

Ollama se instala con un único script oficial. No snaps, no flatpaks, no dramas.

curl -fsSL https://ollama.com/install.sh | sh

Qué hace este script (para tu tranquilidad mental):

Descarga el binario de Ollama
Lo instala en /usr/bin/ollama
Crea un servicio systemd
Arranca Ollama automáticamente

Comprobar que el servicio está vivo

En un server, systemd manda:

systemctl status ollama

Deberías ver algo como:

Active: active (running)
Escuchando en 127.0.0.1:11434

Si no está activo:

sudo systemctl enable --now ollama

Probar Ollama desde terminal

Aquí viene la parte bonita: usar IA sin navegador.

Prueba con un modelo ligero primero:

ollama run phi

O uno más conocido:

ollama run llama3

La primera vez:

Descarga el modelo
Puede tardar (no está roto, está pensando)

Cuando veas un prompt tipo:

>>>

Ya tienes un LLM local funcionando. Sin nube. Sin vender tu alma.

Ver modelos instalados

ollama list

Descargar modelos sin ejecutarlos:

ollama pull mistral
ollama pull llama3:8b

Uso como servicio (API local)

Ollama levanta una API REST en local:

URL: http://localhost:11434

Prueba rápida:

curl http://localhost:11434/api/tags

Esto es oro puro para:

Scripts Python
Herramientas OSINT
Automatización en ciber
Integrarlo con apps web internas

Permitir acceso desde otra máquina (opcional)

⚠️ Ojo sysadmin: por defecto SOLO escucha en localhost.

Si quieres que otros equipos accedan (por ejemplo, alumnos o un frontend):

Edita el servicio:

sudo systemctl edit ollama

Añade:

[Service]
Environment="OLLAMA_HOST=0.0.0.0:11434"

Luego:

sudo systemctl daemon-reload
sudo systemctl restart ollama

Y abre firewall si procede:

sudo ufw allow 11434/tcp

Dónde guarda Ollama los modelos

Importante para servidores con discos separados:

Por defecto:
/usr/share/ollama/.ollama

Puedes moverlo usando:

export OLLAMA_MODELS=/ruta/grande/ollama-models

En server con /data o /mnt, esto es muy recomendable.

Desinstalar

sudo systemctl stop ollama
sudo rm /usr/bin/ollama
sudo rm /etc/systemd/system/ollama.service
sudo rm -rf /usr/share/ollama

Modelos Ollama – Tamaño en disco y recursos

Modelo	Parámetros (B)	RAM recomendada	Tamaño en disco aprox.	Velocidad	Uso típico
tinyllama	1.1B	2–4 GB	~0.7 GB	Muy alta	Pruebas rápidas
qwen2.5:0.5b	0.5B	2–3 GB	~0.4 GB	Muy alta	Comandos simples
phi	2.7B	4–6 GB	~1.6 GB	Muy alta	Terminal, docencia
orca-mini	3B	6–8 GB	~2.0 GB	Alta	Explicaciones
mistral	7B	8 GB	~4.1 GB	Alta	Uso técnico
qwen2.5:7b	7B	8 GB	~4.0 GB	Alta	Código
llama3:8b ⭐	8B	8–10 GB	~4.7 GB	Alta	Ciber, logs
codellama	7B	8–10 GB	~3.8–4.2 GB	Media	Programación
deepseek-coder	6–7B	8–12 GB	~3.5–4.0 GB	Media	Código
nous-hermes	7–13B	8–16 GB	~4.5–8.0 GB	Media	Razonamiento
mixtral:8x7b	MoE	16–32 GB	~26–28 GB	Media	Análisis complejo
llama3:70b	70B	64+ GB	~40–45 GB	Baja	Servidores grandes
gemma:7b	7B	8 GB	~4.0 GB	Alta	Lenguaje
yi:6b	6B	8 GB	~3.5 GB	Media	Multilenguaje
yi:34b	34B	32+ GB	~20–22 GB	Baja	Análisis profundo

Comprobar que Ollama está instalado y activo

En tu Ubuntu Server 24:

ollama --version
systemctl status ollama

Si ves versión y estado active (running), seguimos.

Instalar (descargar) el modelo `codellama`

Instalar un modelo en Ollama es simplemente hacer un pull:

ollama pull codellama

Qué ocurre aquí:

Se descarga el modelo
Se guarda en disco
No se ejecuta todavía
Puede tardar (son ~4 GB)

Paciencia de sysadmin.

Verificar que el modelo está instalado

ollama list

Deberías ver algo así:

NAME           ID            SIZE     MODIFIED
codellama      xxxx          ~4.0 GB  …

Usar el modelo

Modo interactivo

ollama run codellama

Te aparecerá:

>>>

Ejemplo:

>>> escribe un script bash que liste usuarios conectados

Responderá orientado a código, no a charla.

Uso directo (una sola petición)

ollama run codellama "escribe un script en bash para hacer backup de /etc"

Perfecto para redirecciones:

ollama run codellama "crea un script de backup de /etc" > backup.sh
chmod +x backup.sh

Elegir tamaño de `codellama` (muy importante)

codellama tiene variantes. Puedes pedir una concreta:

Variante	RAM recomendada	Disco aprox.
`codellama:7b`	8–10 GB	~3.8 GB
`codellama:13b`	14–18 GB	~7–8 GB
`codellama:34b`	32+ GB	~20 GB

Ejemplo explícito:

ollama pull codellama:7b

Si no indicas nada, Ollama suele traer la variante por defecto (normalmente 7B).

Uso de Ollama en ejecución del sistema

Ollama puede:

Generar comandos
Generar scripts
Generar código
Analizar salidas de comandos
Decidir qué comando habría que ejecutar

Pero alguien tiene que ejecutarlos. Ese alguien eres tú… o un wrapper.

El esquema mental sano es este:

[ Usuario ] → [ Ollama (razona) ] → [ Script intermedio ] → [ Sistema ]

Nunca:

IA → root → caos

Ollama puede generar contenido:

ollama run llama3 "Escribe un README.md sobre este proyecto" > README.md

Aquí sí crea archivos, pero porque la shell redirige la salida.
Ollama sigue sin tocar el sistema.

El peligro real

El riesgo no es Ollama.
El riesgo es esto:

#Peligro
eval "$(ollama run llama3 'dame un comando para limpiar el sistema')"

Ejecutar comandos con control (wrapper en Bash)

#!/bin/bash
if [ $# -gt 0 ]; then
  pregunta$1
else
    read -p "Pregunta a la IA: " pregunta
fi



respuesta=$(ollama run phi "$pregunta. Devuelve SOLO un comando seguro.")

echo "La IA propone ejecutar:"
echo "$respuesta"

read -p "¿Ejecutar? (s/n): " ok
if [[ "$ok" == "s" ]]; then
    eval "$respuesta"
fi

Qué ocurre aquí:

Ollama propone
El humano autoriza
El sistema ejecuta

En Linux, un comando es solo:

un archivo ejecutable
ubicado en un directorio que esté en $PATH

Si eso se cumple → se ejecuta desde cualquier sitio.

Compruébalo:

echo $PATH

Verás cosas como:

/usr/bin
/usr/local/bin
/bin

Ahí es donde viven los comandos “del sistema”.

Opción recomendada: `/usr/local/bin` (limpio y correcto)

Supongamos que tu script se llama ollama-shell.sh.

Mover el script

sudo mv ollama-shell.sh /usr/local/bin/ollama-shell

Nota:

Quitamos .sh → parece un comando real
Linux no necesita extensión

Dar permisos de ejecución

sudo chmod +x /usr/local/bin/ollama-shell

Probar desde cualquier sitio

cd /tmp
ollama-shell

Script Wraper avanzado

Aquí tienes un script con muchas mas opciones:

#!/usr/bin/env bash
set -euo pipefail

# -----------------------------
# Ollama Shell Assistant (Seguro)
# - Pregunta a un modelo Ollama local
# - Fuerza español usando modelo "llama3-es"
# - Devuelve un único comando
# - Valida contra lista blanca
# - Pide confirmación antes de ejecutar
# - Registra todo en /var/log/ollama-shell.log
# -----------------------------

MODEL="${MODEL:-llama3-es}"
LOG_FILE="${LOG_FILE:-/var/log/ollama-shell.log}"

MODE="${MODE:-ask}"  # ask | exec
TIMEOUT_SECS="${TIMEOUT_SECS:-120}"

# Lista blanca básica de comandos permitidos (ajústala a tu contexto)
ALLOW_CMDS=(
  "ls" "ll" "pwd" "cd"
  "cat" "less" "head" "tail"
  "grep" "egrep" "fgrep" "awk" "sed" "cut" "sort" "uniq" "wc"
  "find" "locate" "which" "whereis"
  "ip" "ss" "netstat" "ping" "traceroute" "dig" "nslookup" "curl" "wget"
  "ps" "top" "htop" "free" "df" "du" "uptime" "uname" "lsblk"
  "systemctl" "journalctl"
  "who" "w" "id" "groups" "last" "lastb"
  "tar" "gzip" "gunzip" "zip" "unzip"
  "apt" "apt-get" "dpkg" "snap"
  "nmap"
)

print_help() {
  cat <<'EOF'
Uso:
  ollama-shell [-e] [-m MODELO] "pregunta..."
  ollama-shell --suggest "pregunta..."
  ollama-shell --exec "pregunta..."
  ollama-shell --help

Opciones:
  -m, --model     Modelo Ollama a usar (por defecto: llama3-es)
  -e, --exec      Permite ejecutar (con confirmación humana)
  --suggest       Solo sugiere (no ejecuta)
  --log FILE      Archivo de log (por defecto: /var/log/ollama-shell.log)

Variables:
  MODEL=llama3-es
  MODE=ask|exec
  LOG_FILE=/var/log/ollama-shell.log
  TIMEOUT_SECS=120

Notas:
- El modelo debe devolver SOLO UN comando.
- Se valida el comando contra una lista blanca básica.
EOF
}

die() {
  echo "ERROR: $*" >&2
  exit 1
}

ensure_ollama() {
  command -v ollama >/dev/null 2>&1 || die "No encuentro 'ollama' en PATH. ¿Está instalado?"
  systemctl is-active --quiet ollama 2>/dev/null || true
}

ensure_log_writable() {
  # Intentar escribir en LOG_FILE; si no se puede, degradar a ~/.ollama-shell.log
  if ! (touch "$LOG_FILE" 2>/dev/null); then
    LOG_FILE="$HOME/.ollama-shell.log"
    touch "$LOG_FILE" || die "No puedo escribir logs ni en /var/log ni en HOME."
  fi
}

log_line() {
  local msg="$1"
  printf '%s | user=%s | cwd=%s | %s\n' "$(date '+%F %T')" "${USER:-unknown}" "$(pwd)" "$msg" >> "$LOG_FILE"
}

trim() {
  sed -e 's/^[[:space:]]*//' -e 's/[[:space:]]*$//'
}

first_token() {
  # Devuelve el primer token (comando base), ignorando sudo si aparece
  local s="$1"
  s="$(echo "$s" | trim)"
  if [[ "$s" == sudo\ * ]]; then
    echo "$s" | awk '{print $2}'
  else
    echo "$s" | awk '{print $1}'
  fi
}

is_allowed_cmd() {
  local cmd="$1"
  for a in "${ALLOW_CMDS[@]}"; do
    [[ "$cmd" == "$a" ]] && return 0
  done
  return 1
}

looks_dangerous() {
  # Filtros anti-destrucción básicos (no exhaustivos)
  local s="$1"
  s="$(echo "$s" | trim)"
  [[ -z "$s" ]] && return 0

  # Cosas típicas peligrosas
  if echo "$s" | grep -Eqi 'rm\s+-rf\s+/' ; then return 0; fi
  if echo "$s" | grep -Eqi 'mkfs|dd\s+if=|:\(\)\s*\{\s*:\|\s*:\s*;\s*\}\s*;|shutdown|reboot|poweroff' ; then return 0; fi
  if echo "$s" | grep -Eqi '>\s*/etc/|>\s*/bin/|>\s*/usr/bin/|chown\s+root|chmod\s+4[0-7]{3}|chmod\s+u\+s' ; then return 0; fi

  # Inyección obvia
  if echo "$s" | grep -Eqi '\$\(|`' ; then return 0; fi

  return 1
}

ask_ollama_for_command() {
  local question="$1"

  local prompt
  prompt=$(
    cat <<EOF
Eres un asistente técnico experto en Linux y ciberseguridad.
Respondes SIEMPRE en español.
Tu tarea: proponer EXACTAMENTE UN comando de terminal (una sola línea) para ayudar con la petición del usuario.
REGLAS:
- Devuelve SOLO el comando. Sin explicaciones. Sin comillas. Sin markdown.
- El comando debe ser lo más seguro posible (preferir lectura/consulta a escritura).
- Evita acciones destructivas. No uses rm, mkfs, dd, ni cambios de permisos peligrosos.
Petición del usuario:
$question
EOF
  )

  # Timeout para evitar bloqueos largos
  # Nota: 'timeout' suele estar en coreutils
  if command -v timeout >/dev/null 2>&1; then
    timeout "$TIMEOUT_SECS" ollama run "$MODEL" "$prompt" 2>/dev/null | head -n 1 | trim
  else
    ollama run "$MODEL" "$prompt" 2>/dev/null | head -n 1 | trim
  fi
}

confirm() {
  local msg="$1"
  read -r -p "$msg (s/n): " ans
  [[ "${ans,,}" == "s" ]]
}

main() {
  local question=""
  local explicit_mode=""
  local explicit_model=""
  local explicit_log=""

  while [[ $# -gt 0 ]]; do
    case "$1" in
      -m|--model) explicit_model="$2"; shift 2 ;;
      -e|--exec) explicit_mode="exec"; shift ;;
      --suggest) explicit_mode="ask"; shift ;;
      --log) explicit_log="$2"; shift 2 ;;
      -h|--help) print_help; exit 0 ;;
      *)
        # Resto como pregunta (permitimos comillas)
        question="$*"
        break
        ;;
    esac
  done

  [[ -n "$explicit_model" ]] && MODEL="$explicit_model"
  [[ -n "$explicit_mode" ]] && MODE="$explicit_mode"
  [[ -n "$explicit_log" ]] && LOG_FILE="$explicit_log"

  [[ -z "$question" ]] && die "Falta la pregunta. Usa --help para ver ejemplos."

  ensure_ollama
  ensure_log_writable

  log_line "question=$(printf '%q' "$question") model=$MODEL mode=$MODE"

  local cmd
  cmd="$(ask_ollama_for_command "$question")"

  log_line "raw_cmd=$(printf '%q' "$cmd")"

  [[ -z "$cmd" ]] && die "El modelo no devolvió un comando."

  # Validaciones básicas
  if looks_dangerous "$cmd"; then
    log_line "blocked_reason=dangerous_pattern"
    die "Comando bloqueado por patrón peligroso: $cmd"
  fi

  local base
  base="$(first_token "$cmd")"
  if ! is_allowed_cmd "$base"; then
    log_line "blocked_reason=not_in_allowlist base=$base"
    die "Comando bloqueado (no está en la lista blanca): $base"
  fi

  echo "$cmd"

  if [[ "$MODE" == "exec" ]]; then
    if confirm "¿Ejecutar el comando anterior?"; then
      log_line "exec=YES cmd=$(printf '%q' "$cmd")"
      # Ejecuta tal cual (sin eval). Bash interpretará la línea como comando.
      bash -lc "$cmd"
    else
      log_line "exec=NO"
      echo "Cancelado."
    fi
  else
    echo "Modo sugerencia (no ejecuto nada). Usa --exec para permitir ejecución con confirmación."
  fi
}

main "$@"

Instalación global (para todo el sistema)

Mueve el script a /usr/local/bin y dale permisos:

sudo mv ollama-shell /usr/local/bin/ollama-shell
sudo chmod +x /usr/local/bin/ollama-shell

Prueba:

ollama-shell "muestra los puertos en escucha"

Para permitir ejecución (con confirmación):

ollama-shell --exec "muestra los últimos intentos de login fallidos"

Forma más simple: usar el modelo por defecto

En el script que te pasé, al principio tienes:

MODEL="${MODEL:-llama3-es}"

Eso significa:

Si no indicas nada, usa llama3-es
Es el comportamiento por defecto

Ejemplo:

ollama-shell "lista los usuarios conectados"

Usa automáticamente llama3-es.

Indicar el modelo en la llamada (recomendado)

El script soporta el parámetro -m o --model.

Ejemplo:

ollama-shell -m codellama-es "crea un script bash para hacer backup de /etc"

Aquí:

No tocas el script
Cambias el modelo solo para esa ejecución
Ideal para comparar modelos en clase

Forzar el modelo con variable de entorno

Esto es muy Unix y muy elegante.

Para una sola ejecución

MODEL=codellama-es ollama-shell "analiza este script"

Para toda la sesión

export MODEL=codellama-es
ollama-shell "genera un Makefile sencillo"

Hasta que cierres la terminal, siempre usará ese modelo.

Cambiar el modelo por defecto en el script

Si quieres que siempre use codellama-es, edita el script:

nano /usr/local/bin/ollama-shell

Busca:

MODEL="${MODEL:-llama3-es}"

Y cambia a:

MODEL="${MODEL:-codellama-es}"

A partir de ahí, ese será el modelo base.

Ver qué modelo se está usando (opcional pero didáctico)

Si quieres que el script lo muestre, añade justo antes de llamar a Ollama:

echo "Modelo en uso: $MODEL"

O loguéalo:

log_line "model_in_use=$MODEL"

Esto es muy bueno para auditoría

Ejemplos

Comando	Qué ocurre
`ollama-shell "ver procesos"`	Usa modelo por defecto
`ollama-shell -m phi "ver procesos"`	Usa `phi`
`MODEL=codellama-es ollama-shell "crear script"`	Usa `codellama-es`
`ollama-shell --exec -m llama3-es "ver puertos"`	Ejecuta con `llama3-es`

Comandos básicos que conviene conocer

ollama run llama3:8b # Ejecutar modelo
ollama list # Modelos instalados 
ollama pull mistral # Descargar modelo 
ollama rm mistral # Borrar modelo 
ollama ps # Modelos en uso 
ollama stop llama3:8b # Detener modelo

Instalación en Mac-os

1️⃣ Descarga

https://ollama.com/download/mac

Pulsa Download for macOS

2️⃣ Instala

Abre el .dmg
Arrastra Ollama a Applications
Ábrelo (la primera vez macOS pedirá permiso)

📌Ollama se queda ejecutándose en segundo plano (daemon).

3️⃣ Verifica desde Terminal

Abre Terminal y ejecuta:

ollama --version

Si ves algo como:

ollama version x.x.x

✔️ Instalación correcta

Primer uso: ejecutar un modelo

Descargar y ejecutar LLaMA 3 (8B)

ollama run llama3:8b

La primera vez:

Descarga el modelo (varios GB)
Luego entras directamente en modo conversación

diciembre 17, 2025

Categoría: Inteligencia Artificial

Instalación de Ollama en Windows paso a paso

1. Introducción

2. Requisitos previos

3. ¿Qué vamos a instalar?

Paso 1. Descargar Ollama para Windows

Opción A: Instalación con instalador gráfico

Opción B: Instalación desde PowerShell

Paso 2. Comprobar que Ollama está instalado

Paso 3. Comprobar que el servicio responde

Paso 4. Descargar un primer modelo

Paso 5. Ejecutar un modelo

Paso 6. Ver los modelos instalados

Paso 7. Ver qué modelos están cargados en memoria

Paso 8. Detener un modelo cargado

Paso 9. Borrar un modelo

Paso 10. Probar Ollama desde el navegador

Paso 11. Crear una petición a la API de Ollama

Paso 12. Configurar Ollama para acceder desde otro equipo de la red

Configuración recomendada para red local

Paso 13. Abrir el puerto en el firewall de Windows

Paso 14. Averiguar la IP del equipo Windows

Paso 15. Probar Ollama desde otro ordenador

Paso 16. Conectar Open WebUI u otra herramienta

Paso 17. Recomendaciones de modelos para empezar

Paso 18. Buenas prácticas si el equipo también se usa para jugar

Paso 19. Seguridad básica

Paso 20. Comandos principales de Ollama

Actividad propuesta

Tareas

Cargar modelos de ollama en el disco duro secundario

Opción recomendada: usar OLLAMA_MODELS

1. Crea la carpeta en el disco secundario

2. Cierra Ollama

3. Crea la variable de entorno

4. Reinicia Ollama

5. Comprueba que la variable existe

6. Descarga un modelo de prueba

Si ya tenías modelos descargados

1. Cierra Ollama

2. Copia la carpeta antigua al nuevo disco

3. Crea la variable OLLAMA_MODELS

4. Reinicia Windows

Instalación y uso de OpenCode en Windows con WSL Ubuntu

1. Introducción

Objetivos de la práctica

Requisitos previos

Paso 1. Instalar WSL en Windows

Paso 2. Comprobar que WSL funciona

Instala Ubuntu manualmente

Comprueba qué distribuciones tienes instaladas

Paso 3. Actualizar Ubuntu

Paso 4. Instalar herramientas básicas

Paso 5. Instalar OpenCode dentro de WSL

Paso 6. Crear una carpeta de trabajo

Paso 7. Ejecutar OpenCode en el proyecto

Paso 8. Primeras pruebas con OpenCode

Paso 9. Instalar Visual Studio Code

Paso 10. Instalar la extensión Remote WSL

Paso 11. Abrir el proyecto desde WSL en Visual Studio Code

Paso 12. Abrir una terminal integrada en Visual Studio Code

Paso 13. Acceder a proyectos de Windows desde WSL

Paso 14. Usar la versión web de OpenCode desde WSL

Paso 15. Usar la aplicación de escritorio de OpenCode

Paso 16. Recomendación para clase

Paso 17. Comandos resumen

Instalar WSL

Actualizar Ubuntu

Instalar herramientas básicas

Instalar OpenCode

Comprobar versión

Crear proyecto

Abrir Visual Studio Code desde WSL

Ejecutar OpenCode

Ejecutar OpenCode Web

Ejecutar servidor para escritorio

Problemas frecuentes

El comando opencode no se reconoce

El comando code . no funciona

OpenCode no puede conectarse al proveedor de IA

Opción recomendada: usar `OLLAMA_MODELS`

3. Crea la variable `OLLAMA_MODELS`

El comando `opencode` no se reconoce

El comando `code .` no funciona

16) Crea el formulario web `index.php`

17) Crea el script de procesamiento `process.php`

18) Crea la página de resultados `result.php`

19) Crea el descargador `download.php`