Samouczek wywoływania funkcji

Python Node.js Przejdź Dart (migotanie) Android Swift Internet

Wywołanie funkcji ułatwia pobieranie danych wyjściowych z uporządkowanych danych modeli generatywnych. Następnie możesz użyć tych danych wyjściowych do wywołania innych interfejsów API i zwrócenia odpowiednich danych odpowiedzi dla modelu. Innymi słowy, wywołanie funkcji pomaga Łączysz modele generatywne z systemami zewnętrznymi, aby wygenerowane treści zawiera najbardziej aktualne i dokładne informacje.

Modele Gemini możesz przesłać z opisami funkcji. Są to funkcje napisane w języku aplikacji (tzn. nie są Google Cloud Functions). Model może poprosić o wywołanie funkcji i odesłanie aby ułatwić modelowi obsługę zapytania.

Zapoznaj się z Wprowadzenie do wywoływania funkcji więcej.

Przykładowy interfejs API do sterowania oświetleniem

Wyobraź sobie, że masz podstawowy system sterowania oświetleniem i programowanie interfejsu (API) i chcesz umożliwić użytkownikom sterowanie oświetleniem za pomocą prostego żądań tekstowych. Możesz skorzystać z funkcji wywoływania funkcji, aby interpretować oświetlenie zmieniać żądania użytkowników i przekształcać je w wywołania interfejsu API w celu ustawienia oświetlenia . Ten hipotetyczny system sterowania oświetleniem umożliwia jasność światła i temperaturę barwową, które są zdefiniowane jako oddzielne parametry:

Dla uproszczenia ten wymyślony system oświetleniowy ma tylko jedno światło, dzięki czemu użytkownik nie musi określać pomieszczenia ani lokalizacji. Oto przykładowe żądanie JSON można wysłać do interfejsu API sterowania oświetleniem, aby zmienić poziom światła na 50% używając temperatury barwowej światła dziennego:

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

W tym samouczku pokazujemy, jak skonfigurować wywołanie funkcji dla interfejsu Gemini API interpretować żądania użytkowników dotyczące oświetlenia i mapować je na ustawienia interfejsu API, jasność i temperaturę barwową.

Zanim zaczniesz: skonfiguruj projekt i klucz interfejsu API

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

Zdefiniuj funkcję interfejsu API

utworzyć funkcję, która wysyła żądanie do interfejsu API; Tę funkcję należy zdefiniować w kodzie aplikacji, ale może wywoływać usługi lub interfejsy API poza Twojej aplikacji. Gemini API nie wywołuje tej funkcji bezpośrednio, więc może kontrolować sposób i czas wykonywania tej funkcji w aplikacji w kodzie. Dla celów demonstracyjnych w tym samouczku zdefiniowano imitację funkcji interfejsu API, która po prostu 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. Kiedy zadeklarujesz funkcję do użytku przez model, podaj jak najwięcej szczegółów w opisach funkcji i parametrów. Model generatywny wykorzystuje te informacje do określenia, którą funkcję wybrać i jak udostępnić parametrów w wywołaniu funkcji. Ten kod pokazuje, jak zadeklaruj 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{"brightness", "colorTemperature"},
        },
    }},
}

Deklarowanie funkcji podczas inicjowania modelu

Jeśli chcesz używać wywołań funkcji z modelem, musisz podać deklaracji funkcji podczas inicjowania obiektu modelu. Deklarujesz funkcje przez ustawienie parametru 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 poprosić model ze zdefiniowaną funkcją. Wywoływania funkcji należy używać za pomocą: promptów na czacie (SendMessage()), ponieważ wywołanie funkcji zazwyczaj przynosi korzyści w kontekście 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)
}