Solicitar um modelo de linguagem interno com a API de Prompt

A API de prompt é uma API Web experimental que permite solicitar um modelo de linguagem pequena (SLM) integrado ao Microsoft Edge, do código JavaScript do seu site ou extensão do navegador. Use a API de prompt para gerar e analisar texto ou criar lógica de aplicativo com base na entrada do usuário e descubra maneiras inovadoras de integrar recursos de engenharia de prompt ao seu aplicativo da web.

Conteúdo detalhado:

Disponibilidade da API de prompt

A API de prompt está disponível como uma versão prévia do desenvolvedor nos canais do Microsoft Edge Canary e do Edge Dev, começando com a versão 138.0.3309.2.

A API de prompt destina-se a ajudar a descobrir casos de uso e entender os desafios para SLMs integrados. Espera-se que essa API seja sucedida por outras APIs experimentais para tarefas específicas baseadas em IA, como assistência de escrita e tradução de texto. Para saber mais sobre essas outras APIs, confira:

Alternativas e benefícios da API de prompt

Para aproveitar os recursos de IA em sites e extensões de navegador, você também pode usar os seguintes métodos:

A API de prompt usa um SLM que é executado no mesmo dispositivo em que as entradas e saídas do modelo são usadas (ou seja, localmente). Isso tem os seguintes benefícios em comparação com soluções baseadas em nuvem:

  • Custo reduzido: Não há nenhum custo associado ao uso de um serviço de IA na nuvem.

  • Independência de rede: Além do download inicial do modelo, não há latência de rede ao solicitar o modelo e também pode ser usado quando o dispositivo está offline.

  • Privacidade aprimorada: A entrada de dados para o modelo nunca sai do dispositivo e não é coletada para treinar modelos de IA.

A API de prompt usa um modelo fornecido pelo Microsoft Edge e integrado ao navegador, que vem com benefícios adicionais em relação a soluções locais personalizadas, como aquelas baseadas em WebGPU, WebNN ou WebAssembly:

  • Custo único compartilhado: O modelo fornecido pelo navegador é baixado na primeira vez que a API é chamada e compartilhada em todos os sites executados no navegador, reduzindo os custos de rede para o usuário e o desenvolvedor.

  • Uso simplificado para desenvolvedores da Web: O modelo interno pode ser executado usando APIs Web simples e não requer experiência em IA/ML ou estruturas de terceiros.

Pequenos modelos de linguagem integrados ao Microsoft Edge

Nos canais Canary e Dev do Microsoft Edge, a partir da versão 138.0.3309.2, a API de prompt usa o modelo Phi-4-mini, que é integrado ao Microsoft Edge.

A partir da versão 150.0.4070, a API de Prompt também pode ser usada com o modelo de pré-lançamento do Aion-1.0-Instruct, que também é integrado ao Microsoft Edge. O Aion-1.0-Instruct é um modelo menor, mais rápido e mais eficiente do que o Phi-4-mini, e é compatível com dispositivos com GPUs menos compatíveis ou sem GPU, por meio de inferência de CPU. Se a classe de desempenho do seu dispositivo não for alta o suficiente para suportar o Phi-4-mini, você poderá testar o modelo de pré-lançamento do Aion-1.0-Instruct.

Para saber mais sobre os dois modelos e como habilitar o Aion-1.0-Instruct, leia as seções abaixo.

O modelo Phi-4-mini

A API de prompt permite que você faça prompts para o Phi-4-mini, que é integrado ao Microsoft Edge. O Phi-4-mini é um poderoso modelo de linguagem pequena que se destaca em tarefas baseadas em texto. Para saber mais sobre o Phi-4-mini e seus recursos, consulte o modelo de card em microsoft/Phi-4-mini-instruct.

Aviso de isenção

Como outros modelos de linguagem, a família de modelos Phi pode se comportar de maneiras injustas, não confiáveis ou ofensivas. Para saber mais sobre as considerações de IA do modelo, consulte Considerações sobre IA responsável.

Requisitos de hardware

A visualização do desenvolvedor da API de prompt destina-se a funcionar em dispositivos com recursos de hardware que produzem saídas SLM com qualidade e latência previsíveis. No momento, a API de prompt está limitada a:

  • Sistema operacional: Windows 10 ou 11 e macOS 13.3 ou posterior.

  • Armazenamento: Pelo menos 20 GB disponíveis no volume que contém seu perfil do Edge. Se o armazenamento disponível cair abaixo de 10 GB, o modelo será excluído para garantir que outros recursos do navegador tenham espaço suficiente para funcionar.

  • GPU: 5,5 GB de VRAM ou mais.

  • Rede: Plano de dados ilimitado ou conexão ilimitada. O modelo não será baixado se estiver usando uma conexão limitada.

