Agent Platform SDK for Node.js

Grounding is a preview feature that connects model output to verifiable sources to reduce hallucinations. You can access these features via the vertexAI.preview namespace.

Google Search Grounding

Pass a googleSearchRetrieval tool to the generateContent method to enable Google Search grounding.

Vertex AI Search Grounding

Pass a retrieval tool containing a vertexAiSearch configuration with your specific datastore path to enable grounding against your own data stores.

// Google Search Grounding
const googleSearchRetrievalTool = {
  googleSearchRetrieval: {
    disableAttribution: false,
  },
};
const result = await generativeModelPreview.generateContent({
  contents: [{role: 'user', parts: [{text: 'Why is the sky blue?'}]}],
  tools: [googleSearchRetrievalTool],
});

// Vertex AI Search Grounding
const vertexAIRetrievalTool = {
  retrieval: {
    vertexAiSearch: {
      datastore: 'projects/.../locations/.../collections/.../dataStores/...',
    },
    disableAttribution: false,
  },
};
const result = await generativeModelPreview.generateContent({
  contents: [{role: 'user', parts: [{text: 'Why is the sky blue?'}]}],
  tools: [vertexAIRetrievalTool],
});

The Vertex AI SDK supports function calling via sendMessage, sendMessageStream, generateContent, and generateContentStream. You can implement this using a chat session (recommended) or by providing a full conversation history in a single request.

To use function calling, you must:

1. Declare the function: Define the function's name, description, and parameters using FunctionDeclarationSchemaType.
2. Pass tools to the model: Include the declarations in the tools parameter of your request or chat session.
3. Handle the response: When the model returns a functionCall, execute your local logic and send the result back to the model using a functionResponse part.

const functionDeclarations = [
  {
    functionDeclarations: [
      {
        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'],
        },
      },
    ],
  },
];

// Example of sending a follow-up with the function result
const functionResponseParts = [
  {
    functionResponse: {
      name: "get_current_weather",
      response: {name: "get_current_weather", content: {weather: "super nice"}},
    },
  },
];

// Using sendMessageStream in a chat session
const chat = generativeModel.startChat({
  tools: functionDeclarations,
});
const streamingResult = await chat.sendMessageStream('What is the weather in Boston?');
// ... process stream ...
await chat.sendMessageStream(functionResponseParts);
// ... process second stream ...

System instructions provide additional context or persona to the model. You can include them in two ways:

1. During Model Instantiation: Set the systemInstruction property when calling getGenerativeModel. This applies to all requests made with that model instance.
2. Per Request: Include the systemInstruction object in the request payload passed to generateContent.

// During instantiation
const generativeModel = vertexAI.getGenerativeModel({
    model: textModel,
    systemInstruction: {
      role: 'system',
      parts: [{"text": `For example, you are a helpful customer service agent.`}]
    },
});

// In a specific request
const request = {
  contents: [{role: 'user', parts: [{text: 'How are you doing today?'}]}],
  systemInstruction: { role: 'system', parts: [{ text: `For example, you are a helpful customer service agent.` }] },
};
const result = await generativeModel.generateContent(request);