Appel de fonction avec l'API Gemini

L'appel de fonction vous permet de connecter des modèles à des outils et des API externes. Au lieu de générer des réponses textuelles, le modèle comprend quand appeler des fonctions spécifiques et fournit les paramètres nécessaires pour exécuter des actions réelles. Cela permet au modèle de servir de pont entre le langage naturel et les actions et données du monde réel. Les appels de fonction ont trois cas d'utilisation principaux:

• Améliorer les connaissances:accédez aux informations provenant de sources externes telles que des bases de données, des API et des bases de connaissances.
• Étendre les fonctionnalités:utilisez des outils externes pour effectuer des calculs et repousser les limites du modèle, par exemple en utilisant une calculatrice ou en créant des graphiques.
• Effectuer des actions:interagissez avec des systèmes externes à l'aide d'API, par exemple pour planifier des rendez-vous, créer des factures, envoyer des e-mails ou contrôler des appareils connectés.

Obtenir la météo Planifier une réunion Créer un graphique

Fonctionnement des appels de fonction

L'appel de fonction implique une interaction structurée entre votre application, le modèle et les fonctions externes. Voici le détail :

1. Définir la déclaration de fonction:définissez la déclaration de fonction dans le code de votre application. Les déclarations de fonction décrivent le nom, les paramètres et l'objectif de la fonction au modèle.
2. Appeler le LLM avec des déclarations de fonction:envoyez la requête utilisateur avec les déclarations de fonction au modèle. Il analyse la requête et détermine si un appel de fonction serait utile. Si c'est le cas, il répond avec un objet JSON structuré.
3. Exécuter le code de la fonction (votre responsabilité) : le modèle n'exécute pas la fonction lui-même. Votre application est chargée de traiter la réponse et de vérifier l'appel de fonction, si :
   • Oui: extrayez le nom et les arguments de la fonction, puis exécutez la fonction correspondante dans votre application.
   • Non:le modèle a fourni une réponse textuelle directe à la requête (ce flux est moins mis en avant dans l'exemple, mais il s'agit d'un résultat possible).
4. Créez une réponse conviviale:si une fonction a été exécutée, capturez le résultat et renvoyez-le au modèle lors d'un tour ultérieur de la conversation. Il utilisera le résultat pour générer une réponse finale conviviale qui intègre les informations de l'appel de fonction.

Ce processus peut être répété plusieurs fois, ce qui permet des interactions et des workflows complexes. Le modèle permet également d'appeler plusieurs fonctions dans un seul tour (appel de fonction en parallèle) et de manière séquentielle (appel de fonction compositionnel).

Étape 1: Définir la déclaration de fonction

Définissez une fonction et sa déclaration dans le code de votre application, qui permet aux utilisateurs de définir des valeurs de lumière et d'effectuer une requête API. Cette fonction peut appeler des services ou des API externes.

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

Étape 2: Appeler le modèle avec des déclarations de fonction

Une fois que vous avez défini vos déclarations de fonction, vous pouvez demander au modèle d'utiliser la fonction. Il analyse la requête et les déclarations de fonction, puis décide de répondre directement ou d'appeler une fonction. Si une fonction est appelée, l'objet de réponse contient une suggestion d'appel de fonction.

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

Le modèle renvoie ensuite un objet functionCall dans un schéma compatible avec OpenAPI, qui spécifie comment appeler une ou plusieurs des fonctions déclarées pour répondre à la question de l'utilisateur.

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

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

Étape 3: Exécutez le code de la fonction set_light_values

Extrayez les détails de l'appel de fonction à partir de la réponse du modèle, analysez les arguments et exécutez la fonction set_light_values dans votre code.

# 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)}`);
}

Étape 4: Créez une réponse conviviale avec le résultat de la fonction et appelez à nouveau le modèle

Enfin, renvoyez le résultat de l'exécution de la fonction au modèle afin qu'il puisse intégrer ces informations dans sa réponse finale à l'utilisateur.

# 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);

Le flux d'appel de fonction est terminé. Le modèle a correctement utilisé la fonction set_light_values pour effectuer l'action de requête de l'utilisateur.

Déclarations de fonctions

Lorsque vous implémentez l'appel de fonction dans une invite, vous créez un objet tools, qui contient un ou plusieurs function declarations. Vous définissez des fonctions à l'aide de JSON, en particulier avec un sous-ensemble sélectionné du format de schéma OpenAPI. Une seule déclaration de fonction peut inclure les paramètres suivants:

• name (chaîne): nom unique de la fonction (get_weather_forecast, send_email). Utilisez des noms descriptifs sans espaces ni caractères spéciaux (utilisez des traits de soulignement ou du style CamelCase).
• description (chaîne): explication claire et détaillée de l'objectif et des fonctionnalités de la fonction. Il est essentiel que le modèle comprenne quand utiliser la fonction. Soyez précis et fournissez des exemples si nécessaire ("Trouve des cinémas en fonction de la zone géographique et, éventuellement, du titre du film actuellement à l'affiche.").
• parameters (objet): définit les paramètres d'entrée attendus par la fonction.
  • type (chaîne): spécifie le type de données global, par exemple object.
  • properties (objet): liste les paramètres individuels, chacun avec les éléments suivants :
    • type (chaîne): type de données du paramètre, par exemple string, integer ou boolean, array.
    • description (chaîne): description de l'objectif et du format du paramètre. Fournissez des exemples et des contraintes ("La ville et l'état, par exemple, "San Francisco, CA" ou un code postal (par exemple, 95616'.").
    • enum (tableau, facultatif): si les valeurs du paramètre proviennent d'un ensemble fixe, utilisez "enum" pour lister les valeurs autorisées au lieu de simplement les décrire dans la description. Cela améliore la précision ("enum": ["daylight", "cool", "warm"]).
  • required (tableau): tableau de chaînes listant les noms de paramètres obligatoires pour que la fonction fonctionne.

Appel de fonction parallèle

En plus de l'appel de fonction à un seul tour, vous pouvez également appeler plusieurs fonctions à la fois. L'appel de fonction parallèle vous permet d'exécuter plusieurs fonctions à la fois. Il est utilisé lorsque les fonctions ne dépendent pas les unes des autres. Cela est utile dans des scénarios tels que la collecte de données à partir de plusieurs sources indépendantes, comme la récupération des informations sur les clients à partir de différentes bases de données, la vérification des niveaux d'inventaire dans différents entrepôts ou l'exécution de plusieurs actions, comme la conversion de votre appartement en discothèque.

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']
  }
};

