Usar a API Gemini para chamar funções


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

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

Saiba mais sobre chamadas de função na documentação do Google Cloud.

Antes de começar

Siga as etapas do Guia explicativo para SDKs da Vertex AI para Firebase, caso ainda não tenha feito isso. Verifique se você fez o seguinte:

  • Configure um projeto novo ou atual do Firebase, incluindo o uso do plano de preços Blaze e a ativação das APIs necessárias.

  • Conecte seu app ao Firebase, incluindo o registro do app e a adição da configuração do Firebase ao app.

  • Adicione o SDK e inicialize o serviço da Vertex AI e o modelo generativo no seu app.

Depois de conectar seu app ao Firebase, adicionar o SDK e inicializar o serviço da Vertex AI e o modelo generativo, você pode chamar a API Gemini.

Configurar uma chamada de função

Neste tutorial, você fará com que o modelo interaja com uma API hipotética de câmbio de moeda compatível com os seguintes parâmetros:

Parâmetro Tipo Obrigatório Descrição
currencyFrom string sim Moeda da qual converter
currencyTo string sim Moeda a ser convertida

Exemplo de solicitação de API

{
  "currencyFrom": "USD",
  "currencyTo": "SEK"
}

Exemplo de resposta da API

{
  "base": "USD",
  "rates": {"SEK": 10.99}
}

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, se ainda não tiver feito isso.

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

func makeAPIRequest(currencyFrom: String,
                    currencyTo: String) -> JSONObject {
  // This hypothetical API returns a JSON such as:
  // {"base":"USD","rates":{"SEK": 10.99}}
  return [
    "base": .string(currencyFrom),
    "rates": .object([currencyTo: .number(10.99)]),
  ]
}

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

Crie a declaração de 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 de funções e parâmetros. 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.

let getExchangeRate = FunctionDeclaration(
  name: "getExchangeRate",
  description: "Get the exchange rate for currencies between countries",
  parameters: [
    "currencyFrom": Schema(
      type: .string,
      description: "The currency to convert from."
    ),
    "currencyTo": Schema(
      type: .string,
      description: "The currency to convert to."
    ),
  ],
  requiredParameters: ["currencyFrom", "currencyTo"]
)

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 definindo o parâmetro tools do modelo:

import FirebaseVertexAI

// Initialize the Vertex AI service
let vertex = VertexAI.vertexAI()

// Initialize the generative model
// Use a model that supports function calling, like a Gemini 1.5 model
let model = vertex.generativeModel(
  modelName: "gemini-1.5-flash",
  // Specify the function declaration.
  tools: [Tool(functionDeclarations: [getExchangeRate])]
)

Aprenda a escolher um modelo do Gemini e, opcionalmente, um local adequado para seu caso de uso e app.

Etapa 4: gerar uma chamada de função

Agora você pode enviar o comando ao modelo com a função definida.

A maneira recomendada de usar a chamada de função é pela interface de chat, já que elas se encaixam perfeitamente na estrutura de vários turnos do chat.

let chat = model.startChat()

let prompt = "How much is 50 US dollars worth in Swedish krona?"

// Send the message to the generative model
let response1 = try await chat.sendMessage(prompt)

// Check if the model responded with a function call
guard let functionCall = response1.functionCalls.first else {
  fatalError("Model did not respond with a function call.")
}
// Print an error if the returned function was not declared
guard functionCall.name == "getExchangeRate" else {
  fatalError("Unexpected function called: \(functionCall.name)")
}
// Verify that the names and types of the parameters match the declaration
guard case let .string(currencyFrom) = functionCall.args["currencyFrom"] else {
  fatalError("Missing argument: currencyFrom")
}
guard case let .string(currencyTo) = functionCall.args["currencyTo"] else {
  fatalError("Missing argument: currencyTo")
}

// Call the hypothetical API
let apiResponse = makeAPIRequest(currencyFrom: currencyFrom, currencyTo: currencyTo)

// Send the API response back to the model so it can generate a text response that can be
// displayed to the user.
let response = try await chat.sendMessage([ModelContent(
  role: "function",
  parts: [.functionResponse(FunctionResponse(
    name: functionCall.name,
    response: apiResponse
  ))]
)])

// Log the text response.
guard let modelResponse = response.text else {
  fatalError("Model did not respond with text.")
}
print(modelResponse)

O que mais você pode fazer?

Teste outros recursos da API Gemini

Saiba como controlar a geração de conteúdo

Também é possível testar comandos e configurações de modelos usando o Vertex AI Studio.

Saiba mais sobre os modelos do Gemini

Saiba mais sobre os modelos disponíveis para vários casos de uso e as cotas e preços deles.


Envie feedback sobre sua experiência com a Vertex AI para Firebase