Twórz hybrydowe rozwiązania z modelami na urządzeniu i hostowanymi w chmurze


Tworzenie aplikacji i funkcji opartych na AI z użyciem hybrydowego wnioskowania za pomocą Firebase AI Logic. Hybrydowe wnioskowanie umożliwia uruchamianie wnioskowania z wykorzystaniem modeli na urządzeniu (jeśli są dostępne) i bezproblemowe przechodzenie do modeli hostowanych w chmurze.

W tej wersji hybrydowe wnioskowanie jest dostępne za pomocą pakietu SDK klienta Firebase AI Logic dla sieci z obsługą wnioskowania na urządzeniu w Chrome na komputery.

Przejdź do przykładów kodu

Zalecane przypadki użycia i obsługiwane funkcje

Zalecane przypadki użycia:

  • Korzystanie z modelu na urządzeniu do wnioskowania:

    • zwiększona prywatność,
    • Kontekst lokalny
    • Bezpłatne wnioskowanie
    • Funkcje offline

  • Korzystanie z funkcji hybrydowych:

    • Docieraj do 100% swoich odbiorców niezależnie od dostępności modelu urządzenia

Obsługiwane funkcje i możliwości wnioskowania na urządzeniu:

  • Generowanie treści jednoobrotowych, strumieniowych i niestrumieniowych
  • Generowanie tekstu na podstawie danych wejściowych zawierających tylko tekst
  • generowanie tekstu na podstawie tekstu i obrazu, w tym obrazów w formatach JPEG i PNG;
  • generowanie uporządkowanych danych wyjściowych, w tym w formacie JSON i enumeracji;

Rozpocznij

Z tego przewodnika dowiesz się, jak zacząć korzystać z pakietu SDK Firebase AI Logic do wykonywania hybrydowej analizy w internecie.

Wnioskowanie z wykorzystaniem modelu na urządzeniu korzysta z Prompt API w Chrome, natomiast wnioskowanie z wykorzystaniem modelu hostowanego w chmurze korzysta z wybranego przez Ciebie dostawcy Gemini API (Gemini Developer API lub Vertex AI Gemini API).

Krok 1. Skonfiguruj Chrome i Prompt API do działania na urządzeniu

  1. Pobierz najnowszą wersję Chrome Beta.

    Wnioskowanie na urządzeniu jest dostępne w Chrome w wersji 138 lub nowszej.

  2. Włącz interfejs Prompt API w swojej instancji Chrome, ustawiając te flagi:

    • chrome://flags/#optimization-guide-on-device-model: ustaw wartość Włączono.
    • chrome://flags/#prompt-api-for-gemini-nano: ustaw wartość Włączono.

    Więcej informacji o używaniu interfejsów API na localhost znajdziesz w dokumentacji Chrome. Opcjonalnie możesz dołączyć do programu wczesnego testowania Chrome (EPP), aby przesłać opinię.

  3. Aby włączyć model multimodalny na urządzeniu, ustaw tę flagę:

    • chrome://flags/#prompt-api-for-gemini-nano-multimodal-input: ustaw na Włączono.

  4. Weryfikacja interfejsu API lokalnie:

    1. Uruchom ponownie Chrome.

    2. Kliknij Narzędzia dla deweloperów > Konsola.

    3. Wykonaj zapytanie:

      await LanguageModel.availability();

    4. Upewnij się, że dane wyjściowe to available, downloading lub downloadable. .

    5. Jeśli dane wyjściowe to downloadable, możesz rozpocząć pobieranie modelu, wykonując polecenie await LanguageModel.create();. W przeciwnym razie pierwsze żądanie dotyczące wnioskowania na urządzeniu spowoduje w tle pobranie modelu, co może potrwać kilka minut.

Krok 2. Skonfiguruj projekt Firebase i połącz aplikację z Firebase.

  1. Zaloguj się w konsoli Firebase, a następnie wybierz projekt Firebase.

  2. W konsoli Firebase otwórz stronę Firebase AI Logic.

  3. Kliknij Rozpocznij, aby uruchomić skonfigurowany przepływ pracy, który pomoże Ci skonfigurować wymagane interfejsy API i zasoby dla projektu.

  4. Wybierz dostawcę „Gemini API”, którego chcesz używać z pakietami SDK Firebase AI Logic. Gemini Developer API jest zalecany dla początkujących użytkowników. Jeśli chcesz, możesz dodać dane rozliczeniowe lub skonfigurować Vertex AI Gemini APIpóźniej.

    • Gemini Developer API – opcjonalne rozliczenia (dostępne w ramach bezpłatnego planu cenowego Spark; w razie potrzeby możesz później przejść na płatny plan).
      Konsola włączy wymagane interfejsy API i utworzy w Twoim projekcie klucz interfejsu API Gemini.
      Nie dodawaj tego klucza interfejsu API Gemini do kodu aplikacji. Więcej informacji

    • Vertex AI Gemini API – wymagane rozliczenia (wymagane jest opłacanie interfejsów API na bieżąco w ramach planu Blaze).
      Konsola pomoże Ci skonfigurować rozliczenia i włączyć wymagane interfejsy API w projekcie.

  5. Jeśli w ramach procesu w konsoli pojawi się odpowiedni komunikat, postępuj zgodnie z instrukcjami wyświetlanymi na ekranie, aby zarejestrować aplikację i połączyć ją z Firebase.

  6. Aby dodać pakiet SDK do aplikacji, przejdź do następnego kroku w tym przewodniku.

