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 instalação do pacote do SDK e a inicialização do modelo.
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:
Parâmetro | Tipo | Obrigatório | Descrição |
---|---|---|---|
currencyDate
|
string | sim | Data em que será feita a busca da taxa de câmbio de (que precisa sempre estar no formato AAAA-MM-DD ou o valor latest se um período não for especificado) |
currencyFrom |
string | sim | Moeda de conversão |
currencyTo |
string | não | Moeda de conversão |
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.
func exchangeRate(currencyDate string,
currencyFrom string, currencyTo string) map[string]any {
// This hypothetical API returns a JSON such as:
// {"base":"USD","date":"2024-04-17","rates":{"SEK": 0.091}}
return map[string]any{
"base": currencyFrom,
"date": currencyDate,
"rates": map[string]any{currencyTo: 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.
currencyExchangeTool := &genai.Tool{
FunctionDeclarations: []*genai.FunctionDeclaration{{
Name: "exchangeRate",
Description: "Lookup currency exchange rates by date",
Parameters: &genai.Schema{
Type: genai.TypeObject,
Properties: map[string]*genai.Schema{
"currencyDate": {
Type: genai.TypeString,
Description: "A date that must always be in YYYY-MM-DD format" +
" or the value 'latest' if a time period is not specified",
},
"currencyFrom": {
Type: genai.TypeString,
Description: "Currency to convert from",
},
"currencyTo": {
Type: genai.TypeString,
Description: "Currency to convert to",
},
},
Required: []string{"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:
// ...
currencyExchangeTool := &genai.Tool{
// ...
}
// Use a model that supports function calling, like a Gemini 1.5 model
model := client.GenerativeModel("gemini-1.5-flash")
// Specify the function declaration.
model.Tools = []*genai.Tool{currencyExchangeTool}
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.
// Start new chat session.
session := model.StartChat()
prompt := "How much is 50 US dollars worth in Swedish krona?"
// Send the message to the generative model.
resp, err := session.SendMessage(ctx, genai.Text(prompt))
if err != nil {
log.Fatalf("Error sending message: %v\n", err)
}
// Check that you got the expected function call back.
part := resp.Candidates[0].Content.Parts[0]
funcall, ok := part.(genai.FunctionCall)
if !ok {
log.Fatalf("Expected type FunctionCall, got %T", part)
}
if g, e := funcall.Name, currencyExchangeTool.FunctionDeclarations[0].Name; g != e {
log.Fatalf("Expected FunctionCall.Name %q, got %q", e, g)
}
fmt.Printf("Received function call response:\n%q\n\n", part)
apiResult := map[string]any{
"base": "USD",
"date": "2024-04-17",
"rates": map[string]any{"SEK": 0.091}}
// Send the hypothetical API result back to the generative model.
fmt.Printf("Sending API result:\n%q\n\n", apiResult)
resp, err = session.SendMessage(ctx, genai.FunctionResponse{
Name: currencyExchangeTool.FunctionDeclarations[0].Name,
Response: apiResult,
})
if err != nil {
log.Fatalf("Error sending message: %v\n", err)
}
// Show the model's response, which is expected to be text.
for _, part := range resp.Candidates[0].Content.Parts {
fmt.Printf("%v\n", part)
}