Firebase AI Logic

https://firebase.google.com/docs/ai-logic
Admin
Firebase AI Logic enables developers to build AI-powered mobile and web apps using Google's Gemini...
Tokens:353,254
Snippets:2,093
Trust Score:10
Update:1 hour ago
Show doc for...
Tokens:
Raw
### Start on-device model download with LanguageModel.create()

Source: https://firebase.google.com/docs/ai-logic/hybrid/web/get-started

Run in the browser console when the availability check returns 'downloadable' to start the model download.

```javascript
await LanguageModel.create();
```

--------------------------------

### System instructions: role syntax example

Source: https://firebase.google.com/docs/ai-logic/server-prompt-templates/syntax-and-examples

Prompt using {{role "system"}} and {{role "user"}} syntax to specify system instructions and user prompt. The frontmatter configuration is the same as the hello world example.

```yaml
---
model: 'gemini-3.8-flash'
---
```

```text
{{role "system"}}
All output must be a clearly structured invoice document.
Use a tabular or clearly delineated list format for line items.

{{role "user"}}
Create an example customer invoice for a customer.
```

--------------------------------

### Hello world: minimal server prompt template

Source: https://firebase.google.com/docs/ai-logic/server-prompt-templates/syntax-and-examples

Minimal example of a server prompt template with frontmatter configuration and a prompt. The frontmatter specifies the model as 'gemini-3.8-flash'.

```yaml
---
model: 'gemini-3.8-flash'
---
```

```text
Write a story about a magic backpack.
```

--------------------------------

### Unity: Example Response with Thought Summary

Source: https://firebase.google.com/docs/ai-logic/thinking

Shows the expected response and thought summary output for the Unity example. The response includes the answer and the thought summary contains the model's reasoning process.

```text
# Example Response:
#     Okay, let's solve the quadratic equation x² + 4x + 4 = 0.
#     ...
#     **Answer:**
#     The solution to the equation x² + 4x + 4 = 0 is x = -2. This is a repeated root (or a root with multiplicity 2).
```

```text
# Example Thought Summary:
#     **My Thought Process for Solving the Quadratic Equation**
#
#     Alright, let's break down this quadratic, x² + 4x + 4 = 0. First things first:
#     it's a quadratic; the x² term gives it away, and we know the general form is
#     ax² + bx + c = 0.
#
#     So, let's identify the coefficients: a = 1, b = 4, and c = 4. Now, what's the
#     most efficient path to the solution? My gut tells me to try factoring; it's
#     often the fastest route if it works. If that fails, I'll default to the quadratic
#     formula, which is foolproof. Completing the square? It's good for deriving the
#     formula or when factoring is difficult, but not usually my first choice for
#     direct solving, but it can't hurt to keep it as an option.
#
#     Factoring, then. I need to find two numbers that multiply to 'c' (4) and add
#     up to 'b' (4). Let's see... 1 and 4 don't work (add up to 5). 2 and 2? Bingo!
#     They multiply to 4 and add up to 4. This means I can rewrite the equation as
#     (x + 2)(x + 2) = 0, or more concisely, (x + 2)² = 0. Solving for x is now
#     trivial: x + 2 = 0, thus x = -2.
#
#     Okay, just to be absolutely certain, I'll run the quadratic formula just to
#     double-check. x = [-b ± √(b² - 4ac)] / 2a. Plugging in the values, x = [-4 ±
#     √(4² - 4 * 1 * 4)] / (2 * 1). That simplifies to x = [-4 ± √0] / 2. So, x =
#     -2 again - a repeated root. Nice.
#
#     Now, let's check via completing the square. Starting from the same equation,
#     (x² + 4x) = -4. Take half of the b-value (4/2 = 2), square it (2² = 4), and
#     add it to both sides, so x² + 4x + 4 = -4 + 4. Which simplifies into (x + 2)²
#     = 0. The square root on both sides gives us x + 2 = 0, therefore x = -2, as
#      expected.
#
#     Always, *always* confirm! Let's substitute x = -2 back into the original
#     equation: (-2)² + 4(-2) + 4 = 0. That's 4 - 8 + 4 = 0. It checks out.
#
#     Conclusion: the solution is x = -2. Confirmed.
```

