Diese Seite wurde von der Cloud Translation API übersetzt.

Hybride Lösungen mit On-Device- und Cloud-gehosteten Modellen erstellen

Mit Firebase AI Logic KI-gestützte Apps und Funktionen mit Hybrid-Inferenz erstellen. Mit der hybriden Inferenz können Sie Inferenz mit On-Device-Modellen ausführen, wenn diese verfügbar sind, und nahtlos auf cloudbasierte Modelle zurückgreifen, wenn nicht.

Mit dieser Version ist die hybride Inferenz mit dem Firebase AI Logic-Client-SDK für Web verfügbar. Sie unterstützt die Inferenz auf dem Gerät für Chrome auf dem Desktop.

Zu den Codebeispielen springen

Empfohlene Anwendungsfälle und unterstützte Funktionen

Empfohlene Anwendungsfälle:

Die Verwendung eines On-Device-Modells für die Inferenz bietet folgende Vorteile:
- Besserer Datenschutz
- Lokaler Kontext
- Kostenlose Inferenz
- Offlinefunktionen
Vorteile der Hybridfunktionen:
- 100% Ihrer Zielgruppe erreichen, unabhängig von der Verfügbarkeit von On-Device-Modellen

Unterstützte Funktionen und Features für die Inferenz auf dem Gerät:

Inhaltsgenerierung in einem Durchgang, Streaming und Nicht-Streaming
Text aus reinen Texteingaben generieren
Text aus Text- und Bildeingaben generieren, insbesondere aus Eingabebildern im JPEG- und PNG-Format
Strukturierte Ausgabe generieren, einschließlich JSON und Enums

Jetzt starten

In dieser Anleitung erfahren Sie, wie Sie mit dem Firebase AI Logic SDK für Web Hybrid Inference ausführen.

Für die Inferenz mit einem On-Device-Modell wird die Prompt API von Chrome verwendet. Für die Inferenz mit einem in der Cloud gehosteten Modell wird der von Ihnen ausgewählte Gemini API-Anbieter (entweder Gemini Developer API oder Vertex AI Gemini API) verwendet.

Schritt 1: Chrome und die Prompt API für die On-Device-Inferenz einrichten

Laden Sie den aktuellen Chrome Beta-Build herunter.

Die Inferenz auf dem Gerät ist ab Chrome 138 und höher verfügbar.
Aktivieren Sie die Prompt API für Ihre Chrome-Instanz, indem Sie die folgenden Flags festlegen:
- chrome://flags/#optimization-guide-on-device-model: Auf Aktiviert festgelegt.
- chrome://flags/#prompt-api-for-gemini-nano: Auf Aktiviert festgelegt.
Weitere Informationen zur Verwendung von APIs auf localhost finden Sie in der Chrome-Dokumentation. Optional können Sie am Chrome Early Preview Program (EPP) teilnehmen, um Feedback zu geben.
Aktivieren Sie das multimodale On-Device-Modell, indem Sie das folgende Flag festlegen:
- chrome://flags/#prompt-api-for-gemini-nano-multimodal-input: Auf Aktiviert festgelegt.
API lokal testen:
1. Starten Sie Chrome neu.
2. Öffnen Sie die Entwicklertools > Konsole.
3. Führen Sie den folgenden Befehl aus:
```
await LanguageModel.availability();
```
4. Achten Sie darauf, dass die Ausgabe available, downloading oder downloadable ist. .
5. Wenn die Ausgabe downloadable ist, können Sie den Modell-Download mit await LanguageModel.create(); starten. Andernfalls wird bei der ersten Anfrage für die Inferenz auf dem Gerät ein Modelldownload im Hintergrund gestartet, der mehrere Minuten dauern kann.

Schritt 2: Firebase-Projekt einrichten und App mit Firebase verbinden

Melden Sie sich in der Firebase Console an und wählen Sie Ihr Firebase-Projekt aus.
Sie haben noch kein Firebase-Projekt?

