Anleitung: Funktionsaufruf mit der Gemini API

Python Node.js Go Dart (Flutter) Android Swift Web

Funktionsaufrufe erleichtern Ihnen die Ausgabe strukturierter Daten aus generativen Modellen. Sie können diese Ausgaben dann verwenden, um andere APIs aufzurufen und die relevanten Antwortdaten an das Modell zurückzugeben. Mit anderen Worten: Funktionsaufrufe helfen Ihnen, generative Modelle mit externen Systemen zu verbinden, damit der generierte Inhalt die aktuellsten und genauesten Informationen enthält.

Sie können Gemini-Modelle mit Funktionsbeschreibungen bereitstellen. Dies sind Funktionen, die Sie in der Sprache Ihrer Anwendung schreiben (d. h. sie sind nicht Google Cloud Functions). Möglicherweise fordert das Modell Sie auf, eine Funktion aufzurufen und das Ergebnis zurückzusenden, um das Modell bei der Verarbeitung Ihrer Abfrage zu unterstützen.

Weitere Informationen finden Sie unter Einführung in Funktionsaufrufe.

Projekt einrichten

Bevor Sie die Gemini API aufrufen, müssen Sie Ihr Xcode-Projekt einrichten. Dazu müssen Sie Ihren API-Schlüssel einrichten, dem Xcode-Projekt das SDK-Paket hinzufügen und das Modell initialisieren.

enum APIKey {
  // Fetch the API key from `GenerativeAI-Info.plist`
  static var `default`: String {
    guard let filePath = Bundle.main.path(forResource: "GenerativeAI-Info", ofType: "plist")
    else {
      fatalError("Couldn't find file 'GenerativeAI-Info.plist'.")
    }
    let plist = NSDictionary(contentsOfFile: filePath)
    guard let value = plist?.object(forKey: "API_KEY") as? String else {
      fatalError("Couldn't find key 'API_KEY' in 'GenerativeAI-Info.plist'.")
    }
    if value.starts(with: "_") {
      fatalError(
        "Follow the instructions at https://ai.google.dev/tutorials/setup to get an API key."
      )
    }
    return value
  }
}

Funktionsaufruf einrichten

Im Rahmen dieser Anleitung interagiert das Modell mit einer hypothetischen Währungstausch-API, die die folgenden Parameter unterstützt:

Beispiel für eine API-Anfrage

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

Beispiel für eine API-Antwort

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

Schritt 1: Funktion erstellen, die die API-Anfrage stellt

Erstellen Sie zuerst die Funktion, die eine API-Anfrage stellt, falls noch nicht geschehen.

Zu Demonstrationszwecken werden in dieser Anleitung statt einer API-Anfrage hartcodierte Werte in demselben Format zurückgegeben, das eine echte API zurückgeben würde.

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

Schritt 2: Funktionsdeklaration erstellen

Erstellen Sie die Funktionsdeklaration, die Sie an das generative Modell übergeben (nächster Schritt dieser Anleitung).

Geben Sie so viele Details wie möglich in die Funktions- und Parameterbeschreibung ein. Das generative Modell verwendet diese Informationen, um zu bestimmen, welche Funktion ausgewählt werden soll und wie Werte für die Parameter im Funktionsaufruf bereitgestellt werden.

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"]
)

Schritt 3: Funktionsdeklaration bei der Modellinitialisierung angeben

Geben Sie die Funktionsdeklaration beim Initialisieren des generativen Modells an, indem Sie den Parameter tools des Modells festlegen:

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

Schritt 4: Funktionsaufruf generieren

Jetzt können Sie das Modell mit der definierten Funktion abfragen.

Die empfohlene Methode zum Verwenden von Funktionsaufrufen erfolgt über die Chat-Oberfläche, da Funktionsaufrufe gut in die Multi-Turn-Struktur eines Chats passen.

let chat = generativeModel.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)