Partager via

Bibliothèque cliente Azure AI Agents pour JavaScript - version 1.1.0

Utilisez la bibliothèque cliente AI Agents pour :

  • Développer des agents à l’aide du service Azure AI Agent, en tirant parti d’un vaste écosystème de modèles, d’outils et de fonctionnalités d’OpenAI, de Microsoft et d’autres fournisseurs LLM. Le service d’agent Azure AI permet de créer des agents pour un large éventail de cas d’utilisation de l’IA générative.
  • Note: Bien que ce package puisse être utilisé indépendamment, nous vous recommandons d’utiliser la bibliothèque cliente Azure AI Projects pour une expérience améliorée. La bibliothèque de projets offre un accès simplifié à des fonctionnalités avancées, telles que la création et la gestion d’agents, l’énumération de modèles d’IA, l’utilisation de jeux de données et la gestion d’index de recherche, l’évaluation des performances de l’IA générative et l’activation du suivi OpenTelemetry.

Documentation | du produitÉchantillons | Paquet (npm) | Documentation de référence sur l’API

Table des matières

Mise en route

Prérequis

Autorisation

  • L’Entra ID est nécessaire pour authentifier le client. Votre application a besoin d’un objet qui implémente l’interface TokenCredential. Les exemples de code ici utilisent DefaultAzureCredential. Pour travailler, vous aurez besoin des éléments suivants :
    • Rôle Contributor. Le rôle attribué peut être effectué via l’onglet « Contrôle d’accès (IAM) » de votre ressource Azure AI Project dans le portail Azure. Pour en savoir plus sur l’attribution des rôles , cliquez ici.
    • azure CLI installé.
    • Vous êtes connecté à votre compte Azure en exécutant az login.
    • Notez que si vous avez plusieurs abonnements Azure, l’abonnement qui contient votre ressource Azure AI Project doit être votre abonnement par défaut. Exécutez az account list --output table pour répertorier l’ensemble de votre abonnement et voir lequel est la valeur par défaut. Exécutez az account set --subscription "Your Subscription ID or Name" pour modifier votre abonnement par défaut.

Installer le package

npm install @azure/ai-agents @azure/identity

Concepts clés

Créer et authentifier le client

Le AgentsClient est utilisé pour construire le client. Actuellement, nous vous recommandons d’utiliser AgentsClient via la bibliothèque cliente Azure AI Projects à l’aide de client.agents.

Pour obtenir le point de terminaison de votre projet, vous pouvez vous référer à la documentation. Ci-dessous, nous supposerons que la variable PROJECT_ENDPOINT d’environnement contient cette valeur.

import { AgentsClient } from "@azure/ai-agents";
import { DefaultAzureCredential } from "@azure/identity";

const projectEndpoint = process.env["PROJECT_ENDPOINT"] || "<project endpoint>";
const modelDeploymentName = process.env["MODEL_DEPLOYMENT_NAME"] || "gpt-4o";
const client = new AgentsClient(projectEndpoint, new DefaultAzureCredential());

Exemples

Agents

Les agents de la bibliothèque cliente Azure AI Projects sont conçus pour faciliter diverses interactions et opérations au sein de vos projets IA. Ils servent de composants principaux qui gèrent et exécutent des tâches, en tirant parti de différents outils et ressources pour atteindre des objectifs spécifiques. Les étapes suivantes décrivent la séquence classique d’interaction avec les agents. Consultez les exemples de package pour obtenir d’autres exemples d’Agent.

Créer un agent

Voici un exemple de création d’un agent :

const agent = await client.createAgent("gpt-4o", {
  name: "my-agent",
  instructions: "You are a helpful assistant",
});

Pour autoriser les agents à accéder à vos ressources ou fonctions personnalisées, vous avez besoin d’outils. Vous pouvez transmettre des outils pour createAgent par le biais des arguments tools et toolResources.

Vous pouvez utiliser ToolSet pour ce faire :

import { ToolSet } from "@azure/ai-agents";

