Sdílet prostřednictvím

Klientská knihovna Azure AI Agents pro JavaScript – verze 1.1.0

Klientskou knihovnu AI Agents můžete použít k následujícím účelům:

  • vývoj agentů pomocí služby Azure AI Agent Service, využití rozsáhlého ekosystému modelů, nástrojů a možností od openAI, Microsoftu a dalších poskytovatelů LLM. Služba agenta Azure AI umožňuje vytváření agentů pro širokou škálu případů použití generující umělé inteligence.
  • Poznámka: I když je možné tento balíček používat samostatně, doporučujeme pro lepší prostředí použít klientskou knihovnu Azure AI Projects . Knihovna projektů poskytuje zjednodušený přístup k pokročilým funkcím, jako je vytváření a správa agentů, vytváření výčtu modelů AI, práce s datovými sadami a správa indexů vyhledávání, vyhodnocování výkonu generativní AI a povolení trasování OpenTelemetry.

Dokumentace | k výrobkuVzorky | Balíček (npm) | Referenční dokumentace k rozhraní API

Obsah

Začínáme

Předpoklad

Autorizace

  • Entra ID je potřeba k ověření klienta. Vaše aplikace potřebuje objekt, který implementuje rozhraní TokenCredential. Ukázky kódu zde používají DefaultAzureCredential. Abyste mohli pracovat, budete potřebovat:
    • Role Contributor. Přiřazení role je možné provést prostřednictvím karty Řízení přístupu (IAM) vašeho prostředku projektu Azure AI na webu Azure Portal. Další informace o přiřazení rolí najdete tady.
    • nainstalované rozhraní příkazové ho řádku Azure CLI.
    • Jste přihlášeni ke svému účtu Azure spuštěním az login.
    • Upozorňujeme, že pokud máte více předplatných Azure, musí být výchozím předplatným předplatného, které obsahuje váš prostředek projektu Azure AI. Spuštěním az account list --output table zobrazte seznam všech vašich předplatných a podívejte se, která z nich je výchozí. Spuštěním az account set --subscription "Your Subscription ID or Name" změňte výchozí předplatné.

Nainstalujte balíček

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

Klíčové koncepty

Vytvoření a ověření klienta

Slouží AgentsClient ke konstrukci klienta. V současné době doporučujeme používat AgentsClient prostřednictvím klientské knihovny Azure AI Projects pomocí client.agents.

Pokud chcete získat koncový bod projektu, můžete se podívat do dokumentace. Níže budeme předpokládat, že proměnná PROJECT_ENDPOINT prostředí má tuto hodnotu.

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

Příklady

Agenti

Agenti v klientské knihovně Azure AI Projects jsou navrženi tak, aby usnadnili různé interakce a operace v rámci vašich projektů AI. Slouží jako základní komponenty, které spravují a provádějí úlohy, a k dosažení konkrétních cílů využívají různé nástroje a prostředky. Následující kroky popisují typickou sekvenci pro interakci s agenty. Další ukázky agentů najdete v ukázkách balíčků .

Vytvoření agenta

Tady je příklad vytvoření agenta:

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

Pokud chcete agentům povolit přístup k prostředkům nebo vlastním funkcím, potřebujete nástroje. Nástroje můžete předat createAgent prostřednictvím tools a toolResources argumentů.

K tomu můžete použít ToolSet:

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

Více agentů

Můžete vytvořit více agentů s různými nástroji a poté je propojit dohromady.

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

Abychom mohli prohledávat soubory agentem, musíme nejprve nahrát soubor, vytvořit vektorové úložiště a přidružit ho k úložišti vektorů. Tady je příklad:

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

Vytvoření agenta s interpretem kódu

Tady je příklad pro nahrání souboru a jeho použití pro interpret kódu agentem:

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

Vytvoření agenta pomocí zemnění Bingu

Pokud chcete agentu povolit vyhledávání prostřednictvím rozhraní API Bingu pro vyhledávání, použijete ToolUtility.createBingGroundingTool() společně s připojením. Další informace o uzemnění pomocí vyhledávání Bing naleznete zde .

Tady je příklad:

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 je podnikový vyhledávací systém pro vysoce výkonné aplikace. Integruje se se službou Azure OpenAI a Azure Machine Learning a nabízí pokročilé technologie vyhledávání, jako je vektorové vyhledávání a fulltextové vyhledávání. Ideální pro přehledy znalostní báze, zjišťování informací a automatizaci