Krok 3. Dodaj pakiet SDK

Biblioteka Firebase zapewnia dostęp do interfejsów API do interakcji z modelami generatywnymi. Biblioteka jest zawarta w pakiecie Firebase JavaScript SDK na potrzeby internetu.

  1. Zainstaluj pakiet Firebase JS SDK na potrzeby Internetu za pomocą npm:

    npm install --save-exact firebase@eap-ai-hybridinference

    Funkcja hybrydowa jest dostępna pod innym tagiem npm, więc pamiętaj, aby uwzględnić go w komandach instalacji.

    Tagi są implementowane jako wersje poprawek, więc flaga --save-exact informuje NPM, aby nie aktualizować automatycznie, gdy dostępna jest nowa, być może niezwiązana wersja.

  2. Inicjalizacja Firebase w aplikacji:

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

Krok 4. Inicjuj usługę i utwórz instancję modelu.

Kliknij dostawcę Gemini API, aby wyświetlić na tej stronie treści i kod związane z tym dostawcą.

Zanim wyślesz prompt do modelu Gemini, zainicjuj usługę wybranego dostawcy interfejsu API i utwórz instancję GenerativeModel.

Ustaw wartość mode na jedną z tych opcji:

  • prefer_on_device: konfiguruje pakiet SDK tak, aby używał modelu na urządzeniu, jeśli jest dostępny, lub przełączył się na model hostowany w chmurze.

  • only_on_device: konfiguruje pakiet SDK do korzystania z modelu na urządzeniu lub zgłasza wyjątek.

  • only_in_cloud: skonfiguruj pakiet SDK tak, aby nigdy nie używał modelu na urządzeniu.

Domyślnie, gdy używasz prefer_on_device lub only_in_cloud, model hostowany w chmurze ma wartość gemini-2.0-flash-lite, ale możesz zastąpić ustawienie domyślne.

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

Wysyłanie żądania prompta do modelu

W tej sekcji znajdziesz przykłady przesyłania różnych typów danych wejściowych w celu generowania różnych typów danych wyjściowych, w tym:

Jeśli chcesz wygenerować dane wyjściowe w uporządkowanej formie (np. w formacie JSON lub enum), użyj jednego z tych przykładów „generowania tekstu” i dodatkowo skonfiguruj model, aby odpowiadał zgodnie z dostarczonym schematem.

Generowanie tekstu na podstawie danych wejściowych zawierających tylko tekst

Zanim spróbujesz użyć tego przykładu, przeczytaj sekcję Wprowadzenie w tym przewodniku.

Możesz użyć generateContent() do wygenerowania tekstu z prompta zawierającego tekst:

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

Generowanie tekstu na podstawie danych multimodalnych (tekstowo-obrazowych)

Zanim spróbujesz użyć tego przykładu, przeczytaj sekcję Wprowadzenie w tym przewodniku.

Możesz użyć prompta generateContent(), aby wygenerować tekst z prompta zawierającego pliki tekstowe i obrazowe. W tym celu podaj mimeType każdego pliku wejściowego oraz sam plik.

Obsługiwane typy obrazów wejściowych do wnioskowania na urządzeniu to PNG i 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();

Co jeszcze możesz zrobić?

Oprócz powyższych przykładów możesz też użyć alternatywnych trybów wnioskowania, zastąpić domyślny model zapasowy i skonfigurować model, aby kontrolować odpowiedzi.

Używanie alternatywnych trybów wnioskowania

W przykladach powyżej użyto trybu prefer_on_device, aby skonfigurować pakiet SDK do używania modelu na urządzeniu (jeśli jest dostępny) lub do korzystania z modelu hostowanego w chmurze. Pakiet SDK oferuje 2 alternatywne tryby wnioskowania: only_on_device i only_in_cloud.

  • Użyj trybu only_on_device, aby pakiet SDK mógł korzystać tylko z modelu na urządzeniu. W tej konfiguracji interfejs API zwróci błąd, jeśli model na urządzeniu jest niedostępny.

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

  • Użyj trybu only_in_cloud, aby pakiet SDK mógł korzystać tylko z modelu hostowanego w chmurze.

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

Zastępowanie domyślnego modelu zastępczego

Jeśli używasz trybu prefer_on_device, pakiet SDK użyje modelu hostowanego w chmurze, jeśli model na urządzeniu jest niedostępny. Domyślny model zapasowy hostowany w chmurze to gemini-2.0-flash-lite. Ten model hostowany w chmurze jest też domyślnie używany w trybie only_in_cloud.

