Crea experiencias híbridas con modelos alojados en la nube y en el dispositivo


Compila apps y funciones potenciadas por IA con inferencia híbrida con Firebase AI Logic. La inferencia híbrida permite ejecutar inferencias con modelos integrados en el dispositivo cuando están disponibles y, de lo contrario, recurrir sin problemas a modelos alojados en la nube.

Con esta versión, la inferencia híbrida está disponible con el SDK cliente de Firebase AI Logic para la Web con compatibilidad con la inferencia integrada en el dispositivo para Chrome para computadoras.

Ir a los ejemplos de código

Casos de uso recomendados y funciones compatibles

Casos de uso recomendados:

  • El uso de un modelo integrado en el dispositivo para la inferencia ofrece las siguientes ventajas:

    • Privacidad mejorada
    • Contexto local
    • Inferencia sin costo
    • Funcionalidad sin conexión

  • Usar ofertas de funciones híbridas:

    • Llega al 100% de tu público, independientemente de la disponibilidad del modelo integrado en el dispositivo

Funciones y capacidades compatibles para la inferencia integrada en el dispositivo:

  • Generación de contenido de un solo turno, transmisión y sin transmisión
  • Cómo generar texto a partir de una entrada de solo texto
  • Generar texto a partir de entradas de texto e imagen, específicamente, tipos de imágenes de entrada de JPEG y PNG
  • Genera un resultado estructurado, incluidos JSON y enums

Comenzar

En esta guía, se muestra cómo comenzar a usar el SDK de Firebase AI Logic para la Web para realizar inferencia híbrida.

La inferencia con un modelo integrado en el dispositivo usa la API de Prompt de Chrome, mientras que la inferencia con un modelo alojado en la nube usa el proveedor de Gemini API que elijas (Gemini Developer API o Vertex AI Gemini API).

Paso 1: Configura Chrome y la API de Prompt para la inferencia integrada en el dispositivo

  1. Descarga la compilación más reciente de Chrome Dev.

    La inferencia integrada en el dispositivo está disponible en Chrome 138 y versiones posteriores.

  2. Para habilitar la API de Prompt en tu instancia de Chrome, establece las siguientes marcas:

    • chrome://flags/#optimization-guide-on-device-model: Se establece en Habilitado.
    • chrome://flags/#prompt-api-for-gemini-nano: Se establece en Habilitado.

    Obtén más información para usar APIs en localhost en la documentación de Chrome. De forma opcional, únete al Programa de versión preliminar temprana (EPP) de Chrome para enviar comentarios.

  3. Para habilitar el modelo multimodal integrado en el dispositivo, establece la siguiente marca:

    • chrome://flags/#prompt-api-for-gemini-nano-multimodal-input: Configúralo como Habilitado.

  4. Verifica la API de forma local:

    1. Reinicia Chrome.

    2. Abre Herramientas para desarrolladores > Consola.

    3. Ejecuta lo siguiente:

      await LanguageModel.availability();

    4. Asegúrate de que el resultado sea available, downloading o downloadable. .

    5. Si el resultado es downloadable, puedes iniciar la descarga del modelo ejecutando await LanguageModel.create();. De lo contrario, la primera solicitud para la inferencia en el dispositivo iniciará una descarga de modelo en segundo plano, lo que podría tardar varios minutos.

Paso 2: Configura un proyecto de Firebase y conecta tu app a Firebase

  1. Accede a la consola de Firebase y selecciona tu proyecto de Firebase.

  2. En la consola de Firebase, ve a la página Firebase AI Logic.

  3. Haz clic en Comenzar para iniciar un flujo de trabajo guiado que te ayudará a configurar las APIs requeridas y los recursos de tu proyecto.

  4. Selecciona el proveedor "Gemini API" que deseas usar con los SDKs de Firebase AI Logic. Si lo deseas, puedes configurar y usar el otro proveedor de API más adelante.

    • Gemini Developer API: Facturación opcional (disponible en el plan de precios sin costo de Spark)
      Console habilitará las APIs requeridas y creará una clave de API Gemini en tu proyecto. Puedes configurar la facturación más adelante si deseas actualizar tu plan de precios.

    • Vertex AI Gemini API: Facturación obligatoria (requiere el plan de precios de Blaze de pago por uso)
      La consola te ayudará a configurar la facturación y habilitar las APIs necesarias en tu proyecto.

  5. Si se te solicita en el flujo de trabajo de la consola, sigue las instrucciones en pantalla para registrar tu app y conectarla a Firebase.

  6. Continúa con el siguiente paso de esta guía para agregar el SDK a tu app.

