La API de Prompt

Thomas Steiner

Alexandra Klepper

Fecha de publicación: 20 de mayo de 2025. Última actualización: 19 de mayo 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 parámetros de muestreo	Chrome 148	Ver	Intención de experimentar

Con la API de Prompt, puedes enviar solicitudes de lenguaje natural a Gemini Nano en Chrome.

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

• Búsqueda potenciada por IA: Responde preguntas basadas en el contenido de una página web.
• Feeds de noticias personalizados: Crea un feed que clasifique artículos de forma dinámica con categorías y permita que los usuarios filtren ese contenido.
• Filtros de contenido personalizados. Analiza artículos de noticias y desenfoca o esconde automáticamente el contenido según los temas definidos por el usuario.
• Creación de eventos de calendario. Desarrolla 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 unos pocos pasos.
• Extracción de contactos sin problemas. Crea 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 posibilidades, y estamos ansiosos por ver tus creaciones.

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 create() función.

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 e informa al usuario, ya que la descarga puede tardar un tiempo.

Parámetros del modelo

La función params() te informa sobre los parámetros del modelo de lenguaje. El objeto tiene los siguientes campos:

• 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 when using the Prompt API for Chrome Extensions.
await LanguageModel.params();
// {defaultTopK: 3, maxTopK: 128, defaultTemperature: 1, maxTemperature: 2}

Crea una sesión

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

const session = await LanguageModel.create();

Crea una sesión con la API de Prompt para extensiones de Chrome

Cuando usas la API de Prompt para extensiones de Chrome, cada sesión se puede personalizar con topK y temperature mediante un objeto de opciones opcional. Los valores predeterminados para estos parámetros se muestran desde LanguageModel.params().

// Only available when using the Prompt API for Chrome Extensions.
const params = await LanguageModel.params();
// Initializing a new session must either specify both `topK` and
// `temperature` or neither of them.
// Only available when using the Prompt API for Chrome Extensions.
const slightlyHighTemperatureSession = await LanguageModel.create({
  temperature: Math.max(params.defaultTemperature * 1.2, 2.0),
  topK: params.defaultTopK,
});

El objeto de opciones opcional de la función create() también 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,
});

Agrega contexto con instrucciones iniciales

Con las instrucciones iniciales, puedes proporcionar al modelo de lenguaje contexto sobre las 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 ampliar 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 desees completar previamente parte del mensaje de respuesta del rol "assistant". Esto puede ser útil para guiar al modelo de lenguaje para que use un formato de respuesta específico. Para ello, agrega prefix: true al mensaje final del 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 entradas y salidas esperadas

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

• type: Modalidad esperada.
  • Para expectedInputs, puede ser text, image o audio.
  • Para expectedOutputs, la API de Prompt solo permite text.
• languages: Es un array para configurar el idioma o los idiomas esperados. La API de Prompt acepta "en", "ja" y "es". Se está desarrollando la compatibilidad con idiomas adicionales.
  • Para expectedInputs, configura el idioma de la instrucción del sistema y uno o más idiomas de la instrucción del usuario esperados.
  • Configura uno o más idiomas 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 "NotSupportedError" DOMException si el modelo encuentra una entrada o salida no admitida.

Capacidades multimodales

Con estas capacidades, podrías hacer lo siguiente:

• Permitir que los usuarios transcriban mensajes de audio enviados en una aplicación de chat.
• Describe una imagen subida a tu sitio web para usarla en un título o 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 de video 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 que, 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 tiempo, en especial cuando se solicita con 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 initialPrompts es útil 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 crear 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 de JSON

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

En el siguiente ejemplo, el esquema de JSON se asegura de que el modelo responda con true o false para clasificar si un mensaje determinado es 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 de JSON o una expresión regular como parte del mensaje enviado al modelo. Esto usa parte de la ventana de contexto. Puedes medir cuánto 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 });

Solicita el modelo

Puedes solicitar el modelo con las funciones prompt() o promptStreaming().

Salida basada en solicitudes

Si esperas un resultado breve, puedes usar la función prompt() que muestra 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);
}

Salida transmitida

Si esperas una respuesta más larga, debes usar la función promptStreaming() que te permite mostrar resultados parciales a medida que llegan del modelo. La función promptStreaming() muestra 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);
  }
}

Deja de escribir instrucciones y

prompt() y 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 realiza 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 provoque el desbordamiento de la ventana de contexto. En esos casos, se quitarán las partes iniciales de la conversación con el modelo de lenguaje, un par de instrucciones y respuestas a la vez, hasta que haya suficientes tokens disponibles para procesar la nueva instrucción. La excepción es la instrucción del sistema, que nunca se quita.

Para detectar esos desbordamientos, escucha 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 la nueva instrucción, la llamada prompt() o promptStreaming() fallará con una excepción QuotaExceededError y no se quitará nada. QuotaExceededError tiene las siguientes propiedades:

• requested: Cantidad de tokens que contiene la entrada
• contextWindow: Cantidad de tokens disponibles

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

Clona una sesión

Para conservar 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. Es posible que desees mantener la sesión si tienes la intención de solicitar el modelo con frecuencia, ya que crear una sesión puede tardar un 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 muchos casos de uso de la API de Prompt. Las siguientes demostraciones son aplicaciones web:

• Área de juegos de la API de Prompt
• Instrucción de audio de Mediarecorder
• Instrucción de imagen de Canvas

Para probar la API de Prompt en 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. Se puede delegar el acceso a la API 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 ahora, la API de Prompt no está disponible en los trabajadores web debido a la complejidad de establecer un documento responsable para cada trabajador para verificar el estado de la política de permisos.

Participa y comparte comentarios

Tu opinión puede afectar directamente la forma en que compilamos e implementamos versiones futuras de esta API y todas las APIs de IA integradas.

• Para enviar comentarios sobre la implementación de Chrome, registra 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.