Archivo de la categoría: General

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 conectar Google Stitch con Google Antigravity: Aplicaciones atractivas sin esfuerzo

Posted on por
Responder

Si hay algo que me ha costado siempre en el desarrollo de aplicaciones, es el diseño de interfaces. Soy de los que pueden pasar horas peleándose con CSS para que un botón quede centrado, y al final sigue sin convencerme. Seguro que a más de uno os suena.

Pero últimamente Google ha estado soltando herramientas experimentales que, combinadas, pueden cambiar completamente cómo trabajamos. Hoy os traigo la combinación de Google Stitch + Google Antigravity: una dupla que te permite generar aplicaciones funcionales y visualmente atractivas en cuestión de minutos, no días.

¿Qué son estas herramientas?

Google Stitch: diseño por «vibe designing»

Google Stitch es el laboratorio de Google para generación de interfaces. Pero no es un simple generador de imágenes: describes lo que quieres construir y Stitch te propone diseños completos, con múltiples pantallas, flujos de navegación y componentes visuales listos para usar.

Lo mejor es que no te quedas con una imagen estática. Puedes interactuar con el diseño, pedir cambios, anotar modificaciones y, cuando estés satisfecho, descargar el código en HTML/CSS o React/Tailwind.

Actualmente está en beta gratuita (sin límites, de momento), así que es momento de aprovechar.

Google Antigravity: tu compañero de código con IA

Google Antigravity es el IDE de Google con agentes de IA integrados. Piensa en VS Code, pero donde la IA no solo autocompleta: planifica, codifica, depura e itera sobre proyectos complejos con mínima supervisión.

Durante la preview gratuita tienes acceso a Gemini Pro, Deep Think y Flash sin esos molestos límites de API que nos tienen acostumbrados otros servicios.

¿Por qué conectarlas?

Separadas son útiles. Juntas, son otro nivel:

  • Stitch se encarga del diseño visual
  • Antigravity se encarga de la lógica, base de datos, autenticación y despliegue

El truco está en añadir Stitch como servidor MCP (Model Context Protocol) dentro de Antigravity. Así, el agente puede consultar diseños de Stitch directamente e integrarlos en el código que genera.

Paso a paso: la integración

Paso 1: Instalar el servidor MCP de Stitch en Antigravity

En la ventana de agente de Antigravity (la derecha), hacemos clic en los tres puntos y seleccionamos MCP Servers.

Buscamos «stitch» en la lista y lo instalamos. Es un proceso de un clic.

Paso 2: Obtener la API key de Stitch

Necesitamos una clave para que Antigravity pueda hablar con Stitch:

  1. Vamos a stitch.withgoogle.com
  2. En la esquina superior derecha, hacemos clic en nuestro perfil
  3. Seleccionamos «API Keys» y generamos una nueva
  4. Copiamos la clave (empieza por algo como sk-...)

Paso 3: Configurar la API key en Antigravity

Volvemos a Antigravity, a la configuración del MCP Server de Stitch, y pegamos la API key en el campo correspondiente.

Y listo. La integración está completa.

Creando nuestra primera aplicación

Veamos un ejemplo real. Quiero construir un gestor de hábitos con modo oscuro y diseño minimalista.

1. Generamos el diseño en Stitch

Abrimos Stitch y escribimos:

«Aplicación minimalista para llevar un registro de hábitos con modo oscuro, gráficos de progreso semanales y botones para marcar la asistencia diaria. Estética limpia y moderna con toques en color morado».

En menos de un minuto, Stitch genera:

  • Pantalla principal con lista de hábitos
  • Gráfico de progreso semanal
  • Modal para añadir nuevos hábitos
  • Diseño responsive

Podemos iterar hasta que nos guste el resultado final.

2. Pasamos a Antigravity

Ahora viene la magia. En Antigravity, abrimos el chat con el agente y escribimos algo como:

«Crea una aplicación de gestión de hábitos usando el diseño que obtengas del servidor Stitch MCP. La app debe incluir:
– Autenticación con Clerk
– Base de datos con Convex
– Las funcionalidades que propone el diseño de Stitch
– Despliegue en Vercel»

El agente consultará Stitch, obtendrá el diseño, y empezará a construir la aplicación completa.

3. Iteración automática

Aquí es donde brilla Antigravity: no solo genera código, sino que:

  • Abre el navegador para probar la app
  • Detecta errores y los corrige
  • Verifica que la autenticación funcione
  • Comprueba que la base de datos se conecte correctamente

En mi caso, construí una app funcional en 23 minutos. Y no es un prototipo: tiene auth real, base de datos persistente y está lista para producción.

Trucos y consideraciones

Lo que funciona de maravilla

  • Diseños complejos: Stitch maneja bien múltiples pantallas y estados
  • Componentes modernos: Tailwind CSS, React, layouts responsive
  • Iteración rápida: cambiar el diseño en Stitch y pedir a Antigravity que actualice el código funciona sorprendentemente bien

