Samouczek wywoływania funkcji

Wywoływanie funkcji ułatwia uzyskiwanie uporządkowanych danych wyjściowych z modeli generatywnych. Następnie możesz używać tych danych do wywoływania innych interfejsów API i zwracania odpowiednich danych odpowiedzi do modelu. Innymi słowy, wywoływanie funkcji pomaga Ci łączyć modele generatywne z systemami zewnętrznymi, aby generowane treści zawierały jak najbardziej aktualne i dokładne informacje.

Możesz przekazywać modelom Gemini opisy funkcji. Są to funkcje zapisane w języku aplikacji (czyli nie są to funkcje Google Cloud Functions). Model może poprosić o wywołanie funkcji i odesłanie wyniku, aby pomóc w obróbce zapytania.

Jeśli jeszcze tego nie zrobiłeś, zapoznaj się z artykułem Wprowadzenie do wywoływania funkcji, aby dowiedzieć się więcej.

Przykład interfejsu API do sterowania oświetleniem

Wyobraź sobie, że masz podstawowy system sterowania oświetleniem z interfejsem programowania aplikacji (API) i chcesz umożliwić użytkownikom sterowanie światłami za pomocą prostych żądań tekstowych. Za pomocą funkcji wywoływania funkcji możesz interpretować żądania zmiany oświetlenia od użytkowników i przekształcać je w wywołania interfejsu API, aby ustawiać wartości oświetlenia. Ten hipotetyczny system sterowania oświetleniem umożliwia kontrolowanie jasności światła i jego temperatury barwowej, zdefiniowanych jako dwa oddzielne parametry:

Parametr Typ Wymagane Opis
brightness liczba tak Poziom światła od 0 do 100. Zero oznacza wyłączone, a 100 – pełną jasność.
colorTemperature ciąg znaków tak Temperatura kolorów oświetlenia, która może wynosić daylight, cool lub warm.

W ramach uproszczenia tego wyimaginowanego systemu oświetlenia ma on tylko jedną lampę, więc użytkownik nie musi określać pokoju ani lokalizacji. Oto przykładowy plik JSON, który możesz wysłać do interfejsu Lighting Control API, aby zmienić poziom światła na 50% przy użyciu temperatury barwowej światła dziennego:

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

W tym samouczku pokazujemy, jak skonfigurować wywołanie funkcji dla interfejsu Gemini API, aby interpretować żądania dotyczące oświetlenia użytkowników i mapować je na ustawienia interfejsu API w celu sterowania wartościami jasności i temperatury barwowej światła.

Zanim zaczniesz: skonfiguruj projekt i klucz interfejsu API

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

Definiowanie funkcji interfejsu API

Utwórz funkcję, która wysyła żądanie do interfejsu API. Funkcję tę należy zdefiniować w kodzie aplikacji, ale może ona wywoływać usługi lub interfejsy API spoza aplikacji. Interfejs Gemini API nie wywołuje tej funkcji bezpośrednio, więc możesz kontrolować, jak i kiedy jest ona wykonywana za pomocą kodu aplikacji. Na potrzeby tego samouczka zdefiniowaliśmy w nim fikcyjną funkcję interfejsu API, która zwraca tylko żądane wartości oświetlenia:

Future<Map<String, Object?>> setLightValues(
  Map<String, Object?> arguments,
) async =>
    // This mock API returns the requested lighting values
    {
      'brightness': arguments['brightness'],
      'colorTemperature': arguments['colorTemp'],
    };

Tworzenie deklaracji funkcji

Utwórz deklarację funkcji, którą przekażesz do modelu generatywnego. Podczas deklarowania funkcji do użycia przez model należy podać jak najwięcej szczegółów w opisie funkcji i parametrów. Model generatywny używa tych informacji, aby określić, którą funkcję wybrać i jak podać wartości parametrów w wywołaniu funkcji. Poniższy kod pokazuje, jak zadeklarować funkcję sterowania oświetleniem:

final lightControlTool = FunctionDeclaration(
    'setLightValues',
    'Set the brightness and color temperature of a room light.',
    Schema(SchemaType.object, properties: {
      'brightness': Schema(SchemaType.number,
          description: 'Light level from 0 to 100. '
              'Zero is off and 100 is full brightness.'),
      'colorTemperature': Schema(SchemaType.string,
          description: 'Color temperature of the light fixture, '
              'which can be `daylight`, `cool` or `warm`.'),
    }, requiredProperties: [
      'brightness',
      'colorTemperature'
    ]));

Deklarowanie funkcji podczas inicjowania modelu

Jeśli chcesz używać wywołań funkcji w przypadku modelu, podczas inicjowania obiektu modelu musisz podać deklaracje funkcji. Funkcje deklarujesz, ustawiając parametr tools modelu. Pakiet SDK Dart obsługuje też deklarowanie funkcji jako argumentów interfejsów API generateContent i generateContentStream.

final model = GenerativeModel(
  model: 'gemini-1.5-flash',
  apiKey: apiKey,

  // Specify the function declaration.
  tools: [
    Tool(functionDeclarations: [lightControlTool])
  ],
);

Generowanie wywołania funkcji

Po zainicjowaniu modelu za pomocą deklaracji funkcji możesz wywołać model za pomocą zdefiniowanej funkcji. Do wywoływania funkcji należy używać promptów czatu (sendMessage()), ponieważ wywoływanie funkcji zwykle korzysta z kontekstu poprzednich promptów i odpowiedzi.

final chat = model.startChat(); final prompt =
  'Dim the lights so the room feels cozy and warm.';

// Send the message to the generative model.
var response = await chat.sendMessage(Content.text(prompt));

final functionCalls = response.functionCalls.toList();
// When the model response with a function call, invoke the function.
if (functionCalls.isNotEmpty) {
  final functionCall = functionCalls.first;
  final result = switch (functionCall.name) {
    // Forward arguments to the hypothetical API.
    'setLightValues' => await setLightValues(functionCall.args),
    // Throw an exception if the model attempted to call a function that was
    // not declared.
    _ => throw UnimplementedError(
        'Function not implemented: ${functionCall.name}')
  };
  // Send the response to the model so that it can use the result to generate
  // text for the user.
  response = await chat
      .sendMessage(Content.functionResponse(functionCall.name, result));
}
// When the model responds with non-null text content, print it.
if (response.text case final text?) {
  print(text);
}