Compartir a través de

Solicitud de un modelo de lenguaje integrado con prompt API

Prompt API es una API web experimental que permite solicitar un modelo de lenguaje pequeño (SLM) integrado en Microsoft Edge, desde el código JavaScript de la extensión del sitio web o del explorador. Use prompt API para generar y analizar texto o crear lógica de aplicación basada en la entrada del usuario y descubrir formas innovadoras de integrar funcionalidades de ingeniería de mensajes en la aplicación web.

Contenido detallado:

Disponibilidad de la API de aviso

Prompt API está disponible como versión preliminar para desarrolladores en los canales Dev o Microsoft Edge Canary, a partir de la versión 138.0.3309.2.

Prompt API está diseñada para ayudar a detectar casos de uso y comprender los desafíos de los SLM integrados. Se espera que otras API experimentales realicen correctamente esta API para tareas específicas con tecnología de inteligencia artificial, como la asistencia para escritura y la traducción de texto. Para obtener más información sobre estas otras API, consulte:

Alternativas y ventajas de prompt API

Para aprovechar las funcionalidades de inteligencia artificial en sitios web y extensiones de explorador, también puede usar los métodos siguientes:

La API prompt usa un SLM que se ejecuta en el mismo dispositivo donde se usan las entradas y salidas del modelo (es decir, localmente). Esto tiene las siguientes ventajas en comparación con las soluciones basadas en la nube:

  • Costo reducido: No hay ningún costo asociado con el uso de un servicio de inteligencia artificial en la nube.

  • Independencia de red: Más allá de la descarga del modelo inicial, no hay latencia de red al solicitar el modelo y también se puede usar cuando el dispositivo está sin conexión.

  • Privacidad mejorada: La entrada de datos al modelo nunca sale del dispositivo y no se recopila para entrenar modelos de inteligencia artificial.

Prompt API usa un modelo proporcionado por Microsoft Edge y integrado en el explorador, que incluye las ventajas adicionales sobre las soluciones locales personalizadas, como las basadas en WebGPU, WebNN o WebAssembly:

  • Costo compartido de una sola vez: El modelo proporcionado por el explorador se descarga la primera vez que se llama a la API y se comparte entre todos los sitios web que se ejecutan en el explorador, lo que reduce los costos de red para el usuario y el desarrollador.

  • Uso simplificado para desarrolladores web: El modelo integrado se puede ejecutar mediante API web sencillas y no requiere experiencia en inteligencia artificial o aprendizaje automático ni el uso de marcos de trabajo de terceros.

Modelo Phi-4-mini

Prompt API le permite solicitar Phi-4-mini, un potente modelo de lenguaje pequeño que destaca en las tareas basadas en texto, integrado en Microsoft Edge. Para obtener más información sobre Phi-4-mini y sus capacidades, consulte la tarjeta modelo en microsoft/Phi-4-mini-instruct.

Aviso de declinación de responsabilidades

Al igual que otros modelos de lenguaje, la familia de modelos Phi puede comportarse potencialmente de maneras injustas, poco confiables o ofensivas. Para obtener más información sobre las consideraciones de inteligencia artificial del modelo, consulte Consideraciones de IA responsable.

Requisitos de hardware

La versión preliminar del desarrollador de Prompt API está diseñada para funcionar en dispositivos con funcionalidades de hardware que generan salidas SLM con una calidad y latencia predecibles. La API de aviso está limitada actualmente a:

  • Sistema operativo: Windows 10 o 11 y macOS 13.3 o posterior.

  • Almacenamiento: Al menos 20 GB disponibles en el volumen que contiene el perfil de Edge. Si el almacenamiento disponible cae por debajo de 10 GB, el modelo se eliminará para asegurarse de que otras características del explorador tengan espacio suficiente para funcionar.

  • GPU: 5,5 GB de VRAM o más.

  • Red: Plan de datos ilimitado o conexión sin medidor. El modelo no se descarga si se usa una conexión de uso medido.

Para comprobar si el dispositivo admite la versión preliminar del desarrollador de Prompt API, consulte Habilitación de la API de aviso a continuación y comprobación de la clase de rendimiento del dispositivo.

