Azure AI Projects client library for JavaScript - verzió 2.2.0

Az AI Projects klienskönyvtár (előzetes verzióban) a Microsoft Foundry SDK része, és könnyű hozzáférést biztosít a Microsoft Foundry Project erőforrásaihoz. A következőkre lehet használni:

  • Ügynökök létrehozása és futtatása az ügyfél tulajdonságával .agents .
  • Fejlesztsd az ügynököket speciális eszközökkel:
    • Ügynök memóriakeresés (előnézet)
    • Ügynök-ügynök (A2A) (Előzetes)
    • Azure AI Keresés
    • Bing Custom Search (Preview)
    • Bing Földelés
    • Böngészőautomatizálás (Előnézet)
    • Kódértelmező
    • Számítógép használata (Előzetes)
    • Fájlkeresés
    • Function Tool
    • Képgenerálás
    • Microsoft Fabric (Preview)
    • Model Kontextus Protokoll (MCP)
    • OpenAPI
    • Microsoft SharePoint (Előzetes)
    • Webes keresés (Előzetes)
  • Szerezz egy OpenAI klienst azzal a .getOpenAIClient. módszerrel, amellyel válaszokat, beszélgetéseket, értékeléseket és finomhangolási műveleteket futtathatsz az ügynökeddel.
  • A béta ügynök ülések és fájlok (előnézet) kezelése a .beta.agents műveletek segítségével.
  • A képességek kezelése (előnézet) újrahasználható ügynök képességekhez a műveletek felhasználásával .beta.skills .
  • Kezeld az eszközdobozokat (előnézetet ) az eszközök újrahasználható gyűjteményekbe csoportosításához, az alábbi .beta.toolboxes műveletek segítségével.
  • Kezeld a memória tárolókat (előnézet) az ügynök beszélgetésekhez a műveletek segítségével .beta.memoryStores .
  • Kezelni a rutinokat (előnézet) az automatizált munkafolyamatok ütemezéséhez és diszpécserhez, a .beta.routines műveletek segítségével.
  • Kezeld a modellverziókat (előnézet) egyedi modellverziók létrehozásához, frissítéséhez és kezeléséhez az alábbi műveletek segítségével .beta.models .
  • Fedezze fel további értékelési eszközöket (némelyik előzetes verzióban), hogy értékelje generatív MI alkalmazásának teljesítményét a .evaluationRules, .beta.evaluationTaxonomies, .beta.evaluators, .beta.insights, és .beta.schedules műveletek segítségével.
  • Indítsd el a Red Team szkenneléseket (előnézetet), hogy azonosítsd a generatív AI alkalmazásoddal kapcsolatos kockázatokat, a .beta.redTeams műveletek segítségével.
  • Finomhangolás AI modellezni az adataidat.
  • Felsorold az AI modelleket telepítve a Foundry-Project az .deployments műveletek használatával.
  • Felsorold a csatlakoztatott Azure erőforrásokat a Foundry projektedben a .connections műveletek segítségével.
  • Dokumentumok feltöltése és adatkészletek létrehozása a műveletek használatával .datasets való hivatkozáshoz.
  • Keresési indexek létrehozása és számbavétele a műveletekkel .indexes .

A klienskönyvtár a Microsoft Foundry adat sík REST API-iv1 verzióját használja.

Product dokumentáció | Samples | Package (npm) | API referencia dokumentáció | SDK forráskód

Tartalomjegyzék

Első lépések

Előfeltétel

  • A Node.jsLTS-változatai
  • Egy Azure előfizetés.
  • Egy projekt a Microsoft Foundry-ben.
  • A projekt végpontjának URL-je az űrlap https://your-ai-services-account-name.services.ai.azure.com/api/projects/your-project-name. Megtalálható a Microsoft Foundry Project áttekintési oldalán. Az alábbiakban feltételezzük, hogy a környezeti változót FOUNDRY_PROJECT_ENDPOINT úgy definiálták, hogy ezt az értéket megtartsa.

Engedélyezés

  • Az ügyfél hitelesítéséhez Entra ID szükséges. Az alkalmazásnak szüksége van egy objektumra, amely implementálja a TokenCredential felületet. Itt a kódminták a DefaultAzureCredential használatával rendelkeznek. Ahhoz, hogy ez működjön, a következőkre lesz szüksége:
    • Megfelelő szerepkiosztás. lásd Szerepalapú hozzáférés-vezérlés a Microsoft Foundry portál területén. A szerep kijelölése az Azure AI Project erőforrás "Access Control (IAM)" fülén keresztül végezhető el az Azure portálban.
    • Azure CLI telepítve.
    • A Azure fiókodba az az login futtatásával vagy bejelentkezve.
    • Fontos megjegyezni, hogy ha több Azure előfizetésed van, akkor az alapértelmezett előfizetés, amely tartalmazza az Azure AI Project erőforrásodat. 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".

Csomag telepítése

npm install @azure/ai-projects dotenv

főbb fogalmak

Hozd létre és hitelesítse az ügyfél azonosítását az Entra ID-vel

Az Entra ID jelenleg az egyetlen hitelesítési módszer, amelyet az ügyfél támogat.

AIProjectsClientEgy , a projectEndpoint lekérhető a projectEndpoint fájlból. Az alábbiakban feltételezzük, hogy a környezeti változó FOUNDRY_PROJECT_ENDPOINT úgy lett definiálva, hogy ezt az értéket tartsa:

import { AIProjectClient } from "@azure/ai-projects";
import { DefaultAzureCredential } from "@azure/identity";

const projectEndpoint = process.env["FOUNDRY_PROJECT_ENDPOINT"] || "<project endpoint string>";
project = new AIProjectClient(projectEndpoint, new DefaultAzureCredential());

Műveletcsoportok és opt-in funkciózászlók előnézete

Néhány előzetes művelet kifejezetten engedélyezett jelölést igényel foundryFeatures . Például:

await project.agents.createVersion(
  "preview-agent",
  {
    kind: "workflow",
  },
  { foundryFeatures: "WorkflowAgents=V1Preview" },
);
for await (const rule of project.evaluationRules.list()) {
  console.log(rule.id);
}

Az előzetes műveleti csoportok közé .beta.agentstartozik , .beta.skills, .beta.toolboxes, .beta.memoryStores, , .beta.routines, .beta.evaluators.beta.insights.beta.schedules.beta.models.beta.evaluationTaxonomies, és ..beta.redTeams

Példák