// Upload file for code interpreter tool
const filePath1 = "./data/syntheticCompanyQuarterlyResults.csv";
const fileStream1 = fs.createReadStream(filePath1);
const codeInterpreterFile = await client.files.upload(fileStream1, "assistants", {
  fileName: "myLocalFile",
});
console.log(`Uploaded local file, file ID : ${codeInterpreterFile.id}`);
// Upload file for file search tool
const filePath2 = "./data/sampleFileForUpload.txt";
const fileStream2 = fs.createReadStream(filePath2);
const fileSearchFile = await client.files.upload(fileStream2, "assistants", {
  fileName: "sampleFileForUpload.txt",
});
console.log(`Uploaded file, file ID: ${fileSearchFile.id}`);
// Create vector store for file search tool
const vectorStore = await client.vectorStores
  .createAndPoll({
    fileIds: [fileSearchFile.id],
  })
  .pollUntilDone();
// Create tool set
const toolSet = new ToolSet();
toolSet.addFileSearchTool([vectorStore.id]);
toolSet.addCodeInterpreterTool([codeInterpreterFile.id]);

// Create agent with tool set
const agent = await client.createAgent("gpt-4o", {
  name: "my-agent",
  instructions: "You are a helpful agent",
  tools: toolSet.toolDefinitions,
  toolResources: toolSet.toolResources,
});
console.log(`Created agent, agent ID: ${agent.id}`);

Agents multiples

Vous pouvez créer plusieurs agents avec différents outils, puis les connecter ensemble.

import { ToolUtility } from "@azure/ai-agents";

const connectedAgentName = "stock_price_bot";
const modelDeploymentName = process.env["MODEL_DEPLOYMENT_NAME"] || "gpt-4o";
const stockAgent = await client.createAgent(modelDeploymentName, {
  name: "stock-price-agent",
  instructions:
    "Your job is to get the stock price of a company. If you don't know the realtime stock price, return the last known stock price.",
});
// Initialize Connected Agent tool with the agent id, name, and description
const connectedAgentTool = ToolUtility.createConnectedAgentTool(
  stockAgent.id,
  connectedAgentName,
  "Gets the stock price of a company",
);
// Create agent with the Connected Agent tool and process assistant run
const agent = await client.createAgent(modelDeploymentName, {
  name: "my-agent",
  instructions: "You are a helpful assistant, and use the connected agent to get stock prices.",
  tools: [connectedAgentTool.definition],
});
console.log(`Created agent, agent ID: ${agent.id}`);

Pour effectuer une recherche de fichiers par un agent, nous devons d’abord charger un fichier, créer un magasin de vecteurs et associer le fichier au magasin vectoriel. Voici un exemple :

import { ToolUtility } from "@azure/ai-agents";

const filePath = "./data/sampleFileForUpload.txt";
const localFileStream = fs.createReadStream(filePath);
const file = await client.files.upload(localFileStream, "assistants", {
  fileName: "sampleFileForUpload.txt",
});
console.log(`Uploaded file, file ID: ${file.id}`);

const vectorStore = await client.vectorStores.create({
  fileIds: [file.id],
  name: "myVectorStore",
});
console.log(`Created vector store, vector store ID: ${vectorStore.id}`);

const fileSearchTool = ToolUtility.createFileSearchTool([vectorStore.id]);

const agent = await client.createAgent("gpt-4o", {
  name: "File Search Agent",
  instructions: "You are helpful agent that can help fetch data from files you know about.",
  tools: [fileSearchTool.definition],
  toolResources: fileSearchTool.resources,
});
console.log(`Created agent, agent ID : ${agent.id}`);

Créer un agent avec l’interpréteur de code

Voici un exemple pour charger un fichier et l’utiliser pour l’interpréteur de code par un agent :

import { ToolUtility } from "@azure/ai-agents";

const filePath = "./data/syntheticCompanyQuarterlyResults.csv";
const localFileStream = fs.createReadStream(filePath);
const localFile = await client.files.upload(localFileStream, "assistants", {
  fileName: "localFile",
});

