Wywoływanie funkcji ułatwia uzyskiwanie uporządkowanych danych wyjściowych z modeli generatywnych. Następnie możesz użyć tych danych wyjściowych, aby wywoływać inne interfejsy API i zwracać odpowiednie dane odpowiedzi do modelu. Inaczej mówiąc, wywołania funkcji pomagają połączyć modele generatywne z systemami zewnętrznymi, aby generowane treści zawierały aktualne i dokładne informacje.
Modelom Gemini możesz podawać opisy funkcji. Są to funkcje, które piszesz w języku swojej aplikacji (nie należą one do Google Cloud Functions). Model może poprosić Cię o wywołanie funkcji i odesłanie wyniku, aby model mógł lepiej obsłużyć zapytanie.
Więcej informacji znajdziesz w wprowadzeniu do wywoływania funkcji.
Konfigurowanie projektu
Zanim wywołasz interfejs Gemini API, musisz skonfigurować projekt, który obejmuje skonfigurowanie klucza interfejsu API, zainstalowanie pakietu SDK i zainicjowanie modelu.
Konfigurowanie wywołania funkcji
W tym samouczku model będzie wchodzić w interakcje z hipotetycznym interfejsem API wymiany walut, który obsługuje te parametry:
Parametr | Typ | Wymagane | Opis |
---|---|---|---|
currencyDate
|
string, | tak | Data pobrania kursu wymiany dla (musi zawsze mieć format RRRR-MM-DD lub wartość latest , jeśli nie określono przedziału czasu) |
currencyFrom |
string, | tak | Waluta, z której chcesz przeliczyć |
currencyTo |
string, | nie | Waluta do przeliczenia |
Przykładowe żądanie do interfejsu API
{
"currencyDate": "2024-04-17",
"currencyFrom": "USD",
"currencyTo": "SEK"
}
Przykładowa odpowiedź interfejsu API
{
"base": "USD",
"date": "2024-04-17",
"rates": {"SEK": 0.091}
}
Krok 1. Utwórz funkcję, która wysyła żądanie do interfejsu API
Zacznij od utworzenia funkcji, która wysyła żądanie do interfejsu API.
Na potrzeby demonstracji w tym samouczku zamiast wysyłania rzeczywistego żądania do interfejsu API będziesz zwracać wartości zakodowane na stałe w tym samym formacie, w jakim jest zwrócony interfejs API.
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}}
}
Krok 2. Utwórz deklarację funkcji
Utwórz deklarację funkcji, którą przekażesz do modelu generatywnego (następny krok tego samouczka).
W opisach funkcji i parametrów podaj jak najwięcej szczegółów. Model generatywny wykorzystuje te informacje do określenia, którą funkcję wybrać i jak podać wartości parametrów w jej wywołaniu.
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"},
},
}},
}
Krok 3. Określ deklarację funkcji podczas inicjowania modelu
Podczas inicjowania modelu generatywnego określ deklarację funkcji, przekazując ją do parametru Tools
modelu:
// ...
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}
Krok 4. Wygeneruj wywołanie funkcji
Teraz możesz wywołać dla modelu zdefiniowaną funkcję.
Zalecanym sposobem korzystania z wywołań funkcji jest korzystanie z interfejsu czatu, ponieważ wywołania funkcji dobrze pasują do wieloetapowej struktury czatu.
// 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)
}