Funktionsaufrufe erleichtern Ihnen, Ausgaben für strukturierte Daten generativen Modellen. Sie können diese Ausgaben dann verwenden, um andere APIs aufzurufen und die relevanten Antwortdaten an das Modell zu senden. Mit anderen Worten, Funktionsaufrufe helfen generative Modelle mit externen Systemen verbinden, damit die generierten Inhalte aktuelle und korrekte Informationen enthält.
Sie können Gemini-Modellen Beschreibungen von Funktionen zur Verfügung stellen. Dies sind Funktionen, die Sie in der Sprache Ihrer App schreiben (d. h. sie sind Google Cloud Functions). Das Modell fordert Sie möglicherweise auf, eine Funktion aufzurufen und das Ergebnis, damit das Modell Ihre Abfrage verarbeiten kann.
Falls Sie dies noch nicht getan haben, sollten Sie sich die Einführung in Funktionsaufrufe mehr.
Beispiel-API für die Beleuchtungssteuerung
Stellen Sie sich vor, Sie hätten eine einfache Lichtsteuerung mit einer Anwendungsprogrammierung. und es den Nutzern ermöglichen möchten, die Beleuchtung über Textanfragen. Mit der Funktion „Funktionsaufruf“ können Sie die Beleuchtung interpretieren und in API-Aufrufe umwandeln, um die Lichtverhältnisse Werte. Mit diesem hypothetischen Lichtsteuerungssystem kannst du Helligkeit des Lichts und seine Farbtemperatur, definiert als zwei separate Parameter:
Parameter | Typ | Erforderlich | Beschreibung |
---|---|---|---|
brightness |
Zahl | Ja | Lichtpegel von 0 bis 100. Null ist deaktiviert und 100 entspricht voller Helligkeit. |
colorTemperature |
String | Ja | Die Farbtemperatur der Leuchte. Kann daylight , cool oder warm sein. |
Der Einfachheit halber hat dieses imaginäre Beleuchtungssystem nur eine Leuchte, sodass die Nutzenden muss kein Raum oder Standort angeben. Hier ist ein Beispiel für eine JSON-Anfrage, können Sie an die Lighting Control API senden, um die Helligkeit auf 50 % zu ändern. mithilfe der Tageslicht-Farbtemperatur:
{
"brightness": "50",
"colorTemperature": "daylight"
}
In dieser Anleitung erfahren Sie, wie Sie einen Funktionsaufruf für die Gemini API einrichten, um Beleuchtungsanfragen der Nutzer interpretieren und API-Einstellungen zuordnen, um ein die Helligkeits- und Farbtemperaturwerte.
Hinweis: Projekt und API-Schlüssel einrichten
Bevor Sie die Gemini API aufrufen, müssen Sie Ihr Projekt einrichten und konfigurieren Ihren API-Schlüssel.
API-Funktion definieren
Erstellen Sie eine Funktion, die eine API-Anfrage stellt. Diese Funktion sollte definiert werden, innerhalb des Codes Ihrer Anwendung, könnte aber auch Dienste oder APIs außerhalb von Ihre Anwendung. Die Gemini API ruft diese Funktion nicht direkt auf. Sie müssen also kann steuern, wie und wann diese Funktion über Ihre Anwendung ausgeführt wird Code. Zu Demonstrationszwecken wird in dieser Anleitung eine API-Beispielfunktion definiert, die gibt nur die angeforderten Beleuchtungswerte zurück:
Future<Map<String, Object?>> setLightValues(
Map<String, Object?> arguments,
) async =>
// This mock API returns the requested lighting values
{
'brightness': arguments['brightness'],
'colorTemperature': arguments['colorTemp'],
};
Funktionsdeklarationen erstellen
Erstellen Sie die Funktionsdeklaration, die Sie an das generative Modell übergeben. Wann? eine Funktion zur Verwendung durch das Modell deklarieren, sollten Sie so viele Details wie möglich in den Funktions- und Parameterbeschreibungen. Das generative Modell bestimmt anhand dieser Informationen, welche Funktion ausgewählt und wie für die Parameter im Funktionsaufruf. Der folgende Code zeigt, wie Sie die Funktion zur Steuerung der Beleuchtung deklarieren:
final lightControlTool = FunctionDeclaration(
'setLightValues',
'Set the brightness and color temperature of a room light.',
Schema(SchemaType.object, properties: {
'brightness': Schema(SchemaType.number,
description: 'Light level from 0 to 100. '
'Zero is off and 100 is full brightness.'),
'colorTemperature': Schema(SchemaType.string,
description: 'Color temperature of the light fixture, '
'which can be `daylight`, `cool` or `warm`.'),
}, requiredProperties: [
'brightness',
'colorTemperature'
]));
Funktionen während der Modellinitialisierung deklarieren
Wenn Sie Funktionsaufrufe mit einem Modell verwenden möchten, müssen Sie Ihren
Funktionsdeklarationen beim Initialisieren des Modellobjekts. Sie erklären
indem Sie den Parameter tools
des Modells festlegen. Das Dart SDK unterstützt auch
Dabei werden die Funktionen als Argumente für generateContent
oder
generateContentStream
APIs
final model = GenerativeModel(
model: 'gemini-1.5-flash',
apiKey: apiKey,
// Specify the function declaration.
tools: [
Tool(functionDeclarations: [lightControlTool])
],
);
Funktionsaufruf generieren
Sobald Sie das Modell mit Ihren Funktionsdeklarationen initialisiert haben, können Sie
das Modell mit der definierten Funktion. Sie sollten Funktionsaufrufe mit
Chat-Prompts (sendMessage()
), da Funktionsaufrufe im Allgemeinen
im Kontext früherer Prompts und Antworten.
final chat = model.startChat(); final prompt =
'Dim the lights so the room feels cozy and warm.';
// Send the message to the generative model.
var response = await chat.sendMessage(Content.text(prompt));
final functionCalls = response.functionCalls.toList();
// When the model response with a function call, invoke the function.
if (functionCalls.isNotEmpty) {
final functionCall = functionCalls.first;
final result = switch (functionCall.name) {
// Forward arguments to the hypothetical API.
'setLightValues' => await setLightValues(functionCall.args),
// Throw an exception if the model attempted to call a function that was
// not declared.
_ => throw UnimplementedError(
'Function not implemented: ${functionCall.name}')
};
// Send the response to the model so that it can use the result to generate
// text for the user.
response = await chat
.sendMessage(Content.functionResponse(functionCall.name, result));
}
// When the model responds with non-null text content, print it.
if (response.text case final text?) {
print(text);
}