Paso 3: Agrega el SDK

La biblioteca de Firebase proporciona acceso a las APIs para interactuar con modelos generativos. La biblioteca se incluye como parte del SDK de Firebase JavaScript para la Web.

  1. Instala el SDK de Firebase JS para la Web con npm.

    La función híbrida se lanza con una etiqueta npm diferente, por lo que asegúrate de incluirla en tu comando de instalación.

    npm install firebase@eap-ai-hybridinference

  2. Inicializa Firebase en tu app:

    import { initializeApp } from "firebase/app";

// TODO(developer) Replace the following with your app's Firebase configuration
// See: https://firebase.google.com/docs/web/learn-more#config-object
const firebaseConfig = {
  // ...
};

// Initialize FirebaseApp
const firebaseApp = initializeApp(firebaseConfig);

Paso 4: Inicializa el servicio y crea una instancia de modelo

Haz clic en tu proveedor de Gemini API para ver el contenido y el código específicos del proveedor en esta página.

Antes de enviar una instrucción a un modelo Gemini, inicializa el servicio para el proveedor de API que elegiste y crea una instancia de GenerativeModel.

Establece mode en uno de los siguientes valores:

  • prefer_on_device: Configura el SDK para que use el modelo integrado en el dispositivo si está disponible o recurra al modelo alojado en la nube.

  • only_on_device: Configura el SDK para que use el modelo integrado en el dispositivo o arroje una excepción.

  • only_in_cloud: Configura el SDK para que nunca use el modelo integrado en el dispositivo.

De forma predeterminada, cuando usas prefer_on_device o only_in_cloud, el modelo alojado en la nube es gemini-2.0-flash-lite, pero puedes anular el valor predeterminado.

import { initializeApp } from "firebase/app";
import { getAI, getGenerativeModel, GoogleAIBackend } from "firebase/ai";

// TODO(developer) Replace the following with your app's Firebase configuration
// See: https://firebase.google.com/docs/web/learn-more#config-object
const firebaseConfig = {
  // ...
};

// Initialize FirebaseApp
const firebaseApp = initializeApp(firebaseConfig);

// Initialize the Gemini Developer API backend service
const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });

// Create a `GenerativeModel` instance
// Set the mode, for example to use on-device model when possible
const model = getGenerativeModel(ai, { mode: "prefer_on_device" });

Envía una solicitud de instrucción a un modelo

En esta sección, se proporcionan ejemplos de cómo enviar varios tipos de entradas para generar diferentes tipos de salidas, incluidos los siguientes:

Si deseas generar un resultado estructurado (como JSON o enums), usa uno de los siguientes ejemplos de "generar texto" y, además, configura el modelo para que responda según un esquema proporcionado.

Genera texto a partir de una entrada de solo texto

Antes de probar este ejemplo, asegúrate de haber completado la sección Comienza ahora de esta guía.

Puedes usar generateContent() para generar texto a partir de una instrucción que contenga texto:

// Imports + initialization of FirebaseApp and backend service + creation of model instance

// Wrap in an async function so you can use await
async function run() {
  // Provide a prompt that contains text
  const prompt = "Write a story about a magic backpack."

  // To generate text output, call `generateContent` with the text input
  const result = await model.generateContent(prompt);

  const response = result.response;
  const text = response.text();
  console.log(text);
}

run();

Genera texto a partir de una entrada de texto e imagen (multimodal)

Antes de probar este ejemplo, asegúrate de haber completado la sección Comienza ahora de esta guía.

