Megosztás a következőn keresztül:

Azure AI Agents JavaScript-ügyféloldali kódtár – 1.1.0-s verzió

Az AI Agents ügyféloldali kódtár használatával a következőket teheti:

  • Az Azure AI Agent Servicehasználatával fejleszthet ügynököket, kihasználva az OpenAI, a Microsoft és más LLM-szolgáltatók modelljeinek, eszközeinek és képességeinek széles körű ökoszisztémáját. Az Azure AI Agent Service lehetővé teszi az ügynökök kiépítését a generatív AI-használati esetek széles skálájához.
  • Jegyzet: Bár ez a csomag egymástól függetlenül is használható, javasoljuk, hogy a továbbfejlesztett felhasználói élmény érdekében használja az Azure AI Projects ügyféloldali kódtárat . A Projektek kódtár egyszerűsített hozzáférést biztosít a speciális funkciókhoz, például ügynökök létrehozásához és kezeléséhez, AI-modellek számbavételéhez, adathalmazok kezeléséhez és keresési indexek kezeléséhez, a generatív AI-teljesítmény kiértékeléséhez és az OpenTelemetria nyomkövetésének engedélyezéséhez.

Termékdokumentáció | Minták | Csomag (npm) | API referenciadokumentáció

Tartalomjegyzék

Kezdő lépések

Előfeltétel

Engedélyezés

  • Az ügyfél hitelesítéséhez Entra azonosítóra van szükség. Az alkalmazásnak szüksége van egy objektumra, amely implementálja a TokenCredential felületet. Az itt található kódminták DefaultAzureCredentialhasználnak. Ahhoz, hogy ez működjön, a következőkre lesz szüksége:
    • A Contributor szerepkör. A szerepkör-hozzárendelés az Azure PortalOn az Azure AI Project-erőforrás "Hozzáférés-vezérlés (IAM)" lapján végezhető el. A szerepkör-hozzárendelésekről itt olvashat bővebben.
    • Telepített Azure CLI-.
    • A rendszer a az loginfuttatásával jelentkezik be az Azure-fiókjába.
    • Vegye figyelembe, hogy ha több Azure-előfizetéssel rendelkezik, az Azure AI Project-erőforrást tartalmazó előfizetésnek kell lennie az alapértelmezett előfizetésnek. A az account list --output table futtatásával listázhatja az összes előfizetését, és megtekintheti, hogy melyik az alapértelmezett. Az alapértelmezett előfizetés módosításához futtassa a az account set --subscription "Your Subscription ID or Name".

A csomag telepítése

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

Főbb fogalmak

Az ügyfél létrehozása és hitelesítése

A AgentsClient kliens felépítésére szolgál. Jelenleg azt javasoljuk, hogy az AgentsClientet az Azure AI Projects ügyféloldali kódtárán keresztül használja a következővel client.agents: .

A projekt végpontjának lekéréséhez tekintse meg a dokumentációt. Az alábbiakban feltételezzük, hogy a környezeti változó PROJECT_ENDPOINT rendelkezik ezzel az értékkel.

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éldák

Ügynökök

Az Azure AI-projektek ügyfélkódtárában található ügynököket úgy tervezték, hogy megkönnyítsék a különböző interakciókat és műveleteket az AI-projekteken belül. Fő összetevőkként szolgálnak, amelyek feladatokat kezelnek és hajtanak végre, különböző eszközöket és erőforrásokat felhasználva konkrét célokat érnek el. Az alábbi lépések az ügynökökkel való interakció tipikus sorrendjét ismertetik. További ügynökmintákért tekintse meg a csomagmintákat .

Ügynök létrehozása

Íme egy példa az ügynök létrehozásának módjára:

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

Ahhoz, hogy az ügynökök hozzáférhessenek az erőforrásokhoz vagy az egyéni függvényekhez, eszközökre van szüksége. A createAgent és tools argumentumokon keresztül toolResources eszközöket adhat át.