Debido a la naturaleza experimental de prompt API, es posible que observe problemas en configuraciones de hardware específicas. Si ve problemas en configuraciones de hardware específicas, proporcione comentarios abriendo un nuevo problema en el repositorio MSEdgeExplainers.

Disponibilidad del modelo

Se necesitará una descarga inicial del modelo la primera vez que un sitio web llame a una API de inteligencia artificial integrada. Puede supervisar la descarga del modelo mediante la opción de supervisión al crear una nueva sesión de Prompt API. Para más información, consulte Supervisión del progreso de la descarga del modelo, a continuación.

Habilitación de la API de solicitud

Para usar prompt API en Microsoft Edge:

  1. Asegúrese de que usa la versión más reciente de Microsoft Edge Canary o Dev (versión 138.0.3309.2 o posterior). Consulte Convertirse en un insider de Microsoft Edge.

  2. En Microsoft Edge Canary o Dev, abra una nueva pestaña o ventana y vaya a edge://flags/.

  3. En el cuadro de búsqueda, en la parte superior de la página, escriba Prompt API for Phi mini.

    La página se filtra para mostrar la marca coincidente.

  4. En Prompt API for Phi mini (Solicitar API para Phi mini), seleccione Habilitado:

    Página Marcas del explorador

  5. Opcionalmente, para registrar información localmente que puede ser útil para los problemas de depuración, habilite también la marca Habilitar en los registros de depuración del modelo de IA del dispositivo .

  6. Reinicie Microsoft Edge Canary o Dev.

  7. Para comprobar si el dispositivo cumple los requisitos de hardware de la versión preliminar del desarrollador de Prompt API, abra una nueva pestaña, vaya a edge://on-device-internalsy compruebe el valor de clase De rendimiento del dispositivo .

    Si la clase de rendimiento del dispositivo es Alta o mayor, se debe admitir prompt API en el dispositivo. Si sigue observando problemas, cree un nuevo problema en el repositorio MSEdgeExplainers.

Consulte un ejemplo de trabajo

Para ver la API de aviso en acción y revisar el código existente que usa la API:

  1. Habilite la API del símbolo del sistema, como se describió anteriormente.

  2. En el explorador Microsoft Edge Canary o Dev, abra una pestaña o ventana y vaya al área de juegos de Prompt API.

    En el panel de navegación De IA integrado de la izquierda, se selecciona Preguntar .

  3. En el banner de información de la parte superior, compruebe el estado: inicialmente lee Descarga del modelo, espere:

    Indicador de estado que muestra el progreso de descarga del modelo

    Una vez descargado el modelo, el banner de información lee API y modelo listos, lo que indica que se pueden usar la API y el modelo:

    Indicador de estado que muestra la API y el modelo listos

    Si no se inicia la descarga del modelo, reinicie Microsoft Edge e inténtelo de nuevo.

    La API de aviso solo se admite en dispositivos que cumplen determinados requisitos de hardware. Para obtener más información, consulte Requisitos de hardware, anteriormente.

  4. Opcionalmente, cambie los valores de configuración del símbolo del sistema, como:

    • Solicitud de usuario
    • Símbolo del sistema
    • Esquema de restricción de respuesta
    • Más opciones de configuración>Instrucciones de aviso de N-shot
    • TopK
    • Temperatura

  5. Haga clic en el botón Preguntar , en la parte inferior de la página.

    La respuesta se genera en la sección de respuesta de la página:

    La página De demostración del símbolo del sistema con la configuración y un botón Preguntar

  6. Para dejar de generar la respuesta, en cualquier momento, haga clic en el botón Detener .

Vea también:

  • /built-in-ai/ - Código fuente y Léame para áreas de juegos integradas de IA, incluido el área de juegos de Prompt API.

Uso de la API del símbolo del sistema

Comprobación de si la API está habilitada

Antes de usar la API en el código de su sitio web o extensión, compruebe que la API está habilitada mediante la prueba de la presencia del LanguageModel objeto:

if (!LanguageModel) {
  // The Prompt API is not available.
} else {
  // The Prompt API is available.
}

