函式呼叫簡介

const {   VertexAI,   FunctionDeclarationSchemaType, } = require('@google-cloud/vertexai');  const functionDeclarations = [   {     function_declarations: [       {         name: 'get_current_weather',         description: 'get weather in a given location',         parameters: {           type: FunctionDeclarationSchemaType.OBJECT,           properties: {             location: {type: FunctionDeclarationSchemaType.STRING},             unit: {               type: FunctionDeclarationSchemaType.STRING,               enum: ['celsius', 'fahrenheit'],             },           },           required: ['location'],         },       },     ],   }, ];  const functionResponseParts = [   {     functionResponse: {       name: 'get_current_weather',       response: {name: 'get_current_weather', content: {weather: 'super nice'}},     },   }, ];  /**  * TODO(developer): Update these variables before running the sample.  */ async function functionCallingStreamContent(   projectId = 'PROJECT_ID',   location = 'us-central1',   model = 'gemini-2.0-flash-001' ) {   // Initialize Vertex with your Cloud project and location   const vertexAI = new VertexAI({project: projectId, location: location});    // Instantiate the model   const generativeModel = vertexAI.getGenerativeModel({     model: model,   });    const request = {     contents: [       {role: 'user', parts: [{text: 'What is the weather in Boston?'}]},       {         role: 'ASSISTANT',         parts: [           {             functionCall: {               name: 'get_current_weather',               args: {location: 'Boston'},             },           },         ],       },       {role: 'USER', parts: functionResponseParts},     ],     tools: functionDeclarations,   };   const streamingResp = await generativeModel.generateContentStream(request);   for await (const item of streamingResp.stream) {     console.log(item.candidates[0].content.parts[0].text);   } }

import ( 	"context" 	"fmt" 	"io"  	genai "google.golang.org/genai" )  // generateWithFuncCall shows how to submit a prompt and a function declaration to the model, // allowing it to suggest a call to the function to fetch external data. Returning this data // enables the model to generate a text response that incorporates the data. func generateWithFuncCall(w io.Writer) error { 	ctx := context.Background()  	client, err := genai.NewClient(ctx, &genai.ClientConfig{ 		HTTPOptions: genai.HTTPOptions{APIVersion: "v1"}, 	}) 	if err != nil { 		return fmt.Errorf("failed to create genai client: %w", err) 	}  	weatherFunc := &genai.FunctionDeclaration{ 		Description: "Returns the current weather in a location.", 		Name:        "getCurrentWeather", 		Parameters: &genai.Schema{ 			Type: "object", 			Properties: map[string]*genai.Schema{ 				"location": {Type: "string"}, 			}, 			Required: []string{"location"}, 		}, 	} 	config := &genai.GenerateContentConfig{ 		Tools: []*genai.Tool{ 			{FunctionDeclarations: []*genai.FunctionDeclaration{weatherFunc}}, 		}, 		Temperature: genai.Ptr(float32(0.0)), 	}  	modelName := "gemini-2.5-flash" 	contents := []*genai.Content{ 		{Parts: []*genai.Part{ 			{Text: "What is the weather like in Boston?"}, 		}, 			Role: "user"}, 	}  	resp, err := client.Models.GenerateContent(ctx, modelName, contents, config) 	if err != nil { 		return fmt.Errorf("failed to generate content: %w", err) 	}  	var funcCall *genai.FunctionCall 	for _, p := range resp.Candidates[0].Content.Parts { 		if p.FunctionCall != nil { 			funcCall = p.FunctionCall 			fmt.Fprint(w, "The model suggests to call the function ") 			fmt.Fprintf(w, "%q with args: %v\n", funcCall.Name, funcCall.Args) 			// Example response: 			// The model suggests to call the function "getCurrentWeather" with args: map[location:Boston] 		} 	} 	if funcCall == nil { 		return fmt.Errorf("model did not suggest a function call") 	}  	// Use synthetic data to simulate a response from the external API. 	// In a real application, this would come from an actual weather API. 	funcResp := &genai.FunctionResponse{ 		Name: "getCurrentWeather", 		Response: map[string]any{ 			"location":         "Boston", 			"temperature":      "38", 			"temperature_unit": "F", 			"description":      "Cold and cloudy", 			"humidity":         "65", 			"wind":             `{"speed": "10", "direction": "NW"}`, 		}, 	}  	// Return conversation turns and API response to complete the model's response. 	contents = []*genai.Content{ 		{Parts: []*genai.Part{ 			{Text: "What is the weather like in Boston?"}, 		}, 			Role: "user"}, 		{Parts: []*genai.Part{ 			{FunctionCall: funcCall}, 		}}, 		{Parts: []*genai.Part{ 			{FunctionResponse: funcResp}, 		}}, 	}  	resp, err = client.Models.GenerateContent(ctx, modelName, contents, config) 	if err != nil { 		return fmt.Errorf("failed to generate content: %w", err) 	}  	respText := resp.Text()  	fmt.Fprintln(w, respText)  	// Example response: 	// The weather in Boston is cold and cloudy with a temperature of 38 degrees Fahrenheit. The humidity is ...  	return nil } 

 using Google.Cloud.AIPlatform.V1; using System; using System.Threading.Tasks; using Type = Google.Cloud.AIPlatform.V1.Type; using Value = Google.Protobuf.WellKnownTypes.Value;  public class FunctionCalling {     public async Task<string> GenerateFunctionCall(         string projectId = "your-project-id",         string location = "us-central1",         string publisher = "google",         string model = "gemini-2.0-flash-001")     {         var predictionServiceClient = new PredictionServiceClientBuilder         {             Endpoint = $"{location}-aiplatform.googleapis.com"         }.Build();          // Define the user's prompt in a Content object that we can reuse in         // model calls         var userPromptContent = new Content         {             Role = "USER",             Parts =             {                 new Part { Text = "What is the weather like in Boston?" }             }         };          // Specify a function declaration and parameters for an API request         var functionName = "get_current_weather";         var getCurrentWeatherFunc = new FunctionDeclaration         {             Name = functionName,             Description = "Get the current weather in a given location",             Parameters = new OpenApiSchema             {                 Type = Type.Object,                 Properties =                 {                     ["location"] = new()                     {                         Type = Type.String,                         Description = "Get the current weather in a given location"                     },                     ["unit"] = new()                     {                         Type = Type.String,                         Description = "The unit of measurement for the temperature",                         Enum = {"celsius", "fahrenheit"}                     }                 },                 Required = { "location" }             }         };          // Send the prompt and instruct the model to generate content using the tool that you just created         var generateContentRequest = new GenerateContentRequest         {             Model = $"projects/{projectId}/locations/{location}/publishers/{publisher}/models/{model}",             GenerationConfig = new GenerationConfig             {                 Temperature = 0f             },             Contents =             {                 userPromptContent             },             Tools =             {                 new Tool                 {                     FunctionDeclarations = { getCurrentWeatherFunc }                 }             }         };          GenerateContentResponse response = await predictionServiceClient.GenerateContentAsync(generateContentRequest);          var functionCall = response.Candidates[0].Content.Parts[0].FunctionCall;         Console.WriteLine(functionCall);          string apiResponse = "";          // Check the function name that the model responded with, and make an API call to an external system         if (functionCall.Name == functionName)         {             // Extract the arguments to use in your API call             string locationCity = functionCall.Args.Fields["location"].StringValue;              // Here you can use your preferred method to make an API request to             // fetch the current weather              // In this example, we'll use synthetic data to simulate a response             // payload from an external API             apiResponse = @"{ ""location"": ""Boston, MA"",                     ""temperature"": 38, ""description"": ""Partly Cloudy""}";         }          // Return the API response to Gemini so it can generate a model response or request another function call         generateContentRequest = new GenerateContentRequest         {             Model = $"projects/{projectId}/locations/{location}/publishers/{publisher}/models/{model}",             Contents =             {                 userPromptContent, // User prompt                 response.Candidates[0].Content, // Function call response,                 new Content                 {                     Parts =                     {                         new Part                         {                             FunctionResponse = new()                             {                                 Name = functionName,                                 Response = new()                                 {                                     Fields =                                     {                                         { "content", new Value { StringValue = apiResponse } }                                     }                                 }                             }                         }                     }                 }             },             Tools =             {                 new Tool                 {                     FunctionDeclarations = { getCurrentWeatherFunc }                 }             }         };          response = await predictionServiceClient.GenerateContentAsync(generateContentRequest);          string responseText = response.Candidates[0].Content.Parts[0].Text;         Console.WriteLine(responseText);          return responseText;     } } 

import com.google.cloud.vertexai.VertexAI; import com.google.cloud.vertexai.api.Content; import com.google.cloud.vertexai.api.FunctionDeclaration; import com.google.cloud.vertexai.api.GenerateContentResponse; import com.google.cloud.vertexai.api.Schema; import com.google.cloud.vertexai.api.Tool; import com.google.cloud.vertexai.api.Type; import com.google.cloud.vertexai.generativeai.ChatSession; import com.google.cloud.vertexai.generativeai.ContentMaker; import com.google.cloud.vertexai.generativeai.GenerativeModel; import com.google.cloud.vertexai.generativeai.PartMaker; import com.google.cloud.vertexai.generativeai.ResponseHandler; import java.io.IOException; import java.util.Arrays; import java.util.Collections;  public class FunctionCalling {   public static void main(String[] args) throws IOException {     // TODO(developer): Replace these variables before running the sample.     String projectId = "your-google-cloud-project-id";     String location = "us-central1";     String modelName = "gemini-2.0-flash-001";      String promptText = "What's the weather like in Paris?";      whatsTheWeatherLike(projectId, location, modelName, promptText);   }    // A request involving the interaction with an external tool   public static String whatsTheWeatherLike(String projectId, String location,                                            String modelName, String promptText)       throws IOException {     // Initialize client that will be used to send requests.     // This client only needs to be created once, and can be reused for multiple requests.     try (VertexAI vertexAI = new VertexAI(projectId, location)) {        FunctionDeclaration functionDeclaration = FunctionDeclaration.newBuilder()           .setName("getCurrentWeather")           .setDescription("Get the current weather in a given location")           .setParameters(               Schema.newBuilder()                   .setType(Type.OBJECT)                   .putProperties("location", Schema.newBuilder()                       .setType(Type.STRING)                       .setDescription("location")                       .build()                   )                   .addRequired("location")                   .build()           )           .build();        System.out.println("Function declaration:");       System.out.println(functionDeclaration);        // Add the function to a "tool"       Tool tool = Tool.newBuilder()           .addFunctionDeclarations(functionDeclaration)           .build();        // Start a chat session from a model, with the use of the declared function.       GenerativeModel model = new GenerativeModel(modelName, vertexAI)           .withTools(Arrays.asList(tool));       ChatSession chat = model.startChat();        System.out.println(String.format("Ask the question: %s", promptText));       GenerateContentResponse response = chat.sendMessage(promptText);        // The model will most likely return a function call to the declared       // function `getCurrentWeather` with "Paris" as the value for the       // argument `location`.       System.out.println("\nPrint response: ");       System.out.println(ResponseHandler.getContent(response));        // Provide an answer to the model so that it knows what the result       // of a "function call" is.       Content content =           ContentMaker.fromMultiModalData(               PartMaker.fromFunctionResponse(                   "getCurrentWeather",                   Collections.singletonMap("currentWeather", "sunny")));       System.out.println("Provide the function response: ");       System.out.println(content);       response = chat.sendMessage(content);        // See what the model replies now       System.out.println("Print response: ");       String finalAnswer = ResponseHandler.getText(response);       System.out.println(finalAnswer);        return finalAnswer;     }   } }