Válaszműveletek végrehajtása OpenAI-kliens használatával

A Microsoft Foundry projektedben egy vagy több AI modell is bevezetett. Ezek lehetnek OpenAI modellek, Microsoft modellek vagy más szolgáltatók modelljei. Az alábbi kód segítségével hitelesített OpenAI-t kaphat az openai csomagból, és végrehajthat egy csevegési befejezési hívást.

Futtassa az alábbi kódot. Itt feltételezzük, hogy deploymentName az (str) definiált. Ez egy AI modell telepítési neve a Foundry Project-ben. Amint az a "Modellek + végpontok" lapon, a "Név" oszlopban látható.

További mintákért, beleértve a streaming válaszokat is lásd a package samples "responses" mappájában.

const openAIClient = project.getOpenAIClient();
const response = await openAIClient.responses.create({
  model: deploymentName,
  input: "What is the size of France in square miles?",
});
console.log("response = ", JSON.stringify(response, null, 2));
const detailResponse = await openAIClient.responses.create({
  model: deploymentName,
  input: "And what is the capital city?",
  previous_response_id: response.id,
});
console.log("detailed response = ", JSON.stringify(detailResponse, null, 2));

Ügynöki műveletek végrehajtása

A .agents tulajdonság AIProjectsClient hozzáférést biztosít az összes ügynöki művelethez. Az ügynökök az OpenAI Responses protokoll kiterjesztését használják, így valószínűleg meg kell szereznie egy ügyfelet OpenAI az ügynökműveletek elvégzéséhez, ahogy az alábbi példában látható.

const openAIClient = project.getOpenAIClient();
const agent = await project.agents.createVersion("my-agent-basic", {
  kind: "prompt",
  model: deploymentName,
  instructions: "You are a helpful assistant that answers general questions",
});
console.log(`Agent created (id: ${agent.id}, name: ${agent.name}, version: ${agent.version})`);
const conversation = await openAIClient.conversations.create({
  items: [
    { type: "message", role: "user", content: "What is the size of France in square miles?" },
  ],
});
console.log(`Created conversation with initial user message (id: ${conversation.id})`);
// Generate response using the agent
console.log("\nGenerating response...");
const response = await openAIClient.responses.create(
  {
    conversation: conversation.id,
  },
  {
    body: { agent: { name: agent.name, type: "agent_reference" } },
  },
);
console.log(`Response output: ${response.output_text}`);
// Add a second user message to the conversation
console.log("\nAdding a second user message to the conversation...");
await openAIClient.conversations.items.create(conversation.id, {
  items: [{ type: "message", role: "user", content: "And what is the capital city?" }],
});
console.log("Added a second user message to the conversation");
// Generate second response
console.log("\nGenerating second response...");
const response2 = await openAIClient.responses.create(
  {
    conversation: conversation.id,
  },
  {
    body: { agent: { name: agent.name, type: "agent_reference" } },
  },
);
console.log(`Response output: ${response2.output_text}`);
// Clean up
console.log("\nCleaning up resources...");
await openAIClient.conversations.delete(conversation.id);
console.log("Conversation deleted");
await project.agents.deleteVersion(agent.name, agent.version);
console.log("Agent deleted");

Ügynök eszközök használata

Az ügynököket speciális eszközökkel lehet fejleszteni különféle képességekhez. Az eszközök a kapcsolati követelményeik szerint vannak rendezve:

Beépített eszközök

Ezek az eszközök azonnal működnek, külső kapcsolatok nélkül.

Kódértelmező

Írj és futtass Javascript kódot egy sandbox környezetben, dolgozz fel fájlokat, és dolgozz különféle adatformátumokkal. Az OpenAI dokumentációja

const openAIClient = project.getOpenAIClient();
const response = await openAIClient.responses.create({
  model: deploymentName,
  input: "I need to solve the equation 3x + 11 = 14. Can you help me?",
  tools: [{ type: "code_interpreter", container: { type: "auto" } }],
});
console.log(`Response output: ${response.output_text}`);

Lásd a teljes mintakódot a agentCodeInterpreter.ts szövegben.

fájlkeresés

Beépített RAG (Retrieval-Augmented Generation) eszköz, amely vektortárolókkal dolgozza fel és keresse a dokumentumokat tudáskereséshez. Az OpenAI dokumentációja

const openAIClient = project.getOpenAIClient();
const assetFilePath = path.join(
  __dirname,
  "..",
  "samples-dev",
  "agents",
  "assets",
  "product_info.txt",
);
const vectorStore = await openAIClient.vectorStores.create({
  name: "ProductInfoStreamStore",
});
console.log(`Vector store created (id: ${vectorStore.id})`);
// Upload file to vector store
const fileStream = fs.createReadStream(assetFilePath);
const uploadedFile = await openAIClient.vectorStores.files.uploadAndPoll(
  vectorStore.id,
  fileStream,
);
console.log(`File uploaded to vector store (id: ${uploadedFile.id})`);
// Create agent with file search tool
const agent = await project.agents.createVersion("StreamingFileSearchAgent", {
  kind: "prompt",
  model: deploymentName,
  instructions:
    "You are a helpful assistant that can search through product information and provide detailed responses. Use the file search tool to find relevant information before answering.",
  tools: [
    {
      type: "file_search",
      vector_store_ids: [vectorStore.id],
    },
  ],
});
console.log(`Agent created (id: ${agent.id}, name: ${agent.name}, version: ${agent.version})`);

Lásd a teljes mintakódot a agentFileSearchStream.ts oldalon.

Képgenerálás

Generálj képeket szöveges promptok alapján, testreszabható felbontással, minőséggel és stílusbeállításokkal:

const agent = await project.agents.createVersion("agent-image-generation", {
  kind: "prompt",
  model: deploymentName,
  instructions: "Generate images based on user prompts",
  tools: [
    {
      type: "image_generation",
      quality: "low",
      size: "1024x1024",
    },
  ],
});
console.log(`Agent created (id: ${agent.id}, name: ${agent.name}, version: ${agent.version})`);

Hívás responses.create()után letöltheted a fájlt a visszaküldött válasz segítségével:

import { fileURLToPath } from "url";