--------------------------------

### Safety settings: multiple settings example

Source: https://firebase.google.com/docs/ai-logic/server-prompt-templates/syntax-and-examples

Frontmatter configuration with multiple safety settings: HARM_CATEGORY_HARASSMENT with BLOCK_ONLY_HIGH and HARM_CATEGORY_HATE_SPEECH with BLOCK_MEDIUM_AND_ABOVE. The prompt is the same as the hello world example.

```yaml
---
model: 'gemini-3.8-flash'
config:
  safetySettings:
    - category: HARM_CATEGORY_HARASSMENT
      threshold: BLOCK_ONLY_HIGH
    - category: HARM_CATEGORY_HATE_SPEECH
      threshold: BLOCK_MEDIUM_AND_ABOVE
---
```

```text
Write a story about a magic backpack.
```

--------------------------------

### Safety settings: single setting example

Source: https://firebase.google.com/docs/ai-logic/server-prompt-templates/syntax-and-examples

Frontmatter configuration with one safety setting: HARM_CATEGORY_HARASSMENT with threshold BLOCK_ONLY_HIGH. The prompt is the same as the hello world example.

```yaml
---
model: 'gemini-3.8-flash'
config:
  safetySettings:
    - category: HARM_CATEGORY_HARASSMENT
      threshold: BLOCK_ONLY_HIGH
---
```

```text
Write a story about a magic backpack.
```

--------------------------------

### Reference cache in server prompt template (example)

Source: https://firebase.google.com/docs/ai-logic/context-caching

Example server prompt template that references the cache created in the previous step using its fully-qualified resource name. The location must match the cache's location.

```plaintext
{{cachedContent name="projects/861083271981/locations/global/cachedContents/4545031458888089601"}}

{{role "user"}}
{{userPrompt}}
```

--------------------------------

### Create an explicit cache via REST API (example request)

Source: https://firebase.google.com/docs/ai-logic/context-caching

Concrete example request that creates a cache for a PDF file using the model `gemini-3.8-flash` in the `global` location. The response includes a fully-qualified resource `name` used in subsequent steps.

```bash
PROJECT_ID="my-amazing-app"
MODEL_ID="gemini-3.8-flash"
LOCATION="global"
MIME_TYPE="application/pdf"
CACHED_CONTENT_URI="gs://cloud-samples-data/generative-ai/pdf/2312.11805v3.pdf"
CACHE_DISPLAY_NAME="Gemini - A Family of Highly Capable Multimodal Model (PDF)"
TTL="7200s"

curl \
-X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
https://${LOCATION}-aiplatform.googleapis.com/v1beta1/projects/${PROJECT_ID}/locations/${LOCATION}/cachedContents \
-d @- <<EOF
{
  "model":"projects/${PROJECT_ID}/locations/${LOCATION}/publishers/google/models/${MODEL_ID}",
  "contents": [
    {
      "role": "user",
      "parts": [
        {
          "fileData": {
            "mimeType": "${MIME_TYPE}",
            "fileUri": "${CACHED_CONTENT_URI}"
          }
        }
      ]
    }
  ],
  "displayName": "${CACHE_DISPLAY_NAME}",
  "ttl": "${TTL}"
}
EOF
```

--------------------------------

### Example output from code execution

Source: https://firebase.google.com/docs/ai-logic/code-execution

Shows a formatted example of the model's response when using code execution, including text, executable code, and the result. The output combines content parts: text, executableCode, and codeExecutionResult.

