Interaktionen mit mehreren Durchgängen mit Server-Promptvorlagen


Dieser Leitfaden gilt für alle Funktionen, die auf mehrstufigen Interaktionen basieren, einschließlich:

Gesamtübersicht

Bei Multi-Turn-Interaktionen verwalten die Firebase AI Logic SDKs den Status der Unterhaltung. Das gilt auch, wenn Sie Server-Prompt-Vorlagen verwenden.

Der grundlegende Workflow für Multi-Turn-Interaktionen und Server-Prompt-Vorlagen ist im Wesentlichen derselbe wie für Single-Turn-Anfragen, mit einigen wichtigen Unterschieden:

  1. Erstellen Sie die Vorlage mithilfe der geführten Benutzeroberfläche in der Firebase-Console.

    Bei mehrstufigen Interaktionen müssen Sie das Tag {{history}} in den Inhalt der Vorlage einfügen. Dadurch wird der Vorlage mitgeteilt, wo die vom Client-SDK verwalteten Gesprächsrunden eingefügt werden sollen.

  2. Testen Sie die Vorlage in einer echten Anfrage mit der Testumgebung in der Firebase-Konsole.

    Bei Interaktionen mit mehreren Runden kann die Console nur die erste Runde testen. Sie können testen, wie nachfolgende Turns (der Verlauf) verarbeitet werden, indem Sie die Vorlage mit Ihrer tatsächlichen Anwendung verwenden.

  3. Greifen Sie mit templateGenerativeModel über den Code Ihrer App auf die Vorlage zu.

    Für Multi-Turn-Interaktionen müssen Sie startChat und sendMessage verwenden (genau wie bei Multi-Turn-Interaktionen, wenn Sie keine Server-Prompt-Vorlagen verwenden).

Beachten Sie, dass es für Funktionsaufrufe einige weitere Unterschiede gibt, die im entsprechenden Abschnitt weiter unten auf dieser Seite beschrieben werden.


Multi-Turn-Unterhaltung (Chat)

Wenn Sie es noch nicht getan haben, lesen Sie den allgemeinen Leitfaden zum Erstellen von Multi-Turn-Unterhaltungen (Chat), wenn Sie keine Server-Promptvorlagen verwenden.

Grundlegendes Format einer Server-Prompt-Vorlage

Für Firebase AI Logic bietet die Firebase-Console eine geführte Benutzeroberfläche, auf der Sie die Frontmatter und den Inhalt der Vorlage angeben können.

Server-Prompt-Vorlagen verwenden eine Dotprompt-basierte Syntax und ein Dotprompt-basiertes Format. Weitere Informationen finden Sie unter Format, Syntax und Beispiele für Vorlagen.

Die folgende Beispielvorlage zeigt die wichtigsten Komponenten für eine Vorlage, wenn Sie eine Unterhaltung mit mehreren Runden (Chat) erstellen. Beachten Sie, dass im Inhalt der Vorlage das Tag {{history}} hinzugefügt wurde. Dadurch weiß die Vorlage, wo die vom Client-SDK verwalteten Gesprächsrunden eingefügt werden sollen.

---
model: 'gemini-3.8-flash'
---

{{role "system"}}
You help customers with their invoices, including answering questions or providing their invoices to them.
If an invoice is requested, it must be a clearly structured invoice document that uses a tabular or clearly delineated list format for line items.

{{history}}

Vorlage im Code verwenden

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

Der folgende Beispiel-Clientcode zeigt, wie Sie die Vorlage in Ihrem Code verwenden. Beachten Sie die Verwendung von templateGenerativeModel zusammen mit startChat und sendMessage beim Erstellen von mehrstufigen Interaktionen.

Swift 

For Swift, using server prompt templates with multi-turn interactions is not yet supported. Check back soon!

Kotlin 


// ...

// Initialize the Gemini Developer API backend service.
// Create a `TemplateGenerativeModel` instance.
val model = Firebase.ai(backend = GenerativeBackend.googleAI())
                        .templateGenerativeModel()

// Start a chat session with a template.
val chatSession = model.startChat(
  // Specify your template ID.
  templateId= "my-chat-template-v1-0-0",
  inputs = emptyMap()
)

// Send messages.
// The template's system instructions and model config apply to every turn automatically.
// The SDK automatically manages the state of the conversation.
val response = chatSession.sendMessage(
  content("user") { text("I need a copy of my invoice.") }
)

