La API de Prompt

Thomas Steiner

Alexandra Klepper

Publicación: 20 de mayo de 2025; última actualización: 21 de octubre de 2026

Explicativa	Web	Extensiones	Estado de Chrome	Intención
GitHub	Chrome 148	Chrome 138	Ver	Intención de enviar
GitHub	Prueba de origen para los parámetros de muestreo	Chrome 148	Ver	Intención de experimentar

Con la API de Prompt, puedes enviar solicitudes en lenguaje natural al modelo de base en Chrome.

Existen muchas formas de usar la API de Prompt. Por ejemplo, podrías crear lo siguiente:

• Búsqueda potenciada por IA: Responde preguntas según el contenido de una página web.
• Feeds de noticias personalizados: Crea un feed que clasifique de forma dinámica los artículos con categorías y permita que los usuarios filtren ese contenido.
• Filtros de contenido personalizados. Analizar artículos de noticias y desenfocar u ocultar contenido automáticamente según temas definidos por el usuario
• Creación de eventos de calendario Desarrollar una extensión de Chrome que extraiga automáticamente los detalles de los eventos de las páginas web para que los usuarios puedan crear entradas de calendario en solo unos pasos
• Extracción de contactos sin problemas. Compila una extensión que extraiga información de contacto de sitios web, lo que facilita que los usuarios se comuniquen con una empresa o agreguen detalles a su lista de contactos.

Estas son solo algunas de las posibilidades, y estamos ansiosos por ver lo que crearás.

Usa la API de Prompt

La API de Prompt usa el modelo Gemini Nano en Chrome. Si bien la API está integrada en Chrome, el modelo se descarga por separado la primera vez que un origen usa la API.

Para determinar si el modelo está listo para usarse, llama a LanguageModel.availability().

const availability = await LanguageModel.availability({
  // The same options in `prompt()` or `promptStreaming()`
});

Para activar la descarga y crear una instancia del modelo de lenguaje, verifica la activación del usuario. Luego, llama a la función create().

const session = await LanguageModel.create({
  monitor(m) {
    m.addEventListener('downloadprogress', (e) => {
      console.log(`Downloaded ${e.loaded * 100}%`);
    });
  },
});

Si la respuesta a availability() fue downloading, escucha el progreso de la descarga y, luego, informa al usuario, ya que la descarga puede tardar un tiempo.

Crea una sesión

Una vez que se pueda ejecutar la API de Prompt, crea una sesión con la función create().

const session = await LanguageModel.create();

El objeto de opciones opcional de la función create() toma un campo signal, que te permite pasar un AbortSignal para destruir la sesión.

const controller = new AbortController();
stopButton.onclick = () => controller.abort();

const session = await LanguageModel.create({
  signal: controller.signal,
});

Parámetros de muestreo

Controlar el muestreo te permite ajustar qué tan predecibles (determinísticas) o creativas (variadas) son las respuestas del modelo. La disponibilidad de los parámetros de muestreo difiere entre la plataforma web y las extensiones de Chrome:

• Web: Usa la opción samplingMode, que utiliza valores de enumeración descriptivos en lugar de números sin procesar para ajustar la previsibilidad de los resultados.
• Extensiones de Chrome: Se admiten los parámetros numéricos heredados (topK, temperature) y el método LanguageModel.params().

Modo de muestreo web

Pasa la opción samplingMode a LanguageModel.create() (o LanguageModel.availability()).

Los valores de enumeración samplingMode admitidos son los siguientes:

• "most-predictable": El mayor determinismo y previsibilidad.
• "predictable": Resultado más predecible con una variación mínima.
• "slightly-predictable": El resultado es un poco predecible.
• "balanced": Un equilibrio entre la previsibilidad y la creatividad (comportamiento predeterminado típico).
• "slightly-creative": Resultado ligeramente variado y creativo.
• "creative": Resultado creativo y variado.
• "most-creative": Variabilidad y creatividad máximas.

// Available on the web with the Sampling Parameters Origin Trial enabled
const session = await LanguageModel.create({
  samplingMode: 'creative',
});

// The configured sampling mode is exposed on the session instance
console.log(session.samplingMode);
// "creative"

Parámetros de muestreo para las extensiones de Chrome

Cuando se usa la API de Prompt en las extensiones de Chrome, cada sesión se puede personalizar con topK y temperature con el objeto de opciones.

La función estática LanguageModel.params() te informa sobre los límites de parámetros predeterminados y máximos del modelo de lenguaje:

• defaultTopK: Es el valor predeterminado de top-K.
• maxTopK: Es el valor máximo de top-K.
• defaultTemperature: Es la temperatura predeterminada.
• maxTemperature: Es la temperatura máxima.