Tady je příklad integrace služby 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}`);

Vytvoření agenta s voláním funkce

Agenty můžete vylepšit definováním funkcí zpětného volání jako nástrojů funkcí. Lze je poskytnout pro createAgent prostřednictvím kombinace tools a toolResources. Pro createAgentjsou k dispozici pouze definice a popisy funkce bez implementací. Run nebo event handler of stream vyvolá stav requires_action na základě definic funkce. Váš kód musí zpracovat tento stav a volat příslušné funkce.

Tady je příklad:

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

Vytvoření agenta pomocí OpenAPI

Specifikace OpenAPI popisují operace REST s konkrétním koncovým bodem. Sada Agents SDK dokáže přečíst specifikaci OpenAPI, vytvořit z ní funkci a zavolat ji proti koncovému bodu REST bez dalšího spuštění na straně klienta. Tady je příklad vytvoření nástroje OpenAPI (pomocí anonymního ověřování):

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

Vytvořit vlákno

Pro každou relaci nebo konverzaci se vyžaduje vlákno. Tady je příklad:

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

Vytvoření vlákna s prostředkem nástroje

V některých scénářích může být potřeba přiřadit konkrétní prostředky jednotlivým vláknům. Chcete-li toho dosáhnout, zadáte argument toolResourcesthreads.create. V následujícím příkladu vytvoříte vektorové úložiště a nahrajete soubor, povolíte agenta pro vyhledávání souborů pomocí argumentu tools a pak přidružíte soubor k vláknu pomocí argumentu 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 });

Seznam vláken

Chcete-li zobrazit seznam všech vláken připojených k danému agentovi, použijte 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(`---- `);
}

Vytvořit zprávu

Pokud chcete vytvořit zprávu pro zpracování asistenta, předáte user jako role a otázku jako content:

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

Vytvoření zprávy s přílohou hledání souborů

Pokud chcete připojit soubor ke zprávě pro vyhledávání obsahu, použijte ToolUtility.createFileSearchTool() a 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],
      },
    ],
  },
);

Vytvoření zprávy s přílohou interpretu kódu

K připojení souboru ke zprávě pro analýzu dat použijete ToolUtility.createCodeInterpreterTool() a argument attachment.

Tady je příklad:

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

Vytvoření zprávy se vstupy obrázků

Agentům Azure můžete odesílat zprávy s vstupy obrázků následujícími způsoby:

  • Použití obrázku uloženého jako nahraného souboru
  • Použití veřejného obrázku přístupného přes adresu URL
  • Použití řetězce obrázku s kódováním base64

Následující příklad ukazuje metodu base64:

Vytvoření zprávy se vstupem obrázku s kódováním 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}`);

Vytvoření spuštění, Run_and_Process nebo streamu

Tady je příklad runs.create a dotazování, dokud se spuštění nedokončuje:

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

K dotazování sady SDK vaším jménem použijte metodu createThreadAndRun.

Tady je příklad:

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

U streamování se také nemusí brát v úvahu dotazování.

Tady je příklad:

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

Zpracování událostí je možné provést následujícím způsobem:

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

Načtení zprávy

Pokud chcete načíst zprávy z agentů, použijte následující příklad:

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

Načtení souboru

Soubory nahrané agenty nelze načíst zpět. Pokud váš případ použití potřebuje přístup k obsahu souboru nahranému agenty, doporučujeme zachovat další kopii přístupnou vaší aplikací. Soubory vygenerované agenty jsou však možné načíst pomocí files.getContent.

Tady je příklad načítání ID souborů ze zpráv:

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

Roztrhání

Pokud chcete prostředky po dokončení úkolů odebrat, použijte následující funkce:

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

Řešení problémů

Výjimky

Klientské metody, které volání služby vyvolávají RestError pro odpověď stavového kódu HTTP bez úspěchu ze služby. code výjimky bude obsahovat stavový kód odpovědi HTTP. error.message výjimky obsahuje podrobnou zprávu, která může být užitečná při diagnostice problému:

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

Pokud například zadáte nesprávné přihlašovací údaje:

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

Hlášení problémů

Pokud chcete nahlásit problémy s klientskou knihovnou nebo požádat o další funkce, otevřete problém na GitHubu tady

Další kroky

Podívejte se na ukázky balíčků složce obsahující plně spustitelný kód.

Přispění

Tento projekt vítá příspěvky a návrhy. Většina příspěvků vyžaduje souhlas s licenční smlouvou s přispěvatelem (CLA), která deklaruje, že máte právo a ve skutečnosti nám udělíte práva k používání vašeho příspěvku. Podrobnosti najdete na adrese https://cla.microsoft.com.

Když odešlete žádost o přijetí změn, robot CLA automaticky určí, jestli potřebujete poskytnout CLA, a odpovídajícím způsobem vyzdobit žádost o přijetí změn (např. popisek, komentář). Stačí postupovat podle pokynů poskytovaných robotem. Stačí to udělat jen jednou napříč všemi úložištěmi pomocí naší cla.

Tento projekt se řídí Pravidly chování pro Microsoft Open Source. Další informace najdete v nejčastějších dotazech k kodexu chování nebo se obraťte na opencode@microsoft.com s dalšími dotazy nebo komentáři.

  • Last updated on