Tutorial: chamada de funções com a API Gemini

Python Node.js Go Dart (Flutter) Android Swift Web

A chamada de função facilita a geração de saídas de dados estruturados de modelos generativos. Assim, é possível usar essas saídas para chamar outras APIs e retornar os dados de resposta relevantes para o modelo. Em outras palavras, a chamada de função ajuda a conectar modelos generativos a sistemas externos para que o conteúdo gerado inclua as informações mais atualizadas e precisas.

É possível fornecer modelos do Gemini com descrições de funções. São funções que você escreve na linguagem do seu app (ou seja, não são funções do Google Cloud). O modelo pode pedir que você chame uma função e envie o resultado para ajudar o modelo a processar a consulta.

Se ainda não fez isso, confira a Introdução à chamada de função para saber mais.

Configurar seu projeto

Antes de chamar a API Gemini, você precisa configurar seu projeto, o que inclui a configuração da chave de API, a adição do SDK às dependências do Pub e a inicialização do modelo.

dart pub add google_generative_ai

flutter pub add google_generative_ai

import 'package:google_generative_ai/google_generative_ai.dart';

// Access your API key as an environment variable (see "Set up your API key" above)
final apiKey = Platform.environment['API_KEY'];
if (apiKey == null) {
  print('No \$API_KEY environment variable');
  exit(1);
}

// Use a model that supports function calling, like a Gemini 1.5 model
final model = GenerativeModel(model: 'gemini-1.5-flash', apiKey: apiKey);

Configurar uma chamada de função

Neste tutorial, o modelo vai interagir com uma API hipotética de troca de moedas compatível com os seguintes parâmetros:

Exemplo de solicitação de API

{
  "currencyDate": "2024-04-17",
  "currencyFrom": "USD",
  "currencyTo": "SEK"
}

Exemplo de resposta da API

{
  "base": "USD",
  "date": "2024-04-17",
  "rates": {"SEK": 0.091}
}

Etapa 1: criar a função que faz a solicitação de API

Comece criando a função que faz uma solicitação de API, caso ainda não tenha feito isso.

Para fins de demonstração neste tutorial, em vez de enviar uma solicitação de API real, você retornará valores fixados no código no mesmo formato que uma API real retornaria.

Future<Map<String, Object?>> findExchangeRate(
  Map<String, Object?> arguments,
) async =>
    // This hypothetical API returns a JSON such as:
    // {"base":"USD","date":"2024-04-17","rates":{"SEK": 0.091}}
    {
      'date': arguments['currencyDate'],
      'base': arguments['currencyFrom'],
      'rates': <String, Object?>{arguments['currencyTo'] as String: 0.091}
    };

Etapa 2: criar uma declaração de função

Crie a declaração da função que você vai transmitir para o modelo generativo (próxima etapa deste tutorial).

Inclua o máximo de detalhes possível nas descrições da função e do parâmetro. O modelo generativo usa essas informações para determinar qual função selecionar e como fornecer valores para os parâmetros na chamada de função.

final exchangeRateTool = FunctionDeclaration(
    'findExchangeRate',
    'Returns the exchange rate between currencies on given date.',
    Schema(SchemaType.object, properties: {
      'currencyDate': Schema(SchemaType.string,
          description: 'A date in YYYY-MM-DD format or '
              'the exact value "latest" if a time period is not specified.'),
      'currencyFrom': Schema(SchemaType.string,
          description: 'The currency code of the currency to convert from, '
              'such as "USD".'),
      'currencyTo': Schema(SchemaType.string,
          description: 'The currency code of the currency to convert to, '
              'such as "USD".')
    }, requiredProperties: [
      'currencyDate',
      'currencyFrom'
    ]));

Etapa 3: especificar a declaração da função durante a inicialização do modelo

Especifique a declaração da função ao inicializar o modelo generativo transmitindo-o para o parâmetro tools do modelo:

final model = GenerativeModel(
  // Use a model that supports function calling, like a Gemini 1.5 model
  model: 'gemini-1.5-flash',
  apiKey: apiKey,

  // Specify the function declaration.
  tools: [
    Tool(functionDeclarations: [exchangeRateTool])
  ],
);

Etapa 4: gerar uma chamada de função

Agora é possível solicitar o modelo com a função definida.

A maneira recomendada de usar a chamada de funções é pela interface de chat, já que as chamadas de função se encaixam perfeitamente na estrutura de várias interações do chat.

final chat = model.startChat();
final prompt = 'How much is 50 US dollars worth in Swedish krona?';

// Send the message to the generative model.
var response = await chat.sendMessage(Content.text(prompt));

final functionCalls = response.functionCalls.toList();
// When the model response with a function call, invoke the function.
if (functionCalls.isNotEmpty) {
  final functionCall = functionCalls.first;
  final result = switch (functionCall.name) {
    // Forward arguments to the hypothetical API.
    'findExchangeRate' => await findExchangeRate(functionCall.args),
    // Throw an exception if the model attempted to call a function that was
    // not declared.
    _ => throw UnimplementedError(
        'Function not implemented: ${functionCall.name}')
  };
  // Send the response to the model so that it can use the result to generate
  // text for the user.
  response = await chat
      .sendMessage(Content.functionResponse(functionCall.name, result));
}
// When the model responds with non-null text content, print it.
if (response.text case final text?) {
  print(text);
}