val text = response.text
println(text)

Java 


// ...

// Initialize the Gemini Developer API backend service
// Create a `TemplateGenerativeModel` instance.
TemplateGenerativeModel templateModel = FirebaseAI.getInstance(GenerativeBackend.googleAI())
    .templateGenerativeModel();
// Initialize TemplateChat with history and inputs
TemplateChat templateChat = templateModel.startChat(
    // Specify your template ID.
    "my-chat-template-v1-0-0",
    Map.of(),
    Collections.emptyList()
);
TemplateChatFutures chatFutures = TemplateChatFutures.from(templateChat);

// Send messages.
// The template's system instructions and model config apply to every turn automatically.
// The SDK automatically manages the state of the conversation.
Content prompt = new Content.Builder().addText("I need a copy of my invoice.").build();
ListenableFuture responseFuture = chatFutures.sendMessage(prompt);

Futures.addCallback(responseFuture, new FutureCallback() {
  @Override
  public void onSuccess(GenerateContentResponse result) {
    System.out.println("Response: " + result.getText());
  }

  @Override
  public void onFailure(Throwable t) {
    t.printStackTrace();
  }
}, executor);

Web 


// ...

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

// Create a `TemplateGenerativeModel` instance.
const model = getTemplateGenerativeModel(ai);

// Start a chat session with a template.
const chatSession = model.startChat({
  // Specify your template ID.
  templateId: 'my-chat-template-v1-0-0',
  templateVariables: {},
});

// Send messages.
// The template's system instructions and model config apply to every turn automatically.
// The SDK automatically manages the state of the conversation.
const result = await chatSession.sendMessage("I need a copy of my invoice.");

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

Dart 


// ...

// Initialize the Gemini Developer API backend service.
// Create a `TemplateGenerativeModel` instance.
final model = FirebaseAI.googleAI().templateGenerativeModel();

// Start a chat session with a template.
final chatSession = model.startChat(
  // Specify your template ID.
  'my-chat-template-v1-0-0',
  inputs: {},
);

// Send messages.
// The template's system instructions and model config apply to every turn automatically.
// The SDK automatically manages the state of the conversation.
final response = await chatSession.sendMessage(
  Content.text('I need a copy of my invoice.'),
);

final text = response.text;
print(text);

Einheit 


// ...

// Initialize the Gemini Developer API backend service.
var firebaseAI = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI());

// Create a `TemplateGenerativeModel` instance.
var model = firebaseAI.GetTemplateGenerativeModel();

// Start a chat session with a template.
var chatSession = model.StartChat(
    // Specify your template ID.
    "my-chat-template-v1-0-0"
);

// Send messages.
// The template's system instructions and model config apply to every turn automatically.
// The SDK automatically manages the state of the conversation.
try
{
   var response = await chatSession.SendMessageAsync(ModelContent.Text("I need a copy of my invoice."));
   Debug.Log($"Response Text: {response.Text}");
}
catch (Exception e) {
  Debug.LogError($"An error occurred: {e.Message}");
}


Funktionsaufrufe

Wenn Sie es noch nicht getan haben, lesen Sie den allgemeinen Leitfaden für Funktionsaufrufe, wenn Sie keine Server-Prompt-Vorlagen verwenden. In diesem Leitfaden zur Verwendung von Server-Prompt-Vorlagen wird davon ausgegangen, dass Sie mit der allgemeinen Funktionsweise von Funktionsaufrufen vertraut sind.

Grundlegendes Format einer Server-Prompt-Vorlage

Für Firebase AI Logic bietet die Firebase-Console eine geführte Benutzeroberfläche, auf der Sie die Frontmatter und den Inhalt der Vorlage angeben können.

Server-Prompt-Vorlagen verwenden eine Dotprompt-basierte Syntax und ein Dotprompt-basiertes Format. Weitere Informationen finden Sie unter Format, Syntax und Beispiele für Vorlagen.

