Archivo de la categoría: software libre

Explorando omarchy

Posted on por
Responder

Llevo usando linux desde tiempos inmemoriables (bueno, todavía me acuerdo de la primera slackware en el 96 copiando archivos como método de instalación), el caso es que me había decantado por ubuntu desde hace más de 20 años por una cuestión de pragmatismo. Todo lo que necesitaba lo tenía disponible y lo que no vendría pronto a ubuntu por ser la distribución más popular del momento. Tengo ubuntu en el ordenador del trabajo, en casa y en cada portatil que uso y, por qué no decirlo, no tengo grandes problemas que no pueda solucionar. Sin embargo me llamó la atención un video de Nate Gentile en el que se cambiaba, por fin a Linux y había elegido cachy-os (una variante de Arch Linux) y luego instalarle unas personalizaciones del creador de Ruby on rails (David Heinemeier Hansson) que se llama omarchy… Viendo las imágenes de la distribución tengo que decir que me atrajeron mucho por su estética hacker y por el objetivo final, que es utilizar lo menos posible el ratón.

Dicho y hecho, en este post os voy a ir mostrando los problemas que me he ido encontrando hasta tener una distribución totalmente distinta de la que estoy acostumbrado.

Instalación

Lo primero que hay que hacer es bajarse el iso de omarchy que se puede encontrar en su web: https://omarchy.org/ como podéis ver en la foto hay un enlace directo para ello. Luego solo tenemos que generar un usb autoarrancable. Yo usé ballena etcher, pero podéis hacerlo con cualquier otro como unetbootin o incluso utilizar Ventoy (más recomendable éste último, la verdad) y configurar tu bios para que arranque desde ahí.

El proceso de instalación es sumamente sencillo, todo en modo texto, pero no se nospiden cosas raras. Eso si: IMPORTANTE, omarchy con este instalador requiere un disco completo, no vas a poder instalarlo en una partición por lo que si quieres hacer dual boot vas a necesitar tener un segundo disco físico en tu ordenador.

Primer arranque

Lo primero que se ve es que el gestor de arranque no es grub, es Limine y se instala en el disco el cual hayáis usado para instalarlo por lo que es posible, como me pasó a mi, que tengáis que modificar la BIOS para indicar que el disco de arranque ahora es el nuevo.

Luego se puede encadenar los arranques y dejar que Limine ponga otra entrada para el sistema que tengamos en el otro disco, pero eso es algo que todavía no he hecho y que probablemente termine haciendo en algún momento.

Luego verás que te salen tres avisos en la parte superior, el primero para que configures la wifi (si no estás enchufado a una red, ya que si lo estas el asistente wifi ni aparece). Aquí ya verás el primer contraste grande…. Y es que el administrador de wifi aparece dentro de una terminal y no puedes usar el ratón… Luego verás que esto es normal, pero al principio choca un poco.

Lo siguiente, una vez que tienes red, es actualizar el sistema. De nuevo una aplicación de consola que busca e instala todas las actualizaciones… Y ahora viene lo bueno…

Si pinchamos en el cuadrado de arriba a la izquierda en la barra (o hacemos super-alt-espacio) nos aparecerá el menu de omarchy donde verás estas cosas:

Desde ahí podrás acceder a las aplicaciones ya instaladas (Apps)

Pero lo que recomiendo primero es que uses la opción Learn y de ahí directo a los atajos de teclado que será lo más útil que te encontrarás (casi todo se puede hacer con el teclado sin tocar el ratón).

Otra cosa en la que es muy buena esta distribución es en los temas disponibles, hay muchos ya preconfigurados, pero hay muchos más en, por ejemplo https://omarchythemes.com/ y son bastante sencillos de instalar.

Desde git, por ejemplo

omarchy-theme-install https://github.com/row-huh/omarchy-ghost-pastel-theme

Instalar wireguard fue un poco más complicado, pero al final se consigue que funcione sin ningún interfaz gráfico, cosa que si que voy a echar de menos (pero no demasiado).