```text
Okay, I need to calculate the sum of the first 50 prime numbers. Here's how I'll
approach this:

1.  **Generate Prime Numbers:** I'll use an iterative method to find prime
    numbers. I'll start with 2 and check if each subsequent number is divisible
    by any number between 2 and its square root. If not, it's a prime.
2.  **Store Primes:** I'll store the prime numbers in a list until I have 50 of
    them.
3.  **Calculate the Sum:**  Finally, I'll sum the prime numbers in the list.

Here's the Python code to do this:

def is_prime(n):
  """Efficiently checks if a number is prime."""
  if n <= 1:
    return False
  if n <= 3:
    return True
  if n % 2 == 0 or n % 3 == 0:
    return False
  i = 5
  while i * i <= n:
    if n % i == 0 or n % (i + 2) == 0:
      return False
    i += 6
  return True

primes = []
num = 2
while len(primes) < 50:
  if is_prime(num):
    primes.append(num)
  num += 1

sum_of_primes = sum(primes)
print(f'{primes=}')
print(f'{sum_of_primes=}')

primes=[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67,
71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151,
157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229]
sum_of_primes=5117

The sum of the first 50 prime numbers is 5117.
```

--------------------------------

### Model configuration: max output tokens and stop sequences

Source: https://firebase.google.com/docs/ai-logic/server-prompt-templates/syntax-and-examples

Frontmatter configuration to control response generation, setting maxOutputTokens to 200 and stopSequences to ["red"]. The prompt is the same as the hello world example.

```yaml
---
model: 'gemini-3.8-flash'
config:
  maxOutputTokens: 200
  stopSequences: ["red"]
---
```

```text
Write a story about a magic backpack.
```

--------------------------------

### Generate text from text-only input with Gemini Developer API

Source: https://firebase.google.com/docs/ai-logic/apple-foundation-models-framework/capabilities

Initializes the Gemini Developer API backend service and a `geminiLanguageModel`, then creates a `LanguageModelSession` to generate a text response. Use for single-turn interactions by creating a new session each time. Requires completing the 'Get started' guide.

```swift
import FoundationModels
import FirebaseCore
import FirebaseAILogic

// Initialize the Gemini Developer API backend service.
let ai = FirebaseAI.firebaseAI(backend: .googleAI())
// Initialize a `geminiLanguageModel` with a Gemini model that supports your use case.
let model = ai.geminiLanguageModel(name: "gemini-3.8-flash")

// Provide a prompt that contains text.
let prompt = "Write a story about a magic backpack."

// Create a session by injecting the model into Apple's `LanguageModelSession`.
// For a single-turn interaction, create a new session each time you call the model.
let session = LanguageModelSession(model: model)

// Generate a text response to the prompt.
let response = try await session.respond(to: prompt)
print(response.content)
```

--------------------------------

### Web: Install latest Firebase JS SDK with yarn

Source: https://firebase.google.com/docs/ai-logic/migrate-from-preview

Installs the latest Firebase JS SDK for Web using yarn. Run this command to get the latest version before updating imports.

```bash
yarn add firebase@latest
```

--------------------------------

### Kotlin: Define function schema in client code and start chat

Source: https://firebase.google.com/docs/ai-logic/server-prompt-templates/multi-turn-interactions

Kotlin example showing how to define a function declaration for fetchWeather and provide it in startChat. The client-side schema overrides any template-defined schema. The template must still list the function with a matching name.

