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 uzyskanie klucza interfejsu API, zaimportowanie pakietu SDK i zainicjowanie modelu. Aby uzyskać szczegółowe instrukcje, rozwiń sekcje poniżej.
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 |
---|---|---|---|
currencyFrom |
string, | tak | Waluta, z której chcesz przeliczyć |
currencyTo |
string, | tak | Waluta do przeliczenia |
Przykładowe żądanie do interfejsu API
{
"currencyFrom": "USD",
"currencyTo": "SEK"
}
Przykładowa odpowiedź interfejsu API
{
"base": "USD",
"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.
async function makeApiRequest(currencyFrom, currencyTo) {
// This hypothetical API returns a JSON such as:
// {"base":"USD","rates":{"SEK": 0.091}}
return {
base: currencyFrom,
rates: { [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.
// Function declaration, to pass to the model.
const getExchangeRateFunctionDeclaration = {
name: "getExchangeRate",
parameters: {
type: "OBJECT",
description: "Get the exchange rate for currencies between countries",
properties: {
currencyFrom: {
type: "STRING",
description: "The currency to convert from.",
},
currencyTo: {
type: "STRING",
description: "The currency to convert to.",
},
},
required: ["currencyTo", "currencyFrom"],
},
};
// 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 = {
getExchangeRate: ({ currencyFrom, currencyTo }) => {
return makeApiRequest( currencyFrom, currencyTo)
}
};
Krok 3. Określ deklarację funkcji podczas inicjowania modelu
Podczas inicjowania modelu generatywnego określ deklarację funkcji, przekazując ją do parametru tools
modelu:
<html>
<body>
<!-- ... Your HTML and CSS -->
<script type="importmap">
{
"imports": {
"@google/generative-ai": "https://esm.run/@google/generative-ai"
}
}
</script>
<script type="module">
import { GoogleGenerativeAI } from "@google/generative-ai";
// Fetch your API_KEY
const API_KEY = "...";
// Access your API key (see "Set up your API key" above)
const genAI = new GoogleGenerativeAI(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: [getExchangeRateFunctionDeclaration],
},
});
</script>
</body>
</html>
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.
const chat = generativeModel.startChat();
const prompt = "How much is 50 US dollars worth in Swedish krona?";
// 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 result = await chat.sendMessage([{functionResponse: {
name: 'getExchangeRate',
response: apiResponse
}}]);
// Log the text response.
console.log(result.response.text());
}