Delen via

Azure AI Agents-clientbibliotheek voor JavaScript - versie 1.1.0

Gebruik de AI Agents-clientbibliotheek om:

  • Agents ontwikkelen met behulp van de Azure AI Agent Service, gebruikmakend van een uitgebreid ecosysteem van modellen, hulpprogramma's en mogelijkheden van OpenAI, Microsoft en andere LLM-providers. De Azure AI Agent Service maakt het bouwen van agents mogelijk voor een breed scala aan generatieve AI-gebruiksvoorbeelden.
  • Notitie: Hoewel dit pakket onafhankelijk kan worden gebruikt, raden we u aan de Azure AI Projects-clientbibliotheek te gebruiken voor een verbeterde ervaring. De bibliotheek Projecten biedt vereenvoudigde toegang tot geavanceerde functionaliteit, zoals het maken en beheren van agents, het opsommen van AI-modellen, het werken met gegevenssets en het beheren van zoekindexen, het evalueren van generatieve AI-prestaties en het inschakelen van OpenTelemetrie-tracering.

Product documentatie | Monsters | Pakket (npm) | Documentatie voor API-referentie

Inhoudsopgave

Aan de slag

Voorwaarde

Autorisatie

  • Entra ID is nodig om de client te authenticeren. Uw toepassing heeft een object nodig waarmee de interface TokenCredential wordt geïmplementeerd. Codevoorbeelden hier gebruiken DefaultAzureCredential-. Om dat te kunnen doen, hebt u het volgende nodig:
    • De Contributor rol. De toegewezen rol kan worden uitgevoerd via het tabblad Toegangsbeheer (IAM) van uw Azure AI-projectresource in Azure Portal. Meer informatie over roltoewijzingen vindt u hier.
    • Azure CLI geïnstalleerd.
    • U bent aangemeld bij uw Azure-account door az loginuit te voeren.
    • Houd er rekening mee dat als u meerdere Azure-abonnementen hebt, het abonnement dat uw Azure AI Project-resource bevat, uw standaardabonnement moet zijn. Voer az account list --output table uit om al uw abonnement weer te geven en te zien welke standaard is. Voer az account set --subscription "Your Subscription ID or Name" uit om uw standaardabonnement te wijzigen.

Installeer het pakket

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

Belangrijke concepten

De client maken en verifiëren

Het AgentsClient wordt gebruikt om de client te bouwen. Momenteel raden we u aan de AgentsClient te gebruiken via de Azure AI Projects-clientbibliotheek met behulp van client.agents.

Om het eindpunt van uw project te krijgen, kunt u de documentatie raadplegen. Hieronder gaan we ervan uit dat de omgevingsvariabele PROJECT_ENDPOINT deze waarde bevat.

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());

Voorbeelden

Agenten

Agents in de Azure AI Projects-clientbibliotheek zijn ontworpen om verschillende interacties en bewerkingen binnen uw AI-projecten te vergemakkelijken. Ze fungeren als de kernonderdelen die taken beheren en uitvoeren, waarbij gebruik wordt gemaakt van verschillende hulpprogramma's en resources om specifieke doelen te bereiken. De volgende stappen geven een overzicht van de typische volgorde voor interactie met agents. Zie de pakketvoorbeelden voor aanvullende Agent-monsters.

Agent maken

Hier volgt een voorbeeld van het maken van een agent:

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

Als u agents toegang wilt geven tot uw resources of aangepaste functies, hebt u hulpprogramma's nodig. U kunt hulpprogramma's doorgeven aan createAgent via de argumenten tools en toolResources.

U kunt ToolSet gebruiken om dit te doen:

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}`);

Meerdere agenten

U kunt meerdere agents maken met verschillende tools en deze vervolgens met elkaar verbinden.

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}`);

Als u bestanden wilt zoeken door een agent, moeten we eerst een bestand uploaden, een vectorarchief maken en het bestand koppelen aan het vectorarchief. Hier volgt een voorbeeld:

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}`);

Agent maken met code-interpreter

Hier volgt een voorbeeld om een bestand te uploaden en te gebruiken voor code-interpreter door een 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}`);

Agent maken met Bing Grounding

Als u wilt dat uw agent zoekopdrachten kan uitvoeren via de Bing Search-API, gebruikt u ToolUtility.createBingGroundingTool() samen met een verbinding. Kijk hier voor meer informatie over aarden met Bing Search.

Hier volgt een voorbeeld:

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 is een zoeksysteem voor ondernemingen voor hoogwaardige toepassingen. Het is geïntegreerd met Azure OpenAI Service en Azure Machine Learning, met geavanceerde zoektechnologieën zoals vectorzoekopdrachten en zoeken in volledige tekst. Ideaal voor kennisdatabaseinzichten, informatiedetectie en automatisering

Hier volgt een voorbeeld voor het integreren van 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}`);

Agent maken met functieoproep

U kunt uw agents verbeteren door callbackfuncties als functiehulpprogramma's te definiëren. Deze kunnen worden verstrekt aan createAgent via de combinatie van tools en toolResources. Alleen de functiedefinities en -beschrijvingen worden verstrekt aan createAgent, zonder de implementaties. De Run of event handler of stream krijgt een requires_action status op basis van de functiedefinities. Uw code moet deze status afhandelen en de juiste functies aanroepen.

Hier volgt een voorbeeld:

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}`);

