Samouczek wywoływania funkcji

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

Wywołania funkcji ułatwiają uzyskiwanie danych wyjściowych uporządkowanych danych z modeli generatywnych. Następnie możesz używać tych danych wyjściowych do wywoływania innych interfejsów API i zwracania odpowiednich danych odpowiedzi do modelu. Inaczej mówiąc, wywołanie funkcji pomaga połączyć modele generatywne z systemami zewnętrznymi, aby generowane treści zawierały najbardziej aktualne i dokładne informacje.

Modele Gemini możesz przesłać z opisami funkcji. Są to funkcje, które piszesz w języku aplikacji (czyli nie są to funkcje Google Cloud). Model może poprosić o wywołanie funkcji i odesłanie wyniku, aby ułatwić mu obsługę zapytania.

Więcej informacji znajdziesz we wprowadzeniu do wywoływania funkcji.

Przykładowy interfejs API do sterowania oświetleniem

Załóżmy, że masz podstawowy system sterowania oświetleniem z interfejsem programowania aplikacji (API) i chcesz umożliwić użytkownikom sterowanie oświetleniem za pomocą prostych żądań tekstowych. Możesz użyć funkcji wywołań funkcji, aby zinterpretować prośby użytkowników o zmianę oświetlenia i przełożyć je na wywołania interfejsu API w celu ustawienia wartości oświetlenia. Ten hipotetyczny system sterowania oświetleniem umożliwia kontrolowanie jasności światła oraz temperatury barwowej za pomocą 2 osobnych parametrów:

Dla uproszczenia ten wymyślony system oświetleniowy ma tylko 1 światło, więc użytkownik nie musi określać pomieszczenia ani lokalizacji. Oto przykładowe żądanie JSON, które możesz wysłać do interfejsu API sterowania oświetleniem, aby zmienić poziom jasności na 50% z użyciem temperatury barwowej światła dziennego:

{
  "brightness": "50",
  "colorTemperature": "daylight"
}

Ten samouczek pokazuje, jak skonfigurować wywołanie funkcji dla interfejsu Gemini API, aby zinterpretować żądania dotyczące oświetlenia i mapować je na ustawienia interfejsu API w celu sterowania wartościami jasności i temperatury kolorów.

Zanim zaczniesz: skonfiguruj projekt i klucz interfejsu API

Zanim wywołasz Gemini API, musisz skonfigurować projekt i klucz interfejsu API.

Zdefiniuj funkcję interfejsu API

utworzyć funkcję, która wysyła żądanie do interfejsu API; Ta funkcja powinna być zdefiniowana w kodzie aplikacji, ale może wywoływać usługi lub interfejsy API poza nią. Interfejs Gemini API nie wywołuje tej funkcji bezpośrednio, więc możesz kontrolować, jak i kiedy ta funkcja jest wykonywana za pomocą kodu aplikacji. Dla celów demonstracyjnych ten samouczek definiuje przykładową funkcję interfejsu API, która zwraca żądane wartości oświetlenia:

func setLightValues(brightness int, colorTemp string) map[string]any {
    // This mock API returns the requested lighting values
    return map[string]any{
        "brightness":       brightness,
        "colorTemperature": colorTemp}
}

Utwórz deklarację funkcji

Utwórz deklarację funkcji, którą przekażesz do modelu generatywnego. Deklarując funkcję do użycia przez model, podaj jak najwięcej szczegółów w opisach funkcji i parametrów. Na podstawie tych informacji model generatywny określa, którą funkcję wybrać i jak podać wartości dla parametrów w wywołaniu funkcji. Ten kod pokazuje, jak zadeklarować funkcję sterowania oświetleniem:

lightControlTool := &genai.Tool{
    FunctionDeclarations: []*genai.FunctionDeclaration{{
        Name:        "controlLight",
        Description: "Set the brightness and color temperature of a room light.",
        Parameters: &genai.Schema{
            Type: genai.TypeObject,
            Properties: map[string]*genai.Schema{
                "brightness": {
                    Type:        genai.TypeString,
                    Description: "Light level from 0 to 100. Zero is off and"+
                        " 100 is full brightness.",
                },
                "colorTemperature": {
                    Type:        genai.TypeString,
                    Description: "Color temperature of the light fixture which" +
                        " can be `daylight`, `cool` or `warm`.",
                },
            },
            Required: []string{"currencyDate", "currencyFrom"},
        },
    }},
}

Deklarowanie funkcji podczas inicjowania modelu

Jeśli chcesz używać wywołań funkcji z modelem, musisz podczas inicjowania obiektu modelu przesłać deklaracje funkcji. Aby zadeklarować funkcje, ustaw parametr Tools modelu:

// ...

lightControlTool := &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{lightControlTool}

Wygeneruj wywołanie funkcji

Po zainicjowaniu modelu z deklaracjami funkcji możesz wyświetlić prompt za pomocą zdefiniowanej funkcji. Wywoływać funkcji należy używać za pomocą promptów na czacie (SendMessage()), ponieważ wywołanie funkcji zwykle korzysta z kontekstu poprzednich promptów i odpowiedzi.

// Start new chat session.
session := model.StartChat()

prompt := "Dim the lights so the room feels cozy and warm."

// 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, lightControlTool.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{
    "brightness":  "30",
    "colorTemperature":  "warm" }

// 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:     lightControlTool.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)
}