console.log(`Uploaded local file, file ID : ${localFile.id}`);

const codeInterpreterTool = ToolUtility.createCodeInterpreterTool([localFile.id]);

// Notice that CodeInterpreter must be enabled in the agent creation, otherwise the agent will not be able to see the file attachment
const agent = await client.createAgent("gpt-4o", {
  name: "my-agent",
  instructions: "You are a helpful agent",
  tools: [codeInterpreterTool.definition],
  toolResources: codeInterpreterTool.resources,
});
console.log(`Created agent, agent ID: ${agent.id}`);

Créer un agent avec Bing Grounding

Pour permettre à votre agent d’effectuer une recherche via l’API recherche Bing, vous utilisez ToolUtility.createBingGroundingTool() avec une connexion. Cliquez ici pour en savoir plus sur l’ancrage avec Bing Search.

Voici un exemple :

import { ToolUtility } from "@azure/ai-agents";

const connectionId = process.env["AZURE_BING_CONNECTION_ID"] || "<connection-name>";

// Initialize agent bing tool with the connection id
const bingTool = ToolUtility.createBingGroundingTool([{ connectionId: connectionId }]);

// Create agent with the bing tool and process assistant run
const agent = await client.createAgent("gpt-4o", {
  name: "my-agent",
  instructions: "You are a helpful agent",
  tools: [bingTool.definition],
});
console.log(`Created agent, agent ID : ${agent.id}`);

Azure AI Search est un système de recherche d’entreprise pour les applications hautes performances. Il s’intègre à Azure OpenAI Service et Azure Machine Learning, offrant des technologies de recherche avancées telles que la recherche vectorielle et la recherche en texte intégral. Idéal pour les insights de base de connaissances, la découverte des informations et l’automatisation

Voici un exemple d’intégration d’Azure AI Search :

import { ToolUtility } from "@azure/ai-agents";

const connectionName = process.env["AZURE_AI_SEARCH_CONNECTION_NAME"] || "<connection-name>";

// Initialize Azure AI Search tool
const azureAISearchTool = ToolUtility.createAzureAISearchTool(connectionName, "search-index", {
  queryType: "simple",
  topK: 3,
  filter: "", // Add string here to filter results
  indexConnectionId: connectionName,
  indexName: "search-index",
});

// Create agent with the Azure AI search tool
const agent = await client.createAgent("gpt-4o", {
  name: "my-agent",
  instructions: "You are a helpful agent",
  tools: [azureAISearchTool.definition],
  toolResources: azureAISearchTool.resources,
});
console.log(`Created agent, agent ID : ${agent.id}`);

Créer un agent avec l’appel de fonction

Vous pouvez améliorer vos agents en définissant des fonctions de rappel en tant qu’outils de fonction. Ceux-ci peuvent être fournis à createAgent via la combinaison de tools et de toolResources. Seules les définitions et descriptions des fonctions sont fournies à createAgent, sans les implémentations. Le Run ou event handler of stream déclenche un état de requires_action en fonction des définitions de fonction. Votre code doit gérer cet état et appeler les fonctions appropriées.

Voici un exemple :

import {
  FunctionToolDefinition,
  ToolUtility,
  RequiredToolCall,
  ToolOutput,
} from "@azure/ai-agents";

class FunctionToolExecutor {
  private functionTools: {
    func: Function;
    definition: FunctionToolDefinition;
  }[];

  constructor() {
    this.functionTools = [
      {
        func: this.getUserFavoriteCity,
        ...ToolUtility.createFunctionTool({
          name: "getUserFavoriteCity",
          description: "Gets the user's favorite city.",
          parameters: {},
        }),
      },
      {
        func: this.getCityNickname,
        ...ToolUtility.createFunctionTool({
          name: "getCityNickname",
          description: "Gets the nickname of a city, e.g. 'LA' for 'Los Angeles, CA'.",
          parameters: {
            type: "object",
            properties: {
              location: { type: "string", description: "The city and state, e.g. Seattle, Wa" },
            },
          },
        }),
      },
      {
        func: this.getWeather,
        ...ToolUtility.createFunctionTool({
          name: "getWeather",
          description: "Gets the weather for a location.",
          parameters: {
            type: "object",
            properties: {
              location: { type: "string", description: "The city and state, e.g. Seattle, Wa" },
              unit: { type: "string", enum: ["c", "f"] },
            },
          },
        }),
      },
    ];
  }