```kotlin
// ...

// Initialize your desired Gemini API backend service.
// Create a `TemplateGenerativeModel` instance.
...

// Define the schema for any functions listed in your template.
val fetchWeatherTool = functionDeclarations(
    functionDeclarations = listOf(
        FunctionDeclaration(
            name = "fetchWeather",
            description = "Returns the weather for a given location at a given time",
            parameters = mapOf(
                "location" to Schema.obj(
                    description = "The name of the city and its state for which to get the weather. Only cities in the USA are supported.",
                    properties = mapOf(
                        "city" to Schema.string(
                            description = "The city of the location."
                        ),
                        "state" to Schema.string(
                            description = "The state of the location."
                        ),
                        "zipCode" to Schema.string(
                            description = "Optional zip code of the location.",
                            nullable = true
                        )
                    ),
                    optionalProperties = listOf("zipCode")
                ),
                "date" to Schema.string(
                    description = "The date for which to get the weather. Date must be in the format: YYYY-MM-DD."
                ),
                "unit" to Schema.enumeration(
                    description = "The temperature unit.",
                    values = listOf("CELSIUS", "FAHRENHEIT"),
                    nullable = true
                )

            ),
            optionalParameters = listOf("unit"),
        )
    )
)

// Start a chat session with a template that has functions listed as tools.
var chatSessionWithSchemaOverride = model.startChat(
    // Specify your template ID.
    templateId = "my-function-calling-template-with-no-function-schema-v1-0-0",
    // In `startChat`, provide the schema for any functions listed in your template.
    // This client-side schema will override any schema defined in the template.
    tools = listOf(fetchWeatherTool)
)

// Send a message that might trigger a function call.
...

// When the model responds with one or more function calls, invoke the function(s).
// Note that this is the same as when *not* using server prompt templates.
...

// Forward the structured input data from the model to the hypothetical external API.
...
```

--------------------------------

### LiveModel with systemInstruction (Kotlin)

Source: https://firebase.google.com/docs/ai-logic/system-instructions

Creates a LiveModel instance with system instructions for the Gemini Live API in Kotlin.

```APIDOC
## [Kotlin] LiveModel with systemInstruction

### Description
Creates a LiveModel instance with system instructions for the Gemini Live API in Kotlin.

### Method
LiveModel creation

### Endpoint
Firebase.ai(backend = GenerativeBackend.googleAI()).liveModel(modelName:systemInstruction:)

### Parameters
#### Parameters
- **modelName** (String) - Required - The name of the Gemini Live model.
- **systemInstruction** (Content) - Required - The system instructions to set for the model.

### Request Example
```kotlin
val liveModel = Firebase.ai(backend = GenerativeBackend.googleAI()).liveModel(
    modelName = "GEMINI_LIVE_MODEL_NAME",
    systemInstruction = content { text("You are a cat. Your name is Neko.") },
    // ...
)
```

### Response
No response body; returns a LiveModel instance.
```

--------------------------------

### Grounding with Google Maps tool prompt with system and user roles

Source: https://firebase.google.com/docs/ai-logic/server-prompt-templates/syntax-and-examples

Prompt that uses the `role` helper to define system and user messages, instructing the model to act as a tour guide and use the Google Maps tool.

```text
{{role "system"}}
You are a helpful tour guide. Use the Google Maps tool with the provided coordinates to answer the user's question based on their location.

{{role "user"}}
{{question}}
```

--------------------------------

### LiveModel with systemInstruction (Swift)

Source: https://firebase.google.com/docs/ai-logic/system-instructions

Creates a LiveModel instance with system instructions for the Gemini Live API in Swift.

```APIDOC
## [Swift] LiveModel with systemInstruction

### Description
Creates a LiveModel instance with system instructions for the Gemini Live API in Swift.

### Method
LiveModel creation

### Endpoint
FirebaseAI.firebaseAI(backend: .googleAI()).liveModel(modelName:systemInstruction:)

### Parameters
#### Parameters
- **modelName** (String) - Required - The name of the Gemini Live model.
- **systemInstruction** (ModelContent) - Required - The system instructions to set for the model.

### Request Example
```swift
let liveModel = FirebaseAI.firebaseAI(backend: .googleAI()).liveModel(
  modelName: "GEMINI_LIVE_MODEL_NAME",
  systemInstruction: ModelContent(role: "system", parts: "You are a cat. Your name is Neko."),
  // ...
)
```

### Response
No response body; returns a LiveModel instance.
```

--------------------------------

### Streaming multimodal response with streamResponse

Source: https://firebase.google.com/docs/ai-logic/apple-foundation-models-framework/capabilities