const openAIClient = project.getOpenAIClient();
const agent = await project.agents.createVersion("agent-image-generation", {
  kind: "prompt",
  model: deploymentName,
  instructions: "Generate images based on user prompts",
  tools: [
    {
      type: "image_generation",
      quality: "low",
      size: "1024x1024",
    },
  ],
});
console.log(`Agent created (id: ${agent.id}, name: ${agent.name}, version: ${agent.version})`);
const response = await openAIClient.responses.create(
  {
    input: "Generate an image of Microsoft logo.",
  },
  {
    body: { agent: { name: agent.name, type: "agent_reference" } },
  },
);
console.log(`Response created: ${response.id}`);
const imageData = response.output?.filter((output) => output.type === "image_generation_call");
if (imageData && imageData.length > 0 && imageData[0].result) {
  console.log("Downloading generated image...");
  const __filename = fileURLToPath(import.meta.url);
  const __dirname = path.dirname(__filename);
  const filename = "microsoft.png";
  const filePath = path.join(__dirname, filename);
  // Decode base64 and save to file
  const imageBuffer = Buffer.from(imageData[0].result, "base64");
  fs.writeFileSync(filePath, imageBuffer);
  console.log(`Image downloaded and saved to: ${path.resolve(filePath)}`);
} else {
  console.log("No image data found in the response.");
}

Webes keresés (Előzetes)

Általános webes kereséseket végezzen, hogy aktuális információkat szerezzen az internetről. Az OpenAI dokumentációja

const openAIClient = project.getOpenAIClient();
// Create Agent with web search tool
const agent = await project.agents.createVersion("agent-web-search", {
  kind: "prompt",
  model: deploymentName,
  instructions: "You are a helpful assistant that can search the web",
  tools: [
    {
      type: "web_search_preview",
      user_location: {
        type: "approximate",
        country: "GB",
        city: "London",
        region: "London",
      },
    },
  ],
});
console.log(`Agent created (id: ${agent.id}, name: ${agent.name}, version: ${agent.version})`);
// Create a conversation for the agent interaction
const conversation = await openAIClient.conversations.create();
console.log(`Created conversation (id: ${conversation.id})`);
// Send a query to search the web
console.log("\nSending web search query...");
const response = await openAIClient.responses.create(
  {
    conversation: conversation.id,
    input: "Show me the latest London Underground service updates",
  },
  {
    body: { agent: { name: agent.name, type: "agent_reference" } },
  },
);
console.log(`Response: ${response.output_text}`);

Lásd a teljes mintakódot a agentWebSearch.ts szövegben.

Számítógép használata (Előzetes)

Lehetővé tenni az ügynökök közvetlen interakcióját a számítógépes rendszerekkel a feladatautomatizálás és rendszerműveletek érdekében:

const agent = await project.agents.createVersion("ComputerUseAgent", {
  kind: "prompt" as const,
  model: deploymentName,
  instructions: `
You are a computer automation assistant.

Be direct and efficient. When you reach the search results page, read and describe the actual search result titles and descriptions you can see.
    `.trim(),
  tools: [
    {
      type: "computer_use_preview",
      display_width: 1026,
      display_height: 769,
      environment: "windows" as const,
    },
  ],
});
console.log(`Agent created (id: ${agent.id}, name: ${agent.name}, version: ${agent.version})`);

A hívás responses.create()után , dolgozza fel a választ egy interakciós hurokban. Kezeld computer_call a kimeneti elemeket és adj képernyőképeket a computer_call_outputcomputer_screenshot típus szerint, hogy folytasd az interakciót.

Lásd a teljes mintakódot a agentComputerUse.ts betűben.

Model Kontextus Protokoll (MCP)

MCP szerverek integrálása az ügynök képességeinek kiterjesztéséhez szabványosított eszközökkel és erőforrásokkal. Az OpenAI dokumentációja

const openAIClient = project.getOpenAIClient();
const agent = await project.agents.createVersion("agent-mcp", {
  kind: "prompt",
  model: deploymentName,
  instructions:
    "You are a helpful agent that can use MCP tools to assist users. Use the available MCP tools to answer questions and perform tasks.",
  tools: [
    {
      type: "mcp",
      server_label: "api-specs",
      server_url: "https://gitmcp.io/Azure/azure-rest-api-specs",
      require_approval: "always",
    },
  ],
});
console.log(`Agent created (id: ${agent.id}, name: ${agent.name}, version: ${agent.version})`);
// Create a conversation thread to maintain context across multiple interactions
console.log("\nCreating conversation...");
const conversation = await openAIClient.conversations.create();
console.log(`Created conversation (id: ${conversation.id})`);
// Send initial request that will trigger the MCP tool to access Azure REST API specs
// This will generate an approval request since requireApproval="always"
console.log("\nSending request that will trigger MCP approval...");
const response = await openAIClient.responses.create(
  {
    conversation: conversation.id,
    input: "Please summarize the Azure REST API specifications Readme",
  },
  {
    body: { agent: { name: agent.name, type: "agent_reference" } },
  },
);

Hívás responses.create()után ellenőrizzétek, hogy vannak-e mcp_approval_request elemek a válaszkimenetben. Küldd McpApprovalResponse vissza a jóváhagyással a döntéseddel, hogy az ügynök folytassa a munkáját.

A teljes mintakódot lásd a agentMcp.ts részben.

OpenAPI

Hívjon külső API-kat, amelyeket az OpenAPI specifikációk határoznak meg, további kliensoldali kód nélkül. Az OpenAI dokumentációja

const weatherSpecPath = path.resolve(__dirname, "../assets", "weather_openapi.json");
const agent = await project.agents.createVersion("MyOpenApiAgent", {
  kind: "prompt",
  model: deploymentName,
  instructions:
    "You are a helpful assistant that can call external APIs defined by OpenAPI specs to answer user questions. When calling the weather tool, always include the query parameter format=j1.",
  tools: [
    {
      type: "openapi",
      openapi: {
        name: "get_weather",
        description: "Retrieve weather information for a location using wttr.in",
        spec: weatherSpecPath,
        auth: { type: "anonymous" },
      },
    },
  ],
});
console.log(`Agent created (id: ${agent.id}, name: ${agent.name}, version: ${agent.version})`);

Lásd a teljes mintakódot a agentOpenApi.ts szövegben.

Function Tool

Határozz meg egyedi függvényeket, amelyek lehetővé teszik az ügynökök számára, hogy külső API-kkal, adatbázisokkal vagy alkalmazáslogikával interakcióba léphessenek. Az OpenAI dokumentációja

/**
 * Define a function tool for the model to use
 */