Para marcar se o dispositivo dá suporte à visualização do desenvolvedor da API de prompt, consulte Habilitar a API de prompt abaixo e marcar a classe de desempenho do dispositivo.

Devido à natureza experimental da API de prompt, você pode observar problemas em configurações de hardware específicas. Se você encontrar problemas em configurações de hardware específicas, forneça comentários abrindo um novo problema no repositório MSEdgeExplainers.

Disponibilidade do modelo Phi-4-mini

Um download inicial do modelo Phi-4-mini é necessário na primeira vez que um site chama uma API que requer um modelo no dispositivo. Você pode monitorar o download do modelo Phi-4-mini usando a opção de monitor ao criar uma nova sessão de API de Prompt. Para saber mais, consulte Monitorar o progresso do download do modelo, abaixo.

O modelo Aion-1.0-Instruct

No Microsoft Edge Canary ou Edge Dev, a partir da versão 150.0.4070, a API de prompt também pode ser usada com o modelo de pré-lançamento do Aion-1.0-Instruct, que é integrado ao Microsoft Edge.

Este modelo Aion-1.0-Instruct é significativamente menor, mais rápido e mais eficiente do que o Phi-4-mini, e é suportado em dispositivos com GPUs menos capazes ou sem GPU, por meio de inferência de CPU.

Espera-se que o Aion-1.0-Instruct seja disponibilizado como um modelo de código aberto em julho de 2026.

Habilitar o Aion-1.0-Instruct para a API de prompt

Por padrão, a API de Prompt usa o modelo Phi-4-mini. Para usar o Aion-1.0-Instruct no Microsoft Edge Canary ou Edge Dev, habilite o sinalizador de modelo de idioma no dispositivo para habilitar pré-lançamento, conforme descrito nas etapas abaixo. Quando esse sinalizador está habilitado, o Aion-1.0-Instruct substitui o Phi-4-mini como o modelo padrão para a API de Prompt.

  1. Verifique se você está usando a versão mais recente do Edge Canary ou Edge Dev (versão 150.0.4070 ou posterior). Consulte Torne-se um Microsoft Edge Insider.

  2. No Edge Canary ou Edge Dev, abra uma nova guia ou janela e vá para edge://flags.

  3. Na caixa de pesquisa na parte superior da página, insira Habilitar modelo de idioma de pré-lançamento no dispositivo.

  4. Na lista suspensa Habilitar modelo de idioma no dispositivo de pré-lançamento , selecione Habilitado e clique no botão Reiniciar :

    Página Sinalizadores mostrando o sinalizador do modelo de idioma no dispositivo de pré-lançamento

  5. Para marcar se o Aion-1.0-Instruct está sendo usado como o modelo de idioma no dispositivo, vá para edge://on-device-internals, clique em Status do modelo e marque se o Nome do modelo está definido como Aion-1.0-Instruct.

Aviso de isenção

O modelo Aion-1.0-Instruct é disponibilizado no Microsoft Edge 150.0.4070 para testes e comentários antecipados do desenvolvedor. Além das considerações de IA Responsável listadas acima, observe que, devido ao seu estado de pré-lançamento, os comportamentos e capacidades do modelo estão sujeitos a alterações.

Disponibilidade do modelo Aion-1.0-Instruct

Um download inicial do modelo Aion-1.0-Instruct é necessário na primeira vez que um site chama uma API que requer um modelo no dispositivo. Você pode monitorar o download do modelo Aion-1.0-Instruct usando a opção de monitor ao criar uma nova sessão da API de Prompt. Para saber mais, consulte Monitorar o progresso do download do modelo, abaixo.

Habilitar a API de prompt