// Only available in Chrome Extensions
const params = await LanguageModel.params();
// {defaultTopK: 3, maxTopK: 128, defaultTemperature: 1, maxTemperature: 2}

// Initializing a new session in extensions must either specify both `topK` and
// `temperature` or neither of them.
const slightlyHighTemperatureSession = await LanguageModel.create({
  temperature: Math.min(params.defaultTemperature * 1.2, params.maxTemperature),
  topK: params.defaultTopK,
});

console.log(slightlyHighTemperatureSession.temperature);
console.log(slightlyHighTemperatureSession.topK);

Agrega contexto con instrucciones iniciales

Con las instrucciones iniciales, puedes proporcionarle al modelo de lenguaje contexto sobre interacciones anteriores, por ejemplo, para permitir que el usuario reanude una sesión almacenada después de reiniciar el navegador.

const session = await LanguageModel.create({
  initialPrompts: [
    { role: 'system', content: 'You are a helpful and friendly assistant.' },
    { role: 'user', content: 'What is the capital of Italy?' },
    { role: 'assistant', content: 'The capital of Italy is Rome.' },
    { role: 'user', content: 'What language is spoken there?' },
    {
      role: 'assistant',
      content: 'The official language of Italy is Italian. [...]',
    },
  ],
});

Restringe las respuestas con un prefijo

Puedes agregar un rol "assistant", además de los roles anteriores, para elaborar las respuestas anteriores del modelo. Por ejemplo:

const followup = await session.prompt([
  {
    role: "user",
    content: "I'm nervous about my presentation tomorrow"
  },
  {
    role: "assistant",
    content: "Presentations are tough!"
  }
]);

En algunos casos, en lugar de solicitar una respuesta nueva, es posible que quieras completar previamente parte del mensaje de respuesta del rol "assistant". Esto puede ser útil para guiar al modelo de lenguaje a usar un formato de respuesta específico. Para ello, agrega prefix: true al mensaje final con el rol "assistant". Por ejemplo:

const characterSheet = await session.prompt([
  {
    role: 'user',
    content: 'Create a TOML character sheet for a gnome barbarian',
  },
  {
    role: 'assistant',
    content: '```toml\n',
    prefix: true,
  },
]);

Agrega parámetros de entrada y salida esperados

La API de Prompt tiene capacidades multimodales y admite varios idiomas. Establece las modalidades y los idiomas de expectedInputs y expectedOutputs cuando crees tu sesión.

• type: Se espera la modalidad.
  • Para expectedInputs, puede ser text, image o audio.
  • En el caso de expectedOutputs, la API de Prompt solo permite text.
• languages: Es un array para establecer el idioma o los idiomas esperados. La API de Prompt acepta "en", "ja", "es", "de" y "fr". La compatibilidad con otros idiomas está en desarrollo.
  • Para expectedInputs, establece el idioma de la instrucción del sistema y uno o más idiomas esperados para la instrucción del usuario.
  • Establece uno o más idiomas de expectedOutputs.

const session = await LanguageModel.create({
  expectedInputs: [
    { type: "text", languages: ["en" /* system prompt */, "ja" /* user prompt */] }
  ],
  expectedOutputs: [
    { type: "text", languages: ["ja"] }
  ]
});

Es posible que recibas una DOMException "NotSupportedError" si el modelo encuentra una entrada o salida no admitida.

Capacidades multimodales

Con estas funciones, podrías hacer lo siguiente:

• Permite que los usuarios transcriban los mensajes de audio que se envían en una aplicación de chat.
• Describe una imagen subida a tu sitio web para usarla en una leyenda o un texto alternativo.

Consulta la demostración de Mediarecorder Audio Prompt para usar la API de Prompt con entrada de audio y la demostración de Canvas Image Prompt para usar la API de Prompt con entrada de imagen.

La API de Prompt admite los siguientes tipos de entrada:

• Audio:
  • AudioBuffer
  • ArrayBufferView
  • ArrayBuffer
  • Blob
• Visual:
  • HTMLImageElement
  • SVGImageElement
  • HTMLVideoElement (usa el fotograma en la posición actual del video)
  • HTMLCanvasElement
  • ImageBitmap
  • OffscreenCanvas
  • VideoFrame
  • Blob
  • ImageData

En este fragmento, se muestra una sesión multimodal que primero procesa dos elementos visuales (una imagen Blob y un HTMLCanvasElement) y hace que la IA los compare, y, en segundo lugar, permite que el usuario responda con una grabación de audio (como un AudioBuffer).

const session = await LanguageModel.create({
  expectedInputs: [
    { type: "text", languages: ["en"] },
    { type: "audio" },
    { type: "image" },
  ],
  expectedOutputs: [{ type: "text", languages: ["en"] }],
});