const funcTool = {
  type: "function" as const,
  function: {
    name: "get_horoscope",
    description: "Get today's horoscope for an astrological sign.",
    strict: true,
    parameters: {
      type: "object",
      properties: {
        sign: {
          type: "string",
          description: "An astrological sign like Taurus or Aquarius",
        },
      },
      required: ["sign"],
      additional_properties: false,
    },
  },
};
const agent = await project.agents.createVersion("function-tool-agent", {
  kind: "prompt",
  model: deploymentName,
  instructions: "You are a helpful assistant that can use function tools.",
  tools: [funcTool],
});
console.log(`Agent created (id: ${agent.id}, name: ${agent.name}, version: ${agent.version})`);

Miután meghívtad responses.create(), a válaszkimenetből dolgozd function_call fel az elemeket, futtasd le a függvénylogikát a megadott argumentumokkal, és küldd vissza FunctionCallOutput az eredményeket.

A teljes mintakódot lásd a agentFunctionTool.ts szövegben.

  • Memóriakereső eszköz (Előnézet)

A Memória Tároló Eszköz hozzáad Memóriát egy ügynökhöz, lehetővé téve az ügynök MI modellje számára, hogy a jelenlegi felhasználói prompthoz kapcsolódó korábbi információkat keresse.

Ez embeddingModelDeployment annak a modellnek a neve, amelyet vektorbeágyazásokhoz használnak memóriatárolásra és keresésre.

const memoryStoreName = "AgentMemoryStore";
const embeddingModelDeployment =
  process.env["MEMORY_STORE_EMBEDDING_MODEL_DEPLOYMENT_NAME"] || "<embedding model>";
const scope = "user_123";
const memoryStore = await project.beta.memoryStores.create(
  memoryStoreName,
  {
    kind: "default",
    chat_model: deploymentName,
    embedding_model: embeddingModelDeployment,
    options: {
      user_profile_enabled: true,
      chat_summary_enabled: true,
    },
  },
  {
    description: "Memory store for agent conversations",
  },
);
console.log(
  `Created memory store: ${memoryStore.name} (${memoryStore.id}) using chat model '${deploymentName}'`,
);
// Create an agent that will use the Memory Search tool
const agent = await project.agents.createVersion("MemorySearchAgent", {
  kind: "prompt",
  model: deploymentName,
  instructions:
    "You are a helpful assistant that remembers user preferences using the memory search tool.",
  tools: [
    {
      type: "memory_search_preview",
      memory_store_name: memoryStore.name,
      scope,
      update_delay: 1, // wait briefly after conversation inactivity before updating memories
    },
  ],
});

Lásd a teljes mintakódot a agentMemorySearch.ts betűben.

Connection-Based Eszközök

Ezek az eszközök megkövetelik, hogy konfiguráld a kapcsolatokat az AI Foundry projektedben, és használd projectConnectionId.

Azure AI Keresés

Integrálja az Azure AI Keresés indexeket az erős tudáskeresési és szemantikai keresési képességekhez:

const aiSearchConnectionId = process.env["AI_SEARCH_CONNECTION_ID"] || "";
const aiSearchIndexName = process.env["AI_SEARCH_INDEX_NAME"] || "";
const agent = await project.agents.createVersion("MyAISearchAgent", {
  kind: "prompt",
  model: deploymentName,
  instructions:
    "You are a helpful assistant. You must always provide citations for answers using the tool and render them as: `[message_idx:search_idx†source]`.",
  tools: [
    {
      type: "azure_ai_search",
      azure_ai_search: {
        indexes: [
          {
            project_connection_id: aiSearchConnectionId,
            index_name: aiSearchIndexName,
            query_type: "simple",
          },
        ],
      },
    },
  ],
});
console.log(`Agent created (id: ${agent.id}, name: ${agent.name}, version: ${agent.version})`);

Lásd a teljes mintakódot a agentAiSearch.ts szövegben.

Bing Földelés

Földi ügynök válaszai valós idejű webes keresési eredményekkel a Bing-től, hogy up-todátum információt biztosítsanak:

const bingProjectConnectionId = process.env["BING_GROUNDING_CONNECTION_ID"] || "";
const agent = await project.agents.createVersion("MyBingGroundingAgent", {
  kind: "prompt",
  model: deploymentName,
  instructions: "You are a helpful assistant.",
  tools: [
    {
      type: "bing_grounding",
      bing_grounding: {
        search_configurations: [
          {
            project_connection_id: bingProjectConnectionId,
          },
        ],
      },
    },
  ],
});
console.log(`Agent created (id: ${agent.id}, name: ${agent.name}, version: ${agent.version})`);

Lásd a teljes mintakódot a agentBingGrounding.ts formátumban.

Bing Custom Search (Preview)

Használj egyedi konfigurált Bing keresési példányokat domainspecifikus vagy szűrt webes keresési eredményekhez:

const bingCustomSearchProjectConnectionId = process.env["BING_CUSTOM_SEARCH_CONNECTION_ID"] || "";
const bingCustomSearchInstanceName = process.env["BING_CUSTOM_SEARCH_INSTANCE_NAME"] || "";
const agent = await project.agents.createVersion("MyAgent", {
  kind: "prompt",
  model: deploymentName,
  instructions:
    "You are a helpful agent that can use Bing Custom Search tools to assist users. Use the available Bing Custom Search tools to answer questions and perform tasks.",
  tools: [
    {
      type: "bing_custom_search_preview",
      bing_custom_search_preview: {
        search_configurations: [
          {
            project_connection_id: bingCustomSearchProjectConnectionId,
            instance_name: bingCustomSearchInstanceName,
          },
        ],
      },
    },
  ],
});
console.log(`Agent created (id: ${agent.id}, name: ${agent.name}, version: ${agent.version})`);

Lásd a teljes mintakódot a agentBingCustomSearch.ts szövegben.

Microsoft Fabric (Előzetes)

Csatlakozz a Microsoft Fabric-hez, és kérdezz le:

const fabricProjectConnectionId = process.env["FABRIC_PROJECT_CONNECTION_ID"] || "";
const agent = await project.agents.createVersion("MyFabricAgent", {
  kind: "prompt",
  model: deploymentName,
  instructions: "You are a helpful assistant.",
  tools: [
    {
      type: "fabric_dataagent_preview",
      fabric_dataagent_preview: {
        project_connections: [
          {
            project_connection_id: fabricProjectConnectionId,
          },
        ],
      },
    },
  ],
});
console.log(`Agent created (id: ${agent.id}, name: ${agent.name}, version: ${agent.version})`);

Lásd a teljes mintakódot a agentFabric.ts betűben.

Microsoft SharePoint (Előzetes)