Shows how to stream partial results from a multimodal request using streamResponse instead of respond. The snapshot contains all content generated so far, and the loop accumulates the final response. Imports and backend initialization are omitted in the source; the session and model setup are assumed from the previous example.

```swift
// imports
// initialization of Gemini API backend service and a `geminiLanguageModel`

// Create a session by injecting the model into Apple's `LanguageModelSession`.
// For a single-turn interaction, create a new session each time you call the model.
let session = LanguageModelSession(model: model)

let cgImage: CGImage = // ... fetch CGImage from your datasource.
let stream = session.streamResponse {
  "What are the dominant colors of this image, in order?"
  Attachment(cgImage)
}

var response = ""
for try await snapshot in stream {
  // The snapshot contains *all* content generated so far.
  response = snapshot.content
}
print(response)
```

--------------------------------

### LiveModel with systemInstruction (Java)

Source: https://firebase.google.com/docs/ai-logic/system-instructions

Creates a LiveModel instance with system instructions for the Gemini Live API in Java.

```APIDOC
## [Java] LiveModel with systemInstruction

### Description
Creates a LiveModel instance with system instructions for the Gemini Live API in Java.

### Method
LiveModel creation

### Endpoint
FirebaseAI.getInstance(GenerativeBackend.googleAI()).liveModel(modelName:systemInstruction:)

### Parameters
#### Parameters
- **modelName** (String) - Required - The name of the Gemini Live model.
- **systemInstruction** (Content) - Optional - The system instructions to set for the model.

### Request Example
```java
LiveGenerativeModel lm = FirebaseAI.getInstance(GenerativeBackend.googleAI()).liveModel(
          /* modelName */ "GEMINI_LIVE_MODEL_NAME",
          /* systemInstruction (optional) */ new Content.Builder().addText("You are a cat. Your name is Neko.").build()
          // ...
);

LiveModelFutures liveModel = LiveModelFutures.from(lm);
```

### Response
No response body; returns a LiveModel instance.
```

--------------------------------

### Unity: Configure context window compression for live model

Source: https://firebase.google.com/docs/ai-logic/live-api/sessions

Sets up a live model with context window compression, enabling automatic compression when the context window reaches 10,000 tokens, targeting a 2000-token sliding window. Requires a valid GEMINI_LIVE_API_MODEL_NAME.

```Unity
// ...

var liveModel = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI()).GetLiveModel(
    modelName: "GEMINI_LIVE_API_MODEL_NAME",
    // Enable context window compression.
    // (Optional) Configure the number of tokens in the context window that triggers the compression.
    liveGenerationConfig: new LiveGenerationConfig(
        responseModalities: new[] { ResponseModality.Audio },
        contextWindowCompression: new ContextWindowCompressionConfig(
            triggerTokens: 10000,
            slidingWindow: new SlidingWindow(targetTokens: 2000)
        )
    )
);
```

--------------------------------

### Install Firebase JS SDK for Web

Source: https://firebase.google.com/docs/ai-logic/get-started

Install the Firebase JavaScript SDK for Web using npm.

```bash
npm install firebase
```

--------------------------------

### GenerativeModel with systemInstruction (Unity)

Source: https://firebase.google.com/docs/ai-logic/system-instructions

Creates a GenerativeModel instance with system instructions for general use cases in Unity.

```APIDOC
## [Unity] GenerativeModel with systemInstruction

### Description
Creates a GenerativeModel instance with system instructions for general use cases in Unity.

### Method
GenerativeModel creation

### Endpoint
FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI()).GetGenerativeModel(modelName:systemInstruction:)

### Parameters
#### Parameters
- **modelName** (String) - Required - The name of the Gemini model.
- **systemInstruction** (ModelContent) - Required - The system instructions to set for the model.

### Request Example
```csharp
var ai = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI());