  private getUserFavoriteCity(): {} {
    return { location: "Seattle, WA" };
  }

  private getCityNickname(_location: string): {} {
    return { nickname: "The Emerald City" };
  }

  private getWeather(_location: string, unit: string): {} {
    return { weather: unit === "f" ? "72f" : "22c" };
  }

  public invokeTool(toolCall: RequiredToolCall & FunctionToolDefinition): ToolOutput | undefined {
    console.log(`Function tool call - ${toolCall.function.name}`);
    const args: any[] = [];
    if (toolCall.function.parameters) {
      try {
        const params = JSON.parse(toolCall.function.parameters);
        for (const key in params) {
          if (Object.prototype.hasOwnProperty.call(params, key)) {
            args.push(params[key]);
          }
        }
      } catch (error) {
        console.error(`Failed to parse parameters: ${toolCall.function.parameters}`, error);
        return undefined;
      }
    }
    // Create a mapping of function names to their implementations
    const functionMap = new Map(
      this.functionTools.map((tool) => [tool.definition.function.name, tool.func]),
    );
    const result = functionMap.get(toolCall.function.name)?.(...args);
    return result
      ? {
          toolCallId: toolCall.id,
          output: JSON.stringify(result),
        }
      : {
          toolCallId: toolCall.id,
          output: JSON.stringify({
            error: `No matching tool found for function: ${toolCall.function.name}`,
          }),
        };
  }

  public getFunctionDefinitions(): FunctionToolDefinition[] {
    return this.functionTools.map((tool) => {
      return tool.definition;
    });
  }
}
const functionToolExecutor = new FunctionToolExecutor();
const functionTools = functionToolExecutor.getFunctionDefinitions();
const agent = await client.createAgent("gpt-4o", {
  name: "my-agent",
  instructions:
    "You are a weather bot. Use the provided functions to help answer questions. Customize your responses to the user's preferences as much as possible and use friendly nicknames for cities whenever possible.",
  tools: functionTools,
});
console.log(`Created agent, agent ID: ${agent.id}`);

Créer un agent avec OpenAPI

Les spécifications OpenAPI décrivent les opérations REST sur un point de terminaison spécifique. Le Kit de développement logiciel (SDK) Agents peut lire une spécification OpenAPI, créer une fonction à partir de celle-ci et appeler cette fonction sur le point de terminaison REST sans exécution côté client supplémentaire. Voici un exemple de création d’un outil OpenAPI (à l’aide de l’authentification anonyme) :

import { ToolUtility } from "@azure/ai-agents";

// Read in OpenApi spec
const filePath = "./data/weatherOpenApi.json";
const openApiSpec = JSON.parse(fs.readFileSync(filePath, "utf-8"));

// Define OpenApi function
const openApiFunction = {
  name: "getWeather",
  spec: openApiSpec,
  description: "Retrieve weather information for a location",
  auth: {
    type: "anonymous",
  },
  default_params: ["format"], // optional
};

// Create OpenApi tool
const openApiTool = ToolUtility.createOpenApiTool(openApiFunction);

// Create agent with OpenApi tool
const agent = await client.createAgent("gpt-4o", {
  name: "myAgent",
  instructions: "You are a helpful agent",
  tools: [openApiTool.definition],
});
console.log(`Created agent, agent ID: ${agent.id}`);

Créer un thread

Pour chaque session ou conversation, un thread est requis. Voici un exemple :

const thread = await client.threads.create();
console.log(`Created thread, thread ID: ${thread.id}`);

Créer un thread avec une ressource d’outil