Die folgende Beispielvorlage zeigt die wichtigsten Komponenten für eine Vorlage, wenn Funktionsaufrufe verwendet werden. Wichtige Hinweise:

  • Listen Sie im Frontmatter der Vorlage die Funktionen auf, auf die das Modell Zugriff hat, indem Sie Funktionsdeklarationen im tools-Objekt angeben.

    • Definieren Sie den name (erforderlich) und die description (optional) für jede Funktion, auf die das Modell Zugriff hat.

    • Definieren Sie das Schema für jede Funktion, auf die das Modell Zugriff hat.

      In der folgenden Beispielvorlage wird davon ausgegangen, dass Sie Funktionsschemas in der Vorlage definieren. Sie können das Schema der Funktion stattdessen im Clientcode angeben. Das im Clientcode definierte Schema überschreibt alle in der Vorlage definierten Schemas. Weiter unten auf dieser Seite finden Sie ein Beispiel für eine Vorlage und einen Clientcode zum Definieren des Schemas im Clientcode.

  • Fügen Sie im Inhalt der Vorlage das Tag {{history}} hinzu. Dadurch wird der Vorlage mitgeteilt, wo die vom Client SDK verwalteten Gesprächsrunden eingefügt werden sollen.

Beispielvorlage mit in der Vorlage definiertem Funktionsschema

---
model: gemini-3.8-flash
tools:
  - name: fetchWeather
    description: Get the weather conditions for a specific city on a specific date.
    input:
      schema:
        location(object, The name of the city and its state for which to get the weather. Only cities in the USA are supported.):
          city: string, The city of the location.
          state: string, The state of the location.
        date: string, The date for which to get the weather. Date must be in the format YYYY-MM-DD.

---

What was the weather like in Boston, Massachusetts on 10/17 in year 2024?

{{history}}

Vorlage im Code verwenden

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

Der folgende Beispiel-Clientcode zeigt, wie Sie die Vorlage in Ihrem Code verwenden. Wichtige Hinweise:

  • Verwenden Sie templateGenerativeModel zusammen mit startChat und sendMessage, wenn Sie Multi-Turn-Interaktionen verwenden.

  • Listen Sie bei der Initialisierung des Modells in Ihrem Clientcode nicht die Funktionen auf, auf die das Modell Zugriff hat. Stattdessen müssen Funktionen im tools-Objekt des Frontmatters der Vorlage aufgeführt werden (siehe oben).

  • In diesem Beispiel-Clientcode wird davon ausgegangen, dass Sie Funktionsschemas in der Vorlage definieren. Wenn Sie das Schema stattdessen in Ihrem Clientcode definieren, wird das in der Vorlage definierte Schema überschrieben. Weiter unten auf dieser Seite finden Sie eine Beispielvorlage und einen Clientcode zum Definieren des Schemas im Clientcode.

  • Prüfen, ob das Modell im Rahmen der Erfüllung einer Anfrage einen Funktionsaufruf zurückgibt. Wenn ja, muss Ihre App die lokale Logik ausführen und das Ergebnis dann an das Modell zurücksenden.

Beispiel für Clientcode mit in der Vorlage definiertem Funktionsschema

Swift 

For Swift, using server prompt templates with multi-turn interactions is not yet supported. Check back soon!

Kotlin 


// ...

// Initialize the Gemini Developer API backend service.
// Create a `TemplateGenerativeModel` instance.
val model = Firebase.ai(backend = GenerativeBackend.googleAI())
    .templateGenerativeModel()

// Start a chat session with a template that has functions listed as tools.
val chatSession = model.startChat(
    // Specify your template ID
    templateId = "my-function-calling-template-v1-0-0",
    inputs = emptyMap()
)

// Send a message that might trigger a function call.
val response = chatSession.sendMessage(
    content("user") { text(userMessage) }
)

// 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.
val functionCalls = response.functionCalls
val fetchWeatherCall = functionCalls.find { it.name == "fetchWeather" }

// Forward the structured input data from the model to the hypothetical external API.
val functionResponse = fetchWeatherCall?.let {
  // Alternatively, if your `Location` class is marked as @Serializable, you can use
  // val location = Json.decodeFromJsonElement(it.args["location"]!!)
  val location = Location(
      it.args["location"]!!.jsonObject["city"]!!.jsonPrimitive.content,
      it.args["location"]!!.jsonObject["state"]!!.jsonPrimitive.content
  )
  val date = it.args["date"]!!.jsonPrimitive.content
  fetchWeather(location, date)
}

Java 

// ...