Wenn Sie noch kein Firebase-Projekt haben, klicken Sie auf Projekt erstellen und verwenden Sie eine der folgenden Optionen:
- Option 1: Erstellen Sie ein völlig neues Firebase-Projekt (und das zugrunde liegende Google Cloud-Projekt automatisch), indem Sie im ersten Schritt des Workflows „Projekt erstellen“ einen neuen Projektnamen eingeben.
- Option 2: Fügen Sie einem vorhandenen Google Cloud-Projekt Firebase hinzu, indem Sie im Drop-down-Menü im ersten Schritt des Workflows „Projekt erstellen“ den Namen Ihres Google Cloud-Projekts auswählen.
Wenn Sie dazu aufgefordert werden, müssen Sie nicht Google Analytics einrichten, um die Firebase AI Logic-SDKs zu verwenden.
Rufen Sie in der Firebase Console die Seite Firebase AI Logic auf.
Klicken Sie auf Jetzt starten, um einen geführten Workflow zu starten, der Sie beim Einrichten der erforderlichen APIs und Ressourcen für Ihr Projekt unterstützt.
Wählen Sie den Gemini API-Anbieter aus, den Sie mit den Firebase AI Logic-SDKs verwenden möchten. Sie können den anderen API-Anbieter jederzeit später einrichten und verwenden.
- Gemini Developer API – Abrechnung optional (verfügbar im kostenlosen Spark-Tarif. Sie können später ein Upgrade durchführen, wenn Sie möchten)
  In der Console werden die erforderlichen APIs aktiviert und ein Gemini-API-Schlüssel in Ihrem Projekt erstellt.
  Fügen Sie diesen Gemini-API-Schlüssel nicht in den Code Ihrer App ein. Weitere Informationen
- Vertex AI Gemini API – Abrechnung erforderlich (erfordert den Blaze-Tarif mit nutzungsabhängiger Abrechnung)
  In der Console können Sie die Abrechnung einrichten und die erforderlichen APIs in Ihrem Projekt aktivieren.
Folgen Sie der Anleitung auf dem Bildschirm, um Ihre App zu registrieren und mit Firebase zu verbinden.
Fahren Sie mit dem nächsten Schritt in dieser Anleitung fort, um das SDK Ihrer App hinzuzufügen.

Schritt 3: SDK hinzufügen

Die Firebase-Bibliothek bietet Zugriff auf die APIs für die Interaktion mit generativen Modellen. Die Bibliothek ist im Firebase JavaScript SDK für Web enthalten.

Installieren Sie das Firebase JS SDK für Web mit npm.

Die Hybridfunktion wird unter einem anderen npm-Tag veröffentlicht. Achten Sie also darauf, dass Sie sie in Ihren Installationsbefehl aufnehmen.
```
npm install firebase@eap-ai-hybridinference
```

Firebase in Ihrer App initialisieren:

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

Schritt 4: Dienst initialisieren und Modellinstanz erstellen

Klicken Sie auf Ihren Gemini API-Anbieter, um anbieterspezifische Inhalte und Code auf dieser Seite aufzurufen.

Bevor Sie einen Prompt an ein Gemini-Modell senden, initialisieren Sie den Dienst für den ausgewählten API-Anbieter und erstellen Sie eine GenerativeModel-Instanz.

Legen Sie den Wert mode auf einen der folgenden Werte fest:

prefer_on_device: Konfiguriert das SDK so, dass das On-Device-Modell verwendet wird, sofern es verfügbar ist. Andernfalls wird auf das in der Cloud gehostete Modell zurückgegriffen.
only_on_device: Konfiguriert das SDK so, dass das On-Device-Modell verwendet wird oder eine Ausnahme ausgelöst wird.
only_in_cloud: Konfiguriert das SDK so, dass das On-Device-Modell nie verwendet wird.

Wenn Sie prefer_on_device oder only_in_cloud verwenden, ist das in der Cloud gehostete Modell standardmäßig gemini-2.0-flash-lite. Sie können den Standardwert überschreiben.

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