Hozzáférés és keresés SharePoint dokumentumokban, listákban és oldalakban vállalati tudásintegrációhoz:

const sharepointProjectConnectionId = process.env["SHAREPOINT_PROJECT_CONNECTION_ID"] || "";
const agent = await project.agents.createVersion("MyAgent", {
  kind: "prompt",
  model: deploymentName,
  instructions:
    "You are a helpful agent that can use SharePoint tools to assist users. Use the available SharePoint tools to answer questions and perform tasks.",
  // Define SharePoint tool that searches SharePoint content
  tools: [
    {
      type: "sharepoint_grounding_preview",
      sharepoint_grounding_preview: {
        project_connections: [
          {
            project_connection_id: sharepointProjectConnectionId,
          },
        ],
      },
    },
  ],
});
console.log(`Agent created (id: ${agent.id}, name: ${agent.name}, version: ${agent.version})`);

A teljes mintakódot lásd a agentSharepoint.ts szövegben.

Böngészőautomatizálás (Előnézet)

Automatizáld a böngészős interakciókat webkapartolás, tesztelés és webalkalmazásokkal való interakció során:

const browserAutomationProjectConnectionId = process.env["BROWSER_AUTOMATION_CONNECTION_ID"] || "";
const agent = await project.agents.createVersion("MyAgent", {
  kind: "prompt",
  model: deploymentName,
  instructions: `You are an Agent helping with browser automation tasks.
              You can answer questions, provide information, and assist with various tasks
              related to web browsing using the Browser Automation tool available to you.`,
  // Define Browser Automation tool
  tools: [
    {
      type: "browser_automation_preview",
      browser_automation_preview: {
        connection: {
          project_connection_id: browserAutomationProjectConnectionId,
        },
      },
    },
  ],
});
console.log(`Agent created (id: ${agent.id}, name: ${agent.name}, version: ${agent.version})`);

Lásd a teljes mintakódot a agentBrowserAutomation.ts szövegben.

MCP Project Connection

MCP integráció projektspecifikus kapcsolatok használatával a csatlakoztatott MCP szerverek eléréséhez:

const mcpProjectConnectionId = process.env["MCP_PROJECT_CONNECTION_ID"] || "";
const agent = await project.agents.createVersion("agent-mcp-connection-auth", {
  kind: "prompt",
  model: deploymentName,
  instructions: "Use MCP tools as needed",
  tools: [
    {
      type: "mcp",
      server_label: "api-specs",
      server_url: "https://api.githubcopilot.com/mcp",
      require_approval: "always",
      project_connection_id: mcpProjectConnectionId,
    },
  ],
});
console.log(`Agent created (id: ${agent.id}, name: ${agent.name}, version: ${agent.version})`);

Lásd a teljes mintakódot a agentMcpConnectionAuth.ts oldalon.

Ügynök-ügynök (A2A) (Előzetes)

Több ügynökös együttműködés engedélyezése, ahol az ügynökök kommunikálhatnak és feladatokat delegálhatnak más speciális ügynököknek:

const a2aProjectConnectionId = process.env["A2A_PROJECT_CONNECTION_ID"] || "";
const agent = await project.agents.createVersion("MyA2AAgent", {
  kind: "prompt",
  model: deploymentName,
  instructions: "You are a helpful assistant.",
  // Define A2A tool for agent-to-agent communication
  tools: [
    {
      type: "a2a_preview",
      project_connection_id: a2aProjectConnectionId,
    },
  ],
});
console.log(`Agent created (id: ${agent.id}, name: ${agent.name}, version: ${agent.version})`);

A teljes mintakódot lásd a agentAgentToAgent.ts formátumban.

OpenAPI Project Connection

Hívjuk meg az OpenAPI specifikációk által meghatározott külső API-kat projektkapcsolat-hitelesítéssel:

const tripAdvisorProjectConnectionId = process.env["TRIPADVISOR_PROJECT_CONNECTION_ID"] || "";
function loadOpenApiSpec(specPath: string): unknown {
  if (!fs.existsSync(specPath)) {
    throw new Error(`OpenAPI specification not found at: ${specPath}`);
  }
  try {
    const data = fs.readFileSync(specPath, "utf-8");
    return JSON.parse(data);
  } catch (error) {
    throw new Error(`Failed to read or parse OpenAPI specification at ${specPath}: ${error}`);
  }
}
const tripAdvisorSpecPath = path.resolve(__dirname, "../assets", "tripadvisor_openapi.json");
const tripAdvisorSpec = loadOpenApiSpec(tripAdvisorSpecPath);
const agent = await project.agents.createVersion("MyOpenApiConnectionAgent", {
  kind: "prompt",
  model: deploymentName,
  instructions:
    "You are a travel assistant that consults the TripAdvisor Content API via project connection to answer user questions about locations.",
  tools: [
    {
      type: "openapi",
      openapi: {
        name: "get_tripadvisor_location_details",
        description:
          "Fetch TripAdvisor location details, reviews, or photos using the Content API via project connection auth.",
        spec: tripAdvisorSpec,
        auth: {
          type: "project_connection",
          security_scheme: {
            project_connection_id: tripAdvisorProjectConnectionId,
          },
        },
      },
    },
  ],
});
console.log(`Agent created (id: ${agent.id}, name: ${agent.name}, version: ${agent.version})`);

Lásd a teljes mintakódot a agentOpenApiConnectionAuth.ts formátumban.

Az összes eszköz teljes munkapéldáját a samples-dev directory oldalán láthatod.

Evaluation

Az értékelés az Azure AI Project klienskönyvtárában kvantitatív és mesterséges intelligencia által támogatott minőségi és biztonsági mutatókat biztosít a teljesítmény értékeléséhez, valamint az LLM modellek, GenAI alkalmazások és ügynökök értékeléséhez. A metrikákat értékelőként határozzák meg. Beépített vagy egyedi értékelők átfogó értékelési betekintést nyújthatnak.

Az alábbi kód néhány értékelési műveletet mutat be. A mintalista teljes listája megtalálható a "evaluations" mappában a package samples

const openAIClient = project.getOpenAIClient();
const dataSourceConfig = {
  type: "custom" as const,
  item_schema: {
    type: "object",
    properties: { query: { type: "string" } },
    required: ["query"],
  },
  include_sample_schema: true,
};
const evalObject = await openAIClient.evals.create({
  name: "Agent Evaluation",
  data_source_config: dataSourceConfig,
  testing_criteria: [
    {
      type: "azure_ai_evaluator",
      name: "violence_detection",
      evaluator_name: "builtin.violence",
      data_mapping: { query: "{{item.query}}", response: "{{item.response}}" },
    } as any,
  ],
});
console.log(`Evaluation created (id: ${evalObject.id}, name: ${evalObject.name})`);