Agent maken met OpenAPI

OpenAPI-specificaties beschrijven REST-bewerkingen op basis van een specifiek eindpunt. Agents SDK kan een OpenAPI-specificatie lezen, er een functie van maken en die functie aanroepen op basis van het REST-eindpunt zonder extra uitvoering aan de clientzijde. Hier volgt een voorbeeld van het maken van een OpenAPI-hulpprogramma (met behulp van anonieme verificatie):

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}`);

Thread maken

Voor elke sessie of gesprek is een thread vereist. Hier volgt een voorbeeld:

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

Thread maken met toolresource

In sommige scenario's moet u mogelijk specifieke resources toewijzen aan afzonderlijke threads. Hiervoor geeft u het argument toolResources op voor threads.create. In het volgende voorbeeld maakt u een vectorarchief en uploadt u een bestand, schakelt u een agent in voor het zoeken naar bestanden met behulp van het argument tools en koppelt u het bestand aan de thread met behulp van het 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 });

Lijstthreads

Om alle threads weer te geven die aan een bepaalde agent zijn gekoppeld, gebruikt u 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(`---- `);
}

Bericht maken

Als u een bericht wilt maken dat assistent moet verwerken, geeft u user door als role en een vraag als content:

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

Bericht maken met bestandszoekbijlage

Als u een bestand wilt toevoegen aan een bericht voor het zoeken naar inhoud, gebruikt u ToolUtility.createFileSearchTool() en het 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],
      },
    ],
  },
);

Bericht maken met code-interpreterbijlage

Als u een bestand wilt toevoegen aan een bericht voor gegevensanalyse, gebruikt u ToolUtility.createCodeInterpreterTool() en het argument attachment.

Hier volgt een voorbeeld:

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}`);

Bericht maken met afbeeldingsinvoer

U kunt berichten verzenden naar Azure-agents met afbeeldingsinvoer op de volgende manieren:

  • Een afbeelding gebruiken die is opgeslagen als een geüpload bestand
  • Een openbare afbeelding gebruiken die toegankelijk is via URL
  • Een met base64 gecodeerde afbeeldingstekenreeks gebruiken

Het volgende voorbeeld demonstreert de base64-methode:

Bericht maken met invoer van base64-gecodeerde installatiekopieën
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}`);

Uitvoeren, Run_and_Process of Stream maken

Hier volgt een voorbeeld van runs.create en poll totdat de uitvoering is voltooid:

// 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}`);

Gebruik de createThreadAndRun methode om de SDK namens u te laten peilen.

Hier volgt een voorbeeld:

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

Bij streaming hoeft polling ook niet te worden overwogen.

Hier volgt een voorbeeld:

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

Gebeurtenisafhandeling kan als volgt worden uitgevoerd:

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;
  }
}

Bericht ophalen

Gebruik het volgende voorbeeld om berichten van agents op te halen:

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}`);
  }
}

Bestand ophalen

Bestanden die door agents zijn geüpload, kunnen niet worden teruggehaald. Als uw use-case toegang nodig heeft tot de bestandsinhoud die door de agents is geüpload, wordt u aangeraden een extra kopie toegankelijk te houden voor uw toepassing. Bestanden die door agents worden gegenereerd, kunnen echter worden opgehaald door files.getContent.

Hier volgt een voorbeeld van het ophalen van bestands-id's uit berichten:

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}`);

Afbreken

Als u resources wilt verwijderen nadat u taken hebt voltooid, gebruikt u de volgende functies:

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}`);

Probleemoplossingsproces

Uitzonderingen

Clientmethoden waarmee serviceaanroepen worden uitgevoerd, genereren een RestError- voor een niet-geslaagd HTTP-statuscodeantwoord van de service. De code van de uitzondering bevat de HTTP-antwoordstatuscode. De error.message van de uitzondering bevat een gedetailleerd bericht dat nuttig kan zijn bij het diagnosticeren van het probleem:

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);
  }
}

Als u bijvoorbeeld onjuiste referenties opgeeft:

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

Problemen melden

Als u problemen met de clientbibliotheek wilt melden of aanvullende functies wilt aanvragen, opent u hier een GitHub-probleem

Volgende stappen

Bekijk de pakketvoorbeelden map met volledig uitvoerbare code.

Bijdragen

Dit project verwelkomt bijdragen en suggesties. Voor de meeste bijdragen moet u akkoord gaan met een Licentieovereenkomst voor inzenders (CLA) waarin wordt aangegeven dat u het recht hebt om, en daadwerkelijk, ons de rechten te verlenen om uw bijdrage te gebruiken. Ga naar https://cla.microsoft.comvoor meer informatie.

Wanneer u een pull-aanvraag indient, bepaalt een CLA-bot automatisch of u een CLA moet opgeven en de pull-aanvraag op de juiste wijze moet inrichten (bijvoorbeeld label, opmerking). Volg gewoon de instructies van de bot. U hoeft dit slechts eenmaal te doen voor alle opslagplaatsen met behulp van onze CLA.

Dit project onderschrijft de Microsoft Open Source gedragscode. Zie de veelgestelde vragen over gedragscodes voor meer informatie of neem contact op met opencode@microsoft.com met eventuele aanvullende vragen of opmerkingen.