Archivo de la categoría: Inteligencia Artificial

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

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
2

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.

Agentes de código abierto

Posted on por
1

Como hemos visto en anteriores entregas, podemos utilizar distintos modelos de IA en distintos agentes. Vimos como usar glm con claude-code, hemos visto como utilizar mcps también en claude-code o en github copilot pero lo ideal sería no depender de un agente comercial, entendiendo como tal alguno que va ligado a algún modelo o ide. Por eso me he puesto a buscar y he encontrado un par de ellos. En esta entrada vamos a intentar configurarlos para que funcionen con los modelos de IA a los que tenemos acceso e incluso añadirles acceso a mcps.

goose

El primero que encontré y que me parece perfecto en muchos aspectos se llama goose, podéis encontrarlo en https://github.com/block/goose

Instalación

nada más sencillo que seguir las instrucciones de https://block.github.io/goose/docs/getting-started/installation/ en mi caso y como uso ubuntu solo tuve que ejecutar:

wget https://github.com/block/goose/releases/download/v1.16.1/goose_1.16.1_amd64.deb
sudo dpkg -i goose_1.16.1_amd64.deb

Os recomiendo que os paseis a ver si hay una versión más nueva a esta que he usado yo.

Si todo ha ido bien solo tienes que buscar goose en el menú y ejecutarlo (o goose desde la terminal)

Configurar el LLM

Vamos a usar como ejemplo lo que vimos en la entrada sobre LLM baratos, el glm-4.6. Para ello pulsaremos en el icono de abajo con forma de robot y seleccionaremos «Change Model»

Eso permitirá acceder a un desplegable con los modelos disponibles. Como inicialmente no tendrás ninguno habrá que seleccionar la opción «Use other provider» que nos sacará una pantalla como esta:

Tal como hicimos con claude vamos a usar una configuración personalizada de anthropic. Pinchamos en configure y le ponemos la url y la api key que pusimos la otra vez:

Y eso es todo, luego cuando queramos seleccionar el modelo ya nos aparecerá la opción anthropic y podremos seleccionarla

Ahora ya podemos preguntarle lo que queramos a nuestro agente que contará con el modelo integrado.

Modos de funcionamiento

Si os fijáis en la parte de abajo a la derecha veréis que hay un marcador que indica el modo en el que está tabajando el agente, en mi caso lo tengo en «Autonomous» que es como darle carta blanca para que haga lo que hay que hacer, pero también tiene otros modos:

Y para cada uno de los modos puedes configurar los permisos para cada una de las extensiones.

Extensiones

Como ya dijimos al principio vamos a darle herramientas a nuestro nuevo agente, en este caso el mismo mcp que usamos en esta otra entrada, para ello nada más sencillo que ir a la opción Extensión en el menú principal que nos llevará a una ventana como esta:

Creamos una extensión nueva y le ponemos los datos tal que así (solo hay que poner en el comando lo que antes poníamos como un array json y rellenar las variables de entorno):

Y luego la activamos (aparecerá arriba). Con eso ya podemos volver a usar la herramienta nueva desde goose preguntando cosas como:

¿puedes recuperar un documento de outline llamado API docufactu y hacerme un resumen?

A este agente se le pueden añadir modelos locales como por ejemplo modelos de ollama que tengas corriendo en tu ordenador además de los más populares. También puede usar directamente github copilot sin entrar al VScode.

Si queréis instalar la versión para terminal también se puede, el único problema es que el ejecutable se llama exactamente igual (goose) que el que hemos usado para lanzar la UI (se guarda en otro directorio) por lo que tendréis goose UI si lo seleccionas por el menu y goose linea de comando si lo ejecutas desde una terminal (también depende del orden que tengas en tu path).

Lo siguiente que quería hacer es instalar opencode, pero creo que lo voy a dejar para una siguiente entrada. Disfrutad de goose lo que podáis.