Lo que aún falla

  • Detalles muy específicos: a veces hay que ajustar manualmente márgenes o colores exactos
  • Integraciones complejas: si necesitas APIs de terceros poco comunes, puede requerir intervención
  • Sesiones largas: después de muchos mensajes, el contexto se pierde un poco

Consejos prácticos

  1. Sé específico en Stitch: cuanto más detalle des en el prompt, mejor será el diseño base
  2. Itera en el diseño primero: mejor gastar 5 minutos ajustando en Stitch que 30 cambiando código
  3. Verifica pasos intermedios: pide a Antigravity que te muestre el diseño integrado antes de añadir complejidad

El futuro del desarrollo

Esta combinación de herramientas me hace reflexionar sobre hacia dónde vamos. No creo que vayan a reemplazar a los desarrolladores, pero sí que cambian el tipo de trabajo que hacemos:

  • Menos tiempo peleándose con CSS
  • Menos tiempo configurando boilers
  • Más tiempo pensando en la lógica de negocio y la experiencia de usuario

Es como pasar de ser albañil a ser arquitecto. Sigues construyendo, pero a otro nivel de abstracción.

¿Habéis probado ya esta combinación? ¿Qué experiencias tenéis con herramientas de IA para desarrollo? Me encantaría leer vuestros comentarios.

Recursos útiles:
Google Stitch
Google Antigravity
Documentación MCP

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.

La IA más barata para generar código

Posted on por
2

Llevo desde casi el principio de toda esta vorágine utilizando github copilot, inicialmente con el modelo único que nos proporcionaba y recientemente en modo agente con claude sonnet y es lo mejor que he probado hasta el momento. Pero los 10 euros del copilot llegan hasta donde llegan y cuando se agota el crédito que tienes para usar claude con copilot te quedas un poco huerfano y es como si tu asistente se hubiese ido de vacaciones… Entonces me puse a buscar lo que costaría tener acceso extra a claude para cuando esto pasaba… Y resulta que son 20 eurazos al mes en su plan básico.

No parece mucho, pero si ya pagas copilot y no quieres pagar un extra tan alto solo para los días que se acaban los créditos de claude, pues se hace un poco cuesta arriba. Así que me puse a buscar qué otras opciones teníamos que fuesen, digamos, un poco más económicas y tuviesen un resultado similar al que te da claude. Y resulta que me topé con glm

Por 3 dolares al mes (contraté el trimestral para probar) dicen que tienen un modelo similar en potencia a claude sonnet 4. Lo que vamos a ver aquí es como utilizar este modelo con el agente claude code que tiene un comportamiento similar a github copilot y que permite, entre otras cosas, interactuar con MCPs. No es un proceso tan complicado, así que os dejo aquí cómo hacerlo:

Lo primero que vamos a necesitar es la clave API de GLM, para eso (suponiendo que os habéis suscrito, que si no nada de esto sirve), os vais a la sección de API keys

Y ahí creais una nueva API KEY. No os preocupeis que podréis copiarla después de haberla creado, no es como en otros sitios que solo te la muestran una vez. Guardad esa API key que la vais a necesitar después. Por cierto, tienen muy buena documentación sobre todo esto en su página web: https://docs.z.ai/guides/overview/quick-start

Lo siguiente que tienes que hacer es instalar claude code, esto suele ser bastante sencillo y bastaría con ejecutar esto (suponiendo que tienes una versión de node >= 18 en tu ordenador):

npm install -g @anthropic-ai/claude-code

Una vez instalado ejecutalo para que se creen los archivos de configuración (y eliges ya de paso el tema)

Luego, como no vamos a usar la cuenta de anthropic, simplemente damos ctrl-c varias veces para salir. Pero con ello ya se nos han creado los directorios de configuración y podemos editarlos.

Pon lo siguiente en el archivo ~/.claude/settings.json

{
    "env": {
        "ANTHROPIC_AUTH_TOKEN": "el api key de glm",
        "ANTHROPIC_BASE_URL": "https://api.z.ai/api/anthropic",
    	"ANTHROPIC_DEFAULT_HAIKU_MODEL": "glm-4.5-air",
        "ANTHROPIC_DEFAULT_SONNET_MODEL": "glm-4.6",
        "ANTHROPIC_DEFAULT_OPUS_MODEL": "glm-4.6"
    }
}

Luego nos vamos a cualquier directorio en el que tengamos código y querramos trabajar y ejecutamos el comando claude

Le decimos que si le damos permiso y ya podremos utilizar claude code con glm (lo podemos comprobar en la parte superior)

Y ya podemos usar el agente de claude con el modelo glm y ver qué tal se le da… En mis pruebas lo ha hecho bastante bien, aunque el interfaz es bastante más espartano que el de github copilot no le falta ninguna de las funcionalidades.

Por ahora disfrutad con esto (lo puedes lanzar desde dentro de un terminal de vscode y lo detecta y se integra con el ide) y en la siguiente entrada ya os digo como acceder a MCPs usando este agente y este modelo.