Funktionsaufrufe mit der Gemini API

Mit Funktionsaufrufen können Sie Modelle mit externen Tools und APIs verbinden. Anstatt Textantworten zu generieren, versteht das Modell, wann bestimmte Funktionen aufgerufen werden müssen, und stellt die erforderlichen Parameter für die Ausführung realer Aktionen bereit. So kann das Modell als Brücke zwischen natürlicher Sprache und realen Aktionen und Daten dienen. Funktionsaufrufe haben drei Hauptanwendungsfälle:

• Wissen erweitern:Sie können auf Informationen aus externen Quellen wie Datenbanken, APIs und Wissensdatenbanken zugreifen.
• Funktionen erweitern:Mit externen Tools können Sie Berechnungen durchführen und die Einschränkungen des Modells erweitern, z. B. mit einem Taschenrechner oder durch Erstellen von Diagrammen.
• Aktionen ausführen:Mithilfe von APIs mit externen Systemen interagieren, z. B. Termine planen, Rechnungen erstellen, E-Mails senden oder Smart-Home-Geräte steuern

Wetter abrufen Videokonferenz planen Diagramm erstellen

Funktionsweise von Funktionsaufrufen

Der Funktionsaufruf umfasst eine strukturierte Interaktion zwischen Ihrer Anwendung, dem Modell und externen Funktionen. So funktionierts:

1. Funktionsdeklaration definieren:Definieren Sie die Funktionsdeklaration in Ihrem Anwendungscode. Funktionsdeklarationen beschreiben dem Modell den Namen, die Parameter und den Zweck der Funktion.
2. LLM mit Funktionsdeklarationen aufrufen:Senden Sie den Nutzer-Prompt zusammen mit den Funktionsdeklarationen an das Modell. Er analysiert die Anfrage und ermittelt, ob ein Funktionsaufruf hilfreich wäre. Falls ja, antwortet er mit einem strukturierten JSON-Objekt.
3. Funktionscode ausführen (Ihre Verantwortung): Die Funktion wird nicht vom Modell selbst ausgeführt. Ihre Anwendung ist dafür verantwortlich, die Antwort zu verarbeiten und nach dem Funktionsaufruf zu suchen, wenn
   • Ja: Der Name und die Argumente der Funktion werden extrahiert und die entsprechende Funktion wird in Ihrer Anwendung ausgeführt.
   • Nein:Das Modell hat eine direkte Textantwort auf den Prompt geliefert. Dieser Ablauf wird im Beispiel weniger betont, ist aber ein mögliches Ergebnis.
4. Nutzerfreundliche Antwort erstellen:Wenn eine Funktion ausgeführt wurde, erfassen Sie das Ergebnis und senden Sie es in einem nachfolgenden Gesprächsschritt an das Modell zurück. Anhand des Ergebnisses wird eine endgültige, nutzerfreundliche Antwort generiert, die die Informationen aus dem Funktionsaufruf enthält.

Dieser Vorgang kann über mehrere Runden wiederholt werden, was komplexe Interaktionen und Workflows ermöglicht. Das Modell unterstützt auch den Aufruf mehrerer Funktionen in einer einzigen Runde (paralleler Funktionsaufruf) und nacheinander (kompositioneller Funktionsaufruf).

Schritt 1: Funktionsdeklaration definieren

Definieren Sie eine Funktion und ihre Deklaration in Ihrem Anwendungscode, mit der Nutzer Leuchtmittelwerte festlegen und eine API-Anfrage stellen können. Diese Funktion kann externe Dienste oder APIs aufrufen.

from google.genai import types

# Define a function that the model can call to control smart lights
set_light_values_declaration = {
    "name": "set_light_values",
    "description": "Sets the brightness and color temperature of a light.",
    "parameters": {
        "type": "object",
        "properties": {
            "brightness": {
                "type": "integer",
                "description": "Light level from 0 to 100. Zero is off and 100 is full brightness",
            },
            "color_temp": {
                "type": "string",
                "enum": ["daylight", "cool", "warm"],
                "description": "Color temperature of the light fixture, which can be `daylight`, `cool` or `warm`.",
            },
        },
        "required": ["brightness", "color_temp"],
    },
}