Lásd a teljes mintakódot a agentEvaluation.ts formátumban.

Központi telepítési műveletek

Az alábbi kód néhány telepítési műveletet mutat be, amelyek lehetővé teszik, hogy felsorold a Microsoft Foundry Projektjeidhez telepített AI modelleket. Ezek a modellek megtekinthetők a Microsoft Foundry Project "Modellek + végpontok" fülön. Teljes minták megtalálhatók a "deployment" mamma alatt a package samples menüpontban.

import { ModelDeployment } from "@azure/ai-projects";

const modelPublisher = process.env["MODEL_PUBLISHER"] || "<model publisher>";
console.log("List all deployments:");
const deployments: ModelDeployment[] = [];
const properties: Array<Record<string, string>> = [];

for await (const deployment of project.deployments.list()) {
  // Check if this is a ModelDeployment (has the required properties)
  if (
    deployment.type === "ModelDeployment" &&
    "modelName" in deployment &&
    "modelPublisher" in deployment &&
    "modelVersion" in deployment
  ) {
    deployments.push(deployment);
    properties.push({
      name: deployment.name,
      modelPublisher: deployment.modelPublisher,
      modelName: deployment.modelName,
    });
  }
}
console.log(`Retrieved deployments: ${JSON.stringify(properties, null, 2)}`);

// List all deployments by a specific model publisher (assuming we have one from the list)
console.log(`List all deployments by the model publisher '${modelPublisher}':`);
const filteredDeployments: ModelDeployment[] = [];
for await (const deployment of project.deployments.list({
  modelPublisher,
})) {
  // Check if this is a ModelDeployment
  if (
    deployment.type === "ModelDeployment" &&
    "modelName" in deployment &&
    "modelPublisher" in deployment &&
    "modelVersion" in deployment
  ) {
    filteredDeployments.push(deployment);
  }
}
console.log(
  `Retrieved ${filteredDeployments.length} deployments from model publisher '${modelPublisher}'`,
);

// Get a single deployment by name
if (deployments.length > 0) {
  const deploymentName = deployments[0].name;
  console.log(`Get a single deployment named '${deploymentName}':`);
  const singleDeployment = await project.deployments.get(deploymentName);
  console.log(`Retrieved deployment: ${JSON.stringify(singleDeployment, null, 2)}`);
}

Kapcsolatok műveletei

Az alábbi kód néhány Connection műveletet mutat be, amelyek lehetővé teszik a Microsoft Foundry Projektekhez csatlakoztatott Azure Resources felsorolását. Ezek a kapcsolatok megtekinthetők a "Management Center" részén, a Microsoft Foundry Project "Connected resources" fülön. Teljes minták megtalálhatók a "connections" mamma alatt a package samples menüpontban.

import { Connection } from "@azure/ai-projects";

// List the details of all the connections
const connections: Connection[] = [];
const connectionNames: string[] = [];
for await (const connection of project.connections.list()) {
  connections.push(connection);
  connectionNames.push(connection.name);
}
console.log(`Retrieved connections: ${connectionNames}`);

// Get the details of a connection, without credentials
const connectionName = connections[0].name;
const connection = await project.connections.get(connectionName);
console.log(`Retrieved connection ${JSON.stringify(connection, null, 2)}`);

const connectionWithCredentials = await project.connections.getWithCredentials(connectionName);
console.log(
  `Retrieved connection with credentials ${JSON.stringify(connectionWithCredentials, null, 2)}`,
);

// List all connections of a specific type
const azureAIConnections: Connection[] = [];
for await (const azureOpenAIConnection of project.connections.list({
  connectionType: "AzureOpenAI",
  defaultConnection: true,
})) {
  azureAIConnections.push(azureOpenAIConnection);
}
console.log(`Retrieved ${azureAIConnections.length} Azure OpenAI connections`);

// Get the details of a default connection
const defaultConnection = await project.connections.getDefault("AzureOpenAI", {
  includeCredentials: true,
});
console.log(`Retrieved default connection ${JSON.stringify(defaultConnection, null, 2)}`);

Adathalmaz-műveletek

Az alábbi kód néhány adathalmaz-műveletet mutat be. Teljes minták megtalálhatók a "datasets" mappa alatt a package samples menüpontban.

import { DatasetVersionUnion } from "@azure/ai-projects";

const VERSION1 = "1.0";
const VERSION2 = "2.0";
const VERSION3 = "3.0";

// sample files to use in the demonstration
const sampleFolder = "sample_folder";
// Create a unique dataset name for this sample run
const datasetName = `sample-dataset-basic`;
console.log("Upload a single file and create a new Dataset to reference the file.");
console.log("Here we explicitly specify the dataset version.");

const dataset1 = await project.datasets.uploadFile(
  datasetName,
  VERSION1,
  path.join(__dirname, sampleFolder, "sample_file1.txt"),
);
console.log("Dataset1 created:", JSON.stringify(dataset1, null, 2));

const credential = project.datasets.getCredentials(dataset1.name, dataset1.version, {});
console.log("Credential for the dataset:", credential);
console.log(
  "Upload all files in a folder (including subfolders) to the existing Dataset to reference the folder.",
);
console.log("Here again we explicitly specify a new dataset version");
const dataset2 = await project.datasets.uploadFolder(
  datasetName,
  VERSION2,
  path.join(__dirname, sampleFolder),
);
console.log("Dataset2 created:", JSON.stringify(dataset2, null, 2));
console.log(
  "Upload a single file to the existing dataset, while letting the service increment the version",
);
const dataset3 = await project.datasets.uploadFile(
  datasetName,
  VERSION3,
  path.join(__dirname, sampleFolder, "sample_file2.txt"),
);
console.log("Dataset3 created:", JSON.stringify(dataset3, null, 2));