Puedes usar generateContent() para generar texto a partir de una instrucción que contiene archivos de texto e imágenes, lo que proporciona el mimeType de cada archivo de entrada y el archivo en sí.

Los tipos de imágenes de entrada admitidos para la inferencia integrada en el dispositivo son PNG y JPEG.

// Imports + initialization of FirebaseApp and backend service + creation of model instance

// Converts a File object to a Part object.
async function fileToGenerativePart(file) {
  const base64EncodedDataPromise = new Promise((resolve) => {
    const reader = new FileReader();
    reader.onloadend = () => resolve(reader.result.split(',')[1]);
    reader.readAsDataURL(file);
  });
  return {
    inlineData: { data: await base64EncodedDataPromise, mimeType: file.type },
  };
}

async function run() {
  // Provide a text prompt to include with the image
  const prompt = "Write a poem about this picture:";

  const fileInputEl = document.querySelector("input[type=file]");
  const imagePart = await fileToGenerativePart(fileInputEl.files[0]);

  // To generate text output, call `generateContent` with the text and image
  const result = await model.generateContent([prompt, imagePart]);

  const response = result.response;
  const text = response.text();
  console.log(text);
}

run();

¿Qué más puedes hacer?

Además de los ejemplos anteriores, también puedes usar modos de inferencia alternativos, anular el modelo de resguardo predeterminado y usar la configuración del modelo para controlar las respuestas.

Usa modos de inferencia alternativos

En los ejemplos anteriores, se usó el modo prefer_on_device para configurar el SDK para que use un modelo integrado en el dispositivo si está disponible o recurra a un modelo alojado en la nube. El SDK ofrece dos modos de inferencia alternativos: only_on_device y only_in_cloud.

  • Usa el modo only_on_device para que el SDK solo pueda usar un modelo integrado en el dispositivo. En esta configuración, la API mostrará un error si no hay un modelo integrado en el dispositivo disponible.

    const model = getGenerativeModel(ai, { mode: "only_on_device" });

  • Usa el modo only_in_cloud para que el SDK solo pueda usar un modelo alojado en la nube.

    const model = getGenerativeModel(ai, { mode: "only_in_cloud" });

Anula el modelo de resguardo predeterminado

Cuando uses el modo prefer_on_device, el SDK usará un modelo alojado en la nube si no hay un modelo integrado en el dispositivo disponible. El modelo predeterminado alojado en la nube es gemini-2.0-flash-lite. Este modelo alojado en la nube también es el predeterminado cuando usas el modoonly_in_cloud.

Puedes usar la opción de configuración inCloudParams para especificar un modelo alternativo predeterminado alojado en la nube:

const model = getGenerativeModel(ai, {
  mode: 'prefer_on_device',
  inCloudParams: {
    model: "gemini-2.0-flash"
  }
});

Busca los nombres de los modelos de Gemini compatibles.

Usa la configuración del modelo para controlar las respuestas

En cada solicitud a un modelo, puedes enviar una configuración del modelo para controlar cómo este genera una respuesta. Los modelos alojados en la nube y los modelos integrados en el dispositivo ofrecen diferentes opciones de configuración.

La configuración se mantiene durante el ciclo de vida de la instancia. Si quieres usar una configuración diferente, crea una instancia GenerativeModel nueva con esa configuración.

Establece la configuración de un modelo alojado en la nube

Usa la opción inCloudParams para configurar un modelo de Gemini alojado en la nube. Obtén información sobre los parámetros disponibles.

const model = getGenerativeModel(ai, {
  mode: 'prefer_on_device',
  inCloudParams: {
    model: "gemini-2.0-flash"
    temperature: 0.8,
    topK: 10
  }
});

Establece la configuración de un modelo integrado en el dispositivo

Ten en cuenta que la inferencia con un modelo integrado en el dispositivo usa la API de Prompt de Chrome.

Usa la opción onDeviceParams para configurar un modelo integrado en el dispositivo. Obtén información sobre los parámetros disponibles.