# This is the actual function that would be called based on the model's suggestion
def set_light_values(brightness: int, color_temp: str) -> dict[str, int | str]:
    """Set the brightness and color temperature of a room light. (mock API).

    Args:
        brightness: Light level from 0 to 100. Zero is off and 100 is full brightness
        color_temp: Color temperature of the light fixture, which can be `daylight`, `cool` or `warm`.

    Returns:
        A dictionary containing the set brightness and color temperature.
    """
    return {"brightness": brightness, "colorTemperature": color_temp}

import { Type } from '@google/genai';

// Define a function that the model can call to control smart lights
const setLightValuesFunctionDeclaration = {
  name: 'set_light_values',
  description: 'Sets the brightness and color temperature of a light.',
  parameters: {
    type: Type.OBJECT,
    properties: {
      brightness: {
        type: Type.NUMBER,
        description: 'Light level from 0 to 100. Zero is off and 100 is full brightness',
      },
      color_temp: {
        type: Type.STRING,
        enum: ['daylight', 'cool', 'warm'],
        description: 'Color temperature of the light fixture, which can be `daylight`, `cool` or `warm`.',
      },
    },
    required: ['brightness', 'color_temp'],
  },
};

/**
* Set the brightness and color temperature of a room light. (mock API)
* @param {number} brightness - Light level from 0 to 100. Zero is off and 100 is full brightness
* @param {string} color_temp - Color temperature of the light fixture, which can be `daylight`, `cool` or `warm`.
* @return {Object} A dictionary containing the set brightness and color temperature.
*/
function setLightValues(brightness, color_temp) {
  return {
    brightness: brightness,
    colorTemperature: color_temp
  };
}

Schritt 2: Modell mit Funktionsdeklarationen aufrufen

Nachdem Sie Ihre Funktionsdeklarationen definiert haben, können Sie das Modell auffordern, die Funktion zu verwenden. Es analysiert den Prompt und die Funktionsdeklarationen und entscheidet, ob es direkt antworten oder eine Funktion aufrufen soll. Wenn eine Funktion aufgerufen wird, enthält das Antwortobjekt einen Vorschlag für einen Funktionsaufruf.

from google import genai

# Generation Config with Function Declaration
tools = types.Tool(function_declarations=[set_light_values_declaration])
config = types.GenerateContentConfig(tools=[tools])

# Configure the client
client = genai.Client(api_key=os.getenv("GEMINI_API_KEY"))

# Define user prompt
contents = [
    types.Content(
        role="user", parts=[types.Part(text="Turn the lights down to a romantic level")]
    )
]

# Send request with function declarations
response = client.models.generate_content(
    model="gemini-2.0-flash", config=config, contents=contents
)

print(response.candidates[0].content.parts[0].function_call)

import { GoogleGenAI } from '@google/genai';

// Generation Config with Function Declaration
const config = {
  tools: [{
    functionDeclarations: [setLightValuesFunctionDeclaration]
  }]
};

// Configure the client
const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });

// Define user prompt
const contents = [
  {
    role: 'user',
    parts: [{ text: 'Turn the lights down to a romantic level' }]
  }
];

// Send request with function declarations
const response = await ai.models.generateContent({
  model: 'gemini-2.0-flash',
  contents: contents,
  config: config
});

console.log(response.functionCalls[0]); 

Das Modell gibt dann ein functionCall-Objekt in einem OpenAPI-kompatiblen Schema zurück, das angibt, wie eine oder mehrere der deklarierten Funktionen aufgerufen werden, um auf die Frage des Nutzers zu antworten.

id=None args={'color_temp': 'warm', 'brightness': 25} name='set_light_values'

{
  name: 'set_light_values',
  args: { brightness: 25, color_temp: 'warm' }
}

Schritt 3: Code der Funktion „set_light_values“ ausführen

Extrahieren Sie die Details des Funktionsaufrufs aus der Antwort des Modells, parsen Sie die Argumente und führen Sie die Funktion set_light_values in unserem Code aus.

# Extract tool call details
tool_call = response.candidates[0].content.parts[0].function_call

if tool_call.name == "set_light_values":
    result = set_light_values(**tool_call.args)
    print(f"Function execution result: {result}")

// Extract tool call details
const tool_call = response.functionCalls[0]

let result;
if (tool_call.name === 'set_light_values') {
  result = setLightValues(tool_call.args.brightness, tool_call.args.color_temp);
  console.log(`Function execution result: ${JSON.stringify(result)}`);
}