Dans certains scénarios, vous devrez peut-être affecter des ressources spécifiques à des threads individuels. Pour ce faire, vous fournissez l’argument toolResources à threads.create. Dans l’exemple suivant, vous créez un magasin de vecteurs et chargez un fichier, activez un agent pour la recherche de fichiers à l’aide de l’argument tools, puis associez le fichier au thread à l’aide de l’argument toolResources.

import { ToolUtility } from "@azure/ai-agents";

const filePath = "./data/syntheticCompanyQuarterlyResults.csv";
const localFileStream = fs.createReadStream(filePath);
const file = await client.files.upload(localFileStream, "assistants", {
  fileName: "sample_file_for_upload.csv",
});
console.log(`Uploaded file, ID: ${file.id}`);

const vectorStore = await client.agents.vectorStores.create()({
  fileIds: [file.id],
});
console.log(`Created vector store, ID: ${vectorStore.id}`);

const fileSearchTool = ToolUtility.createFileSearchTool([vectorStore.id]);

const agent = await client.agents.createAgent("gpt-4o", {
  name: "myAgent",
  instructions: "You are helpful agent that can help fetch data from files you know about.",
  tools: [fileSearchTool.definition],
});
console.log(`Created agent, agent ID : ${agent.id}`);

// Create thread with file resources.
// If the agent has multiple threads, only this thread can search this file.
const thread = await client.threads.create({ toolResources: fileSearchTool.resources });

Répertorier les threads

Pour lister tous les threads attachés à un agent donné, utilisez threads.list:

const threads = client.threads.list();
console.log(`Threads for agent ${agent.id}:`);
for await (const t of threads) {
  console.log(`Thread ID: ${t.id}`);
  console.log(`Created at: ${t.createdAt}`);
  console.log(`Metadata: ${t.metadata}`);
  console.log(`---- `);
}

Créer un message

Pour créer un message permettant à l’Assistant de traiter, vous transmettez user en tant que role et une question en tant que content:

const message = await client.messages.create(thread.id, "user", "hello, world!");
console.log(`Created message, message ID: ${message.id}`);

Créer un message avec une pièce jointe de recherche de fichiers

Pour joindre un fichier à un message pour la recherche de contenu, vous utilisez ToolUtility.createFileSearchTool() et l’argument attachments :

import { ToolUtility } from "@azure/ai-agents";

const fileSearchTool = ToolUtility.createFileSearchTool();
const message = await client.messages.create(
  thread.id,
  "user",
  "What feature does Smart Eyewear offer?",
  {
    attachments: [
      {
        fileId: file.id,
        tools: [fileSearchTool.definition],
      },
    ],
  },
);

Créer un message avec une pièce jointe de l’interpréteur de code

Pour joindre un fichier à un message pour l’analyse des données, vous utilisez ToolUtility.createCodeInterpreterTool() et l’argument attachment.

Voici un exemple :

import { ToolUtility } from "@azure/ai-agents";

// notice that CodeInterpreter must be enabled in the agent creation,
// otherwise the agent will not be able to see the file attachment for code interpretation
const codeInterpreterTool = ToolUtility.createCodeInterpreterTool();
const agent = await client.agents.createAgent("gpt-4o", {
  name: "my-assistant",
  instructions: "You are helpful assistant",
  tools: [codeInterpreterTool.definition],
});
console.log(`Created agent, agent ID: ${agent.id}`);

const thread = await client.threads.create();
console.log(`Created thread, thread ID: ${thread.id}`);

const message = await client.messages.create(
  thread.id,
  "user",
  "Could you please create a bar chart in the TRANSPORTATION sector for the operating profit from the uploaded CSV file and provide the file to me?",
  {
    attachments: [
      {
        fileId: file.id,
        tools: [codeInterpreterTool.definition],
      },
    ],
  },
);
console.log(`Created message, message ID: ${message.id}`);

Créer un message avec des entrées d’image

Vous pouvez envoyer des messages à des agents Azure avec des entrées d’image de différentes manières :

  • Utilisation d’une image stockée en tant que fichier chargé
  • Utilisation d’une image publique accessible via l’URL
  • Utilisation d’une chaîne d’image encodée en base64