var model = ai.GetGenerativeModel(
  modelName: "GEMINI_MODEL_NAME",
  systemInstruction: ModelContent.Text("You are a cat. Your name is Neko.")
);
```

### Response
No response body; returns a GenerativeModel instance.
```

--------------------------------

### Unity: Configure Gemini Nano Banana image generation

Source: https://firebase.google.com/docs/ai-logic/generate-images-gemini

Sets up a GenerationConfig with text and image response modalities, an optional image config for aspect ratio and size, and initializes the generative model with 'gemini-nano-banana-2.1'. Requires initializing a Gemini API backend service.

```csharp
// ...

var generationConfig = new GenerationConfig(
  // Configure the model to respond with text (optional) and images (required).
  // Include the text modality only if you want interleaved text and images in the response.
  responseModalities: new[] { ResponseModality.Text, ResponseModality.Image },
  // Specify aspect ratio and image size (both optional) in an image config.
  imageConfig: new ImageConfig(
    aspectRatio: ImageConfig.AspectRatio.Landscape16x9,
    imageSize: ImageConfig.ImageSize.Size2K)
);

// Make sure you initialize your chosen Gemini API backend service.
var model = FirebaseAI.GetInstance().GetGenerativeModel(
  modelName: "gemini-nano-banana-2.1",
  generationConfig: generationConfig
);

// ...
```

--------------------------------

### GenerativeModel with systemInstruction (Kotlin)

Source: https://firebase.google.com/docs/ai-logic/system-instructions

Creates a GenerativeModel instance with system instructions for general use cases in Kotlin.

```APIDOC
## [Kotlin] GenerativeModel with systemInstruction

### Description
Creates a GenerativeModel instance with system instructions for general use cases in Kotlin.

### Method
GenerativeModel creation

### Endpoint
Firebase.ai(backend = GenerativeBackend.googleAI()).generativeModel(modelName:systemInstruction:)

### Parameters
#### Parameters
- **modelName** (String) - Required - The name of the Gemini model.
- **systemInstruction** (Content) - Required - The system instructions to set for the model.

### Request Example
```kotlin
val model = Firebase.ai(backend = GenerativeBackend.googleAI()).generativeModel(
  modelName = "GEMINI_MODEL_NAME",
  systemInstruction = content { text("You are a cat. Your name is Neko.") }
)
```

### Response
No response body; returns a GenerativeModel instance.
```

--------------------------------

### Dart: Install Remote Config package

Source: https://firebase.google.com/docs/ai-logic/server-prompt-templates/versioning-with-remote-config

Install and add the firebase_remote_config package to your Flutter project.

```bash
flutter pub add firebase_remote_config
```

--------------------------------

### Java: Configure App Check debug provider factory

Source: https://firebase.google.com/docs/ai-logic/get-started

Use this Java code in your debug build to install the debug provider factory for App Check. Initialize FirebaseApp and then install the DebugAppCheckProviderFactory.

```java
FirebaseApp.initializeApp(/*context=*/ this);
FirebaseAppCheck firebaseAppCheck = FirebaseAppCheck.getInstance();
firebaseAppCheck.installAppCheckProviderFactory(
        DebugAppCheckProviderFactory.getInstance());MainActivity.java
```

--------------------------------

### GenerativeModel with systemInstruction (Web)

Source: https://firebase.google.com/docs/ai-logic/system-instructions

Creates a GenerativeModel instance with system instructions for general use cases in Web.

```APIDOC
## [Web] GenerativeModel with systemInstruction

### Description
Creates a GenerativeModel instance with system instructions for general use cases in Web.

### Method
GenerativeModel creation

### Endpoint
getGenerativeModel(ai, { model, systemInstruction })

### Parameters
#### Parameters
- **ai** (AI) - Required - The AI instance obtained from getAI().
- **model** (String) - Required - The name of the Gemini model.
- **systemInstruction** (String) - Required - The system instructions to set for the model.

### Request Example
```javascript
const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });

