SDK Vertex AI Node.js
L'SDK Vertex AI Node.js consente agli sviluppatori di utilizzare i modelli di IA generativa all'avanguardia di Google (come Gemini) per creare funzionalità e applicazioni basate sull'IA.
Visita questa pagina per esempi dettagliati utilizzando l'SDK Vertex AI Node.js.
Prima di iniziare
- Seleziona o crea un progetto della piattaforma Cloud.
- Abilita la fatturazione per il progetto.
- Abilita l'API Vertex AI.
- Configura l'autenticazione con un account di servizio in modo da poter accedere all'API dalla workstation locale.
Installazione
Installa questo SDK tramite Gestione dei partner di rete.
npm install @google-cloud/vertexai
Imposta
Per utilizzare l'SDK, crea un'istanza di VertexAI trasmettendo l'ID progetto e la località Google Cloud. Quindi crea un riferimento a un modello generativo.
const {VertexAI, HarmCategory, HarmBlockThreshold} = require('@google-cloud/vertexai');
const project = 'your-cloud-project';
const location = 'us-central1';
const vertex_ai = new VertexAI({project: project, location: location});
// Instantiate models
const generativeModel = vertex_ai.getGenerativeModel({
model: 'gemini-pro',
// The following parameters are optional
// They can also be passed to individual content generation requests
safety_settings: [{category: HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT, threshold: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE}],
generation_config: {max_output_tokens: 256},
});
const generativeVisionModel = vertex_ai.getGenerativeModel({
model: 'gemini-pro-vision',
});
Generazione di contenuti in streaming
async function streamGenerateContent() {
const request = {
contents: [{role: 'user', parts: [{text: 'How are you doing today?'}]}],
};
const streamingResp = await generativeModel.generateContentStream(request);
for await (const item of streamingResp.stream) {
console.log('stream chunk: ', JSON.stringify(item));
}
console.log('aggregated response: ', JSON.stringify(await streamingResp.response));
};
streamGenerateContent();
Chat in streaming
async function streamChat() {
const chat = generativeModel.startChat();
const chatInput1 = "How can I learn more about Node.js?";
const result1 = await chat.sendMessageStream(chatInput1);
for await (const item of result1.stream) {
console.log(item.candidates[0].content.parts[0].text);
}
console.log('aggregated response: ', JSON.stringify(await result1.response));
}
streamChat();
Generazione di contenuti in più parti
Fornitura di un URI immagine Google Cloud Storage
async function multiPartContent() {
const filePart = {file_data: {file_uri: "gs://generativeai-downloads/images/scones.jpg", mime_type: "image/jpeg"}};
const textPart = {text: 'What is this picture about?'};
const request = {
contents: [{role: 'user', parts: [textPart, filePart]}],
};
const streamingResp = await generativeVisionModel.generateContentStream(request);
for await (const item of streamingResp.stream) {
console.log('stream chunk: ', JSON.stringify(item));
}
const aggregatedResponse = await streamingResp.response;
console.log(aggregatedResponse.candidates[0].content);
}
multiPartContent();
Fornitura di una stringa immagine Base64
async function multiPartContentImageString() {
// Replace this with your own base64 image string
const base64Image = 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwAEhQGAhKmMIQAAAABJRU5ErkJggg==';
const filePart = {inline_data: {data: base64Image, mime_type: 'image/jpeg'}};
const textPart = {text: 'What is this picture about?'};
const request = {
contents: [{role: 'user', parts: [textPart, filePart]}],
};
const resp = await generativeVisionModel.generateContentStream(request);
const contentResponse = await resp.response;
console.log(contentResponse.candidates[0].content.parts[0].text);
}
multiPartContentImageString();
Contenuti in più parti con testo e video
async function multiPartContentVideo() {
const filePart = {file_data: {file_uri: 'gs://cloud-samples-data/video/animals.mp4', mime_type: 'video/mp4'}};
const textPart = {text: 'What is in the video?'};
const request = {
contents: [{role: 'user', parts: [textPart, filePart]}],
};
const streamingResp = await generativeVisionModel.generateContentStream(request);
for await (const item of streamingResp.stream) {
console.log('stream chunk: ', JSON.stringify(item));
}
const aggregatedResponse = await streamingResp.response;
console.log(aggregatedResponse.candidates[0].content);
}
multiPartContentVideo();
Generazione di contenuti: non in streaming
async function generateContent() {
const request = {
contents: [{role: 'user', parts: [{text: 'How are you doing today?'}]}],
};
const resp = await generativeModel.generateContent(request);
console.log('aggregated response: ', JSON.stringify(await resp.response));
};
generateContent();
Conteggio dei token
async function countTokens() {
const request = {
contents: [{role: 'user', parts: [{text: 'How are you doing today?'}]}],
};
const resp = await generativeModel.countTokens(request);
console.log('count tokens response: ', resp);
}
countTokens();
Chiamata di funzione
Node SDK supporta le
chiamate di funzione tramite sendMessage, sendMessageStream, generateContent e generateContentStream. Ti consigliamo di utilizzarlo tramite i metodi di chat
(sendMessage o sendMessageStream), ma di seguito includi esempi di entrambi gli approcci.
Dichiarazioni e risposta delle funzioni
Questo è un esempio di dichiarazione e risposta della funzione, che vengono passate al modello negli snippet successivi.
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"}},
},
},
];
Chiamate di funzioni con chat
async function functionCallingChat() {
// Create a chat session and pass your function declarations
const chat = generativeModel.startChat({
tools: functionDeclarations,
});
const chatInput1 = 'What is the weather in Boston?';
// This should include a functionCall response from the model
const result1 = await chat.sendMessageStream(chatInput1);
for await (const item of result1.stream) {
console.log(item.candidates[0]);
}
const response1 = await result1.response;
// Send a follow up message with a FunctionResponse
const result2 = await chat.sendMessageStream(functionResponseParts);
for await (const item of result2.stream) {
console.log(item.candidates[0]);
}
// This should include a text response from the model using the response content
// provided above
const response2 = await result2.response;
}
functionCallingChat();
Chiamata di funzione con generateContentStream
async function functionCallingGenerateContent() {
const request = {
contents: [
{role: 'user', parts: [{text: 'What is the weather in Boston?'}]},
{role: 'model', parts: [{functionCall: {name: 'get_current_weather', args: {'location': 'Boston'}}}]},
{role: 'function', parts: functionResponseParts}
],
tools: functionDeclarations,
};
const streamingResp =
await generativeModel.generateContentStream(request);
for await (const item of streamingResp.stream) {
console.log(item.candidates[0]);
}
}
functionCallingGenerateContent();
Licenza
I contenuti di questo repository sono concessi in licenza in base alla licenza Apache, versione 2.0.