使用函式呼叫生成內容。這個範例會示範文字模態情境，其中包含一個函式和一個提示。
深入探索
如需包含這個程式碼範例的詳細說明文件，請參閱下列內容：
程式碼範例
C#
在試用這個範例之前，請先按照C#使用用戶端程式庫的 Vertex AI 快速入門中的操作說明進行設定。 詳情請參閱 Vertex AI C# API 參考說明文件。
如要向 Vertex AI 進行驗證，請設定應用程式預設憑證。 詳情請參閱「為本機開發環境設定驗證」。
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;
}
}
Go
在試用這個範例之前，請先按照Go使用用戶端程式庫的 Vertex AI 快速入門中的操作說明進行設定。 詳情請參閱 Vertex AI Go API 參考說明文件。
如要向 Vertex AI 進行驗證，請設定應用程式預設憑證。 詳情請參閱「為本機開發環境設定驗證」。
import (
"context"
"encoding/json"
"errors"
"fmt"
"io"
"cloud.google.com/go/vertexai/genai"
)
// functionCalling demonstrates 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
// to the model enables it to generate a text response that incorporates the data.
func functionCalling(w io.Writer, projectID, location, modelName string) error {
// location = "us-central1"
// modelName = "gemini-2.0-flash-001"
ctx := context.Background()
client, err := genai.NewClient(ctx, projectID, location)
if err != nil {
return fmt.Errorf("failed to create GenAI client: %w", err)
}
defer client.Close()
model := client.GenerativeModel(modelName)
// Set temperature to 0.0 for maximum determinism in function calling.
model.SetTemperature(0.0)
funcName := "getCurrentWeather"
funcDecl := &genai.FunctionDeclaration{
Name: funcName,
Description: "Get the current weather in a given location",
Parameters: &genai.Schema{
Type: genai.TypeObject,
Properties: map[string]*genai.Schema{
"location": {
Type: genai.TypeString,
Description: "location",
},
},
Required: []string{"location"},
},
}
// Add the weather function to our model toolbox.
model.Tools = []*genai.Tool{
{
FunctionDeclarations: []*genai.FunctionDeclaration{funcDecl},
},
}
prompt := genai.Text("What's the weather like in Boston?")
resp, err := model.GenerateContent(ctx, prompt)
if err != nil {
return fmt.Errorf("failed to generate content: %w", err)
}
if len(resp.Candidates) == 0 {
return errors.New("got empty response from model")
} else if len(resp.Candidates[0].FunctionCalls()) == 0 {
return errors.New("got no function call suggestions from model")
}
// In a production environment, consider adding validations for function names and arguments.
for _, fnCall := range resp.Candidates[0].FunctionCalls() {
fmt.Fprintf(w, "The model suggests to call the function %q with args: %v\n", fnCall.Name, fnCall.Args)
// Example response:
// The model suggests to call the function "getCurrentWeather" with args: map[location:Boston]
}
// Use synthetic data to simulate a response from the external API.
// In a real application, this would come from an actual weather API.
mockAPIResp, err := json.Marshal(map[string]string{
"location": "Boston",
"temperature": "38",
"temperature_unit": "F",
"description": "Cold and cloudy",
"humidity": "65",
"wind": `{"speed": "10", "direction": "NW"}`,
})
if err != nil {
return fmt.Errorf("failed to marshal function response to JSON: %w", err)
}
funcResp := &genai.FunctionResponse{
Name: funcName,
Response: map[string]any{
"content": mockAPIResp,
},
}
// Return the API response to the model allowing it to complete its response.
resp, err = model.GenerateContent(ctx, prompt, funcResp)
if err != nil {
return fmt.Errorf("failed to generate content: %w", err)
}
if len(resp.Candidates) == 0 || len(resp.Candidates[0].Content.Parts) == 0 {
return errors.New("got empty response from model")
}
fmt.Fprintln(w, resp.Candidates[0].Content.Parts[0])
// Example response:
// The weather in Boston is cold and cloudy, with a humidity of 65% and a temperature of 38°F. ...
return nil
}
Java
在試用這個範例之前，請先按照Java使用用戶端程式庫的 Vertex AI 快速入門中的操作說明進行設定。 詳情請參閱 Vertex AI Java API 參考說明文件。
如要向 Vertex AI 進行驗證，請設定應用程式預設憑證。 詳情請參閱「為本機開發環境設定驗證」。
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;
}
}
}後續步驟
如要搜尋及篩選其他 Google Cloud 產品的程式碼範例，請參閱Google Cloud 範例瀏覽器。