const model = getGenerativeModel(ai, {
  model: "GEMINI_MODEL_NAME",
  systemInstruction: "You are a cat. Your name is Neko."
});
```

### Response
No response body; returns a GenerativeModel instance.
```

--------------------------------

### Dart: Install Remote Config

Source: https://firebase.google.com/docs/ai-logic/change-model-name-remotely

Install and add Remote Config to your Flutter project using the flutter pub add command.

```bash
flutter pub add firebase_remote_config
```

--------------------------------

### Initialize on-device model with progress callback

Source: https://firebase.google.com/docs/ai-logic/hybrid/web/get-started

Calls initializeDeviceModel() after or on a user interaction and before sending prompts. The callback logs download progress. Downloading can take several minutes; behavior before completion depends on the mode.

```javascript
import { initializeApp } from "firebase/app";
import { getAI, getGenerativeModel, GoogleAIBackend, InferenceMode } 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, use the on-device model if it's available)
const model = getGenerativeModel(ai, { mode: InferenceMode.PREFER_ON_DEVICE });

// `initializeDeviceModel` must be called:
// (1) after or on an end-user page interaction such as a button click
// and
// (2) before any queries to the model (such as `generateContent()`)
// You may want to `await` this promise if using `ONLY_ON_DEVICE` (see note below).
model.initializeDeviceModel((val) =>
  // Example: "Download progress: 72.62%""
  console.log(`Download progress: ${Math.round(val*10000) / 100}%`)
);
```

--------------------------------

### Unity: Set system instructions on GenerativeModel

Source: https://firebase.google.com/docs/ai-logic/system-instructions

Specify systemInstruction when creating a GenerativeModel instance using FirebaseAI.GetInstance with the Google AI backend.

```csharp
// ...

var ai = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI());

// Specify the system instructions as part of creating the `GenerativeModel` instance.
var model = ai.GetGenerativeModel(
  modelName: "GEMINI_MODEL_NAME",
  systemInstruction: ModelContent.Text("You are a cat. Your name is Neko.")
);
```

--------------------------------

### Java: Set system instructions on LiveModel

Source: https://firebase.google.com/docs/ai-logic/system-instructions

Specify systemInstruction when creating a LiveModel instance for the Gemini Live API using FirebaseAI.getInstance.

```java
// ...

// Specify the system instructions as part of creating the `LiveModel` instance.
LiveGenerativeModel lm = FirebaseAI.getInstance(GenerativeBackend.googleAI()).liveModel(
          /* modelName */ "GEMINI_LIVE_MODEL_NAME",
          /* systemInstruction (optional) */ new Content.Builder().addText("You are a cat. Your name is Neko.").build()
          // ...
);

LiveModelFutures liveModel = LiveModelFutures.from(lm);

// ...
```

--------------------------------

### GenerativeModel with systemInstruction (Swift)

Source: https://firebase.google.com/docs/ai-logic/system-instructions

Creates a GenerativeModel instance with system instructions for general use cases in Swift.

```APIDOC
## [Swift] GenerativeModel with systemInstruction

### Description
Creates a GenerativeModel instance with system instructions for general use cases in Swift.

### Method
GenerativeModel creation

### Endpoint
FirebaseAI.firebaseAI(backend: .googleAI()).generativeModel(modelName:systemInstruction:)

### Parameters
#### Parameters
- **modelName** (String) - Required - The name of the Gemini model.
- **systemInstruction** (ModelContent) - Required - The system instructions to set for the model.

### Request Example
```swift
let model = FirebaseAI.firebaseAI(backend: .googleAI()).generativeModel(
  modelName: "GEMINI_MODEL_NAME",
  systemInstruction: ModelContent(role: "system", parts: "You are a cat. Your name is Neko.")
)
```

### Response
No response body; returns a GenerativeModel instance.
```

--------------------------------

### Unity Live API: Send and receive audio with LiveModel

Source: https://firebase.google.com/docs/ai-logic/live-api