El cambio rápido de espacios de trabajo (super+numero) el poder mover cualquier ventana a cualquier espacio (shift+super+numero) el poder moverse entre espacios con super+tab es algo que solo cuando llevas tiempo con ello te das cuenta de lo potente que es y lo que te permite focalizarte en lo que estás haciendo quitando distracciones y ventanas huerfanas o minimizadas que teníamos con otras distribuciones. Por cierto, si quieres poner en Español el sistema tendrás que editar el archivo /etc/locale.conf y poner LANG=es_ES.UTF-8, descomentar en /etc/locale.gen la línea que contiene es_ES.UTF-8 y luego ejecutar sudo locale-gen. Con eso ya solo quedará que vuelvas a iniciar sesión.

Instalar una VPN

Una de las cosas que más tengo que hacer es conectar con la VPN de mi oficina o de mi casa (además del nordVPN que te lo puedes instalar directamente de los menús), como la VPN que uso es wireguard, os comento el procedimiento de instalación que usé (y me funciona perfectamente), básicamente lo podéis encontrar aqui: https://github.com/JacobusXIII/omarchy-wireguard-vpn-toggle

sudo yay -S wireguard-tools
sudo cp vpn.conf /etc/wireguard #Copia tus propias conf
curl -fsSL https://raw.githubusercontent.com/JacobusXIII/omarchy-wireguard-vpn-toggle/main/install.sh | bash

Eso te instalará un complemento en la barra superior para activar/desactivar la VPN. Si tienes varias configuraciones con el click derecho podrás elegir cual usar.

En mi caso las siguientes cosas que instalé eran para programar y todas se instalaron sin problemas y con las versiones más actualizadas (visual studio code y opencode entre ellas). Decir que omarchy ya viene con docker y docker compose de serie y con lazydocker para poder controlarlos visualmente, cosa que agradezco inmensamente.

En fin, que iré completando este post según vaya descubriendo más cosas sobre omarchy… Por ahora lo tengo instalado en mi PC de mi oficina e intentaré hacer el trabajo diario con él a ver si me encuentro algún problema importante.

Acelerando la IA local con llama.cpp

Posted on por
Responder

Como os he contado en muchos post anteriores es bastente sencillo usar IA local, el problema es que el método por defecto (ollama) no es todo lo óptimo que cabría esperar para equipos que andan más limitados de VRAM y recursos. Por eso, e intentando exprimir un poco más la GPU que tengamos vamos a ir a las fuentes de los LLM y a ejecutarlos de la manera más óptima posible. Vamos a instalar llama.cpp y vamos a ver cómo usarlo desde opencode con algunos modelos interesantes para programar (aunque nada impide que uséis otros para otras cosas).

Lo primero que vamos a hacer es descargarnos el repositorio https://github.com/TheTom/llama-cpp-turboquant que, además de llama.cpp está preparado para un método de quantización dinámica de google (ya me lo agradeceréis). Las instrucciones para compilarlo no son del todo triviales, pero os las reproduzco aquí para unar nvidia con CUDA:

git clone git@github.com:TheTom/llama-cpp-turboquant.git
cd llama-cpp-turboquant
cmake -B build -DGGML_CUDA=ON
cmake --build build --config Release

Es posible que no tengáis instalado CUDA Toolkit, que es necesario para poder terminar la compilación adecuadamente, eso se nota si ves un error como

Así que, vamos a la página de nvidia y nos instalamos el correspondiente a nuestra plataforma. En mi caso se traducía en estas instrucciones:

wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2404/x86_64/cuda-keyring_1.1-1_all.deb
sudo dpkg -i cuda-keyring_1.1-1_all.deb
sudo apt-get update
sudo apt-get -y install cuda-toolkit-13-2
sudo apt-get install -y cuda-drivers

Tengo que advertir que esto puede llevar bastante tiempo y puede dar algún error que habrá que solucionar con paciencia (si es que nos queda). En mi caso dio un error sobreescribiendo archivos y tuve que arreglarlo con esto:

apt-get -o Dpkg::Options::="--force-overwrite" install -f

Si tuviste que instalar el cuda toolkit tendrás que añadir en el .rc esto (.bashrc o .zshrc)

export PATH=$PATH:$HOME/.cargo/bin:/usr/local/cuda/bin
export CUDACXX=/usr/local/cuda/bin/nvcc

Una vez con todo en su sitio ya podemos compilar completamente el sistema y nos generará todos los binarios necesarios (ojo, que va a tardar muchos minutos – o incluso horas- dependiendo de vuestro sistema, no os desesperéis)