Schritt 4: Nutzerfreundliche Antwort mit Funktionsergebnis erstellen und Modell noch einmal aufrufen

Senden Sie das Ergebnis der Funktionsausführung schließlich an das Modell zurück, damit es diese Informationen in die endgültige Antwort an den Nutzer einbinden kann.

# Create a function response part
function_response_part = types.Part.from_function_response(
    name=tool_call.name,
    response={"result": result},
)

# Append function call and result of the function execution to contents
contents.append(types.Content(role="model", parts=[types.Part(function_call=tool_call)])) # Append the model's function call message
contents.append(types.Content(role="user", parts=[function_response_part])) # Append the function response

final_response = client.models.generate_content(
    model="gemini-2.0-flash",
    config=config,
    contents=contents,
)

print(final_response.text)

// Create a function response part
const function_response_part = {
  name: tool_call.name,
  response: { result }
}

// Append function call and result of the function execution to contents
contents.push({ role: 'model', parts: [{ functionCall: tool_call }] });
contents.push({ role: 'user', parts: [{ functionResponse: function_response_part }] });

// Get the final response from the model
const final_response = await ai.models.generateContent({
  model: 'gemini-2.0-flash',
  contents: contents,
  config: config
});

console.log(final_response.text);

Damit ist der Aufruf der Funktion abgeschlossen. Das Modell hat die set_light_values-Funktion erfolgreich verwendet, um die Anfrageaktion des Nutzers auszuführen.

Funktionsdeklarationen

Wenn Sie einen Funktionsaufruf in einem Prompt implementieren, erstellen Sie ein tools-Objekt, das ein oder mehrere function declarations enthält. Sie definieren Funktionen mit JSON, insbesondere mit einer ausgewählten Teilmenge des OpenAPI-Schemaformats. Eine einzelne Funktionsdeklaration kann die folgenden Parameter enthalten:

• name (String): Ein eindeutiger Name für die Funktion (get_weather_forecast, send_email). Verwenden Sie beschreibende Namen ohne Leerzeichen oder Sonderzeichen (unterstrichen oder CamelCase).
• description (String): Eine klare und detaillierte Erläuterung des Zwecks und der Funktionen der Funktion. Das ist entscheidend, damit das Modell weiß, wann die Funktion verwendet werden soll. Seien Sie konkret und geben Sie gegebenenfalls Beispiele an („Sucht Kinos basierend auf dem Standort und optional dem Filmtitel, der derzeit in Kinos läuft.“).
• parameters (Objekt): Hier werden die Eingabeparameter definiert, die von der Funktion erwartet werden.
  • type (String): Gibt den Gesamtdatentyp an, z. B. object.
  • properties (Objekt): Hier werden einzelne Parameter mit folgenden Angaben aufgelistet:
    • type (String): Der Datentyp des Parameters, z. B. string, integer, boolean, array.
    • description (String): Eine Beschreibung des Zwecks und des Formats des Parameters. Geben Sie Beispiele und Einschränkungen an („Die Stadt und der Bundesstaat, z.B. „San Francisco, CA“ oder eine Postleitzahl, z.B. '95616'.").
    • enum (Array, optional): Wenn die Parameterwerte aus einem festen Satz stammen, verwenden Sie „enum“, um die zulässigen Werte aufzulisten, anstatt sie nur in der Beschreibung zu beschreiben. Dies verbessert die Genauigkeit („enum“: [„Tageslicht“, „kalt“, „warm“]).
  • required (Array): Ein Array von Strings, das die Parameternamen enthält, die für die Funktion erforderlich sind.

Paralleler Funktionsaufruf

Neben dem Aufruf einer einzelnen Funktion können Sie auch mehrere Funktionen gleichzeitig aufrufen. Mit dem parallelen Funktionsaufruf können Sie mehrere Funktionen gleichzeitig ausführen. Er wird verwendet, wenn die Funktionen nicht voneinander abhängig sind. Das ist nützlich, wenn Sie Daten aus mehreren unabhängigen Quellen erfassen möchten, z. B. Kundendetails aus verschiedenen Datenbanken abrufen, Inventarbestände in verschiedenen Lagern prüfen oder mehrere Aktionen ausführen, z. B. Ihre Wohnung in eine Disco verwandeln.

power_disco_ball = {
    "name": "power_disco_ball",
    "description": "Powers the spinning disco ball.",
    "parameters": {
        "type": "object",
        "properties": {
            "power": {
                "type": "boolean",
                "description": "Whether to turn the disco ball on or off.",
            }
        },
        "required": ["power"],
    },
}

start_music = {
    "name": "start_music",
    "description": "Play some music matching the specified parameters.",
    "parameters": {
        "type": "object",
        "properties": {
            "energetic": {
                "type": "boolean",
                "description": "Whether the music is energetic or not.",
            },
            "loud": {
                "type": "boolean",
                "description": "Whether the music is loud or not.",
            },
        },
        "required": ["energetic", "loud"],
    },
}

dim_lights = {
    "name": "dim_lights",
    "description": "Dim the lights.",
    "parameters": {
        "type": "object",
        "properties": {
            "brightness": {
                "type": "number",
                "description": "The brightness of the lights, 0.0 is off, 1.0 is full.",
            }
        },
        "required": ["brightness"],
    },
}

import { Type } from '@google/genai';

const powerDiscoBall = {
  name: 'power_disco_ball',
  description: 'Powers the spinning disco ball.',
  parameters: {
    type: Type.OBJECT,
    properties: {
      power: {
        type: Type.BOOLEAN,
        description: 'Whether to turn the disco ball on or off.'
      }
    },
    required: ['power']
  }
};

const startMusic = {
  name: 'start_music',
  description: 'Play some music matching the specified parameters.',
  parameters: {
    type: Type.OBJECT,
    properties: {
      energetic: {
        type: Type.BOOLEAN,
        description: 'Whether the music is energetic or not.'
      },
      loud: {
        type: Type.BOOLEAN,
        description: 'Whether the music is loud or not.'
      }
    },
    required: ['energetic', 'loud']
  }
};

const dimLights = {
  name: 'dim_lights',
  description: 'Dim the lights.',
  parameters: {
    type: Type.OBJECT,
    properties: {
      brightness: {
        type: Type.NUMBER,
        description: 'The brightness of the lights, 0.0 is off, 1.0 is full.'
      }
    },
    required: ['brightness']
  }
};

Rufen Sie das Modell mit einer Anweisung auf, die alle angegebenen Tools verwenden könnte. In diesem Beispiel wird ein tool_config verwendet. Weitere Informationen finden Sie unter Funktionsaufrufe konfigurieren.

from google import genai
from google.genai import types

# Set up function declarations
house_tools = [
    types.Tool(function_declarations=[power_disco_ball, start_music, dim_lights])
]

config = {
    "tools": house_tools,
    "automatic_function_calling": {"disable": True},
    # Force the model to call 'any' function, instead of chatting.
    "tool_config": {"function_calling_config": {"mode": "any"}},
}

# Configure the client
client = genai.Client(api_key=os.getenv("GEMINI_API_KEY"))

chat = client.chats.create(model="gemini-2.0-flash", config=config)
response = chat.send_message("Turn this place into a party!")

# Print out each of the function calls requested from this single call
print("Example 1: Forced function calling")
for fn in response.function_calls:
    args = ", ".join(f"{key}={val}" for key, val in fn.args.items())
    print(f"{fn.name}({args})")

import { GoogleGenAI } from '@google/genai';

// Set up function declarations
const houseFns = [powerDiscoBall, startMusic, dimLights];

const config = {
    tools: [{
        functionDeclarations: houseFns
    }],
    // Force the model to call 'any' function, instead of chatting.
    toolConfig: {
        functionCallingConfig: {
        mode: 'any'
        }
    }
};

// Configure the client
const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });

// Create a chat session
const chat = ai.chats.create({
    model: 'gemini-2.0-flash',
    config: config
});
const response = await chat.sendMessage({message: 'Turn this place into a party!'});

// Print out each of the function calls requested from this single call
console.log("Example 1: Forced function calling");
for (const fn of response.functionCalls) {
    const args = Object.entries(fn.args)
        .map(([key, val]) => `${key}=${val}`)
        .join(', ');
    console.log(`${fn.name}(${args})`);
}

Jedes der gedruckten Ergebnisse entspricht einem einzelnen Funktionsaufruf, der vom Modell angefordert wurde. Wenn Sie die Ergebnisse zurücksenden, geben Sie die Antworten in der Reihenfolge an, in der sie angefordert wurden.