// Initialize the Gemini Developer API backend service.
// Create a `TemplateGenerativeModel` instance.
TemplateGenerativeModel model = FirebaseAI.getInstance(GenerativeBackend.googleAI())
    .templateGenerativeModel();


// Start a chat session with a template that has functions listed as tools.
TemplateChat chatSession = model.startChat(
    // Specify your template ID.
    "my-function-calling-template-v1-0-0",
    Map.of(), // Inputs
    List.of() // History
);
TemplateChatFutures chatFutures = TemplateChatFutures.from(chatSession);

// Send a message that might trigger a function call.
Content prompt = new Content.Builder().addText(userMessage).build();
ListenableFuture responseFuture = chatFutures.sendMessage(prompt);

Futures.addCallback(responseFuture, new FutureCallback() {
  @Override
  public void onSuccess(GenerateContentResponse result) {
    // 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.
    for (FunctionCallPart callPart : result.getFunctionCalls()) {
      if ("fetchWeather".equals(callPart.getName())) {
        // Forward the structured input data from the model to the hypothetical external API.
        JsonObject location = (JsonObject) callPart.getArgs().get("location");
        String city = ((JsonPrimitive) location.get("city")).getContent();
        String state = ((JsonPrimitive) location.get("state")).getContent();
        String date = ((JsonPrimitive) callPart.getArgs().get("date")).getContent();
        Object response = fetchWeather(city, state, date);
      }
    }
  }

  @Override
  public void onFailure(Throwable t) {
    t.printStackTrace();
  }
}, executor);

Web 


// ...

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

// Create a `TemplateGenerativeModel` instance.
const model = getTemplateGenerativeModel(ai);

// Start a chat session with a template that has functions listed as tools.
const chatSession = model.startChat({
  // Specify your template ID
  templateId: 'my-function-calling-template-v1-0-0',
  templateVariables: {},
});

// Send a message that might trigger a function call.
const result = await chatSession.sendMessage(userMessage);

// 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.
const functionCalls = result.response.functionCalls();
let functionCall;
let functionResult;

if (functionCalls.length > 0) {
  for (const call of functionCalls) {
    if (call.name === "fetchWeather") {
      // Forward the structured input data prepared by the model
      // to the hypothetical external API.
      functionResult = await fetchWeather(call.args);
      functionCall = call;
    }
  }
}

Dart 


// ...

// Initialize the Gemini Developer API backend service.
// Create a `TemplateGenerativeModel` instance.
final model = FirebaseAI.googleAI().templateGenerativeModel();

// Start a chat session with a template that has functions listed as tools.
var chatSession = model.startChat(
    // Specify your template ID
    'my-function-calling-template-v1-0-0',
    inputs: {},
);

// Send a message that might trigger a function call.
var response = await chatSession.sendMessage(
    Content.text(userMessage),
);

// Check if the model wants to call a function.
// Note that this is the same as when *not* using server prompt templates.
final functionCalls = response?.functionCalls.toList();
// When the model responds with one or more function calls, invoke the function(s).
if (functionCalls != null && functionCalls.isNotEmpty) {
  for (final functionCall in functionCalls) {
    if (functionCall.name == 'fetchWeather') {
      Map<String, dynamic> location =
          functionCall.args['location']! as Map<String, dynamic>;
      var date = functionCall.args['date']! as String;
      var city = location['city'] as String;
      var state = location['state'] as String;
      final functionResult =
          await fetchWeather(Location(city, state), date);
      // Send the response to the model so that it can use the result to
      // generate text for the user.
      response = await chatSession.sendMessage(
        Content.functionResponse(functionCall.name, functionResult),
      );
    }
  }
}

Einheit 


// ...

// Initialize the Gemini Developer API backend service.
var firebaseAI = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI());

// Create a `TemplateGenerativeModel` instance.
var model = firebaseAI.GetTemplateGenerativeModel();

// Start a chat session with a template that has functions listed as tools.
var chatSession = model.StartChat(
    // Specify your template ID
    "my-function-calling-template-v1-0-0"
);

