Tutorial sulla chiamata di funzione

Python Node.js Vai Fretta (flussi) Android Swift Web

La chiamata di funzione semplifica l'ottenimento di output di dati strutturati da e modelli generativi. Puoi quindi utilizzare questi output per chiamare altre API e restituire i dati di risposta pertinenti al modello. In altre parole, la chiamata di funzione colleghi modelli generativi a sistemi esterni in modo che i contenuti generati includa le informazioni più aggiornate e accurate.

Puoi fornire ai modelli Gemini descrizioni delle funzioni. Si tratta di di funzioni che scrivi nella lingua della tua app (ovvero, Google Cloud Functions). Il modello potrebbe chiederti di richiamare una funzione e restituirla il risultato per aiutare il modello a gestire la query.

Se non l'hai già fatto, consulta il Introduzione alle chiamate di funzione per imparare altro ancora.

API di esempio per il controllo dell'illuminazione

Immagina di avere un sistema di base per il controllo dell'illuminazione con una programmazione di un'applicazione (API) e vuoi consentire agli utenti di controllare le luci tramite semplici richieste di testo. Puoi utilizzare la funzionalità di chiamata di funzione per interpretare l'illuminazione modificare le richieste degli utenti e tradurle in chiamate API per e i relativi valori. Questo ipotetico sistema di controllo dell'illuminazione ti consente di controllare luminosità della luce e la relativa temperatura di colore, definita come due parametri:

Per semplicità, questo sistema di illuminazione immaginario ha una sola illuminazione, quindi l'utente non richiede di specificare una stanza o un luogo. Ecco un esempio di richiesta JSON puoi inviare all'API di controllo della luce per impostare il livello della luce al 50% utilizzando la temperatura di colore della luce diurna:

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

Questo tutorial mostra come configurare una chiamata di funzione per l'API Gemini interpretare le richieste di illuminazione degli utenti e mapparle alle impostazioni API per controllare i valori di luminosità e temperatura di colore della luce.

Prima di iniziare: configura il progetto e la chiave API

Prima di chiamare l'API Gemini, devi impostare il tuo progetto la chiave API.

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
  }
}

Definisci una funzione API

Creare una funzione che invia una richiesta API. Questa funzione deve essere definita nel codice della tua applicazione, ma potresti chiamare servizi o API all'esterno la tua applicazione. L'API Gemini non chiama direttamente questa funzione, quindi puoi controllare come e quando questa funzione viene eseguita tramite la tua applicazione le API nel tuo codice. A scopo dimostrativo, questo tutorial definisce una funzione API fittizia che restituisce solo i valori di illuminazione richiesti:

func setLightValues(brightness: String,
                    colorTemp: String) -> JSONObject {
  // This mock API returns the requested lighting values
  return [
    "brightness": .string(brightness),
    "colorTemperature": .string(colorTemp)
  ]
}

crea dichiarazioni di funzione

Crea la dichiarazione di funzione che passerai al modello generativo. Quando dichiari una funzione che deve essere utilizzata dal modello, devi includere il maggior numero di dettagli il più possibile nelle descrizioni delle funzioni e dei parametri. Il modello generativo utilizza queste informazioni per determinare quale funzione selezionare e come offrire per i parametri nella chiamata di funzione. Il seguente codice mostra come dichiara la funzione di controllo dell'illuminazione:

let controlLightFunctionDeclaration = FunctionDeclaration(
  name: "controlLight",
  description: "Set the brightness and color temperature of a room light.",
  parameters: [
    "brightness": Schema(
      type: .string,
      description: "Light level from 0 to 100. Zero is off and 100 is full brightness."
    ),
    "colorTemperature": Schema(
      type: .string,
      description: "Color temperature of the light fixture which can be `daylight`, `cool` or `warm`."
    ),
  ],
  requiredParameters: ["brightness", "colorTemperature"]
)

Dichiara le funzioni durante l'inizializzazione del modello

Quando vuoi utilizzare la chiamata di funzione con un modello, devi fornire le dichiarazioni di funzione quando inizializzato l'oggetto modello. Dichiari le funzioni impostando il parametro tools del modello:

// 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: [controlLightFunctionDeclaration])]
)

Genera una chiamata di funzione

Dopo aver inizializzato il modello con le dichiarazioni di funzione, puoi richiedere del modello con la funzione definita. Dovresti usare le chiamate di funzione utilizzando prompt di chat (sendMessage()), poiché le chiamate di funzione in genere beneficiano contesto dei prompt e delle risposte precedenti.

let chat = generativeModel.startChat()

let prompt = "Dim the lights so the room feels cozy and warm."

// 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 == "controlLight" else {
  fatalError("Unexpected function called: \(functionCall.name)")
}
// Verify that the names and types of the parameters match the declaration
guard case let .string(brightness) = functionCall.args["brightness"] else {
  fatalError("Missing argument: brightness")
}
guard case let .string(colorTemp) = functionCall.args["colorTemperature"] else {
  fatalError("Missing argument: colorTemperature")
}

// Call the hypothetical API
let apiResponse = setLightValues(brightness: brightness, colorTemperature: colorTemp)

// 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)