Das Python SDK unterstützt die Funktion automatischer Funktionsaufruf, die die Python-Funktion in Deklarationen umwandelt und die Ausführung des Funktionsaufrufs und den Antwortzyklus für Sie übernimmt. Im Folgenden finden Sie ein Beispiel für unseren Anwendungsfall „Disco“.

from google import genai
from google.genai import types

# Actual implementation functions
def power_disco_ball_impl(power: bool) -> dict:
    """Powers the spinning disco ball.

    Args:
        power: Whether to turn the disco ball on or off.

    Returns:
        A status dictionary indicating the current state.
    """
    return {"status": f"Disco ball powered {'on' if power else 'off'}"}

def start_music_impl(energetic: bool, loud: bool) -> dict:
    """Play some music matching the specified parameters.

    Args:
        energetic: Whether the music is energetic or not.
        loud: Whether the music is loud or not.

    Returns:
        A dictionary containing the music settings.
    """
    music_type = "energetic" if energetic else "chill"
    volume = "loud" if loud else "quiet"
    return {"music_type": music_type, "volume": volume}

def dim_lights_impl(brightness: float) -> dict:
    """Dim the lights.

    Args:
        brightness: The brightness of the lights, 0.0 is off, 1.0 is full.

    Returns:
        A dictionary containing the new brightness setting.
    """
    return {"brightness": brightness}

config = {
    "tools": [power_disco_ball_impl, start_music_impl, dim_lights_impl],
}

chat = client.chats.create(model="gemini-2.0-flash", config=config)
response = chat.send_message("Do everything you need to this place into party!")

print("\nExample 2: Automatic function calling")
print(response.text)
# I've turned on the disco ball, started playing loud and energetic music, and dimmed the lights to 50% brightness. Let's get this party started!

Zusammengesetzte Funktionsaufrufe

Gemini 2.0 unterstützt den Aufruf von zusammengesetzten Funktionen. Das bedeutet, dass das Modell mehrere Funktionsaufrufe verketten kann. Wenn beispielsweise die Frage „Wie hoch ist die Temperatur an meinem aktuellen Standort?“ beantwortet werden soll, ruft die Gemini API möglicherweise sowohl eine get_current_location()-Funktion als auch eine get_weather()-Funktion auf, die den Standort als Parameter annehmen.

# Light control schemas
turn_on_the_lights_schema = {'name': 'turn_on_the_lights'}
turn_off_the_lights_schema = {'name': 'turn_off_the_lights'}

prompt = """
  Hey, can you write run some python code to turn on the lights, wait 10s and then turn off the lights?
  """

tools = [
    {'code_execution': {}},
    {'function_declarations': [turn_on_the_lights_schema, turn_off_the_lights_schema]}
]

await run(prompt, tools=tools, modality="AUDIO")

// Light control schemas
const turnOnTheLightsSchema = { name: 'turn_on_the_lights' };
const turnOffTheLightsSchema = { name: 'turn_off_the_lights' };

const prompt = `
  Hey, can you write run some python code to turn on the lights, wait 10s and then turn off the lights?
`;

const tools = [
  { codeExecution: {} },
  { functionDeclarations: [turnOnTheLightsSchema, turnOffTheLightsSchema] }
];

await run(prompt, tools=tools, modality="AUDIO")

Modi für Funktionsaufrufe

Mit der Gemini API können Sie steuern, wie das Modell die bereitgestellten Tools (Funktionsdeklarationen) verwendet. Sie können den Modus speziell in function_calling_config festlegen.

• AUTO (Default): Das Modell entscheidet basierend auf dem Prompt und dem Kontext, ob eine Antwort in natürlicher Sprache generiert oder ein Funktionsaufruf vorgeschlagen werden soll. Dieser Modus ist der flexibelste und wird für die meisten Szenarien empfohlen.
• ANY: Das Modell ist darauf beschränkt, immer einen Funktionsaufruf vorherzusagen und die Einhaltung des Funktionsschemas zu gewährleisten. Wenn allowed_function_names nicht angegeben ist, kann das Modell eine beliebige der bereitgestellten Funktionsdeklarationen auswählen. Wenn allowed_function_names als Liste angegeben ist, kann das Modell nur aus den Funktionen in dieser Liste auswählen. Verwenden Sie diesen Modus, wenn Sie (falls zutreffend) einen Funktionsaufruf als Antwort auf jeden Prompt benötigen.