Ehhez használhatja a 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}`);

Több ügynök

Több ügynököt is létrehozhat különböző eszközökkel, majd összekapcsolhatja őket.

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

Ahhoz, hogy egy ügynök fájlkeresést hajthasson végre, először fel kell töltenünk egy fájlt, létre kell hoznunk egy vektortárolót, és a fájlt a vektortárolóhoz kell társítanunk. Íme egy példa:

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

Ügynök létrehozása kódértelmezővel

Íme egy példa egy fájl feltöltésére és egy ügynök kódértelmének használatára:

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

Ügynök létrehozása a Bing Grounding használatával

Ha engedélyezni szeretné, hogy az ügynök a Bing search API-val végezzen keresést, ToolUtility.createBingGroundingTool() és egy kapcsolatot használjon. Itt további információt talál a Bing Search földeléséről.

Íme egy példa:

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

Az Azure AI Search nagy teljesítményű alkalmazások nagyvállalati keresési rendszere. Integrálható az Azure OpenAI Szolgáltatással és az Azure Machine Learning szolgáltatással, olyan fejlett keresési technológiákat kínál, mint a vektoros keresés és a teljes szöveges keresés. Ideális tudásbázis-elemzésekhez, információfelderítéshez és automatizáláshoz

Íme egy példa az Azure AI Search integrálására:

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

Ügynök létrehozása függvényhívással

Az ügynökök továbbfejleszthetők a visszahívási függvények függvényeszközökként való definiálásával. Ezek createAgenttools és toolResourceskombinációjával biztosíthatók. Csak a függvénydefiníciók és -leírások vannak megadva createAgent, implementációk nélkül. A Run vagy event handler of streamrequires_action állapotot hoz létre a függvénydefiníciók alapján. A kódnak kezelnie kell ezt az állapotot, és meg kell hívnia a megfelelő függvényeket.

Íme egy példa:

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

Ügynök létrehozása az OpenAPI-val

Az OpenAPI-specifikációk a REST-műveleteket írják le egy adott végponton. Az ügynökök SDK-jai beolvashatnak egy OpenAPI-specifikációt, létrehozhatnak belőle egy függvényt, és további ügyféloldali végrehajtás nélkül meghívhatják a függvényt a REST-végponton. Íme egy példa egy OpenAPI-eszköz létrehozására (névtelen hitelesítés használatával):

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

Szál létrehozása

Minden munkamenethez vagy beszélgetéshez szálra van szükség. Íme egy példa:

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

Szál létrehozása eszközerőforrással

Bizonyos esetekben előfordulhat, hogy adott erőforrásokat kell hozzárendelnie az egyes szálakhoz. Ennek eléréséhez meg kell adnia a toolResources argumentumot threads.create. Az alábbi példában létrehoz egy vektortárolót, és feltölt egy fájlt, engedélyezi az ügynök számára a fájlkeresést a tools argumentummal, majd a toolResources argumentummal társítja a fájlt a szálhoz.

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

Listaszálak

Egy adott ügynökhöz csatolt összes szál listázásához használja a következőt 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(`---- `);
}

Üzenet létrehozása

Ha üzenetet szeretne létrehozni az asszisztens számára a feldolgozáshoz, userrole, és egy kérdést content:

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

Üzenet létrehozása fájlkeresési melléklettel

Ha fájlokat szeretne csatolni egy üzenethez tartalomkereséshez, használja a ToolUtility.createFileSearchTool() és a attachments argumentumot:

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

Üzenet létrehozása kódértelmező melléklettel

Ha fájlokat szeretne csatolni egy üzenethez adatelemzés céljából, használja a ToolUtility.createCodeInterpreterTool() és a attachment argumentumot.

Íme egy példa:

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

Üzenet létrehozása képbemenetekkel

Az Alábbi módokon küldhet üzeneteket az Azure-ügynököknek képbemenetekkel:

  • Feltöltött fájlként tárolt kép használata
  • URL-címen keresztül elérhető nyilvános rendszerkép használata
  • Base64 kódolású képsztring használata

Az alábbi példa a base64 metódust mutatja be:

Üzenet létrehozása base64 kódolású képbevitellel
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}`);

Futtatás, Run_and_Process vagy stream létrehozása

Íme egy példa a runs.create és a szavazásra a futtatás befejezéséig:

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

Ha az SDK-szavazást az Ön nevében szeretné lekérdezni, használja a createThreadAndRun metódust.

Íme egy példa:

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

A streamelés esetén a lekérdezést sem kell figyelembe venni.

Íme egy példa:

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

Az eseménykezelés az alábbiak szerint végezhető el:

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

Üzenet lekérése

Az üzenetek ügynököktől való lekéréséhez használja az alábbi példát:

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

Fájl lekérése

Az ügynökök által feltöltött fájlok nem kérhetők vissza. Ha a használati esetnek hozzá kell férnie az ügynökök által feltöltött fájltartalomhoz, javasoljuk, hogy egy további másolatot is akadálymentesen tartson az alkalmazás számára. Az ügynökök által létrehozott fájlok azonban lekérthetők files.getContent.

Íme egy példa a fájlazonosítók üzenetekből való lekérésére:

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

Teardown

Ha a tevékenységek elvégzése után el szeretné távolítani az erőforrásokat, használja a következő függvényeket:

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

Hibaelhárítás

Kivételek

A szolgáltatáshívásokat kezdeményező ügyfélmódszerek RestError a szolgáltatás nem sikeres HTTP-állapotkód-válaszához. A kivétel code a HTTP-válasz állapotkódját fogja tárolni. A kivétel error.message részletes üzenetet tartalmaz, amely hasznos lehet a probléma diagnosztizálásában:

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

Ha például helytelen hitelesítő adatokat ad meg:

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

Jelentéskészítési problémák

Az ügyfélkódtár problémáinak jelentéséhez vagy további funkciók kéréséhez nyisson meg egy GitHub-problémát, itt

Következő lépések

Tekintse meg a csomagmintákat mappát, amely teljes mértékben futtatható kódot tartalmaz.

Közreműködés

Ez a projekt üdvözli a hozzájárulásokat és javaslatokat. A legtöbb hozzájárulás megköveteli, hogy elfogadja a közreműködői licencszerződést (CLA), amely kimondja, hogy önnek joga van a hozzájárulás használatára, és valóban meg kell adnia nekünk a jogosultságokat a hozzájárulás használatára. A részletekért látogasson el ide https://cla.microsoft.com.

A lekéréses kérelem elküldésekor a CLA-robot automatikusan meghatározza, hogy meg kell-e adnia egy CLA-t, és megfelelően kell-e díszítenie a lekéréses kérelmet (például címkét, megjegyzést). Egyszerűen kövesse a robot utasításait. Ezt csak egyszer kell elvégeznie az összes adattárban a CLA használatával.

Ez a projekt a Microsoft nyílt forráskóddal kapcsolatos viselkedési szabályzata alapján működik. További információkért tekintse meg a magatartási kódex gyakori kérdéseit, vagy forduljon opencode@microsoft.com további kérdésekhez vagy megjegyzésekhez.

  • Last updated on