L’exemple suivant illustre la méthode base64 :

Créer un message avec une entrée d’image encodée en base64
function imageToBase64DataUrl(imagePath: string, mimeType: string): string {
  try {
    // Read the image file as binary
    const imageBuffer = fs.readFileSync(imagePath);
    // Convert to base64
    const base64Data = imageBuffer.toString("base64");
    // Format as a data URL
    return `data:${mimeType};base64,${base64Data}`;
  } catch (error) {
    console.error(`Error reading image file at ${imagePath}:`, error);
    throw error;
  }
}

// Convert your image file to base64 format
const filePath = "./data/image_file.png";
const imageDataUrl = imageToBase64DataUrl(filePath, "image/png");

// Create a message with both text and image content
console.log("Creating message with image content...");
const inputMessage = "Hello, what is in the image?";
const content = [
  {
    type: "text",
    text: inputMessage,
  },
  {
    type: "image_url",
    imageUrl: {
      url: imageDataUrl,
      detail: "high",
    },
  },
];

const message = await client.messages.create(thread.id, "user", content);
console.log(`Created message, message ID: ${message.id}`);

Créer une exécution, un Run_and_Process ou un flux

Voici un exemple de runs.create et d’interrogation jusqu’à ce que l’exécution soit terminée :

// Create and poll a run
console.log("Creating run...");
const run = await client.runs.createAndPoll(thread.id, agent.id, {
  pollingOptions: {
    intervalInMs: 2000,
  },
  onResponse: (response): void => {
    console.log(`Received response with status: ${response.parsedBody.status}`);
  },
});
console.log(`Run finished with status: ${run.status}`);

Pour que le SDK interroge votre nom, utilisez la méthode createThreadAndRun.

Voici un exemple :

const run = await client.runs.createThreadAndRun(agent.id, {
  thread: {
    messages: [
      {
        role: "user",
        content: "hello, world!",
      },
    ],
  },
});

Avec la diffusion en continu, l’interrogation n’a pas besoin d’être prise en compte.

Voici un exemple :

const streamEventMessages = await client.runs.create(thread.id, agent.id).stream();

La gestion des événements peut être effectuée comme suit :

import { RunStreamEvent, MessageStreamEvent, ErrorEvent, DoneEvent } from "@azure/ai-agents";

const streamEventMessages = await client.runs.create(thread.id, agent.id).stream();

for await (const eventMessage of streamEventMessages) {
  switch (eventMessage.event) {
    case RunStreamEvent.ThreadRunCreated:
      console.log(`ThreadRun status: ${eventMessage.data.status}`);
      break;
    case MessageStreamEvent.ThreadMessageDelta:
      {
        const messageDelta = eventMessage.data;
        messageDelta.delta.content.forEach((contentPart) => {
          if (contentPart.type === "text") {
            const textContent = contentPart;
            const textValue = textContent.text?.value || "No text";
            console.log(`Text delta received:: ${textValue}`);
          }
        });
      }
      break;
    case RunStreamEvent.ThreadRunCompleted:
      console.log("Thread Run Completed");
      break;
    case ErrorEvent.Error:
      console.log(`An error occurred. Data ${eventMessage.data}`);
      break;
    case DoneEvent.Done:
      console.log("Stream completed.");
      break;
  }
}

Récupérer le message

Pour récupérer des messages à partir d’agents, utilisez l’exemple suivant :

const messagesIterator = client.messages.list(thread.id);
const allMessages = [];
for await (const m of messagesIterator) {
  allMessages.push(m);
}
console.log("Messages:", allMessages);

// The messages are following in the reverse order,
// we will iterate them and output only text contents.
const messages = await client.messages.list(thread.id, {
  order: "asc",
});

for await (const dataPoint of messages) {
  const textContent = dataPoint.content.find((item) => item.type === "text");
  if (textContent && "text" in textContent) {
    console.log(`${dataPoint.role}: ${textContent.text.value}`);
  }
}

Récupérer un fichier