• NONE: Dem Modell ist es untersagt, Funktionsaufrufe auszuführen. Das entspricht dem Senden einer Anfrage ohne Funktionsdeklarationen. So können Sie den Funktionsaufruf vorübergehend deaktivieren, ohne Ihre Tooldefinitionen zu entfernen.

from google.genai import types

# Configure function calling mode
tool_config = types.ToolConfig(
    function_calling_config=types.FunctionCallingConfig(
        mode="ANY", allowed_function_names=["get_current_temperature"]
    )
)

# Create the generation config
config = types.GenerateContentConfig(
    temperature=0,
    tools=[tools],  # not defined here.
    tool_config=tool_config,
)

import { FunctionCallingConfigMode } from '@google/genai';

// Configure function calling mode
const toolConfig = {
  functionCallingConfig: {
    mode: FunctionCallingConfigMode.ANY,
    allowedFunctionNames: ['get_current_temperature']
  }
};

// Create the generation config
const config = {
  temperature: 0,
  tools: tools, // not defined here.
  toolConfig: toolConfig,
};

Automatischer Funktionsaufruf (nur Python)

Wenn Sie das Python SDK verwenden, können Sie Python-Funktionen direkt als Tools bereitstellen. Das SDK wandelt die Python-Funktion automatisch in Deklarationen um und übernimmt die Ausführung des Funktionsaufrufs und den Antwortzyklus für Sie. Das Python SDK führt dann automatisch folgende Schritte aus:

1. Erkennt Funktionsaufrufantworten aus dem Modell.
2. Rufen Sie die entsprechende Python-Funktion in Ihrem Code auf.
3. Die Funktionsantwort wird an das Modell zurückgesendet.
4. Gibt die endgültige Textantwort des Modells zurück.

Dazu definieren Sie Ihre Funktion mit Typhinweisen und einer Docstring und übergeben dann die Funktion selbst (keine JSON-Deklaration) als Tool:

from google import genai
from google.genai import types

# Define the function with type hints and docstring
def get_current_temperature(location: str) -> dict:
    """Gets the current temperature for a given location.

    Args:
        location: The city and state, e.g. San Francisco, CA

    Returns:
        A dictionary containing the temperature and unit.
    """
    # ... (implementation) ...
    return {"temperature": 25, "unit": "Celsius"}

# Configure the client and model
client = genai.Client(api_key=os.getenv("GEMINI_API_KEY"))  # Replace with your actual API key setup
config = types.GenerateContentConfig(
    tools=[get_current_temperature]
)  # Pass the function itself

# Make the request
response = client.models.generate_content(
    model="gemini-2.0-flash",
    contents="What's the temperature in London?",
    config=config,
)

print(response.text)  # The SDK handles the function call and returns the final text

Sie können den automatischen Funktionsaufruf mit folgenden Befehlen deaktivieren:

# To disable automatic function calling:
config = types.GenerateContentConfig(
    tools=[get_current_temperature],
    automatic_function_calling=types.AutomaticFunctionCallingConfig(disable=True)
)

Schemadeklaration für automatische Funktionen

Die automatische Schemaextraktion aus Python-Funktionen funktioniert nicht in allen Fällen. Beispiel: Es werden keine Fälle verarbeitet, in denen Sie die Felder eines verschachtelten Dictionary-Objekts beschreiben. Die API kann jeden der folgenden Typen beschreiben:

AllowedType = (int | float | bool | str | list['AllowedType'] | dict[str, AllowedType])

Wenn Sie sehen möchten, wie das abgeleitete Schema aussieht, können Sie es mit from_callable konvertieren:

def multiply(a: float, b: float):
    """Returns a * b."""
    return a * b

fn_decl = types.FunctionDeclaration.from_callable(callable=multiply, client=client)

# to_json_dict() provides a clean JSON representation.
print(fn_decl.to_json_dict())

Mehrere Tools verwenden: Native Tools mit Funktionsaufrufen kombinieren

Mit Gemini 2.0 können Sie mehrere Tools aktivieren, die native Tools mit Funktionsaufrufen kombinieren. Hier ist ein Beispiel, in dem zwei Tools, Grounding mit der Google Suche und Codeausführung, in einer Anfrage mit der Live API aktiviert werden.