Opcję konfiguracji inCloudParams możesz użyć, aby określić alternatywny domyślny model hostowany w chmurze:

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

Znajdź nazwy wszystkich obsługiwanych modeli Gemini.

Używanie konfiguracji modelu do kontrolowania odpowiedzi

W każdym żądaniu wysłanym do modelu możesz dołączyć konfigurację modelu, aby określić, jak model ma generować odpowiedź. Modele hostowane w chmurze i modele na urządzeniu oferują różne opcje konfiguracji.

Konfiguracja jest utrzymywana przez cały okres istnienia instancji. Jeśli chcesz użyć innej konfiguracji, utwórz nową instancję GenerativeModel z tą konfiguracją.

Konfigurowanie modelu hostowanego w chmurze

Aby skonfigurować model Gemini hostowany w chmurze, użyj opcji inCloudParams. Dowiedz się więcej o dostępnych parametrach.

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

Konfigurowanie modelu na urządzeniu

Pamiętaj, że wnioskowanie z użyciem modelu na urządzeniu korzysta z interfejsu Prompt API w Chrome.

Aby skonfigurować model na urządzeniu, użyj opcji onDeviceParams. Dowiedz się więcej o dostępnych parametrach.

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

Konfigurowanie danych uporządkowanych

Generowanie uporządkowanych danych wyjściowych (np. w formacie JSON i enum) jest obsługiwane w przypadku wnioskowania z wykorzystaniem modeli hostowanych w chmurze i na urządzeniu.

W przypadku hybrydowego wnioskowania użyj zarówno parametru inCloudParams, jak i onDeviceParams, aby skonfigurować model w taki sposób, aby odpowiadał w formie danych ustrukturyzowanych. W przypadku innych trybów użyj tylko odpowiedniej konfiguracji.

  • W przypadku inCloudParams: podaj odpowiednią wartość responseMimeType (w tym przykładzie application/json) oraz wartość responseSchema, której model ma używać.

  • W przypadku onDeviceParams: podaj responseConstraint, którego ma używać model.

Dane wyjściowe JSON

W tym przykładzie ogólny przykład danych wyjściowych w formacie JSON jest dostosowany do hybrydowego wnioskowania:

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.5-flash"
    generationConfig: {
      responseMimeType: "application/json",
      responseSchema: jsonSchema
    },
  }
  onDeviceParams: {
    promptOptions: {
      responseConstraint: jsonSchema
    }
  }
});
Wyjście typu wyliczeniowego

Podobnie jak wyżej, ale w przypadku wnioskowania hybrydowego dostosuj dokumentację dotyczącą wyjścia enum:

// ...

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

const model = getGenerativeModel(ai, {

// ...

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

// ...

Funkcje, które nie są jeszcze dostępne na potrzeby wnioskowania na urządzeniu

Ponieważ jest to wersja eksperymentalna, nie wszystkie funkcje pakietu SDK na potrzeby Internetu są dostępne do korzystania z inferencji na urządzeniu. Te funkcje nie są jeszcze obsługiwane w ramach wnioskowania na urządzeniu (ale są zwykle dostępne w przypadku wnioskowania w chmurze).

  • Generowanie tekstu na podstawie plików obrazów innych niż JPEG i PNG

    • Może wrócić do modelu hostowanego w chmurze. Tryb only_on_device spowoduje jednak błąd.

  • generowanie tekstu na podstawie danych wejściowych w postaci dźwięku, wideo i dokumentów (np. plików PDF);

    • Może korzystać z modelu hostowanego w chmurze, ale tryb only_on_device spowoduje błąd.

  • generowanie obrazów za pomocą modeli Gemini lub Imagen,

    • Może wrócić do modelu hostowanego w chmurze. Tryb only_on_device spowoduje jednak błąd.

  • Przesyłanie plików za pomocą adresów URL w żądaniach multimodalnych. Musisz przesłać pliki jako dane wbudowane w modele na urządzeniu.

  • Czat wieloetapowy

    • Może korzystać z modelu hostowanego w chmurze, ale tryb only_on_device spowoduje błąd.

  • Transmisja dwukierunkowa z urządzeniem Gemini Live API

    • Pamiętaj, że pakiet SDK klienta Firebase AI Logic na potrzeby przeglądarki nie obsługuje tej funkcji nawet w przypadku modeli hostowanych w chmurze.

  • Wywoływanie funkcji

    • Już wkrótce!

  • Liczba tokenów

    • Zawsze zwraca błąd. Liczba wyświetleń będzie się różnić w przypadku modeli hostowanych w chmurze i na urządzeniu, więc nie ma intuicyjnego rozwiązania zastępczego.

  • Monitorowanie AI w konsoli Firebase do wnioskowania na urządzeniu.

    • Pamiętaj, że wszelkie wnioskowanie z użyciem modeli hostowanych w chmurze można monitorować tak samo jak inne wnioskowanie z użyciem pakietu SDK klientaFirebase AI Logic na potrzeby sieci.


Przesłanie opinii o użytkowaniu usługi Firebase AI Logic