try
{
   // Send a message that might trigger a function call.
   var response = await chatSession.SendMessageAsync(ModelContent.Text(userMessage));
   var functionResponses = new List();

  // 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.
  foreach (var functionCall in response.FunctionCalls) {
    if (functionCall.Name == "fetchWeather") {
      // TODO(developer): Handle invalid arguments.
      var location = functionCall.Args["location"] as Dictionary<string, object>;
      var city = location["city"] as string;
      var state = location["state"] as string;
      var date = functionCall.Args["date"] as string;

      functionResponses.Add(ModelContent.FunctionResponse(
        name: functionCall.Name,
        // Forward the structured input data prepared by the model
        // to the hypothetical external API.
        response: FetchWeather(city: city, state: state, date: date)
      ));
    }
    // TODO(developer): Handle other potential function calls, if any.
  }

  // Send the function responses back to the model.
  var functionResponseResult = await chatSession.SendMessageAsync(functionResponses);
}
catch (Exception e) {
  Debug.LogError($"An error occurred: {e.Message}");
}


Funktionsaufrufe – Schema im Clientcode definieren

Lesen Sie sich die obigen Abschnitte dazu durch, wie Funktionsaufrufe mit Server-Prompt-Vorlagen funktionieren (insbesondere die Verwendung des Tags {{history}} im Inhalt der Vorlage). In diesem Abschnitt finden Sie eine Beispielvorlage und einen Beispiel-Clientcode, falls Sie das Funktionsschema im Clientcode (anstatt in der Vorlage) definieren möchten.

Beachten Sie Folgendes, wenn Sie ein Funktionsschema im Clientcode definieren:

  • Wenn Sie das Schema einer Funktion in Ihrem Clientcode definieren (wie im Beispiel unten gezeigt), überschreibt das clientseitige Schema alle in der Vorlage definierten Schemas für diese Funktion.

  • Wenn Sie das Funktionsschema im Clientcode definieren möchten, schreiben Sie die Funktionsdeklaration und geben Sie die Deklaration in startChat an, nicht während der Modellinitialisierung (was Sie tun, wenn Sie keine Server-Prompt-Vorlagen verwenden).

  • Auch wenn in der Funktionsdeklaration ein name angegeben ist, müssen in der Vorlage die Funktionen aufgeführt werden, auf die das Modell Zugriff haben soll. Der name in der Vorlage muss mit dem name im Clientcode übereinstimmen.

Beispielvorlage mit im Clientcode definiertem Funktionsschema

---
model: gemini-3.8-flash
tools:
  - name: fetchWeather
    description: Get the weather conditions for a specific city on a specific date.
---

What was the weather like in Boston, Massachusetts on 10/17 in year 2024, formatted in CELSIUS?

{{history}}

Beispiel für Clientcode mit im Clientcode definiertem Funktionsschema
(Details, die in diesem Beispiel weggelassen wurden, finden Sie im Beispiel für Clientcode oben)

Swift 

For Swift, using server prompt templates with multi-turn interactions is not yet supported. Check back soon!

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.
...

Java 

TemplateFunctionDeclaration tool = new TemplateFunctionDeclaration(
    "fetchWeather", // Name
    JsonSchema.obj( // Parameters
        Map.of(
            "location", JsonSchema.obj(
                Map.of(
                    "city", JsonSchema.string(
                        "The city of the location."
                    ),
                    "state", JsonSchema.string(
                        "The state of the location."
                    ),
                    "zipCode", JsonSchema.string(
                        "Optional zip code of the location",
                        true // Nullable
                    )
                ),
                List.of("zipCode"),
                ""
            ),
            "date", JsonSchema.string(
                "The date for which to get the weather. Date must be in the format: YY-MM-DD."
            ),
            "unit", JsonSchema.enumeration(
                List.of("CELSIUS", "FAHRENHEIT"),
                "The temperature unit.",
                true // Nullable
            )
        )
    ),
    JsonSchema.string(
        "A description of the current weather."
    )
);

// Initialize the Gemini Developer API backend service.
// Create a `TemplateGenerativeModel` instance.
TemplateGenerativeModel templateModel = FirebaseAI.getInstance(GenerativeBackend.googleAI())
    .templateGenerativeModel(
        new RequestOptions(),
        List.of(TemplateTool.functionDeclarations(List.of(tool), List.of()))
    );

// In `startChat`, provide the schema for any functions listed in your template.
// This client-side schema will override any schema defined in the template.
TemplateChat chat = templateModel.startChat(
    // Specify your template ID.
    "my-function-calling-template-with-no-function-schema-v1-0-0",
    Map.of(),
    List.of()
);
TemplateChatFutures futures = TemplateChatFutures.from(chat);