Prompt-Anfrage an ein Modell senden

In diesem Abschnitt finden Sie Beispiele dafür, wie Sie verschiedene Arten von Eingaben senden, um verschiedene Arten von Ausgaben zu generieren, darunter:

Text aus reinen Texteingaben generieren
Text aus multimodalen Eingaben (Text und Bild) generieren

Wenn Sie strukturierte Ausgaben (z. B. JSON oder Enums) generieren möchten, verwenden Sie eines der folgenden Beispiele für „Text generieren“ und konfigurieren Sie das Modell zusätzlich so, dass es gemäß einem bereitgestellten Schema antwortet.

Text aus reinen Texteingaben generieren

Bevor Sie dieses Beispiel ausprobieren, müssen Sie den Abschnitt Erste Schritte dieser Anleitung durchgearbeitet haben.

Sie können generateContent() verwenden, um Text aus einem Prompt zu generieren, der Text enthält:

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

Text aus multimodalen Eingaben (Text und Bild) generieren

Bevor Sie dieses Beispiel ausprobieren, müssen Sie den Abschnitt Erste Schritte dieser Anleitung durchgearbeitet haben.

Mit generateContent() können Sie Text aus einem Prompt generieren, der Text- und Bilddateien enthält. Geben Sie dazu für jede Eingabedatei den mimeType und die Datei selbst an.

Die unterstützten Eingabebildtypen für die Inferenz auf dem Gerät sind PNG und 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();

Was kannst du sonst noch tun?

Zusätzlich zu den oben genannten Beispielen können Sie auch alternative Inferenzmodi verwenden, das Standard-Fallbackmodell überschreiben und die Modellkonfiguration verwenden, um Antworten zu steuern.

Alternative Inferenzmodi verwenden

In den obigen Beispielen wurde der prefer_on_device-Modus verwendet, um das SDK so zu konfigurieren, dass ein On-Device-Modell verwendet wird, sofern verfügbar, oder auf ein in der Cloud gehostetes Modell zurückgegriffen wird. Das SDK bietet zwei alternative Inferenzmodi: only_on_device und only_in_cloud.

Verwenden Sie den Modus only_on_device, damit das SDK nur ein On-Device-Modell verwenden kann. In dieser Konfiguration gibt die API einen Fehler aus, wenn kein On-Device-Modell verfügbar ist.
```
const model = getGenerativeModel(ai, { mode: "only_on_device" });
```
Verwenden Sie den Modus only_in_cloud, damit das SDK nur ein in der Cloud gehostetes Modell verwenden kann.
```
const model = getGenerativeModel(ai, { mode: "only_in_cloud" });
```

Standard-Fallback-Modell überschreiben

Wenn Sie den prefer_on_device-Modus verwenden, greift das SDK auf ein in der Cloud gehostetes Modell zurück, wenn kein Modell auf dem Gerät verfügbar ist. Das standardmäßige cloudbasierte Fallback-Modell ist gemini-2.0-flash-lite. Dieses in der Cloud gehostete Modell ist auch die Standardeinstellung, wenn Sie den Modus only_in_cloud verwenden.

Mit der Konfigurationsoption inCloudParams können Sie ein alternatives standardmäßiges cloudbasiertes Modell angeben:

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

Hier finden Sie die Modellnamen für alle unterstützten Gemini-Modelle.

Antworten mit der Modellkonfiguration steuern

In jeder Anfrage an ein Modell können Sie eine Modellkonfiguration senden, um zu steuern, wie das Modell eine Antwort generiert. Cloudbasierte und On-Device-Modelle bieten unterschiedliche Konfigurationsoptionen.

Die Konfiguration bleibt für die gesamte Lebensdauer der Instanz erhalten. Wenn Sie eine andere Konfiguration verwenden möchten, erstellen Sie eine neue GenerativeModel-Instanz mit dieser Konfiguration.