Comprobación de si se puede usar el modelo

La API de aviso solo se puede usar si el dispositivo admite la ejecución del modelo y una vez que Microsoft Edge ha descargado el modelo de lenguaje y el entorno de ejecución del modelo.

Para comprobar si se puede usar la API, use el LanguageModel.availability() método :

const availability = await LanguageModel.availability();

if (availability == "unavailable") {
  // The model is not available.
}

if (availability == "downloadable" || availability == "downloading") {
  // The model can be used, but it needs to be downloaded first.
}

if (availability == "available") {
  // The model is available and can be used.
}

Creación de una nueva sesión

La creación de una sesión indica al explorador que cargue el modelo de lenguaje en la memoria para que se pueda usar. Para poder solicitar el modelo de lenguaje, cree una nueva sesión mediante el create() método :

// Create a LanguageModel session.
const session = await LanguageModel.create();

Para personalizar la sesión del modelo, puede pasar opciones al create() método :

// Create a LanguageModel session with options.
const session = await LanguageModel.create(options);

Las opciones disponibles son:

  • monitor, para seguir el progreso de la descarga del modelo.

  • initialPrompts, para proporcionar el contexto del modelo sobre las solicitudes que se enviarán al modelo y para establecer un patrón de interacciones de usuario o asistente que el modelo debe seguir para futuras solicitudes.

  • topK y temperature, para ajustar la coherencia y el determinismo de la salida del modelo.

Estas opciones se documentan a continuación.

Supervisión del progreso de la descarga del modelo

Puede seguir el progreso de la descarga del modelo mediante la monitor opción . Esto resulta útil cuando el modelo aún no se ha descargado por completo en el dispositivo donde se usará, para informar a los usuarios de su sitio web de que deben esperar.

// Create a LanguageModel session with the monitor option to monitor the model
// download.
const session = await LanguageModel.create({
  monitor: m => {
    // Use the monitor object argument to add an listener for the 
    // downloadprogress event.
    m.addEventListener("downloadprogress", event => {
      // The event is an object with the loaded and total properties.
      if (event.loaded == event.total) {
        // The model is fully downloaded.
      } else {
        // The model is still downloading.
        const percentageComplete = (event.loaded / event.total) * 100;
      }
    });
  }
});
Proporcionar al modelo una solicitud del sistema

Para definir una solicitud del sistema, que es una manera de proporcionar las instrucciones del modelo que se deben usar al generar texto en respuesta a un aviso, use la initialPrompts opción .

La solicitud del sistema que proporciona al crear una nueva sesión se conserva para toda la existencia de la sesión, incluso si la ventana de contexto se desborda debido a demasiadas solicitudes.

// Create a LanguageModel session with a system prompt.
const session = await LanguageModel.create({
  initialPrompts: [{
    role: "system",
    content: "You are a helpful assistant."
  }]
});

Si coloca el símbolo del { role: "system", content: "You are a helpful assistant." } sistema en cualquier lugar además de en la 0ª posición, initialPrompts se rechazará con .TypeError

Solicitud de N-shot con initialPrompts

La initialPrompts opción también le permite proporcionar ejemplos de interacciones de usuario o asistente que desea que el modelo continúe usando cuando se le solicite.

Esta técnica también se conoce como solicitud de N-shot y es útil para que las respuestas generadas por el modelo sean más deterministas.

// Create a LanguageModel session with multiple initial prompts, for N-shot
// prompting.
const session = await LanguageModel.create({
  initialPrompts: [
    { role: "system", content: "Classify the following product reviews as either OK or Not OK." },
    { role: "user", content: "Great shoes! I was surprised at how comfortable these boots are for the price. They fit well and are very lightweight." },
    { role: "assistant", content: "OK" },
    { role: "user", content: "Terrible product. The manufacturer must be completely incompetent." },
    { role: "assistant", content: "Not OK" },
    { role: "user", content: "Could be better. Nice quality overall, but for the price I was expecting something more waterproof" },
    { role: "assistant", content: "OK" }
  ]
});
Establecer topK y temperatura

