การเรียกใช้ฟังก์ชันด้วย Gemini API

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

from google.genai import types  # Configure the client and tools client = genai.Client() tools = types.Tool(function_declarations=[set_light_values_declaration]) config = types.GenerateContentConfig(tools=[tools])  # 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.5-flash",     contents=contents     config=config, )  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({});  // 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.5-flash',   contents: contents,   config: config });  console.log(response.functionCalls[0]); 

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

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

# Extract tool call details, it may not be in the first part. 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)}`); } 

# 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(response.candidates[0].content) # Append the content from the model's response. contents.append(types.Content(role="user", parts=[function_response_part])) # Append the function response  final_response = client.models.generate_content(     model="gemini-2.5-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(response.candidates[0].content); 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.5-flash',   contents: contents,   config: config });  console.log(final_response.text); 

import base64 # After receiving a response from a model with thinking enabled # response = client.models.generate_content(...)  # The signature is attached to the response part containing the function call part = response.candidates[0].content.parts[0] if part.thought_signature:   print(base64.b64encode(part.thought_signature).decode("utf-8")) 

// After receiving a response from a model with thinking enabled // const response = await ai.models.generateContent(...)  // The signature is attached to the response part containing the function call const part = response.candidates[0].content.parts[0]; if (part.thoughtSignature) {   console.log(part.thoughtSignature); } 

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

from google import genai from google.genai import types  # Configure the client and tools client = genai.Client() house_tools = [     types.Tool(function_declarations=[power_disco_ball, start_music, dim_lights]) ] config = types.GenerateContentConfig(     tools=house_tools,     automatic_function_calling=types.AutomaticFunctionCallingConfig(         disable=True     ),     # Force the model to call 'any' function, instead of chatting.     tool_config=types.ToolConfig(         function_calling_config=types.FunctionCallingConfig(mode='ANY')     ), )  chat = client.chats.create(model="gemini-2.5-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({});  // Create a chat session const chat = ai.chats.create({     model: 'gemini-2.5-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})`); } 

from google import genai from google.genai import types  # Actual function implementations 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}  # Configure the client client = genai.Client() config = types.GenerateContentConfig(     tools=[power_disco_ball_impl, start_music_impl, dim_lights_impl] )  # Make the request response = client.models.generate_content(     model="gemini-2.5-flash",     contents="Do everything you need to this place into party!",     config=config, )  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! 

import os from google import genai from google.genai import types  # Example Functions def get_weather_forecast(location: str) -> dict:     """Gets the current weather temperature for a given location."""     print(f"Tool Call: get_weather_forecast(location={location})")     # TODO: Make API call     print("Tool Response: {'temperature': 25, 'unit': 'celsius'}")     return {"temperature": 25, "unit": "celsius"}  # Dummy response  def set_thermostat_temperature(temperature: int) -> dict:     """Sets the thermostat to a desired temperature."""     print(f"Tool Call: set_thermostat_temperature(temperature={temperature})")     # TODO: Interact with a thermostat API     print("Tool Response: {'status': 'success'}")     return {"status": "success"}  # Configure the client and model client = genai.Client() config = types.GenerateContentConfig(     tools=[get_weather_forecast, set_thermostat_temperature] )  # Make the request response = client.models.generate_content(     model="gemini-2.5-flash",     contents="If it's warmer than 20°C in London, set the thermostat to 20°C, otherwise set it to 18°C.",     config=config, )  # Print the final, user-facing response print(response.text) 

Tool Call: get_weather_forecast(location=London) Tool Response: {'temperature': 25, 'unit': 'celsius'} Tool Call: set_thermostat_temperature(temperature=20) Tool Response: {'status': 'success'} OK. I've set the thermostat to 20°C. 