Konfiguration für ein in der Cloud gehostetes Modell festlegen

Verwenden Sie die Option inCloudParams, um ein in der Cloud gehostetes Gemini-Modell zu konfigurieren. Verfügbare Parameter

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

Konfiguration für ein On-Device-Modell festlegen

Für die Inferenz mit einem On-Device-Modell wird die Prompt API von Chrome verwendet.

Verwenden Sie die Option onDeviceParams, um ein On-Device-Modell zu konfigurieren. Verfügbare Parameter

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

Konfiguration für strukturierte Ausgabe festlegen

Die Generierung strukturierter Ausgaben (wie JSON und Enums) wird für die Inferenz sowohl mit cloudbasierten als auch mit On-Device-Modellen unterstützt.

Verwenden Sie für die hybride Inferenz sowohl inCloudParams als auch onDeviceParams, um das Modell so zu konfigurieren, dass es mit strukturierter Ausgabe antwortet. Verwenden Sie für die anderen Modi nur die entsprechende Konfiguration.

Für inCloudParams: Geben Sie die entsprechende responseMimeType (in diesem Beispiel application/json) sowie die responseSchema an, die das Modell verwenden soll.
Für onDeviceParams: Geben Sie die responseConstraint an, die das Modell verwenden soll.

JSON-Ausgabe

Im folgenden Beispiel wird die allgemeine JSON-Ausgabe für die hybride Inferenz angepasst:

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

Enum-Ausgabe

Wie oben, aber mit Anpassung der Dokumentation zur Enum-Ausgabe für Hybrid-Inferenz:

// ...

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

const model = getGenerativeModel(ai, {

// ...

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

// ...

Funktionen, die noch nicht für die Inferenz auf dem Gerät verfügbar sind

Da es sich um eine experimentelle Version handelt, sind nicht alle Funktionen des Web-SDK für die Geräteinferenz verfügbar. Die folgenden Funktionen werden noch nicht für die Inferenz auf dem Gerät unterstützt (sind aber in der Regel für die cloudbasierte Inferenz verfügbar).

Text aus Bilddateieingabetypen generieren, die nicht JPEG und PNG sind
- Kann auf das in der Cloud gehostete Modell zurückgreifen. Im only_on_device-Modus wird jedoch ein Fehler ausgegeben.
Text aus Audio-, Video- und Dokumenteneingaben (z. B. PDFs) generieren
- Kann auf das in der Cloud gehostete Modell zurückgreifen. Im only_on_device-Modus wird jedoch ein Fehler ausgegeben.
Bilder mit Gemini- oder Imagen-Modellen generieren
- Kann auf das in der Cloud gehostete Modell zurückgreifen. Im only_on_device-Modus wird jedoch ein Fehler ausgegeben.
Dateien über URLs in multimodalen Anfragen bereitstellen Sie müssen Dateien als Inline-Daten für On-Device-Modelle bereitstellen.
Wechselseitiger Chat
- Kann auf das in der Cloud gehostete Modell zurückgreifen. Im only_on_device-Modus wird jedoch ein Fehler ausgegeben.
Bidirektionales Streaming mit dem Gemini Live API
- Diese Funktion wird nicht vom Firebase AI Logic-Client-SDK für Web unterstützt, auch nicht für in der Cloud gehostete Modelle.
Funktionsaufrufe
- Bald verfügbar!
Tokens zählen
- Gibt immer einen Fehler aus. Die Anzahl unterscheidet sich zwischen cloudbasierten und On-Device-Modellen, sodass es keinen intuitiven Fallback gibt.
KI-Monitoring in der Firebase Console für die Inferenz auf dem Gerät.
- Hinweis: Alle Inferenzen, die mit den in der Cloud gehosteten Modellen durchgeführt werden, können wie andere Inferenzen mit dem Firebase AI Logic-Client-SDK für das Web überwacht werden.

Feedback zu Firebase AI Logic geben