Para usar a API de prompt no Microsoft Edge:

  1. Verifique se você está usando a versão mais recente do Microsoft Edge Canary ou Edge Dev (versão 138.0.3309.2 ou posterior). Consulte Torne-se um Microsoft Edge Insider.

  2. No Edge Canary ou Edge Dev, abra uma nova guia ou janela e vá para edge://flags/.

  3. Na caixa de pesquisa, na parte superior da página, insira Prompt API para o modelo de idioma no dispositivo.

    A página é filtrada para mostrar o sinalizador correspondente.

  4. Em API de prompt para modelo de idioma no dispositivo, selecione Habilitado:

    Página Sinalizadores do navegador

  5. Opcionalmente, para registrar informações localmente que podem ser úteis para problemas de depuração, habilite também o sinalizador Habilitar logs de depuração do modelo de IA no dispositivo .

  6. Reinicie o Edge Canary ou o Edge Dev.

  7. Para marcar se o dispositivo atende aos requisitos de hardware para a visualização do desenvolvedor da API de Prompt, abra uma nova guia, acesse edge://on-device-internalse marque o valor da classe de desempenho do dispositivo.

    Se a classe de desempenho do dispositivo for alta ou superior, a API de prompt deverá ter suporte em seu dispositivo.

    Se a classe de desempenho do dispositivo for Média ou Baixa, a API de prompt só terá suporte por meio do modelo de pré-lançamento do Aion-1.0-Instruct, que está disponível a partir da versão 150.0.4070 do Edge. Para testar o modelo Aion-1.0-Instruct, consulte Habilitar o Aion-1.0-Instruct para a API de prompt, acima.

    Se você notar problemas com esses modelos, crie um novo problema no repositório MSEdgeExplainers.

Veja um exemplo de trabalho

Para ver a API de prompt em ação e examinar o código existente que usa a API:

  1. Habilite a API de prompt, conforme descrito acima.

  2. No Edge Canary ou Edge Dev, abra uma guia ou janela e vá para o playground da API de prompt.

    Na navegação de playgrounds de IA integrada à esquerda, Prompt está selecionado.

  3. Na faixa de informações na parte superior, marque o status: inicialmente lê-se Download do modelo, aguarde:

    Indicador de status mostrando o progresso do download do modelo

    Depois que o modelo for baixado, o banner de informações indicará API e modelo prontos, indicando que a API e o modelo podem ser usados:

    Indicador de status mostrando a API e o modelo prontos

    Se o download do modelo não iniciar, reinicie o Microsoft Edge e tente novamente.

    A API de prompt só tem suporte em dispositivos que atendem a determinados requisitos de hardware. Para obter mais informações, consulte Requisitos de hardware, acima.

  4. Opcionalmente, altere os valores de configurações de prompt, como:

    • Prompt de usuário
    • Prompt do sistema
    • Esquema de restrição de resposta
    • Mais configurações>Instruções de prompt N-shot

  5. Clique no botão Avisar , na parte inferior da página.

    A resposta é gerada na seção de resposta da página:

    A página de demonstração Prompt com configurações e um botão Prompt

  6. Para parar de gerar a resposta, a qualquer momento, clique no botão Parar .

Veja também:

Usar a API de prompt

Verificar se a API está habilitada

Antes de usar a API no código do seu site ou extensão, marque se a API está habilitada testando a presença do LanguageModel objeto:

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

Verifique se o modelo pode ser usado

A API de prompt só poderá ser usada se o dispositivo der suporte à execução do modelo e depois que o modelo de idioma e o tempo de execução do modelo tiverem sido baixados pelo Microsoft Edge.

Para marcar se a API pode ser usada, use o 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.
}

Criar uma nova sessão

A criação de uma sessão instrui o navegador a carregar o modelo de linguagem na memória, para que ele possa ser usado. Antes de solicitar o modelo de linguagem, crie uma nova sessão usando o create() método:

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

Para personalizar a sessão de modelo, você pode passar opções para o create() método:

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

As opções disponíveis são:

  • monitor, para acompanhar o progresso do download do modelo.

  • initialPrompts, para fornecer o contexto do modelo sobre os prompts que serão enviados ao modelo e para estabelecer um padrão de interações usuário/assistente que o modelo deve seguir para prompts futuros.

Essas opções estão documentadas abaixo.

Monitorar o progresso do download do modelo

Você pode acompanhar o progresso do download do modelo usando a monitor opção. Isso é útil quando o modelo ainda não foi totalmente baixado no dispositivo em que será usado, para informar aos usuários do seu site que eles devem 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;
      }
    });
  }
});
Forneça ao modelo um prompt do sistema

Para definir um prompt do sistema, que é uma maneira de fornecer instruções ao modelo a serem usadas ao gerar texto em resposta a um prompt, use a initialPrompts opção.

O prompt do sistema fornecido ao criar uma nova sessão é preservado por toda a existência da sessão, mesmo que a janela de contexto seja excedida devido a muitos prompts.

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