console.log("Get an existing Dataset version `1`:");
const datasetVersion1 = await project.datasets.get(datasetName, VERSION1);
console.log("Dataset version 1:", JSON.stringify(datasetVersion1, null, 2));
console.log(`Listing all versions of the Dataset named '${datasetName}':`);
const datasetVersions = project.datasets.listVersions(datasetName);
for await (const version of datasetVersions) {
  console.log("List versions:", version);
}
console.log("List latest versions of all Datasets:");
const latestDatasets = project.datasets.list();
for await (const dataset of latestDatasets) {
  console.log("List datasets:", dataset);
}
// List the details of all the datasets
const datasets = project.datasets.listVersions(datasetName);
const allDatasets: DatasetVersionUnion[] = [];
for await (const dataset of datasets) {
  allDatasets.push(dataset);
}
console.log(`Retrieved ${allDatasets.length} datasets`);
console.log("Delete all Datasets created above:");
await project.datasets.delete(datasetName, VERSION1);
await project.datasets.delete(datasetName, VERSION2);
await project.datasets.delete(datasetName, dataset3.version);
console.log("All specified Datasets have been deleted.");

Fájlok műveletei

Az alábbi kód néhány fájlműveletet mutat be az OpenAI-kliens használatával, amelyek lehetővé teszik fájlok feltöltését, lekérését, listázását és törlését. Ezek a műveletek hasznosak a finomhangoláshoz és más AI-modellműveletekhez használható fájlokkal való munkához. Teljes minták megtalálhatók a "files" mappa alatt a package samples menüpontban.

const openAIClient = project.getOpenAIClient();
console.log("Uploading file");
const created = await openAIClient.files.create({
  file: fs.createReadStream(filePath),
  purpose: "fine-tune",
});
console.log(`Uploaded file with ID: ${created.id}`);
const uploadedFile = await openAIClient.files.retrieve(created.id);
console.log("Processed file metadata:\n", JSON.stringify(uploadedFile, null, 2));
console.log(`Retrieving file content with ID: ${uploadedFile.id}`);
const contentResponse = await openAIClient.files.content(uploadedFile.id);
const buf = Buffer.from(await contentResponse.arrayBuffer());
console.log(buf.toString("utf-8"));
// 4) List all files
console.log("Listing all files:");
const filesList = await openAIClient.files.list();
for (const f of filesList.data ?? []) {
  console.log(JSON.stringify(f));
}
// 5) Delete the file
console.log(`Deleting file with ID: ${uploadedFile.id}`);
const deleted = await openAIClient.files.delete(uploadedFile.id);
console.log(
  `Successfully deleted file: ${deleted?.id || uploadedFile.id}, deleted=${String(deleted?.deleted ?? true)}`,
);

Indexelési műveletek

Az alábbi kód néhány indexelési műveletet mutat be. Teljes minták megtalálhatók az "indexes" mappa alatt a package samples menüpontban.

import { AzureAISearchIndex } from "@azure/ai-projects";

const indexName = "sample-index";
const version = "1";
const azureAIConnectionConfig: AzureAISearchIndex = {
  name: indexName,
  type: "AzureSearch",
  version,
  indexName,
  connectionName: "sample-connection",
};

// Create a new Index
const newIndex = await project.indexes.createOrUpdate(indexName, version, azureAIConnectionConfig);
console.log("Created a new Index:", newIndex);
console.log(`Get an existing Index version '${version}':`);
const index = await project.indexes.get(indexName, version);
console.log(index);
console.log(`Listing all versions of the Index named '${indexName}':`);
const indexVersions = project.indexes.listVersions(indexName);
for await (const indexVersion of indexVersions) {
  console.log(indexVersion);
}
console.log("List all Indexes:");
const allIndexes = project.indexes.list();
for await (const i of allIndexes) {
  console.log("Index:", i);
}
console.log("Delete the Index versions created above:");
await project.indexes.delete(indexName, version);

Műveletek finomhangolása

Az alábbi kód bemutatja, hogyan lehet finomhangoló feladatokat létrehozni az OpenAI kliensel. Ezek a műveletek különféle finomhangolási technikákat támogatnak, mint például a Supervised Fine-Tuning (SFT), Reinforcement Fine-Tuning (RFT) és Direct Performance Optimization (DPO). Teljes minták megtalálhatók a "finetuning" mappa alatt a package samples menüpontban.

import { JobCreateParams } from "openai/resources/fine-tuning/jobs";

const trainingFilePath = "training_data_path.jsonl";
const validationFilePath = "validation_data_path.jsonl";
const openAIClient = project.getOpenAIClient();
// 1) Create the training and validation files
const trainingFile = await openAIClient.files.create({
  file: fs.createReadStream(trainingFilePath),
  purpose: "fine-tune",
});
console.log(`Uploaded file with ID: ${trainingFile.id}`);
const validationFile = await openAIClient.files.create({
  file: fs.createReadStream(validationFilePath),
  purpose: "fine-tune",
});
console.log(`Uploaded file with ID: ${validationFile.id}`);
// 2) Wait for the files to be processed
await openAIClient.files.waitForProcessing(trainingFile.id);
await openAIClient.files.waitForProcessing(validationFile.id);
console.log("Files processed.");
// 3) Create a supervised fine-tuning job
const fineTuningJob = await openAIClient.fineTuning.jobs.create({} as JobCreateParams, {
  body: {
    trainingType: "Standard",
    training_file: trainingFile.id,
    validation_file: validationFile.id,
    model: deploymentName,
    method: {
      type: "supervised",
      supervised: {
        hyperparameters: {
          n_epochs: 3,
          batch_size: 1,
          learning_rate_multiplier: 1.0,
        },
      },
    },
  },
});
console.log("Created fine-tuning job:\n", JSON.stringify(fineTuningJob));

Beta ügynök sessions műveletek (előzetes)

Az .beta.agents üzemeltetés lehetővé teszi, hogy kezeld az ügynök üléseket és a hinterjelent ügynökök munkamenetfájljait. A sessionok elszigetelt homokozó környezeteket biztosítanak az ügynök interakciókhoz.

import { VersionRefIndicator } from "@azure/ai-projects";

const agentName = "MyBetaAgent";
// Create a session for the agent
const versionIndicator: VersionRefIndicator = {
  type: "version_ref",
  agent_version: "1.0",
};
const session = await project.beta.agents.createSession(agentName, versionIndicator);
console.log(`Session created: ${session.agent_session_id}`);
// Upload a file to the session sandbox
const filePath = "/sandbox/hello.txt";
const fileContent = new TextEncoder().encode("Hello from the beta agents sample!");
const uploadResult = await project.beta.agents.uploadSessionFile(
  agentName,
  session.agent_session_id,
  filePath,
  fileContent,
);
console.log(`Uploaded file: ${uploadResult.path} (${uploadResult.bytes_written} bytes)`);