Una vez compilado, lo siguiente es bajarse un modelo que pueda ejecutar llama. Para eso hay que visitar https://huggingface.co/ y buscar algún modelo bueno en formato GGUF, por ejemplo https://huggingface.co/jgebbeken/gemma-4-coder-gguf/resolve/main/gemma-4-E4b-it.Q4_K_M.gguf?download=true (gemma-4-coder), que es un modelo relativamente pequeño y nos servirá para probar llama.cpp, primero lo descargamos en el directorio models y después:

./build/bin/llama-cli -m models/gemma-4-E4b-it.Q4_K_M.gguf -c 2048 -fa on --cache-type-v turbo3

Una cosa interesante cuando sales del cliente es que te indica el uso de memoria (en este caso os muestro lo que sale en una 3080 de 10Gb con este modelo

Si hemos llegado a este punto ya estamos listos para utilizar llama.ccp para hacer cosas más interesantes. Para ello primero tendremos que lanzar el servidor, esto se hace con el comando:

./build/bin/llama-server --models-dir ./models

Podemos acceder a http://127.0.0.1:8080 y ver un chat donde podremos interactuar con cualquiera de los modelos seleccionandolo (lo que hará que se cargue en memoria), pero lo más interesante es utilizarlo con otro agente. Por ejemplo opencode, ya vimos como usar ollama con opencode, ahora podemos hacer algo similar para añadir el modelo. Básicamente consiste en editar el archivo opencode.jsonc y poner esto (uso los valores del modelo que nos hemos bajado)

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "llamacpp": {
      "npm": "@ai-sdk/openai-compatible",
      "options": {
        "baseURL": "http://localhost:8080/v1"
      },
      "models": {
        "gemma-4-E4b-it.Q4_K_M.gguf": {
          "name": "gemma-4 (local)"
        }
      }
    }
  }
}

Y después de arrancar opencode ya podremos seleccionar ese modelo con /models

Y trabajar normalmente con nuestro agente… Ya solo queda experimentar y ver qué modelo cabe en vuestra VRAM.

Cómo instalar OpenClaw en Linux: Tu propio agente de IA en WhatsApp y Telegram

Posted on por
Responder

Si os habéis pasado por aquí últimamente, sabréis que estoy bastante metido en el mundo de los agentes de IA. Primero os enseñé cómo instalar opencode, y ahora os traigo otra joyita que me tiene enganchado: OpenClaw (antes conocido como ClawdBot o MoltBot, por si os suena de algo).

¿Qué es OpenClaw? Pues básicamente es un gateway que te permite tener tu propio asistente de IA conectado a WhatsApp, Telegram, Discord, iMessage y más. Imagina tener a tu disposición un agente que puede limpiar tu bandeja de entrada, enviar correos, gestionar tu calendario o incluso hacer check-in en vuelos, todo desde la app de mensajería que ya usas. Y lo mejor: self-hosted, tus datos en tu máquina, tus reglas.

Requisitos previos

Antes de meternos en harina, aseguraos de tener:

  • Node.js 22 o superior (imprescindible, no valen versiones antiguas)
  • Una API key de algún proveedor de IA (Anthropic recomendado, pero podéis usar otros)
  • Ganas de experimentar (esto no es plug-and-play, pero tampoco es rocket science)

Instalación paso a paso

La instalación es bastante sencilla gracias a npm. Abrimos terminal y ejecutamos:

npm install -g openclaw

Una vez instalado, toca configurar el entorno. OpenClaw guarda todo en ~/.openclaw/, así que vamos a preparar el terreno:

openclaw setup

Esto crea la estructura de carpetas y los archivos de configuración iniciales. Si queréis hacerlo desde el repositorio fuente (para los más aventureros), necesitaréis pnpm y ejecutar pnpm install seguido de pnpm build.

Configuración básica

El archivo de configuración vive en ~/.openclaw/openclaw.json. Aquí podéis ajustar qué canales queréis activar y cómo comportarse el agente. Un ejemplo básico para WhatsApp:

{
  "channels": {
    "whatsapp": {
      "allowFrom": ["+34600123456"],
      "groups": {
        "*": { "requireMention": true }
      }
    }
  }
}

Con esto, solo vuestro número podrá interactuar con el bot, y en grupos tendrá que mencionaros para responder (útil para no saturar las conversaciones).

Iniciar el Gateway

Ahora viene lo bueno. Arrancamos el gateway con:

openclaw gateway --port 18789 --verbose

