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ż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 napisane w języku aplikacji (czyli nie są to funkcje 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ład interfejsu 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 kontrolowanie jasności światła i jego temperatury barwowej, zdefiniowanych jako dwa oddzielne parametry:

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ł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 w interfejsie 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.

Zdefiniuj funkcję 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. 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. Na potrzeby demonstracji ten samouczek definiuje fikcyjną funkcję interfejsu API, która zwraca tylko żądane wartości oświetlenia:

async function setLightValues(brightness, colorTemp) {
  // This mock API returns the requested lighting values
  return {
    brightness: brightness,
    colorTemperature: colorTemp
  };
}

Tworzenie deklaracji 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 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:

const controlLightFunctionDeclaration = {
  name: "controlLight",
  parameters: {
    type: "OBJECT",
    description: "Set the brightness and color temperature of a room light.",
    properties: {
      brightness: {
        type: "NUMBER",
        description: "Light level from 0 to 100. Zero is off and 100 is full brightness.",
      },
      colorTemperature: {
        type: "STRING",
        description: "Color temperature of the light fixture which can be `daylight`, `cool` or `warm`.",
      },
    },
    required: ["brightness", "colorTemperature"],
  },
};

// Executable function code. Put it in a map keyed by the function name
// so that you can call it once you get the name string from the model.
const functions = {
  controlLight: ({ brightness, colorTemperature }) => {
    return setLightValues( 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. Funkcje deklarujesz, ustawiając parametr tools modelu:

const { GoogleGenerativeAI } = require("@google/generative-ai");

// Access your API key as an environment variable (see "Set up your API key" above)
const genAI = new GoogleGenerativeAI(process.env.API_KEY);

// ...

const generativeModel = genAI.getGenerativeModel({
  // Use a model that supports function calling, like a Gemini 1.5 model
  model: "gemini-1.5-flash",

  // Specify the function declaration.
  tools: {
    functionDeclarations: [controlLightFunctionDeclaration],
  },
});

Generowanie wywołania funkcji

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

const chat = generativeModel.startChat();
const prompt = "Dim the lights so the room feels cozy and warm.";

// Send the message to the model.
const result = await chat.sendMessage(prompt);

// For simplicity, this uses the first function call found.
const call = result.response.functionCalls()[0];

if (call) {
  // Call the executable function named in the function call
  // with the arguments specified in the function call and
  // let it call the hypothetical API.
  const apiResponse = await functions[call.name](call.args);

  // Send the API response back to the model so it can generate
  // a text response that can be displayed to the user.
  const result2 = await chat.sendMessage([{functionResponse: {
    name: 'controlLight',
    response: apiResponse
  }}]);

  // Log the text response.
  console.log(result2.response.text());
}