Lásd a teljes mintakódot a betaAgents.ts formátumban.

Készségműveletek (előzetes megtekintés)

Az .beta.skills üzemeltetés lehetővé teszi, hogy újrahasználható készségeket hozzon létre és kezelj, amelyek meghatározzák az ügynök képességeit.

const skillName = "sample-skill";
// Create a new skill
const created = await project.beta.skills.create(skillName, {
  description: "Example skill created by the @azure/ai-projects sample.",
  instructions: "You are a helpful assistant that answers questions concisely.",
  metadata: { owner: "sample" },
});
console.log(`Skill created: ${created.name} (id: ${created.skill_id})`);
// Retrieve the skill
const fetched = await project.beta.skills.get(skillName);
console.log(`Retrieved skill: ${fetched.name} (id: ${fetched.skill_id})`);

Lásd a teljes mintakódot skillBasic.ts formátumban.

Toolbox műveletek (előnézet)

Az .beta.toolboxes üzemeltetés lehetővé teszi eszközdobozok létrehozását és kezelését — újrahasználható eszközgyűjteményeket, amelyeket ügynökök között lehet megosztani.

import { ToolUnion, MCPTool } from "@azure/ai-projects";

const toolboxName = "mcp";
// Define tools for the toolbox
const tools: ToolUnion[] = [
  {
    type: "mcp",
    server_label: "api_specs",
    server_url: "https://github.com/Azure/azure-rest-api-specs",
    require_approval: "never",
  } satisfies MCPTool,
];
// Create a new toolbox version
const created = await project.beta.toolboxes.createVersion(toolboxName, tools, {
  description: "Example toolbox created by the @azure/ai-projects sample.",
  metadata: { status: "created" },
});
console.log(`Toolbox: ${created.name} (tools: ${created.tools.length})`);
// Retrieve the toolbox
const fetched = await project.beta.toolboxes.get(toolboxName);
console.log(`Retrieved toolbox: ${fetched.name} (${fetched.id})`);

Lásd a teljes mintakódot a toolboxesCrud.ts oldalon.

Nyomkövetés

Jegyzet: A nyomkövetési funkció előzetes előzetes verzióban érhető el, és változhat. A tartományok, attribútumok és események a későbbi verziókban módosulhatnak.

Egy Application Insights Azure erőforrást hozzáadhatsz a Microsoft Foundry projektedhez. Nézd meg a Tracing fület a Microsoft Foundry projektedben. Ha az egyik engedélyezve van, akkor beszerezheted az Application Insights kapcsolati karakterlánc-et, konfigurálhatod az AI Projects kliensedet, és megfigyelheted a teljes végrehajtási útvonalat az Azure Monitor-on. Általában érdemes elkezdeni a nyomkövetést, mielőtt létrehoz egy ügyfelet vagy ügynököt.

Installation

npm install @azure/monitor-opentelemetry@^1.14.2 @opentelemetry/api@^1.9.0

Hogyan engedélyezzük a követést

Íme egy kódminta, amely bemutatja, hogyan lehet engedélyezni az Azure Monitor követését:

import { AzureMonitorOpenTelemetryOptions, useAzureMonitor } from "@azure/monitor-opentelemetry";

const TELEMETRY_CONNECTION_STRING = process.env["TELEMETRY_CONNECTION_STRING"];
const options: AzureMonitorOpenTelemetryOptions = {
  azureMonitorExporterOptions: {
    connectionString: TELEMETRY_CONNECTION_STRING,
  },
};
useAzureMonitor(options);

Lásd a teljes mintakódot a remoteTelemetry.ts formátumban.

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 { isRestError } from "@azure/core-rest-pipeline";

try {
  const result = await project.connections.list();
} catch (e) {
  if (isRestError(e)) {
    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

Ha problémákat szeretnél jelenteni az ügyfélkönyvtárral, vagy további funkciókat kérni, kérjük, nyisson meg egy GitHub problémát itt

Következő lépések

Nézd meg a package samples mappát, amely teljesen futtatható kódot tartalmaz.

Újragenerálás TypeSpec-ből (karbantartók)

Ez a csomag a TypeSpec specifikációból regenerálódik Azure/azure-rest-api-specs verzióban. A teljes munkafolyamat hat képességből van kódolva a .github/skills/ alatt, és egy GitHub Copilot kódoló ügynök feladat irányíthatja végponttól végéig.

A regén felhőügynökként történő elküldéséhez ebből a könyvtárból futassunk el:

pwsh -NoProfile -File ./scripts/start-cloud-regen.ps1                     # latest commit on feature/foundry-release
pwsh -NoProfile -File ./scripts/start-cloud-regen.ps1 -TspCommit <sha>    # pin a specific commit
pwsh -NoProfile -File ./scripts/start-cloud-regen.ps1 -DryRun             # render the prompt locally, do not dispatch
pwsh -NoProfile -File ./scripts/start-cloud-regen.ps1 -Repo myuser/azure-sdk-for-js -Follow   # smoke-test on a fork

Windows esetén a szkript közvetlen hívása (pl. ./scripts/start-cloud-regen.ps1) blokkolható az alapértelmezett Restricted végrehajtási politika által. A pwsh -NoProfile -File ... fenti forma ezt kikerüli. Alternatívaként egyszer futtathatod Set-ExecutionPolicy -Scope CurrentUser -ExecutionPolicy RemoteSigned , hogy engedélyezd a helyi szkripteket.

Prerequisites:

  • gh A CLI telepítve és hitelesítésben (gh auth login) a célállomás ellen. Az agent-task alparancsnokság előnézetben van, és friss gh.
  • Tagság olyan szervezetben, ahol a GitHub Copilot kódoló ügynök engedélyezett a célrepo számára.
  • Push-t hozzáférést a célrepóhoz (a felhőügynök saját GitHub alkalmazásazonosítóját használja a draft PR megnyitásához).

Megjegyzés: a küldött prompt pnpm install --filter @azure/ai-projects... fut és pnpm --filter @azure/ai-projects... build befut a feladat elején. Ha a felhőügynök homokozó blokkolja ezeket a hálózati hívásokat, a feladat a beállításkor megbukik; ebben az esetben futtatjuk a készségeket helyben, vagy koordináljuk az SDK építőcsapattal, hogy egy központilag menedzselt copilot-setup-steps.yml munkafolyamatot adjunk hozzá a repo gyökérnél.

hozzájárulási

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 elfogadta a Microsoft Open Source Code of Conduct -t. 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