// 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.
...

Web 

// ...

// Initialize your desired Gemini API backend service.
...

// Create a `TemplateGenerativeModel` instance.
...

// Start a chat session with a template that has functions listed as tools.
const chatSessionWithSchemaOverride = model.startChat({
  // Specify your template ID.
  templateId: 'my-function-calling-template-with-no-function-schema-v1-0-0',
  templateVariables: {},
  // 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: [
    {
      functionDeclarations: [
        {
          name: "fetchWeather",
          parameters: {
            type: SchemaType.OBJECT,
            properties: {
              location: {
                type: SchemaType.OBJECT,
                description: "The name of the city and its state for which to get the weather. Only cities in the USA are supported.",
                properties: {
                  city: {
                    type: SchemaType.STRING,
                    description: "The city of the location."
                  },
                  state: {
                    type: SchemaType.STRING,
                    description: "The state of the location."
                  },
                  zipCode: {
                    type: SchemaType.INTEGER,
                    description: "Optional zip code of the location.",
                    nullable: true
                  },
                },
                required: ["city", "state"],
              },
              date: {
                type: SchemaType.STRING,
                description: "The date for which to get the weather. Date must be in the format: YYYY-MM-DD.",
              },
              unit: {
                type: SchemaType.STRING,
                description: "The temperature unit.",
                enum: ["CELSIUS", "FAHRENHEIT"],
                nullable: true,
              },
            },
            required: ["location", "date"],
          },
        },
      ],
    }
  ],
});

// 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.
...

Dart 

// ...

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

// Start a chat session with a template that has functions listed as tools.
final chatSessionWithSchemaOverride = model?.startChat(
      // Specify your template ID.
      'my-function-calling-template-with-no-function-schema-v1-0-0',
      inputs: {},
      // 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: [
        TemplateTool.functionDeclarations(
          [
            TemplateFunctionDeclaration(
              'fetchWeather',
              parameters: {
                'location': JSONSchema.object(
                  description:
                      'The name of the city and its state for which to get '
                      'the weather. Only cities in the USA are supported.',
                  properties: {
                    'city': JSONSchema.string(
                      description: 'The city of the location.',
                    ),
                    'state': JSONSchema.string(
                      description: 'The state of the location.',
                    ),
                    'zipCode': JSONSchema.integer(
                      description: 'Optional zip code of the location.',
                      nullable: true,
                    ),
                  },
                  optionalProperties: ['zipCode'],
                ),
                'date': JSONSchema.string(
                  description: 'The date for which to get the weather. '
                      'Date must be in the format: YYYY-MM-DD.',
                ),
                'unit': JSONSchema.enumString(
                  enumValues: ['CELSIUS', 'FAHRENHEIT'],
                  description: 'The temperature unit.',
                  nullable: true,
                ),
              },
              optionalParameters: ['unit'],
            ),
          ],
        ),
      ],
    );

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

// Check if the model wants to call a function.
// Note that this is the same as when *not* using server prompt templates.
...

Einheit 

// ...

// Initialize your chosen Gemini API backend service.
...

// Create a `TemplateGenerativeModel` instance.
...

// Define the schema for any functions listed in your template.
var fetchWeatherTool = new TemplateTool.FunctionDeclaration(
    name: "fetchWeather",
    parameters: new Dictionary<string, JsonSchema>() {
        { "location", JsonSchema.Object(
            description: "The name of the city and its state for which to get the weather. Only cities in the USA are supported.",
            properties: new Dictionary<string, JsonSchema>() {
                { "city", JsonSchema.String(description: "The city of the location.") },
                { "state", JsonSchema.String(description: "The state of the location.") },
                { "zipCode", JsonSchema.Int(description: "Optional zip code of the location.", nullable: true) }
            },
            optionalProperties: new[] { "zipCode" })
        },
        { "date", JsonSchema.String(description: "The date for which to get the weather. Date must be in the format: YYYY-MM-DD.")},
        { "unit", JsonSchema.Enum(
            values: new[] { "CELSIUS", "FAHRENHEIT" },
            description: "The temperature unit.",
            nullable: true)
        }
    },
    optionalParameters: new[] { "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: new[] { fetchWeatherTool }
);

try
{
   // 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.
  ...
}

// ...


Nächste Schritte