Appelez le modèle avec une instruction pouvant utiliser tous les outils spécifiés. Cet exemple utilise un tool_config. Pour en savoir plus, consultez la section Configurer les appels de fonction.

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})`);
}

Chacun des résultats imprimés reflète un seul appel de fonction que le modèle a demandé. Pour renvoyer les résultats, incluez les réponses dans l'ordre dans lequel elles ont été demandées.

Le SDK Python est compatible avec une fonctionnalité appelée appel de fonction automatique, qui convertit la fonction Python en déclarations, gère l'exécution de l'appel de fonction et le cycle de réponse à votre place. Voici un exemple pour notre cas d'utilisation de discothèque.

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!

Appel de fonction compositionnel

Gemini 2.0 est compatible avec l'appel de fonction compositionnel, ce qui signifie que le modèle peut enchaîner plusieurs appels de fonction. Par exemple, pour répondre à la requête "Obtenir la température à mon emplacement actuel", l'API Gemini peut appeler à la fois une fonction get_current_location() et une fonction get_weather() qui acceptent la position en tant que paramètre.

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

Modes d'appel de fonction

L'API Gemini vous permet de contrôler la façon dont le modèle utilise les outils fournis (déclarations de fonction). Plus précisément, vous pouvez définir le mode dans function_calling_config.

• AUTO (Default): le modèle décide de générer une réponse en langage naturel ou de suggérer un appel de fonction en fonction de la requête et du contexte. Il s'agit du mode le plus flexible et recommandé dans la plupart des cas.
• ANY: le modèle est contraint de toujours prédire un appel de fonction et de garantir le respect du schéma de fonction. Si allowed_function_names n'est pas spécifié, le modèle peut choisir parmi les déclarations de fonction fournies. Si allowed_function_names est fourni sous forme de liste, le modèle ne peut choisir que parmi les fonctions de cette liste. Utilisez ce mode lorsque vous avez besoin d'un appel de fonction en réponse à chaque requête (le cas échéant).

• NONE: le modèle est interdit d'effectuer des appels de fonction. Cela équivaut à envoyer une requête sans aucune déclaration de fonction. Utilisez cette option pour désactiver temporairement l'appel de fonction sans supprimer les définitions de vos outils.

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

Appel de fonction automatique (Python uniquement)

Lorsque vous utilisez le SDK Python, vous pouvez fournir des fonctions Python directement en tant qu'outils. Le SDK convertit automatiquement la fonction Python en déclarations, gère l'exécution de l'appel de fonction et le cycle de réponse à votre place. Le SDK Python effectue ensuite automatiquement les opérations suivantes:

1. Détecte les réponses d'appel de fonction du modèle.
2. Appelez la fonction Python correspondante dans votre code.
3. Renvoie la réponse de la fonction au modèle.
4. Renvoie la réponse textuelle finale du modèle.

Pour utiliser cette fonctionnalité, définissez votre fonction avec des indications de type et une docstring, puis transmettez la fonction elle-même (et non une déclaration JSON) en tant qu'outil:

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

Vous pouvez désactiver l'appel automatique des fonctions avec:

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

Déclaration automatique du schéma de fonction

L'extraction automatique de schémas à partir de fonctions Python ne fonctionne pas dans tous les cas. Par exemple, il ne gère pas les cas où vous décrivez les champs d'un objet de dictionnaire imbriqué. L'API peut décrire l'un des types suivants:

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

Pour voir à quoi ressemble le schéma inféré, vous pouvez le convertir à l'aide de from_callable:

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

Utilisation de plusieurs outils: combiner des outils natifs avec l'appel de fonction

Avec Gemini 2.0, vous pouvez activer plusieurs outils combinant des outils natifs et l'appel de fonction en même temps. Voici un exemple qui active deux outils, Grounding with Google Search (Ancrage avec la recherche Google) et code execution (Exécution de code), dans une requête à l'aide de l'API en direct.

# 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"});

Les développeurs Python peuvent essayer cette fonctionnalité dans le notebook "Utilisation de l'outil d'API en direct".

Modèles compatibles

Les modèles expérimentaux ne sont pas inclus. Vous trouverez leurs fonctionnalités sur la page Présentation du modèle.

Bonnes pratiques

• Descriptions des fonctions et des paramètres:soyez extrêmement clair et précis dans vos descriptions. Le modèle s'appuie sur ces éléments pour choisir la fonction appropriée et fournir les arguments appropriés.
• Noms:utilisez des noms de fonction descriptifs (sans espaces, points ni tirets).
• Typage strict:utilisez des types spécifiques (entier, chaîne, énumération) pour les paramètres afin de réduire les erreurs. Si un paramètre a un ensemble limité de valeurs valides, utilisez un énumérateur.
• Ingénierie des requêtes:
  • Fournissez du contexte: indiquez au modèle son rôle (par exemple, "Vous êtes un assistant météo serviable.")
  • Donnez des instructions: indiquez comment et quand utiliser les fonctions (par exemple, "Ne devinez pas de date. Utilisez toujours une date future pour les prévisions.").
  • Encouragez les clarifications: demandez au modèle de poser des questions de clarification si nécessaire.
• Température:utilisez une température basse (par exemple, 0) pour des appels de fonction plus déterministes et fiables.
• Validation:si un appel de fonction a des conséquences importantes (par exemple, passer une commande), validez-le auprès de l'utilisateur avant de l'exécuter.
• Gestion des erreurs: implémentez une gestion des erreurs robuste dans vos fonctions pour gérer correctement les entrées inattendues ou les échecs d'API. Renvoyez des messages d'erreur informatifs que le modèle peut utiliser pour générer des réponses utiles à l'utilisateur.
• Sécurité:soyez attentif à la sécurité lorsque vous appelez des API externes. Utilisez des mécanismes d'authentification et d'autorisation appropriés. Évitez d'exposer des données sensibles dans les appels de fonction.
• Limites de jetons:les descriptions et les paramètres des fonctions sont comptabilisés dans la limite de jetons d'entrée. Si vous atteignez les limites de jetons, envisagez de limiter le nombre de fonctions ou la longueur des descriptions, et de décomposer les tâches complexes en ensembles de fonctions plus petits et plus ciblés.

Remarques et limites

• Seul un sous-ensemble du schéma OpenAPI est accepté.
• Les types de paramètres compatibles dans Python sont limités.
• L'appel automatique de fonction est une fonctionnalité du SDK Python uniquement.