Używanie interfejsu Gemini API do wywoływania funkcji


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ą w Cloud Functions). Model może poprosić o wywołanie funkcji i odesłanie aby ułatwić modelowi obsługę zapytania.

Dostępne opcje więcej informacji o wywoływaniu funkcji znajdziesz w dokumentacji Google Cloud.

Zanim zaczniesz

W razie potrzeby wykonaj jeszcze raz wprowadzenie do pakietów SDK Vertex AI dla Firebase Upewnij się, że masz wykonane wszystkie te czynności:

  • Skonfiguruj nowy lub istniejący projekt Firebase, w tym Abonament Blaze i włączanie wymaganych interfejsów API.

  • połączyć aplikację z Firebase, w tym zarejestrować ją i dodać do konfigurację Firebase w aplikacji.

  • Dodaj pakiet SDK i zainicjuj usługę Vertex AI oraz model generatywny w aplikacji.

Gdy połączysz aplikację z Firebase, dodasz pakiet SDK i zainicjujesz usługę Vertex AI i model generatywny, możesz już wywołać interfejs Gemini API.

Skonfiguruj wywołanie funkcji

W tym samouczku model będzie wchodzić w interakcję z hipotetyczną walutą API Exchange, który obsługuje te parametry:

Parametr Typ Wymagane Opis
currencyFrom ciąg znaków tak Waluta, z której zostanie przeliczony
currencyTo ciąg znaków tak Waluta, na którą zostanie przeliczona

Przykładowe żądanie do interfejsu API

{
  "currencyFrom": "USD",
  "currencyTo": "SEK"
}

Przykładowa odpowiedź interfejsu API

{
  "base": "USD",
  "rates": {"SEK": 10.99}
}

Krok 1. Utwórz funkcję, która wysyła żądanie do interfejsu API

Zacznij od utworzenia funkcji, która tworzy Żądanie do interfejsu API.

Zamiast wysyłania rzeczywistego interfejsu API na potrzeby prezentacji w tym samouczku będziesz zwracać wartości zakodowane na stałe w tym samym formacie Interfejs API zostanie zwrócony.

func makeAPIRequest(currencyFrom: String,
                    currencyTo: String) -> JSONObject {
  // This hypothetical API returns a JSON such as:
  // {"base":"USD","rates":{"SEK": 10.99}}
  return [
    "base": .string(currencyFrom),
    "rates": .object([currencyTo: .number(10.99)]),
  ]
}

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ć oraz jak podać wartości parametrów w wywołaniu funkcji.

let getExchangeRate = FunctionDeclaration(
  name: "getExchangeRate",
  description: "Get the exchange rate for currencies between countries",
  parameters: [
    "currencyFrom": Schema(
      type: .string,
      description: "The currency to convert from."
    ),
    "currencyTo": Schema(
      type: .string,
      description: "The currency to convert to."
    ),
  ],
  requiredParameters: ["currencyFrom", "currencyTo"]
)

Krok 3. Określ deklarację funkcji podczas inicjowania modelu

Określ deklarację funkcji podczas inicjowania modelu generatywnego przez ustawianie parametru tools modelu:

import FirebaseVertexAI

// Initialize the Vertex AI service
let vertex = VertexAI.vertexAI()

// Initialize the generative model
// Use a model that supports function calling, like a Gemini 1.5 model
let model = vertex.generativeModel(
  modelName: "gemini-1.5-flash",
  // Specify the function declaration.
  tools: [Tool(functionDeclarations: [getExchangeRate])]
)

Dowiedz się, jak wybrać model Gemini i opcjonalnie lokalizację odpowiednio do konkretnego przypadku użycia i aplikacji.

Krok 4. Wygeneruj wywołanie funkcji

Teraz możesz utworzyć prompt dla modelu za pomocą zdefiniowanej funkcji.

Zalecany sposób wywoływania funkcji to interfejs czatu, ponieważ które świetnie pasują do wieloetapowej struktury czatu.

let chat = model.startChat()

let prompt = "How much is 50 US dollars worth in Swedish krona?"

// Send the message to the generative model
let response1 = try await chat.sendMessage(prompt)

// Check if the model responded with a function call
guard let functionCall = response1.functionCalls.first else {
  fatalError("Model did not respond with a function call.")
}
// Print an error if the returned function was not declared
guard functionCall.name == "getExchangeRate" else {
  fatalError("Unexpected function called: \(functionCall.name)")
}
// Verify that the names and types of the parameters match the declaration
guard case let .string(currencyFrom) = functionCall.args["currencyFrom"] else {
  fatalError("Missing argument: currencyFrom")
}
guard case let .string(currencyTo) = functionCall.args["currencyTo"] else {
  fatalError("Missing argument: currencyTo")
}

// Call the hypothetical API
let apiResponse = makeAPIRequest(currencyFrom: currencyFrom, currencyTo: currencyTo)

// Send the API response back to the model so it can generate a text response that can be
// displayed to the user.
let response = try await chat.sendMessage([ModelContent(
  role: "function",
  parts: [.functionResponse(FunctionResponse(
    name: functionCall.name,
    response: apiResponse
  ))]
)])

// Log the text response.
guard let modelResponse = response.text else {
  fatalError("Model did not respond with text.")
}
print(modelResponse)

Co jeszcze możesz zrobić?

Wypróbuj inne możliwości interfejsu Gemini API

Dowiedz się, jak kontrolować generowanie treści

. Możesz też eksperymentować z promptami i konfiguracjami modeli za pomocą Vertex AI Studio

Więcej informacji o modelach Gemini

Dowiedz się więcej o dostępne modele do różnych zastosowań oraz ich poniższych limitów i cen.


Przesyłanie opinii o swoich doświadczeniach z Vertex AI dla Firebase,