Si todo va bien, veréis el mensaje de que el servidor está corriendo. Por defecto, la interfaz de control está disponible en http://127.0.0.1:18789/. Desde ahí podréis gestionar sesiones, ver logs y configurar canales.

Conectar WhatsApp

Esto es lo más chulo. Ejecutad:

openclaw channels login

Os mostrará un código QR que tenéis que escanear con WhatsApp en vuestro móvil (Ajustes ? Dispositivos vinculados ? Vincular dispositivo). Una vez hecho, vuestro número de WhatsApp estará conectado al agente de IA.

Verificar que todo funciona

Para aseguraros de que la instalación está correcta:

openclaw health

Si devuelve OK, estáis listos para empezar a chatear con vuestra IA desde WhatsApp o Telegram.

Algunos trucos que he aprendido

  • Workspace personalizado: Guardad vuestras skills y configuraciones en ~/.openclaw/workspace. Podéis hacer un repo git privado y así tener backups y control de versiones.
  • Heartbeats: OpenClaw tiene un sistema de «heartbeats» que permite al agente hacer comprobaciones periódicas (emails, calendario, etc.) y avisaros proactivamente.
  • Sesiones: Cada conversación es una sesión independiente. Podéis tener diferentes contextos para diferentes tareas.
  • Skills: La comunidad está creando skills para todo (GitHub, Notion, Slack…). Echad un vistazo al repositorio oficial.

Conclusión

OpenClaw es una de esas herramientas que, una vez que las pruebas, te preguntas cómo has vivido sin ellas. Tener un agente de IA verdaderamente personal, que corre en tu máquina y se integra con tus apps de mensajería habituales, es una experiencia que no tiene nada que ver con los asistentes en la nube.

Eso sí, requiere cierto nivel técnico y ganas de trastear. Si os gusta eso de «romper cosas para entenderlas», OpenClaw es vuestro sitio. ¿Ya lo habéis probado? Contadme vuestras experiencias en los comentarios.

Nota: Este post es una guía introductoria. Para configuraciones avanzadas y troubleshooting, consultad la documentación oficial.

Usar una IA local con opencode

Posted on por
Responder

Ya vimos en el anterior post cómo instalar el agente opencode que nos va a permitir utilizar distintos proveedores de IA en nuestros flujos de trabajo (en concreto a mi para programar, pero quien sabe para qué querréis usarlos vosotros), vimos cómo configurarlo con un proveedor externo (por tanto de pago), pero nada nos impide utilizar un proveedor local (si tenéis una tarjeta con GPU solo tenéis que seguir algunos de mis posts al respecto) y ya tendréis un ollama operativo del que tirar. Así que, si cumplís los requisitos vamos a ver cómo configurar nuestra instalación de opencode para dejar de gastar dinero en proveedores externos y usar nuestra propia GPU.

No hay una forma «gráfica» de configurar el modelo, así que vamos con las instrucciones para hacerlo de manera manual:

  1. Crea el archivo opencode.jsonc (en mi caso en ~/.config/opencode ). si habéis seguido la guía de instalación previa os sonará porque es donde hemos metido la configuración mcp
  2. Mete esto (con los cambios que luego veremos):
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "ollama": {
      "npm": "@ai-sdk/openai-compatible",
      "options": {
        "baseURL": "http://localhost:11434/v1"
      },
      "models": {
        "qwen3:latest-16k": {
          "reasoning": true
        }
      }
    }
  }
}

En este caso hemos supuesto que tenemos el servidor ollama corriendo en nuestra propia máquina y el modelo que hemos elegido es qwen3… Pero eso tiene cierto truco, si usas el modelo tal cual te lo bajas no va a funcionar porque el contexto en ollama para este modelo es demasiado pequeño, antes tienes que hacer esto:

docker exec -it ollama bash
# ollama run qwen3:latest

>>> /set parameter num_ctx 16384
Set parameter 'num_ctx' to '16384'

>>> /save qwen3:latest-16k
Created new model 'qwen3:8b-16k'

>>> /bye

Si todo ha ido bien, cuando abras opencode en cualquier proyecto ya podrás elegir este modelo:

Y, dependiendo de los recursos de tu máquina podrás disfrutar de todas las ventajas de un modelo local. Eso si, para utilizar las capacidades de opencode aseguraos de que el modelo que estéis usando tenga capacidades para tools y thinking. Podéis verlo, por ejemplo con este modelo de nvidia (si tienes 20Gb de memoria en tu GPU es un buen candidato):

