Volver al blog
IABunCódigo AbiertoLLM

Muse Spark Open: el modelo abierto de Meta corriendo con Bun

17 de octubre de 2026·7 min de lectura·Diego Horvatti

En abril, Meta lanzó Muse Spark como modelo cerrado y dijo que quizá abriría versiones futuras. Ahora salió Muse Spark Open, la versión con pesos abiertos, anunciada en el blog de investigación de Meta. Para quien programa en TypeScript, la pregunta práctica es una sola: ¿se puede correr esto en tu máquina y llamarlo desde tu código Bun sin montar una central de infraestructura? Se puede. Y es más simple de lo que parece.

Qué es Muse Spark Open

Muse Spark fue el primer modelo de Meta Superintelligence Labs, el laboratorio que Meta montó después de la etapa Llama. Salió cerrado y alimenta a Meta AI. La versión Open te entrega los pesos para descargarlos, correrlos y adaptarlos.

No voy a repetir benchmarks aquí. Las cifras de lanzamiento envejecen en una semana, y el post oficial trae tamaños, licencia y comparativas completas. Lee la licencia con atención antes de llevarlo a producción. "Abierto" en el mundo de los LLM es un espectro: hay modelos con licencia permisiva de verdad y hay modelos con cláusulas escondidas sobre número de usuarios o uso comercial.

Lo que le importa al dev es esto:

  • Los pesos quedan en tu máquina o en tu servidor.
  • Ningún dato del usuario sale de tu infraestructura.
  • El costo deja de ser por token y pasa a ser de hardware.
  • Tú controlas la versión. Nadie te cambia el modelo por debajo un martes cualquiera.

Este último punto está subestimado. Si alguna vez tuviste un prompt que funcionaba perfecto y de repente empezó a responder distinto porque el proveedor actualizó el modelo, sabes de qué hablo.

Por qué un modelo abierto de Meta vuelve a importar

Meta se había vuelto sinónimo de modelo abierto con Llama. Después la empresa cambió de rumbo, montó un laboratorio nuevo y lanzó Muse Spark cerrado. Mucha gente lo leyó como el fin de la era abierta en Meta.

Muse Spark Open demuestra que la puerta no se cerró. Y eso mueve todo el mercado. Cuantos más modelos buenos con pesos abiertos existan, menos poder de negociación tiene quien cobra por token. Ganas alternativas, y las alternativas son lo que mantiene los precios honestos.

Un modelo que no controlas es una dependencia. Un modelo que corre en tu máquina es una herramienta.

Mi opinión firme: para la mayoría de las features de IA en un producto, como resumir, clasificar, extraer campos de un texto o sugerir respuestas, no necesitas el modelo más potente del planeta. Necesitas un modelo bueno, predecible y barato. Justo ahí es donde brilla un modelo abierto.

Cómo llamar a Muse Spark Open desde Bun

El camino más corto es servir el modelo con un runtime local que exponga una API compatible con OpenAI. Ollama, llama.cpp y vLLM lo hacen. Revisa en la página del modelo qué formatos y cuantizaciones ya están disponibles. El nombre exacto del modelo en tu runtime puede variar, así que ajusta la variable de abajo.

Con el servidor levantado, Bun resuelve el resto con fetch nativo. Sin SDK, sin dependencias extra:

// ask.ts
const BASE_URL = Bun.env.LLM_URL ?? "http://localhost:11434/v1";
const MODEL = Bun.env.LLM_MODEL ?? "muse-spark-open";

export async function ask(prompt: string) {
  const res = await fetch(`${BASE_URL}/chat/completions`, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      model: MODEL,
      messages: [{ role: "user", content: prompt }],
      temperature: 0.2,
    }),
  });

  if (!res.ok) throw new Error(`El LLM respondió ${res.status}`);
  const data = await res.json();
  return data.choices[0].message.content as string;
}

console.log(await ask("Explica qué es un índice parcial en PostgreSQL en 3 frases."));

Se ejecuta con bun ask.ts. Bun lee el .env solo, así que cambiar de modelo es cambiar una línea de configuración.

Fíjate que el código no sabe si está hablando con un modelo local o con un proveedor en la nube. Es intencional. Si mañana quieres comparar Muse Spark Open con otro modelo, cambias la URL y listo.

Streaming con Bun.serve en pocas líneas

Las respuestas de un LLM tardan. Si el usuario se queda mirando un spinner 8 segundos, cree que se colgó. El streaming lo resuelve, y Bun lo facilita porque Bun.serve acepta un Response con el body que viene directo de otro fetch:

// server.ts
Bun.serve({
  port: 3000,
  async fetch(req) {
    const { prompt } = await req.json();

    const upstream = await fetch(`${Bun.env.LLM_URL}/chat/completions`, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({
        model: Bun.env.LLM_MODEL,
        stream: true,
        messages: [{ role: "user", content: prompt }],
      }),
    });

    return new Response(upstream.body, {
      headers: { "Content-Type": "text/event-stream" },
    });
  },
});