Colocar o { role: "system", content: "You are a helpful assistant." } prompt em qualquer lugar além da 0ª posição em initialPrompts rejeitará com um TypeError.

Solicitação N-shot com initialPrompts

A initialPrompts opção também permite que você forneça exemplos de interações usuário/assistente que você deseja que o modelo continue usando quando solicitado.

Essa técnica também é conhecida como prompt N-shot e é útil para tornar as respostas geradas pelo modelo mais determinísticas.

// 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" }
  ]
});

Clone uma sessão para iniciar a conversa novamente com as mesmas opções

Clone uma sessão existente para solicitar o modelo sem o conhecimento das interações anteriores, mas com as mesmas opções de sessão.

A clonagem de uma sessão é útil quando você deseja usar as opções de uma sessão anterior, mas sem influenciar o modelo com respostas anteriores.

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

// 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();

Solicitar o modelo

Para solicitar o modelo, depois de criar uma sessão de modelo, use os session.prompt() métodos ou session.promptStreaming() .

Aguarde a resposta final

O prompt método retorna uma promessa que é resolvida quando o modelo termina de gerar texto em resposta ao prompt:

// 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);
Exibir tokens à medida que são gerados

O promptStreaming método retorna um objeto de fluxo imediatamente. Use o fluxo para exibir os tokens de resposta à medida que eles estão sendo gerados:

// 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);
}

Você pode chamar os prompt métodos and promptStreaming várias vezes no mesmo objeto de sessão para continuar gerando texto com base em interações anteriores com o modelo nessa sessão.

Restrinja a saída do modelo usando um esquema JSON ou uma expressão regular

Para tornar o formato das respostas do modelo mais determinístico e fácil de usar de maneira programática, use a responseConstraint opção ao solicitar o modelo.

A responseConstraint opção aceita um esquema JSON ou uma expressão regular:

  • Para fazer o modelo responder com um objeto JSON stringificado que segue um determinado esquema, defina responseConstraint o esquema JSON que você deseja usar.

  • Para fazer o modelo responder com uma cadeia de caracteres que corresponda a uma expressão regular, defina responseConstraint como essa expressão regular.

O exemplo a seguir mostra como fazer o modelo responder a um prompt com um objeto JSON que segue um determinado esquema:

// 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
  }
);

A execução do código acima retorna uma resposta que contém um objeto JSON stringificado, como:

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

Em seguida, você pode usar a resposta em sua lógica de código analisando-a usando a JSON.parse() função:

// 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}`);
Enviar várias mensagens por prompt

Além das cadeias de caracteres, os prompt métodos and promptStreaming também aceitam uma matriz de objetos usada para enviar várias mensagens com funções personalizadas. Os objetos enviados devem estar no formato { role, content }, em que role is ou userassistant, e content é a mensagem.

Por exemplo, para fornecer várias mensagens de usuário e uma mensagem de assistente no mesmo prompt:

// 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" }
]);

Parar a geração de texto

Para anular um prompt antes que a promessa retornada por session.prompt() tenha sido resolvida ou antes que o fluxo retornado por session.promptStreaming() tenha terminado, use um AbortController sinal:

// 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 uma sessão

Destrua a sessão para que o navegador saiba que você não precisa mais do modelo de linguagem, para que o modelo possa ser descarregado da memória.

Você pode destruir uma sessão de duas maneiras diferentes:

  • Usando o destroy() método.
  • Ao usar um AbortControllerarquivo .
Destrua uma sessão usando o método destroy()
// Create a LanguageModel session.
const session = await LanguageModel.create();

// Later, destroy the session by using the destroy method.
session.destroy();
Destrua uma sessão usando um 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 comentários

A visualização do desenvolvedor da API de prompt destina-se a ajudar a descobrir casos de uso para modelos de idioma fornecidos pelo navegador.

Estamos interessados em aprender sobre:

  • O intervalo de cenários para os quais você pretende usar a API de prompt.
  • Qualquer problema com a API de prompt.
  • Quaisquer problemas com os modelos de linguagem.
  • Se novas APIs específicas de tarefas seriam úteis.

Para enviar comentários sobre seus cenários e as tarefas que você deseja realizar, adicione um comentário ao problema de comentários da API de Prompt.

Se você notar algum problema ao usar a API, informe-o no repositório.

Você também pode contribuir para a discussão sobre o design da API de prompt no repositório do Grupo de Trabalho de Aprendizado de Máquina da Web do W3C.

Confira também

  • Last updated on