topK y temperature se conocen como parámetros de muestreo y los usa el modelo para influir en la generación de texto.

  • El muestreo topK limita el número de palabras consideradas para cada palabra posterior en el texto generado, lo que puede acelerar el proceso de generación y dar lugar a salidas más coherentes, pero también reducir la diversidad.

  • El muestreo de temperatura controla la aleatoriedad de la salida. Una temperatura más baja da como resultado salidas menos aleatorias, lo que favorece las palabras de mayor probabilidad y, por tanto, produce texto más determinista.

Establezca las topK opciones y temperature para configurar los parámetros de muestreo del modelo:

// Create a LanguageModel session and setting the topK and temperature options.
const session = await LanguageModel.create({
  topK: 10,
  temperature: 0.7
});

Clonación de una sesión para volver a iniciar la conversación con las mismas opciones

Clone una sesión existente para solicitar el modelo sin el conocimiento de las interacciones anteriores, pero con las mismas opciones de sesión.

La clonación de una sesión es útil cuando se quieren usar las opciones de una sesión anterior, pero sin influir en el modelo con respuestas anteriores.

// Create a first LanguageModel session.
const firstSession = await LanguageModel.create({
  initialPrompts: [
    role: "system",
    content: "You are a helpful assistant."
  ],
  topK: 10,
  temperature: 0.7
});

// Later, create a new session by cloning the first session to start a new
// conversation with the model, but preserve the first session's settings.
const secondSession = await firstSession.clone();

Preguntar al modelo

Para solicitar el modelo, después de crear una sesión de modelo, use los session.prompt() métodos o session.promptStreaming() .

Esperar la respuesta final

El prompt método devuelve una promesa que se resuelve una vez que el modelo ha terminado de generar texto en respuesta al mensaje:

// Create a LanguageModel session.
const session = await LanguageModel.create();

// Prompt the model and wait for the response to be generated.
const result = await session.prompt(promptString);

// Use the generated text.
console.log(result);
Mostrar tokens a medida que se generan

El promptStreaming método devuelve un objeto de secuencia de inmediato. Use la secuencia para mostrar los tokens de respuesta a medida que se generan:

// Create a LanguageModel session.
 const session = await LanguageModel.create();

// Prompt the model.
 const stream = session.promptStreaming(myPromptString);

// Use the stream object to display tokens that are generated by the model, as
// they are being generated.
for await (const chunk of stream) {
  console.log(chunk);
}

Puede llamar a los prompt métodos y promptStreaming varias veces dentro del mismo objeto de sesión para seguir generando texto basado en interacciones anteriores con el modelo dentro de esa sesión.

Restringir la salida del modelo mediante un esquema JSON o una expresión regular

Para que el formato de las respuestas del modelo sea más determinista y fácil de usar de forma programática, use la responseConstraint opción al solicitar el modelo.

La responseConstraint opción acepta un esquema JSON o una expresión regular:

  • Para que el modelo responda con un objeto JSON con cadena que sigue a un esquema determinado, establezca responseConstraint en el esquema JSON que desea usar.

  • Para que el modelo responda con una cadena que coincida con una expresión regular, establezca en responseConstraint esa expresión regular.

En el ejemplo siguiente se muestra cómo hacer que el modelo responda a un símbolo del sistema con un objeto JSON que sigue un esquema determinado:

// Create a LanguageModel session.
const session = await LanguageModel.create();

// Define a JSON schema for the Prompt API to constrain the generated response.
const schema = {
  "type": "object",
  "required": ["sentiment", "confidence"],
  "additionalProperties": false,
  "properties": {
    "sentiment": {
      "type": "string",
      "enum": ["positive", "negative", "neutral"],
      "description": "The sentiment classification of the input text."
    },
    "confidence": {
      "type": "number",
      "minimum": 0,
      "maximum": 1,
      "description": "A confidence score indicating certainty of the sentiment classification."
    }
  }
}
;