const referenceImage = await (await fetch("reference-image.jpeg")).blob();
const userDrawnImage = document.querySelector("canvas");

const response1 = await session.prompt([
  {
    role: "user",
    content: [
      {
        type: "text",
        value:
          "Give a helpful artistic critique of how well the second image matches the first:",
      },
      { type: "image", value: referenceImage },
      { type: "image", value: userDrawnImage },
    ],
  },
]);
console.log(response1);

const audioBuffer = await captureMicrophoneInput({ seconds: 10 });

const response2 = await session.prompt([
  {
    role: "user",
    content: [
      { type: "text", value: "My response to your critique:" },
      { type: "audio", value: audioBuffer },
    ],
  },
]);
console.log(response2);

Agrega mensajes

La inferencia puede tardar un poco, en especial cuando se usan entradas multimodales. Puede ser útil enviar instrucciones predeterminadas con anticipación para propagar la sesión, de modo que el modelo pueda comenzar a procesar.

Si bien los initialPrompts son útiles en la creación de sesiones, el método append() se puede usar además de los métodos prompt() o promptStreaming() para proporcionar instrucciones contextuales adicionales después de que se crea la sesión.

Por ejemplo:

const session = await LanguageModel.create({
  initialPrompts: [
    {
      role: 'system',
      content:
        'You are a skilled analyst who correlates patterns across multiple images.',
    },
  ],
  expectedInputs: [{ type: 'image' }],
});

fileUpload.onchange = async () => {
  await session.append([
    {
      role: 'user',
      content: [
        {
          type: 'text',
          value: `Here's one image. Notes: ${fileNotesInput.value}`,
        },
        { type: 'image', value: fileUpload.files[0] },
      ],
    },
  ]);
};

analyzeButton.onclick = async (e) => {
  analysisResult.textContent = await session.prompt(userQuestionInput.value);
};

La promesa que muestra append() se cumple una vez que se valida, procesa y agrega la instrucción a la sesión. La promesa se rechaza si no se puede agregar la instrucción.

Pasa un esquema JSON

Agrega el campo responseConstraint al método prompt() o promptStreaming() para pasar un esquema JSON como valor. Luego, puedes usar el resultado estructurado con la API de Prompt.

En el siguiente ejemplo, el esquema JSON se asegura de que el modelo responda con true o false para clasificar si un mensaje determinado trata sobre cerámica.

const session = await LanguageModel.create();

const schema = {
  "type": "boolean"
};

const post = "Mugs and ramen bowls, both a bit smaller than intended, but that
happens with reclaim. Glaze crawled the first time around, but pretty happy
with it after refiring.";

const result = await session.prompt(
  `Is this post about pottery?\n\n${post}`,
  {
    responseConstraint: schema,
  }
);
console.log(JSON.parse(result));
// true

Tu implementación puede incluir un esquema JSON o una expresión regular como parte del mensaje enviado al modelo. Esto usa parte de la ventana de contexto. Puedes medir qué parte de la ventana de contexto usará pasando la opción responseConstraint a session.measureContextUsage().

Puedes evitar este comportamiento con la opción omitResponseConstraintInput. Si lo haces, te recomendamos que incluyas algunas instrucciones en la instrucción:

const result = await session.prompt(`
  Summarize this feedback into a rating between 0-5. Only output a JSON
  object { rating }, with a single property whose value is a number:
  The food was delicious, service was excellent, will recommend.
`, { responseConstraint: schema, omitResponseConstraintInput: true });

Envía instrucciones al modelo

Puedes enviar instrucciones al modelo con las funciones prompt() o promptStreaming().

Resultado basado en solicitudes

Si esperas un resultado breve, puedes usar la función prompt() que devuelve la respuesta una vez que está disponible.

// Start by checking if it's possible to create a session based on the
// availability of the model, and the characteristics of the device.
const available = await LanguageModel.availability({
  expectedInputs: [{type: 'text', languages: ['en']}],
  expectedOutputs: [{type: 'text', languages: ['en']}],
});

if (available !== 'unavailable') {
  const session = await LanguageModel.create();

  // Prompt the model and wait for the whole result to come back.
  const result = await session.prompt('Write me a poem!');
  console.log(result);
}

Resultado transmitido

Si esperas una respuesta más larga, debes usar la función promptStreaming(), que te permite mostrar resultados parciales a medida que provienen del modelo. La función promptStreaming() devuelve un ReadableStream.

const available = await LanguageModel.availability({
  expectedInputs: [{type: 'text', languages: ['en']}],
  expectedOutputs: [{type: 'text', languages: ['en']}],
});
if (available !== 'unavailable') {
  const session = await LanguageModel.create();

  // Prompt the model and stream the result:
  const stream = session.promptStreaming('Write me an extra-long poem!');
  for await (const chunk of stream) {
    console.log(chunk);
  }
}