# Multiple tasks example - combining lights, code execution, and search
prompt = """
  Hey, I need you to do three things for me.

    1.  Turn on the lights.
    2.  Then compute the largest prime palindrome under 100000.
    3.  Then use Google Search to look up information about the largest earthquake in California the week of Dec 5 2024.

  Thanks!
  """

tools = [
    {'google_search': {}},
    {'code_execution': {}},
    {'function_declarations': [turn_on_the_lights_schema, turn_off_the_lights_schema]} # not defined here.
]

# Execute the prompt with specified tools in audio modality
await run(prompt, tools=tools, modality="AUDIO")

// Multiple tasks example - combining lights, code execution, and search
const prompt = `
  Hey, I need you to do three things for me.

    1.  Turn on the lights.
    2.  Then compute the largest prime palindrome under 100000.
    3.  Then use Google Search to look up information about the largest earthquake in California the week of Dec 5 2024.

  Thanks!
`;

const tools = [
  { googleSearch: {} },
  { codeExecution: {} },
  { functionDeclarations: [turnOnTheLightsSchema, turnOffTheLightsSchema] } // not defined here.
];

// Execute the prompt with specified tools in audio modality
await run(prompt, {tools: tools, modality: "AUDIO"});

Python-Entwickler können dies im Notebook zur Verwendung des Live API-Tools ausprobieren.

Unterstützte Modelle

Experimentelle Modelle sind nicht enthalten. Die Funktionen finden Sie auf der Seite Modellübersicht.

Best Practices

• Funktions- und Parameterbeschreibungen:Formulieren Sie Ihre Beschreibungen möglichst klar und präzise. Anhand dieser Informationen wählt das Modell die richtige Funktion aus und gibt die entsprechenden Argumente an.
• Benennung:Verwenden Sie aussagekräftige Funktionsnamen (ohne Leerzeichen, Punkte oder Bindestriche).
• Starke Typisierung:Verwenden Sie bestimmte Typen (Integer, String, Enum) für Parameter, um Fehler zu reduzieren. Wenn ein Parameter eine begrenzte Anzahl gültiger Werte hat, verwenden Sie ein Enum.
• Prompt Engineering:
  • Kontext angeben: Geben Sie dem Modell seine Rolle an (z.B. „Sie sind ein hilfreicher Wetterassistent.“).
  • Geben Sie eine Anleitung: Geben Sie an, wie und wann Funktionen verwendet werden sollen (z.B. „Verwenden Sie keine Schätzungen, sondern immer ein Datum in der Zukunft für Prognosen.“
  • Klärungsbedarf äußern: Bitten Sie das Modell, bei Bedarf klärende Fragen zu stellen.
• Temperatur:Verwenden Sie eine niedrige Temperatur (z.B. 0) für deterministischere und zuverlässigere Funktionsaufrufe.
• Validierung:Wenn ein Funktionsaufruf erhebliche Konsequenzen hat (z.B. eine Bestellung aufgeben), validieren Sie den Aufruf vor der Ausführung mit dem Nutzer.
• Fehlerbehandlung: Implementieren Sie eine robuste Fehlerbehandlung in Ihren Funktionen, um unerwartete Eingaben oder API-Fehler fehlerfrei zu verarbeiten. Geben Sie informative Fehlermeldungen zurück, die das Modell verwenden kann, um hilfreiche Antworten für den Nutzer zu generieren.
• Sicherheit:Achten Sie beim Aufruf externer APIs auf die Sicherheit. Verwenden Sie geeignete Authentifizierungs- und Autorisierungsmechanismen. Vermeiden Sie die Offenlegung vertraulicher Daten in Funktionsaufrufen.
• Tokenlimits:Funktionsbeschreibungen und Parameter werden auf das Eingabetokenlimit angerechnet. Wenn Sie die Tokenlimits erreichen, sollten Sie die Anzahl der Funktionen oder die Länge der Beschreibungen begrenzen und komplexe Aufgaben in kleinere, spezifischere Funktionsgruppen unterteilen.

Hinweise und Einschränkungen

• Es wird nur eine Teilmenge des OpenAPI-Schemas unterstützt.
• Die unterstützten Parametertypen in Python sind begrenzt.
• Der automatische Funktionsaufruf ist nur eine Python SDK-Funktion.