Usar una IA local con opencode

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

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

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.

Escribiendo código con una sola mano

Hace unos días he sufrido un desafortunado accidente que ha terminado con el 5º metatarso de mi mano izqierda fracturado. Eso significa que voy a estar de 3 a 8 semanas sin poder usar mi mano izquierda para nada.

El caso es que nunca pensé que echaría de menos tanto a mi mano izquierda pero, en serio, ahora me siento como menos capaz de hacer las mismas cosas que hacía antes, aunque no interviniese para nada la mano izquierda. Yo siempre he dicho que programar es un oficio de cabeza, no de teclas… Pero no veas cómo ayuda poder escribir rápido lo que estás pensando.

La mano izquierda es solo una herramienta, pero una que nos permite hacer mejor y más rápido lo que ya sabemos hacer… Casi como la IA.

Yo estoy suscrito a github copilot casi desde el principio (antes de que lo abriesen al público ya había hecho mis pruebas), como copiloto que te completa las líneas o que escribe por tí las aburridas funciones que le describes, o incluso que adivina lo siguiente que quieres hacer en el archivo en base a lo que ya has escrito antes, era fantástco, una herramienta de la que no te podías fiar 100% pero que te ahorraba muchas horas de búsquedas y pruebas. Pero es que el otro día probé el modo agente (usando claude sonnet 4) y la cabeza casi me estalla…

Había probado antes firebase studio de google, que intenta hacer un desarrollo completo de aplicación de manera visual y en base a instrucciones que le vas dando a la IA y, realmente, me gustó mucho el concepto, la pena es que solo sirve en ese modo para hacer aplicaciones React y yo necesitaba algo más flexible.. Y lo encontré en el modo agente de github copilot

Modo agente de copilot

Puedes usarlo en cualquier proyecto que ya tengas en visual studio code o puedes empezar uno de cero y con unas pocas instrucciones puedes crear el tipo de proyecto que quieras, tanto de front como de back, en el lenguaje que quieras y con el framework que quieras… Y no, no es vibe coding como tal, es una herramienta más que te sirve para ir dando forma y corrigiendo el proyecto en un entorno controlado por ti.

Y lo más flipante es que te explica lo que va a hacer y las ventajas que te da… Y escribe documentación para acompañar… Y además en tu idioma. Solo por eso ya es una herramienta muy valiosa. Pero, lo que es más, te ayuda a comprender que cuanto más claros y detallados están los requisitos más fácil es que lo que obtengas se parezca a lo que querías (igual a nuestros clientes hay que ponerles a hacer vibe coding para que empiecen a aprender a pedirnos las cosas).

Otra cosa muy interesante es poder seguir el razonamiento para arreglar problemas de una manera natural (en azul lo que le digo yo)

La imagen corresponde a un proyecto todavía en marcha, sin embargo puedo poneros como ejemplo un programa que ha desarrollado 100% github copilot (con mi dirección y correcciones). Tenéis todo el código en el repositorio: https://github.com/yoprogramo/imaphp

Ultimamente me he dedicado mucho a hospedar mis propios servidores, aprovechando que estaba probando proxmox. Uno de los servicios qu quería probar era el de servidor de correo e instalé Stalwart, un sistema muy completo y que, a lo mejor, os explico un día como instalar. Tiene multitud de servicios, no solo el de SMTP, sino IMAP, POP, CalDAV, Antispam, etc… Pero algo que no tiene es un cliente webmail. Me puse a buscar a ver si encontraba alguno que no tuviese dependencias y no me gustó ninguno, así que dije.. ¿Qué carajo? Vamos a escribir uno.

Y me puse manos a la obra, decidí que quería que fuese lo más ligero posible y que pudiese ejecutarse en cualquier sitio (docker incluido) y comencé el proyecto de cero usando el modo agente del copilot.

Para poder probarlo de la manera rápida, montad este docker-compose.yml:

services:
  imap-client:
    image: yoprogramo/imaphp:1.0.0
    ports:
      - "8888:80"
    environment:
      - PHP_DISPLAY_ERRORS=Off
      - PHP_ERROR_REPORTING=E_ERROR
    volumes:
      - ./data:/var/www/html/data
    restart: always

Crea un directorio data y dale los permisos para que todo el mundo pueda escribir y lánza el compose:

docker compose up -d

Ahora simplemente accede a http://localhost:8888 (puedes cambiar el puerto en el compose) y verás que se te invita a dar de alta un servidor

Y luego ya podrás entrar con tu usuario imap

Y, finalmente, acceder a tu correo:

Y con esto un pequeño ejemplo del tipo de cosas que se pueden pedir a las IAs de programación actualmente… Pero esto corre que se las pela, lo bueno es que siempre necesitaras a un humano de verdad que entienda lo que está haciendo y cómo arreglarlo.

Instala tu propia perplexity ia (perplexica)

Uno de los sistemas de IA más completos para las actividades diarias es perplexity.ia un sistema que no solo responde preguntas (usando varios proveedores de IA) sino que realiza una búsqueda en internet previa de los conceptos principales por los que estamos preguntando.

El problema principal es que, además de que es un sistema de pago, que todos los datos se los estamos pasando a una empresa que, a pesar de los términos y condiciones que nadie se lee, es posible que esté usando nuestros datos para sus propios fines. Sin embargo, he descubierto que hay un sistema open source que te permite montar un sistema similar a perplexity… El nombre ya da alguna pista: preplexica.

El repositorio principal lo podéis encontar aquí: https://github.com/ItzCrazyKns/Perplexica

En este post vamos a ver cómo utilizar el montaje que hicimos en un post anterior: Como tener tu propia IA en casa donde terminamos teniendo un servidor ollama para tener instalados los modelos open source que queramos y un servidor webui para poder interrogar a los modelos. Lo primero que vamos a hacer es modificar el docker-compose.yml para compartir el puerto por el que hablar con ollama de esta manera:

    ports:
      - "11434:11434"

Esto hace que ya esté disponible desde fuera del contenedor los modelos de ollama. Lo siguiente que tenemos que hacer es bajarnos el repositorio de Perpléxica

git clone https://github.com/ItzCrazyKns/Perplexica
cd Perplexica
cp sample.config.toml config.toml

Dado que el puerto 3000 que es en el que se ejecuta el servidor ya está ocupado por nuestro servicio webui vamos a cambiarlo al 3001 en el archivo docker-compose.yml que hay dentro del directorio Perplexica y lo dejaremos así (el otro puerto que utiliza es el 4000, si ese lo tenemos ocupado podemos cambiarlo en el otro servicio):

    ports:
      - 3001:3000

Luego modificaremos el archivo config.toml que copiamos anteriormente y modificaremos esta parte:

[MODELS.OLLAMA]
API_URL = "http://192.168.1.34:11434"

Poniendo la IP de la máquina en la que se está ejecutando. Ya solo tenemos que levantar el docker… docker compose up -d y conectar con http://localhost:3001 y ya tendremos nuestro intefaz de búsqueda

En la configuración (icono de abajo a la izquierda) podemos configurar los modelos que queremos utilizar:

Y si tenemos Claves de APIs de pago podemos incluirlas igualmente:

Y, con esto ya podremos empezar a preguntar a nuestro nuevo sistema de búsqueda (lo que tarde dependerá más del modelo elegido que de las búsquedas). Lo bueno es que puedes decirle que busque imágenes y videos a la vez:

Así que, ya sabéis, si tenéis una tarjeta gráfica lo suficientemente potente para correr un modelo de AI interesante, podéis mezclarlo con las búsquedas por internet de varias fuentes de una manera muy sencilla..