import { GoogleGenAI, Type } from "@google/genai";  // Configure the client const ai = new GoogleGenAI({});  // Example Functions function get_weather_forecast({ location }) {   console.log(`Tool Call: get_weather_forecast(location=${location})`);   // TODO: Make API call   console.log("Tool Response: {'temperature': 25, 'unit': 'celsius'}");   return { temperature: 25, unit: "celsius" }; }  function set_thermostat_temperature({ temperature }) {   console.log(     `Tool Call: set_thermostat_temperature(temperature=${temperature})`,   );   // TODO: Make API call   console.log("Tool Response: {'status': 'success'}");   return { status: "success" }; }  const toolFunctions = {   get_weather_forecast,   set_thermostat_temperature, };  const tools = [   {     functionDeclarations: [       {         name: "get_weather_forecast",         description:           "Gets the current weather temperature for a given location.",         parameters: {           type: Type.OBJECT,           properties: {             location: {               type: Type.STRING,             },           },           required: ["location"],         },       },       {         name: "set_thermostat_temperature",         description: "Sets the thermostat to a desired temperature.",         parameters: {           type: Type.OBJECT,           properties: {             temperature: {               type: Type.NUMBER,             },           },           required: ["temperature"],         },       },     ],   }, ];  // Prompt for the model let contents = [   {     role: "user",     parts: [       {         text: "If it's warmer than 20°C in London, set the thermostat to 20°C, otherwise set it to 18°C.",       },     ],   }, ];  // Loop until the model has no more function calls to make while (true) {   const result = await ai.models.generateContent({     model: "gemini-2.5-flash",     contents,     config: { tools },   });    if (result.functionCalls && result.functionCalls.length > 0) {     const functionCall = result.functionCalls[0];      const { name, args } = functionCall;      if (!toolFunctions[name]) {       throw new Error(`Unknown function call: ${name}`);     }      // Call the function and get the response.     const toolResponse = toolFunctions[name](args);      const functionResponsePart = {       name: functionCall.name,       response: {         result: toolResponse,       },     };      // Send the function response back to the model.     contents.push({       role: "model",       parts: [         {           functionCall: functionCall,         },       ],     });     contents.push({       role: "user",       parts: [         {           functionResponse: functionResponsePart,         },       ],     });   } else {     // No more function calls, break the loop.     console.log(result.text);     break;   } } 

Tool Call: get_weather_forecast(location=London) Tool Response: {'temperature': 25, 'unit': 'celsius'} Tool Call: set_thermostat_temperature(temperature=20) Tool Response: {'status': 'success'} OK. It's 25°C in London, so I've set the thermostat to 20°C. 

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

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(     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 = {   tools: tools, // not defined here.   toolConfig: toolConfig, }; 

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 client = genai.Client() config = types.GenerateContentConfig(     tools=[get_current_temperature] )  # Pass the function itself  # Make the request response = client.models.generate_content(     model="gemini-2.5-flash",     contents="What's the temperature in Boston?",     config=config, )  print(response.text)  # The SDK handles the function call and returns the final text 

config = types.GenerateContentConfig(     tools=[get_current_temperature],     automatic_function_calling=types.AutomaticFunctionCallingConfig(disable=True) ) 

AllowedType = (   int | float | bool | str | list['AllowedType'] | pydantic.BaseModel) 

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

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

pip install mcp 

import os import asyncio from datetime import datetime from mcp import ClientSession, StdioServerParameters from mcp.client.stdio import stdio_client from google import genai  client = genai.Client()  # Create server parameters for stdio connection server_params = StdioServerParameters(     command="npx",  # Executable     args=["-y", "@philschmid/weather-mcp"],  # MCP Server     env=None,  # Optional environment variables )  async def run():     async with stdio_client(server_params) as (read, write):         async with ClientSession(read, write) as session:             # Prompt to get the weather for the current day in London.             prompt = f"What is the weather in London in {datetime.now().strftime('%Y-%m-%d')}?"              # Initialize the connection between client and server             await session.initialize()              # Send request to the model with MCP function declarations             response = await client.aio.models.generate_content(                 model="gemini-2.5-flash",                 contents=prompt,                 config=genai.types.GenerateContentConfig(                     temperature=0,                     tools=[session],  # uses the session, will automatically call the tool                     # Uncomment if you **don't** want the SDK to automatically call the tool                     # automatic_function_calling=genai.types.AutomaticFunctionCallingConfig(                     #     disable=True                     # ),                 ),             )             print(response.text)  # Start the asyncio event loop and run the main function asyncio.run(run()) 

npm install @modelcontextprotocol/sdk 

import { GoogleGenAI, FunctionCallingConfigMode , mcpToTool} from '@google/genai'; import { Client } from "@modelcontextprotocol/sdk/client/index.js"; import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";  // Create server parameters for stdio connection const serverParams = new StdioClientTransport({   command: "npx", // Executable   args: ["-y", "@philschmid/weather-mcp"] // MCP Server });  const client = new Client(   {     name: "example-client",     version: "1.0.0"   } );  // Configure the client const ai = new GoogleGenAI({});  // Initialize the connection between client and server await client.connect(serverParams);  // Send request to the model with MCP tools const response = await ai.models.generateContent({   model: "gemini-2.5-flash",   contents: `What is the weather in London in ${new Date().toLocaleDateString()}?`,   config: {     tools: [mcpToTool(client)],  // uses the session, will automatically call the tool     // Uncomment if you **don't** want the sdk to automatically call the tool     // automaticFunctionCalling: {     //   disable: true,     // },   }, }); console.log(response.text)  // Close the connection await client.close();