// Prompt the model, by providing a system prompt and the JSON schema in the
// responseConstraints option.
const response = await session.prompt(
  "Ordered a Philly cheesesteak, and it was not edible. Their milkshake is just milk with cheap syrup. Horrible place!",
  {
    initialPrompts: [
      {
        role: "system",
        content: "You are an AI model designed to analyze the sentiment of user-provided text. Your goal is to classify the sentiment into predefined categories and provide a confidence score. Follow these guidelines:\n\n- Identify whether the sentiment is positive, negative, or neutral.\n- Provide a confidence score (0-1) reflecting the certainty of the classification.\n- Ensure the sentiment classification is contextually accurate.\n- If the sentiment is unclear or highly ambiguous, default to neutral.\n\nYour responses should be structured and concise, adhering to the defined output schema."
      },
    ],
    responseConstraint: schema
  }
);

Al ejecutar el código anterior, se devuelve una respuesta que contiene un objeto JSON con cadena, como:

{"sentiment": "negative", "confidence": 0.95}

A continuación, puede usar la respuesta en la lógica de código mediante el análisis mediante la JSON.parse() función :

// Parse the JSON string generated by the model and extract the sentiment and
// confidence values.
const { sentiment, confidence } = JSON.parse(response);

// Use the values.
console.log(`Sentiment: ${sentiment}`);
console.log(`Confidence: ${confidence}`);

Para más información, consulte Salida estructurada con restricciones RegExp o esquema JSON.

Envío de varios mensajes por símbolo del sistema

Además de las cadenas, los prompt métodos y promptStreaming también aceptan una matriz de objetos que se usan para enviar varios mensajes con roles personalizados. Los objetos que envíe deben tener el formato { role, content }, donde role es user o assistant, y content es el mensaje.

Por ejemplo, para proporcionar varios mensajes de usuario y un mensaje de asistente en el mismo mensaje:

// Create a LanguageModel session.
const session = await LanguageModel.create();

// Prompt the model by sending multiple messages at once.
const result = await session.prompt([
  { role: "user", content: "First user message" },
  { role: "user", content: "Second user message" },
  { role: "assistant", content: "The assistant message" }
]);

Dejar de generar texto

Para anular un mensaje antes de que se haya resuelto la promesa devuelta por session.prompt() o antes de que finalice la secuencia devuelta por session.promptStreaming() , use una AbortController señal:

// Create a LanguageModel session.
const session = await LanguageModel.create();

// Create an AbortController object.
const abortController = new AbortController();

// Prompt the model by passing the AbortController object by using the signal
// option.
const stream = session.promptStreaming(myPromptString , {
  signal: abortController.signal
});

// Later, perhaps when the user presses a "Stop" button, call the abort()
// method on the AbortController object to stop generating text.
abortController.abort();

Destruir una sesión

Destruya la sesión para que el explorador sepa que ya no necesita el modelo de lenguaje, de modo que el modelo se pueda descargar de la memoria.

Puede destruir una sesión de dos maneras diferentes:

  • Mediante el destroy() método .
  • Mediante el uso de .AbortController
Destrucción de una sesión mediante el método destroy()
// Create a LanguageModel session.
const session = await LanguageModel.create();

// Later, destroy the session by using the destroy method.
session.destroy();
Destrucción de una sesión mediante Un abortController
// Create an AbortController object.
const controller = new AbortController();

// Create a LanguageModel session and pass the AbortController object by using
// the signal option.
const session = await LanguageModel.create({ signal: controller.signal });

// Later, perhaps when the user interacts with the UI, destroy the session by
// calling the abort() function of the AbortController object.
controller.abort();

Enviar comentarios

La versión preliminar del desarrollador de Prompt API está pensada para ayudar a detectar casos de uso para los modelos de lenguaje proporcionados por el explorador. Estamos muy interesados en conocer la gama de escenarios para los que tiene previsto usar la API de aviso, los problemas con la API o los modelos de lenguaje y si las nuevas API específicas de tareas, como la revisión o la traducción, serían útiles.

Para enviar comentarios sobre los escenarios y las tareas que desea lograr, agregue un comentario al problema de comentarios de Prompt API.

Si observa algún problema al usar la API en su lugar, notifíquelo en el repositorio.

También puede contribuir a la discusión sobre el diseño de prompt API en el repositorio del grupo de trabajo de W3C Web Machine Learning.

Vea también

  • Last updated on