const model = getGenerativeModel(ai, {
  mode: 'prefer_on_device',
  onDeviceParams: {
    createOptions: {
      temperature: 0.8,
      topK: 8
    }
  }
});

Establece la configuración para los resultados estructurados

La generación de resultados estructurados (como JSON y enums) es compatible con la inferencia con modelos alojados en la nube y en el dispositivo.

Para la inferencia híbrida, usa inCloudParams y onDeviceParams para configurar el modelo para que responda con un resultado estructurado. Para los otros modos, usa solo la configuración aplicable.

  • Para inCloudParams: Especifica el responseMimeType apropiado (en este ejemplo, application/json), así como el responseSchema que deseas que use el modelo.

  • Para onDeviceParams: Especifica el responseConstraint que deseas que use el modelo.

Salida de JSON

En el siguiente ejemplo, se adapta el ejemplo general de salida de JSON para la inferencia híbrida:

import {
  getAI,
  getGenerativeModel,
  Schema
} from "firebase/ai";

const jsonSchema = Schema.object({
 properties: {
    characters: Schema.array({
      items: Schema.object({
        properties: {
          name: Schema.string(),
          accessory: Schema.string(),
          age: Schema.number(),
          species: Schema.string(),
        },
        optionalProperties: ["accessory"],
      }),
    }),
  }
});

const model = getGenerativeModel(ai, {
  mode: 'prefer_on_device',
  inCloudParams: {
    model: "gemini-2.0-flash"
    generationConfig: {
      responseMimeType: "application/json",
      responseSchema: jsonSchema
    },
  }
  onDeviceParams: {
    promptOptions: {
      responseConstraint: jsonSchema
    }
  }
});
Salida de enum

Como se indicó anteriormente, pero adaptando la documentación sobre la salida de enum para la inferencia híbrida:

// ...

const enumSchema = Schema.enumString({
  enum: ["drama", "comedy", "documentary"],
});

const model = getGenerativeModel(ai, {

// ...

    generationConfig: {
      responseMimeType: "text/x.enum",
      responseSchema: enumSchema
    },

// ...

Funciones aún no disponibles para la inferencia integrada en el dispositivo

Como versión experimental, no todas las funciones del SDK web están disponibles para la inferencia integrada en el dispositivo. Las siguientes funciones aún no son compatibles con la inferencia integrada en el dispositivo (pero suelen estar disponibles para la inferencia basada en la nube).

  • Generación de texto a partir de tipos de entrada de archivos de imagen distintos de JPEG y PNG

    • Puede recurrir al modelo alojado en la nube. Sin embargo, el modo only_on_device arrojará un error.

  • Generar texto a partir de entradas de audio, video y documentos (como archivos PDF)

    • Puede recurrir al modelo alojado en la nube. Sin embargo, el modo only_on_device arrojará un error.

  • Genera imágenes con modelos Gemini o Imagen

    • Puede recurrir al modelo alojado en la nube. Sin embargo, el modo only_on_device arrojará un error.

  • Proporcionar archivos con URLs en solicitudes multimodales Debes proporcionar archivos como datos intercalados a los modelos integrados en el dispositivo.

  • Chat de varios turnos

    • Puede recurrir al modelo alojado en la nube. Sin embargo, el modo only_on_device arrojará un error.

  • Transmisión bidireccional con Gemini Live API

    • Ten en cuenta que el SDK de cliente Firebase AI Logic para la Web no es compatible con esto, incluso para los modelos alojados en la nube.

  • Llamada a función

    • Disponible próximamente

  • Cuenta tokens

    • Siempre muestra un error. El recuento diferirá entre los modelos alojados en la nube y los integrados en el dispositivo, por lo que no hay un resguardo intuitivo.

  • Supervisión de IA en Firebase console para la inferencia integrada en el dispositivo

    • Ten en cuenta que cualquier inferencia que use los modelos alojados en la nube se puede supervisar al igual que otras inferencias que usan el SDK cliente de Firebase AI Logic para la Web.


Envía comentarios sobre tu experiencia con Firebase AI Logic