Les fichiers chargés par les agents ne peuvent pas être récupérés. Si votre cas d’usage doit accéder au contenu du fichier chargé par les agents, il est conseillé de conserver une copie supplémentaire accessible par votre application. Toutefois, les fichiers générés par les agents sont récupérables par files.getContent.

Voici un exemple de récupération d’ID de fichier à partir de messages :

import { isOutputOfType, MessageTextContent, MessageImageFileContent } from "@azure/ai-agents";

const messagesIterator = client.messages.list(thread.id);
const allMessages = [];
for await (const m of messagesIterator) {
  allMessages.push(m);
}
console.log("Messages:", allMessages);

// Get most recent message from the assistant
const assistantMessage = allMessages.find((msg) => msg.role === "assistant");
if (assistantMessage) {
  const textContent = assistantMessage.content.find((content) =>
    isOutputOfType<MessageTextContent>(content, "text"),
  ) as MessageTextContent;
  if (textContent) {
    console.log(`Last message: ${textContent.text.value}`);
  }
}

const imageFile = (allMessages[0].content[0] as MessageImageFileContent).imageFile;
const imageFileName = (await client.agents.files.get(imageFile.fileId)).filename;

const fileContent = await (await client.files.getContent(imageFile.fileId).asNodeStream()).body;
if (fileContent) {
  const chunks: Buffer[] = [];
  for await (const chunk of fileContent) {
    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
  }
  const buffer = Buffer.concat(chunks);
  fs.writeFileSync(imageFileName, buffer);
} else {
  console.error("Failed to retrieve file content: fileContent is undefined");
}
console.log(`Saved image file to: ${imageFileName}`);

Démontage

Pour supprimer des ressources après avoir effectué des tâches, utilisez les fonctions suivantes :

await client.vectorStores.delete(vectorStore.id);
console.log(`Deleted vector store, vector store ID: ${vectorStore.id}`);

await client.files.delete(file.id);
console.log(`Deleted file, file ID : ${file.id}`);

await client.deleteAgent(agent.id);
console.log(`Deleted agent, agent ID: ${agent.id}`);

Résolution des problèmes

Exceptions

Les méthodes clientes qui effectuent des appels de service déclenchent une RestError pour une réponse de code d’état HTTP non réussie du service. La code de l’exception contiendra le code d’état de la réponse HTTP. Le error.message de l’exception contient un message détaillé qui peut être utile pour diagnostiquer le problème :

import { RestError } from "@azure/core-rest-pipeline";

try {
  const thread = await client.threads.create();
} catch (e) {
  if (e instanceof RestError) {
    console.log(`Status code: ${e.code}`);
    console.log(e.message);
  } else {
    console.error(e);
  }
}

Par exemple, lorsque vous fournissez des informations d’identification incorrectes :

Status code: 401 (Unauthorized)
Operation returned an invalid status 'Unauthorized'

Signaler des problèmes

Pour signaler des problèmes avec la bibliothèque cliente ou demander des fonctionnalités supplémentaires, ouvrez un problème GitHub ici

Étapes suivantes

Examinez le dossier d’exemples de package contenant du code entièrement exécutable.

Contribuer

Ce projet accueille les contributions et suggestions. La plupart des contributions vous obligent à accepter un contrat de licence contributeur (CLA) déclarant que vous avez le droit, et en fait, de nous accorder les droits d’utilisation de votre contribution. Pour plus d’informations, visitez https://cla.microsoft.com.

Lorsque vous envoyez une demande de tirage( pull request), un bot CLA détermine automatiquement si vous devez fournir un CLA et décorer correctement la demande de tirage (par exemple, étiquette, commentaire). Suivez simplement les instructions fournies par le bot. Vous n’aurez besoin de le faire qu’une seule fois sur tous les dépôts à l’aide de notre CLA.

Ce projet a adopté le Code de conduite Open Source Microsoft. Pour plus d’informations, consultez la FAQ sur le code de conduite ou contactez opencode@microsoft.com avec toutes les questions ou commentaires supplémentaires.

  • Last updated on