Detener instrucción

Tanto prompt() como promptStreaming() aceptan un segundo parámetro opcional con un campo signal, que te permite dejar de ejecutar instrucciones.

const controller = new AbortController();
stopButton.onclick = () => controller.abort();

const result = await session.prompt('Write me a poem!', {
  signal: controller.signal,
});

Administración de las sesiones

Cada sesión hace un seguimiento del contexto de la conversación. Las interacciones anteriores se tienen en cuenta para las interacciones futuras hasta que se llena la ventana de contexto de la sesión.

Cada sesión tiene una cantidad máxima de tokens que puede procesar. Verifica tu progreso hacia este límite con lo siguiente:

console.log(`${session.contextUsage}/${session.contextWindow}`);

Es posible enviar una instrucción que haga que la ventana de contexto se desborde. En esos casos, se quitarán las partes iniciales de la conversación con el modelo de lenguaje, un par de instrucción y respuesta a la vez, hasta que haya suficientes tokens disponibles para procesar la instrucción nueva. La excepción es la instrucción del sistema, que nunca se quita.

Estos desbordamientos se pueden detectar escuchando el evento contextoverflow en la sesión:

session.addEventListener("contextoverflow", () => {
  console.log("We've gone past the context window, and some inputs will be dropped!");
});

Si no es posible quitar suficientes tokens del historial de conversaciones para procesar el nuevo mensaje, la llamada prompt() o promptStreaming() fallará con una excepción QuotaExceededError y no se quitará nada. QuotaExceededError tiene las siguientes propiedades:

• requested: cuántos tokens componen la entrada
• contextWindow: cuántos tokens estaban disponibles

Obtén más información sobre la administración de sesiones.

Cómo clonar una sesión

Para conservar los recursos, puedes copiar una sesión existente con la función clone(). Esto crea una bifurcación de la conversación, en la que se conservan el contexto y la instrucción inicial.

La función clone() toma un objeto de opciones opcional con un campo signal, que te permite pasar un AbortSignal para destruir la sesión clonada.

const controller = new AbortController();
stopButton.onclick = () => controller.abort();

const clonedSession = await session.clone({
  signal: controller.signal,
});

Finaliza una sesión

Llama a destroy() para liberar recursos si ya no necesitas una sesión. Cuando se destruye una sesión, ya no se puede usar y se anula cualquier ejecución en curso. Te recomendamos mantener la sesión si tienes la intención de enviar instrucciones al modelo con frecuencia, ya que crear una sesión puede llevar algún tiempo.

await session.prompt(
  "You are a friendly, helpful assistant specialized in clothing choices."
);

session.destroy();

// The promise is rejected with an error explaining that
// the session is destroyed.
await session.prompt(
  "What should I wear today? It is sunny, and I am choosing between a t-shirt
  and a polo."
);

Demostraciones

Creamos varias demostraciones para explorar los numerosos casos de uso de la API de Prompt. Las siguientes demostraciones son aplicaciones web:

• Zona de pruebas de la API de Prompt
• Instrucción de audio de MediaRecorder
• Instrucción de imagen de Canvas

Para probar la API de Prompt en las extensiones de Chrome, instala la extensión de demostración. El código fuente de la extensión está disponible en GitHub.

Estrategia de rendimiento

La API de Prompt para la Web aún está en desarrollo. Mientras compilamos esta API, consulta nuestras prácticas recomendadas sobre la administración de sesiones para obtener un rendimiento óptimo.

Política de permisos, iframes y trabajadores web

De forma predeterminada, la API de Prompt solo está disponible para las ventanas de nivel superior y sus iframes del mismo origen. El acceso a la API se puede delegar a iframes de origen cruzado con el atributo allow="" de la política de permisos:

<!--
  The hosting site at https://main.example.com can grant a cross-origin iframe
  at https://cross-origin.example.com/ access to the Prompt API by
  setting the `allow="language-model"` attribute.
-->
<iframe src="https://cross-origin.example.com/" allow="language-model"></iframe>

Por el momento, la API de Prompt no está disponible en los trabajadores web debido a la complejidad de establecer un documento responsable para cada trabajador con el objetivo de verificar el estado con respecto a las políticas de permisos.

Participa y comparte comentarios

Tus comentarios pueden influir directamente en la forma en que compilamos e implementamos las versiones futuras de esta API y todas las APIs de IA integradas.

• Para enviar comentarios sobre la implementación de Chrome, envía un informe de errores o una solicitud de función.
• Para compartir tus comentarios sobre la forma de la API, comenta un problema existente o abre uno nuevo en el repositorio de GitHub de la API de Prompt.
• Únete al programa de versión preliminar anticipada.