Es posible que, aunque tenga acceso a tools no nos permita ejecutar cosas tan simples como listar un directorio o editar un archivo. Eso es debido a que no está accediendo a las herramientas propias de opencode. He tenido que hacer algunos malabares para hacer funcionar algunos modelos concretos, así que dejo en vuestras manos el poder sacar lo mejor del sistema… Sin tener que pagar a otros proveedores ni enviarles información igual demasiado privada.

IA con OpenCode

Posted on por
3

Como ya vimos en la anterior entrada sobre agentes de IA opensource, hay vida más allá de claude code y gemini-cli (ya veremos cuando tengamos tiempo otros como kilo code) y se nos quedó pendiente instalar y probar otro agente muy conocido opencode.

Vamos a hacer aquí un resumen de la instalación, configuración con un modelo LLM que tengamos y hasta el uso de un MCP local, al igual que hicimos con goose. Luego veremos si son comparables y si lo son a sus homólogos «comerciales»

Instalación

La instalación de opencode es de todo menos dificil, solo tienes que entrar a la página https://opencode.ai/download y ahí tienes todas las opciones disponibles, de hecho, lo más sencillo es ejecutar este script que te indican en la página principal:

curl -fsSL https://opencode.ai/install | bash

Por defecto te va a instalar solo la versión de terminal, pero os recomiendo que vayáis a la página de descargas y os instaléis la versión de escritorio también, que no es que tenga muchas ventajas, pero ya que goose lo usamos en su versión de escritorio así podemos comparar un poco mejor (goose también tiene versión de terminal, pero no la he usado demasiado).

Configuración

Lo primero que tenemos que hacer justo después de arrancar opencode es conmfigurar nuestro LLM (debemos tener alguno disponible, ya sea local o remoto, esto es solo un agente).

Por suerte opencode es bastante amable a la hora de configurar un proveedor, solo tenemos que darle al icono + que vemos a la izquierda y se nos presentará la lista de proveedores soportados:

Y tiene un montón, nosotros, como ya hicimos en el post anterior vamos a conectarnos con glm-4.7 (si, ya han sacado nuevo modelo) y lo haremos usando Z.AI codign plan (podemos usar el que nosotros tengamos, aunque sea solo la capa gratuita)

Y luego cuando abramos un proyecto (un directorio) ya se nos permitirá elegir el modelo:

O, si estamos en el terminal, con la opción /model que nos permitirá elegir de los configurados:

Si os fijáis en la última imagen yo tengo ya configurados dos servidores MCP, vamos a ver cómo lo he hecho (tampoco es tan complicado, pero es más difícil que lo de escoger modelo).

En nuestro caso vamos a tener que editar un archivo, que está en /.config/opencode/opencode.jsonc, al que tendremos que adaptar el código que ya pusimos en el post anterior:

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "outline": {
	"type": "local",
	"command": ["docker",
		"run",
		"-i",
		"--rm",
		"--init",
		"-e",
		"DOCKER_CONTAINER=true",
		"-e",
		"OUTLINE_API_KEY",
		"-e",
		"OUTLINE_API_URL",
		"biblioeteca/mcp-outline"
	],
	"environment": {
		"OUTLINE_API_KEY": "ol_api_...",
		"OUTLINE_API_URL": "https://mi-servidor-/api"
	},
	"enabled": true
    },
  }
}

Como véis es muy parecido a lo que poníamos anteriormente, solo aseguraos de que el entorno sea el correcto y luego ya podéis activar los MCP para cualquier proyecto o de manera general.

Para activarlos simplemente pinchar (en la versión de escritorio) en MCP en la parte superior derecha y os aparecerá un desplegable para activar o no los MCP que tengáis configurados:

Y, bueno, con esto ya tenemos otro agente listo para usarse, lo podemos usar en dos modos, modo Plan para que no haga ningún cambio y solo planifique lo que hay que hacer o en modo Build para que haga todos los cambios necesarios.

Me queda mucho por explorar todavía con este agente (y sus plugins, que hay alguno sabroso) pero todavía tengo que ver cómo engancharlo con un ollama local para no tener que usar modelos externos… Eso lo dejo para la próxima.