El servidor solo reenvía el stream. Nada de buffer, nada de librerías. En el front, lo consumes con EventSource o leyendo el ReadableStream. Para un prototipo interno, con esto alcanza. En producción, pon autenticación y límite de tasa antes de exponer ese endpoint, o alguien va a usar tu GPU para escribir poemas.

Prueba el modelo antes de confiar en él

Aquí está el error más común. El dev corre tres prompts, le gusta el resultado y lo sube a producción. Una semana después descubre que el modelo inventa un campo en 1 de cada 20 extracciones.

Con bun test armas una evaluación mínima en minutos. Toma 20 o 30 casos reales de tu dominio y verifica lo que importa:

// extract.test.ts
import { test, expect } from "bun:test";
import { ask } from "./ask";

const casos = [
  { texto: "Pedido 4821 entregado el 12/09", esperado: "4821" },
  { texto: "El cliente se quejó del pedido nº 977", esperado: "977" },
];

for (const c of casos) {
  test(`extrae el pedido de: ${c.texto}`, async () => {
    const out = await ask(`Responde solo con el número del pedido: ${c.texto}`);
    expect(out.trim()).toBe(c.esperado);
  }, 30_000);
}

No es una suite de evaluación científica. Es una red de seguridad. Cuando salga la próxima versión del modelo, o cuando quieras probar una cuantización más chica para ahorrar memoria, la corres de nuevo y comparas. Si la tasa de acierto cae del 95% al 80%, te enteras en la terminal, no en soporte.

¿Vale la pena cambiar tu API de pago por Muse Spark Open?

Depende del caso, y aquí hay que ser honesto.

Tiene sentido cuando:

  • Los datos son sensibles y no pueden salir de la empresa (salud, legal, finanzas).
  • El volumen es alto y predecible, así que el hardware propio sale más barato que los tokens.
  • La tarea es específica y un modelo mediano la resuelve con un buen prompt.
  • Quieres hacer fine-tuning en tu dominio.

No tiene sentido cuando:

  • Tienes 50 usuarios y una feature experimental. Pagar por token es más barato que mantener una GPU encendida.
  • Nadie en el equipo quiere encargarse de la infraestructura de inferencia. Un modelo local también se cae, también necesita monitoreo, también necesita actualizaciones.
  • La tarea exige el máximo razonamiento disponible y cada punto porcentual de calidad vale dinero.

Un punto medio que funciona bien: empieza con la API compatible con OpenAI apuntando a un proveedor que aloje el modelo abierto. No te ocupas de la GPU y mantienes la opción de migrar a hosting propio sin reescribir código. El fetch de arriba sigue igual.

Qué cambia en tu flujo de trabajo

En la práctica, tres cosas.

Primero, el desarrollo offline se vuelve realidad. Puedes programar una feature de IA en el avión, sin créditos de API y sin una clave filtrándose en un log.

Segundo, las pruebas de integración salen baratas. Correr la suite contra un modelo local no genera factura a fin de mes. Eso cambia cuánto pruebas, y probar más siempre compensa.

Tercero, la arquitectura queda más limpia. Cuando tratas el modelo como un endpoint HTTP intercambiable, dejas de acoplar el producto a un proveedor. Es la misma lección que aprendimos con las bases de datos: escribe contra una interfaz, no contra una marca.

Muse Spark Open no va a reemplazar a todos los modelos cerrados mañana. Pero es una pieza buena más en el tablero, y con Bun el costo de experimentar es prácticamente un archivo .ts y un bun run. Mi sugerencia: reserva una tarde, toma una tarea real de tu producto y compara. El resultado te dirá más que cualquier benchmark. Si quieres ver cómo he estado usando IA y Bun en proyectos reales, échale un vistazo a mis proyectos.

Resumen para LinkedIn

Meta volvió a liberar los pesos de un modelo, y eso cambia más cosas de lo que parece.

Salió Muse Spark Open, la versión abierta del primer modelo de Meta Superintelligence Labs.

Para quien programa en TypeScript, lo que importa es que corre en tu máquina, los datos no salen de tu infraestructura y nadie te cambia el modelo por debajo un martes cualquiera.

Con Bun, llamar al modelo es un `fetch` nativo a una API compatible con OpenAI. Sin SDK y sin dependencias extra.

Un modelo que no controlas es una dependencia. Un modelo que corre en tu máquina es una herramienta.

Aun así, pruébalo antes de confiar. Con 20 casos reales en `bun test` descubres los errores en la terminal, no en soporte.

Escribí el paso a paso completo en el blog, con streaming y cuándo vale la pena (o no) cambiar tu API de pago. El enlace está en los comentarios.

#Bun #TypeScript #InteligenciaArtificial #CodigoAbierto #LLM