Creates a LiveModel instance with audio response modality, connects a LiveSession, and starts sending microphone audio and receiving audio responses. Requires a model name that supports the Live API and a microphone device.

```csharp
using Firebase;
using Firebase.AI;

async Task SendTextReceiveAudio() {
  // Initialize the Gemini Developer API backend service.
  // Create a `LiveModel` instance with a model that supports the Live API.
  var liveModel = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI()).GetLiveModel(
      modelName: "GEMINI_LIVE_API_MODEL_NAME",
      // Configure the model to respond with audio.
      liveGenerationConfig: new LiveGenerationConfig(
          responseModalities: new[] { ResponseModality.Audio })
    );

  LiveSession session = await liveModel.ConnectAsync();

  // Start a coroutine to send audio from the Microphone.
  var recordingCoroutine = StartCoroutine(SendAudio(session));

  // Start receiving the response.
  await ReceiveAudio(session);
}

IEnumerator SendAudio(LiveSession liveSession) {
  string microphoneDeviceName = null;
  int recordingFrequency = 16000;
  int recordingBufferSeconds = 2;

  var recordingClip = Microphone.Start(microphoneDeviceName, true,
                                       recordingBufferSeconds, recordingFrequency);

  int lastSamplePosition = 0;
  while (true) {
    if (!Microphone.IsRecording(microphoneDeviceName)) {
      yield break;
    }

    int currentSamplePosition = Microphone.GetPosition(microphoneDeviceName);

    if (currentSamplePosition != lastSamplePosition) {
      // The Microphone uses a circular buffer, so we need to check if the
      // current position wrapped around to the beginning, and handle it accordingly.
      int sampleCount;
      if (currentSamplePosition > lastSamplePosition) {
        sampleCount = currentSamplePosition - lastSamplePosition;
      } else {
        sampleCount = recordingClip.samples - lastSamplePosition + currentSamplePosition;
      }

      if (sampleCount > 0) {
        // Get the audio chunk.
        float[] samples = new float[sampleCount];
        recordingClip.GetData(samples, lastSamplePosition);

        // Send the data, discarding the resulting Task to avoid the warning.
        _ = liveSession.SendAudioAsync(samples);

        lastSamplePosition = currentSamplePosition;
      }
    }

    // Wait for a short delay before reading the next sample from the Microphone.
    const float MicrophoneReadDelay = 0.5f;
    yield return new WaitForSeconds(MicrophoneReadDelay);
  }
}

Queue<float> audioBuffer = new();

async Task ReceiveAudio(LiveSession liveSession) {
  int sampleRate = 24000;
  int channelCount = 1;

  // Create a looping AudioClip to fill with the received audio data.
  int bufferSamples = (int)(sampleRate * channelCount);
  AudioClip clip = AudioClip.Create("StreamingPCM", bufferSamples, channelCount,
                                    sampleRate, true, OnAudioRead);

  // Attach the clip to an AudioSource and start playing it.
  AudioSource audioSource = GetComponent<AudioSource>();
  audioSource.clip = clip;
  audioSource.loop = true;
  audioSource.Play();

  // Start receiving the response.
  await foreach (var message in liveSession.ReceiveAsync()) {
    // Process the received message
    foreach (float[] pcmData in message.AudioAsFloat) {
      lock (audioBuffer) {
        foreach (float sample in pcmData) {
          audioBuffer.Enqueue(sample);
        }
      }
    }
  }
}

// This method is called by the AudioClip to load audio data.
private void OnAudioRead(float[] data) {
  int samplesToProvide = data.Length;
  int samplesProvided = 0;

  lock(audioBuffer) {
    while (samplesProvided < samplesToProvide && audioBuffer.Count > 0) {
      data[samplesProvided] = audioBuffer.Dequeue();
      samplesProvided++;
    }
  }

  while (samplesProvided < samplesToProvide) {
    data[samplesProvided] = 0.0f;
    samplesProvided++;
  }
}

```
Tokens:
Raw