Nástroj pro interpretaci kódu pro agenty Microsoft Foundry

Interpret kódu umožňuje agentovi Microsoft Foundry spouštět Python kód v prostředí spouštění v izolovaném prostoru (sandbox). Model Foundry agenta zapisuje a spouští kód pro analýzu dat, generování grafů a iterativní úlohy řešení problémů.

V tomto článku vytvoříte agenta, který používá interpret kódu, nahraje soubor CSV pro analýzu a stáhne vygenerovaný graf.

Když povolíte interpret kódu, může váš agent zapisovat a spouštět Python kódu iterativním způsobem, aby vyřešil analýzu dat a matematické úlohy a vygeneroval grafy.

Důležité

Interpret kódu má přidatné poplatky nad rámec poplatků založených na tokenech za Azure využití OpenAI. Pokud váš agent volá interpret kódu současně ve dvou různých konverzacích, vytvoří dvě relace interpreta kódu. Každá relace je ve výchozím nastavení aktivní po dobu jedné hodiny s časovým limitem nečinnosti 30 minut.

Podpora využití

Následující tabulka ukazuje podporu sady SDK a nastavení.

podpora Microsoft Foundry Python SDK C# SDK JavaScript SDK Java SDK REST API Základní nastavení agenta Nastavení standardního agenta
✔️ ✔️ ✔️ ✔️ ✔️ ✔️ ✔️ ✔️

Požadavky

  • Základní nebo standardní prostředí agenta. Podrobnosti najdete v nastavení prostředí agenta .
  • Nejnovější balíček sady SDK nainstalovaný pro váš jazyk Sada .NET SDK je aktuálně ve verzi Preview. Postup instalace najdete v rychlém startu .
  • Nasazení modelu Azure AI nakonfigurované ve vašem projektu.
  • Pro operace se soubory: CSV nebo jiné podporované soubory k nahrání pro analýzu.

Poznámka

Interpret kódu není dostupný ve všech oblastech. Viz Kontrola dostupnosti oblastí a modelů.

Vytvoření agenta pomocí interpretu kódu

Následující ukázky ukazují, jak vytvořit agenta s povoleným interpretem kódu, nahrát soubor pro analýzu a stáhnout vygenerovaný výstup.

Tip

Chování interpreta kódu můžete přizpůsobit za běhu, například určit, které soubory se mají zahrnout nebo upravit parametry nástroje na požadavek, pomocí strukturovaných vstupů.

Ukázka použití agenta s nástrojem interpretu kódu v sadě Python SDK

Následující Python ukázce ukazuje, jak vytvořit agenta pomocí nástroje interpretu kódu, nahrát soubor CSV pro analýzu a požádat o pruhový graf na základě dat. Ukazuje úplný pracovní postup: nahrání souboru, vytvoření agenta s povoleným interpretem kódu, vizualizaci dat žádostí a stažení vygenerovaného grafu.

import os
from azure.identity import DefaultAzureCredential
from azure.ai.projects import AIProjectClient
from azure.ai.projects.models import PromptAgentDefinition, CodeInterpreterTool, AutoCodeInterpreterToolParam

# Load the CSV file to be processed
asset_file_path = os.path.abspath(
    os.path.join(os.path.dirname(__file__), "../assets/synthetic_500_quarterly_results.csv")
)

# Format: "https://resource_name.ai.azure.com/api/projects/project_name"
PROJECT_ENDPOINT = "your_project_endpoint"

# Create clients to call Foundry API
project = AIProjectClient(
    endpoint=PROJECT_ENDPOINT,
    credential=DefaultAzureCredential(),
)
openai = project.get_openai_client()

# Upload the CSV file for the code interpreter to use
file = openai.files.create(purpose="assistants", file=open(asset_file_path, "rb"))

# Create agent with code interpreter tool
agent = project.agents.create_version(
    agent_name="MyAgent",
    definition=PromptAgentDefinition(
        model="gpt-5-mini",
        instructions="You are a helpful assistant.",
        tools=[CodeInterpreterTool(container=AutoCodeInterpreterToolParam(file_ids=[file.id]))],
    ),
    description="Code interpreter agent for data analysis and visualization.",
)

# Create a conversation for the agent interaction
conversation = openai.conversations.create()

# Send request to create a chart and generate a file
response = openai.responses.create(
    conversation=conversation.id,
    input="Could you please create bar chart in TRANSPORTATION sector for the operating profit from the uploaded csv file and provide file to me?",
    extra_body={"agent_reference": {"name": agent.name, "type": "agent_reference"}},
)

# Extract file information from response annotations
file_id = ""
filename = ""
container_id = ""

# Get the last message which should contain file citations
last_message = response.output[-1]  # ResponseOutputMessage
if (
    last_message.type == "message"
    and last_message.content
    and last_message.content[-1].type == "output_text"
    and last_message.content[-1].annotations
):
    file_citation = last_message.content[-1].annotations[-1]  # AnnotationContainerFileCitation
    if file_citation.type == "container_file_citation":
        file_id = file_citation.file_id
        filename = file_citation.filename
        container_id = file_citation.container_id
        print(f"Found generated file: {filename} (ID: {file_id})")

# Clean up resources
project.agents.delete_version(agent_name=agent.name, agent_version=agent.version)

# Download the generated file if available
if file_id and filename:
    file_content = openai.containers.files.content.retrieve(file_id=file_id, container_id=container_id)
    print(f"File ready for download: {filename}")
    file_path = os.path.join(os.path.dirname(__file__), filename)
    with open(file_path, "wb") as f:
        f.write(file_content.read())
    print(f"File downloaded successfully: {file_path}")
else:
    print("No file generated in response")

Očekávaný výstup

Vzorový kód vytvoří výstup podobný následujícímu příkladu:

Found generated file: transportation_operating_profit_bar_chart.png (ID: file-xxxxxxxxxxxxxxxxxxxx)
File ready for download: transportation_operating_profit_bar_chart.png
File downloaded successfully: transportation_operating_profit_bar_chart.png

Agent nahraje soubor CSV do Azure úložiště, vytvoří prostředí Python v izolovaném prostoru (sandbox), analyzuje data pro filtrování záznamů odvětví dopravy, vygeneruje pruhový graf PNG zobrazující provozní zisk podle čtvrtletí a stáhne graf do místního adresáře. Poznámky k souboru v odpovědi poskytují ID souboru a informace o kontejneru potřebné k načtení vygenerovaného grafu.

Vytvoření grafu s interpretem kódu v jazyce C#

Následující ukázka jazyka C# ukazuje, jak vytvořit agenta pomocí nástroje Interpret kódu, nahrát soubor CSV pro analýzu a stáhnout vygenerovaný graf. Pro asynchronní použití se podívejte na ukázku kódu v úložišti Azure SDK pro .NET na GitHubu.

using System;
using System.IO;
using Azure.AI.Projects;
using Azure.AI.Extensions.OpenAI;
using Azure.Identity;
using OpenAI.Files;

// Format: "https://resource_name.ai.azure.com/api/projects/project_name"
var projectEndpoint = "your_project_endpoint";

// Create project client to call Foundry API
AIProjectClient projectClient = new(
    endpoint: new Uri(projectEndpoint),
    tokenProvider: new DefaultAzureCredential());

// Upload a CSV file for Code Interpreter to analyze
OpenAIFileClient fileClient = projectClient.ProjectOpenAIClient.GetOpenAIFileClient();
OpenAIFile uploadedFile = fileClient.UploadFile(
    filePath: "synthetic_500_quarterly_results.csv",
    purpose: FileUploadPurpose.Assistants);
Console.WriteLine($"Uploaded file: {uploadedFile.Id}");

// Create an agent with Code Interpreter enabled
DeclarativeAgentDefinition agentDefinition = new(model: "gpt-5-mini")
{
    Instructions = "You are a helpful assistant.",
    Tools = {
        ResponseTool.CreateCodeInterpreterTool(
            new CodeInterpreterToolContainer(
                CodeInterpreterToolContainerConfiguration.CreateAutomaticContainerConfiguration(
                    fileIds: [uploadedFile.Id]
                )
            )
        ),
    }
};
ProjectsAgentVersion agentVersion = projectClient.AgentAdministrationClient.CreateAgentVersion(
    agentName: "myChartAgent",
    options: new(agentDefinition));

// Request chart generation from the uploaded CSV data
AgentReference agentReference = new(name: agentVersion.Name, version: agentVersion.Version);
ProjectResponsesClient responseClient = projectClient.ProjectOpenAIClient.GetProjectResponsesClientForAgent(agentReference);

ResponseResult response = responseClient.CreateResponse(
    "Could you please create bar chart in TRANSPORTATION sector for the operating profit " +
    "from the uploaded csv file and provide file to me?");

Console.WriteLine(response.GetOutputText());

// Extract file information from response annotations
ContainerFileCitationMessageAnnotation containerAnnotation = null;
foreach (ResponseItem item in response.OutputItems)
{
    if (item is MessageResponseItem messageItem)
    {
        foreach (ResponseContentPart content in messageItem.Content)
        {
            foreach (ResponseMessageAnnotation annotation in content.OutputTextAnnotations)
            {
                if (annotation is ContainerFileCitationMessageAnnotation cntrAnnotation)
                {
                    containerAnnotation = cntrAnnotation;
                }
            }
        }
    }
}

// Download the generated chart if available
if (containerAnnotation is not null)
{
    ContainerClient containerClient = projectClient.ProjectOpenAIClient.GetContainerClient();
    BinaryData fileData = containerClient.DownloadContainerFile(
        containerId: containerAnnotation.ContainerId,
        fileId: containerAnnotation.FileId);
    File.WriteAllBytes("chart.png", fileData.ToArray());
    Console.WriteLine($"Chart downloaded: {Path.GetFullPath("chart.png")}");
}
else
{
    Console.WriteLine("No file generated in response");
}

// Clean up resources
projectClient.AgentAdministrationClient.DeleteAgentVersion(
    agentName: agentVersion.Name, agentVersion: agentVersion.Version);

Očekávaný výstup

Vzorový kód vytvoří výstup podobný následujícímu příkladu:

Uploaded file: file-xxxxxxxxxxxxxxxxxxxx
Here is the bar chart showing operating profit by quarter in the TRANSPORTATION sector...
Chart downloaded: C:\Users\you\chart.png

Agent nahraje soubor CSV do Azure úložiště, vytvoří Python prostředí v izolovaném prostoru (sandbox), analyzuje data pro filtrování záznamů odvětví dopravy a vygeneruje pruhový graf PNG. Analýza poznámek extrahuje ID kontejneru a ID souboru z odpovědi, které se používají ke stažení grafu do místního adresáře.

Ukázka použití agenta s nástrojem interpretu kódu v sadě TypeScript SDK

Následující ukázka TypeScriptu ukazuje, jak vytvořit agenta pomocí nástroje pro interpret kódu, nahrát soubor CSV pro analýzu a požádat o pruhový graf na základě dat. Verzi JavaScriptu najdete v ukázce JavaScript v Azure SDK pro úložiště JavaScript na GitHub.

import { DefaultAzureCredential } from "@azure/identity";
import { AIProjectClient } from "@azure/ai-projects";
import * as fs from "fs";
import * as path from "path";
import { fileURLToPath } from "url";

// Format: "https://resource_name.ai.azure.com/api/projects/project_name"
const PROJECT_ENDPOINT = "your_project_endpoint";

// Helper to resolve asset file path
const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

export async function main(): Promise<void> {
  // Create clients to call Foundry API
  const project = new AIProjectClient(PROJECT_ENDPOINT, new DefaultAzureCredential());
  const openai = project.getOpenAIClient();

  // Load and upload CSV file
  const assetFilePath = path.resolve(
    __dirname,
    "../assets/synthetic_500_quarterly_results.csv",
  );
  const fileStream = fs.createReadStream(assetFilePath);

  // Upload CSV file
  const uploadedFile = await openai.files.create({
    file: fileStream,
    purpose: "assistants",
  });

  // Create agent with Code Interpreter tool
  const agent = await project.agents.createVersion("MyAgent", {
    kind: "prompt",
    model: "gpt-5-mini",
    instructions: "You are a helpful assistant.",
    tools: [
      {
        type: "code_interpreter",
        container: {
          type: "auto",
          file_ids: [uploadedFile.id],
        },
      },
    ],
  });

  // Create a conversation
  const conversation = await openai.conversations.create();

  // Request chart generation
  const response = await openai.responses.create(
    {
      conversation: conversation.id,
      input:
        "Could you please create bar chart in TRANSPORTATION sector for the operating profit from the uploaded csv file and provide file to me?",
    },
    {
      body: { agent: { name: agent.name, type: "agent_reference" } },
    },
  );

  // Extract file information from response annotations
  let fileId = "";
  let filename = "";
  let containerId = "";

  // Get the last message which should contain file citations
  const lastMessage = response.output?.[response.output.length - 1];
  if (lastMessage && lastMessage.type === "message") {
    // Get the last content item
    const textContent = lastMessage.content?.[lastMessage.content.length - 1];
    if (textContent && textContent.type === "output_text" && textContent.annotations) {
      // Get the last annotation (most recent file)
      const fileCitation = textContent.annotations[textContent.annotations.length - 1];
      if (fileCitation && fileCitation.type === "container_file_citation") {
        fileId = fileCitation.file_id;
        filename = fileCitation.filename;
        containerId = fileCitation.container_id;
        console.log(`Found generated file: ${filename} (ID: ${fileId})`);
      }
    }
  }

  // Download the generated file if available
  if (fileId && filename) {
    const safeFilename = path.basename(filename);
    const fileContent = await openai.containers.files.content.retrieve({
      file_id: fileId,
      container_id: containerId,
    });

    // Read the readable stream into a buffer
    const chunks: Buffer[] = [];
    for await (const chunk of fileContent.body) {
      chunks.push(Buffer.from(chunk));
    }
    const buffer = Buffer.concat(chunks);

    fs.writeFileSync(safeFilename, buffer);
    console.log(`File ${safeFilename} downloaded successfully.`);
    console.log(`File ready for download: ${safeFilename}`);
  } else {
    console.log("No file generated in response");
  }

  // Clean up resources
  await project.agents.deleteVersion(agent.name, agent.version);
}

main().catch((err) => {
  console.error("The sample encountered an error:", err);
});

Očekávaný výstup

Vzorový kód vytvoří výstup podobný následujícímu příkladu:

Found generated file: transportation_operating_profit_bar_chart.png (ID: file-xxxxxxxxxxxxxxxxxxxx)
File transportation_operating_profit_bar_chart.png downloaded successfully.
File ready for download: transportation_operating_profit_bar_chart.png

Agent nahraje soubor CSV do Azure úložiště, vytvoří prostředí Python v izolovaném prostoru (sandbox), analyzuje data pro filtrování záznamů odvětví dopravy, vygeneruje pruhový graf PNG zobrazující provozní zisk podle čtvrtletí a stáhne graf do místního adresáře. Poznámky k souboru v odpovědi poskytují ID souboru a informace o kontejneru potřebné k načtení vygenerovaného grafu.

Vytvoření grafu s interpretem kódu v Java

Přidejte závislost do svého pom.xml:

<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-ai-agents</artifactId>
    <version>2.0.0</version>
</dependency>

Vytvoření agenta a vygenerování grafu

import com.azure.ai.agents.AgentsClient;
import com.azure.ai.agents.AgentsClientBuilder;
import com.azure.ai.agents.ResponsesClient;
import com.azure.ai.agents.models.AgentReference;
import com.azure.ai.agents.models.AgentVersionDetails;
import com.azure.ai.agents.models.AzureCreateResponseOptions;
import com.azure.ai.agents.models.CodeInterpreterTool;
import com.azure.ai.agents.models.PromptAgentDefinition;
import com.azure.identity.DefaultAzureCredentialBuilder;
import com.openai.models.responses.Response;
import com.openai.models.responses.ResponseCreateParams;

import java.util.Collections;

public class CodeInterpreterChartExample {
    public static void main(String[] args) {
        // Format: "https://resource_name.ai.azure.com/api/projects/project_name"
        String projectEndpoint = "your_project_endpoint";

        AgentsClientBuilder builder = new AgentsClientBuilder()
            .credential(new DefaultAzureCredentialBuilder().build())
            .endpoint(projectEndpoint);

        AgentsClient agentsClient = builder.buildAgentsClient();
        ResponsesClient responsesClient = builder.buildResponsesClient();

        // Create code interpreter tool
        CodeInterpreterTool codeInterpreter = new CodeInterpreterTool();

        // Create agent with code interpreter for data visualization
        PromptAgentDefinition agentDefinition = new PromptAgentDefinition("gpt-5-mini")
            .setInstructions("You are a data visualization assistant. When asked to create charts, "
                + "write and run Python code using matplotlib to generate them.")
            .setTools(Collections.singletonList(codeInterpreter));

        AgentVersionDetails agent = agentsClient.createAgentVersion("chart-agent", agentDefinition);

        // Request a bar chart with inline data
        AgentReference agentReference = new AgentReference(agent.getName())
            .setVersion(agent.getVersion());

        Response response = responsesClient.createAzureResponse(
            new AzureCreateResponseOptions().setAgentReference(agentReference),
            ResponseCreateParams.builder()
                .input("Create a bar chart showing quarterly revenue for 2025: "
                    + "Q1=$2.1M, Q2=$2.8M, Q3=$3.2M, Q4=$2.9M. "
                    + "Use a blue color scheme, add data labels on each bar, "
                    + "and title the chart 'Quarterly Revenue 2025'. "
                    + "Save the chart as a PNG file."));

        System.out.println("Response: " + response.output());

        // Clean up
        agentsClient.deleteAgentVersion(agent.getName(), agent.getVersion());
    }
}

Očekávaný výstup

Response: Here is the bar chart showing quarterly revenue for 2025 with Q1 ($2.1M), Q2 ($2.8M), Q3 ($3.2M), and Q4 ($2.9M) displayed in blue with data labels.

Agent vytvoří relaci pro interpretaci kódu, zapíše Python kód pomocí knihovny matplotlib k vygenerování grafu a spustí kód v izolovaném prostředí sandbox. Příklad, který nahraje soubor CSV a stáhne vygenerovaný graf, vyberte Python nebo TypeScript v horní části tohoto článku. Další příklady najdete v ukázkách Azure AI Agents Java SDK.

Vytvoření grafu s interpretem kódu pomocí rozhraní REST API

Následující příklad ukazuje, jak nahrát soubor CSV, vytvořit agenta s interpretem kódu, požádat o graf a stáhnout vygenerovaný soubor.

Požadavky

Nastavte tyto proměnné prostředí:

  • FOUNDRY_PROJECT_ENDPOINT: Adresa URL koncového bodu projektu.
  • AGENT_TOKEN: Nosný token pro Foundry.

Získání přístupového tokenu:

export AGENT_TOKEN=$(az account get-access-token --scope "https://ai.azure.com/.default" --query accessToken -o tsv)

1. Nahrání souboru CSV

curl -X POST "$FOUNDRY_PROJECT_ENDPOINT/openai/v1/files" \
  -H "Authorization: Bearer $AGENT_TOKEN" \
  -F "purpose=assistants" \
  -F "file=@quarterly_results.csv"

Uložte id z odpovědi (například file-abc123).

2. Vytvoření agenta s interpretem kódu

curl -X POST "$FOUNDRY_PROJECT_ENDPOINT/agents?api-version=v1" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $AGENT_TOKEN" \
  -d '{
    "name": "chart-agent",
    "definition": {
      "kind": "prompt",
      "model": "<MODEL_DEPLOYMENT>",
      "instructions": "You are a data visualization assistant. When asked to create charts, write and run Python code using matplotlib to generate them.",
      "tools": [
        {
          "type": "code_interpreter",
          "container": {
            "type": "auto",
            "file_ids": ["<FILE_ID>"]
          }
        }
      ]
    }
  }'

3. Vygenerování grafu

curl -X POST "$FOUNDRY_PROJECT_ENDPOINT/openai/v1/responses" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $AGENT_TOKEN" \
  -d '{
    "agent_reference": {"type": "agent_reference", "name": "chart-agent"},
    "input": "Create a bar chart of operating profit by quarter from the uploaded CSV file. Use a blue color scheme and add data labels."
  }'

Odpověď obsahuje container_file_citation poznámky s podrobnostmi vygenerovaného souboru. Uložte hodnoty container_id a hodnoty file_id z anotace.

4. Stáhněte si vygenerovaný graf.

curl -X GET "$FOUNDRY_PROJECT_ENDPOINT/openai/v1/containers/<CONTAINER_ID>/files/<FILE_ID>/content" \
  -H "Authorization: Bearer $AGENT_TOKEN" \
  --output chart.png

5. Vyčistěte

curl -X DELETE "$FOUNDRY_PROJECT_ENDPOINT/agents/chart-agent?api-version=v1" \
  -H "Authorization: Bearer $AGENT_TOKEN"

Kontrola dostupnosti oblastí a modelů

Dostupnost nástrojů se liší podle oblasti a modelu.

Aktuální seznam podporovaných oblastí a modelů pro interpret kódu najdete v tématu Best postupy pro používání nástrojů ve službě Microsoft Foundry Agent Service.

Podporované typy souborů

Formát souboru typ MIME
.c text/x-c
.cpp text/x-c++
.csv application/csv
.docx application/vnd.openxmlformats-officedocument.wordprocessingml.document
.html text/html
.java text/x-java
.json application/json
.md text/markdown
.pdf application/pdf
.php text/x-php
.pptx application/vnd.openxmlformats-officedocument.presentationml.presentation
.py text/x-python
.py text/x-script.python
.rb text/x-ruby
.tex text/x-tex
.txt text/plain
.css text/css
.jpeg image/jpeg
.jpg image/jpeg
.js text/javascript
.gif image/gif
.png image/png
.tar application/x-tar
.ts application/typescript
.xlsx application/vnd.openxmlformats-officedocument.spreadsheetml.sheet
.xml application/xml Nebo text/xml
.zip application/zip

Řešení potíží

Problém Pravděpodobná příčina Rozlišení
Interpret kódu se nespustí. Nástroj není povolený nebo model ho ve vaší oblasti nepodporuje. Ověřte, že je v agentu povolený interpret kódu. Ověřte, že nasazení modelu podporuje nástroj ve vaší oblasti. Viz Kontrola dostupnosti oblastí a modelů.
Negeneruje se žádný soubor. Agent vrátil odpověď pouze na text bez poznámky k souboru. Zkontrolujte poznámky odpovědí pro container_file_citation. Pokud žádný neexistuje, agent nevygeneroval soubor. Přeformulujte výzvu tak, aby explicitně požadovala výstup souboru.
Nahrávání souborů se nezdaří. Nepodporovaný typ souboru nebo nesprávný účel Ověřte, že je typ souboru v seznamu podporovaných typů souborů . Nahrání pomocí purpose="assistants".
Vygenerovaný soubor je poškozený nebo prázdný. Chyba spuštění kódu nebo neúplné zpracování Zkontrolujte chybovou zprávu agenta. Ověřte platnost vstupních dat. Nejprve zkuste jednodušší požadavek.
Časový limit relace nebo vysoká latence Sezení interpreta kódu mají časové limity. Relace mají 1hodinový aktivní časový limit a 30minutový časový limit nečinnosti. Snižte složitost operací nebo rozdělení na menší úlohy.
Neočekávané fakturační poplatky. Bylo vytvořeno několik souběžných relací. Každá konverzace vytvoří samostatnou relaci. Snažte se monitorovat využití relací a konsolidovat operace, pokud je to možné.
Python balíček není k dispozici. Interpret kódu má pevnou sadu balíčků. Interpret kódu zahrnuje běžné balíčky datových věd. Pro vlastní balíčky použijte interpret vlastního kódu.
Stažení souboru se nezdaří. ID kontejneru nebo ID souboru je nesprávné. Ověřte, že používáte správné container_id a file_id z poznámek odpovědí.

Vyčištění prostředků

Odstraňte prostředky, které jste vytvořili v této ukázce, pokud je už nepotřebujete, abyste se vyhnuli průběžným nákladům:

  • Odstraňte verzi agenta.
  • Odstraňte konverzaci.
  • Odstraňte nahrané soubory.

Příklady vzorů pro čištění konverzací a souborů najdete v nástroji pro vyhledávání na webu a nástroj vyhledávání souborů pro agenty.

Izolované spouštěcí prostředí (sandbox)

Interpret kódu spouští Python kód v sandboxu spravovaném Microsoft. Sandbox je navržený pro spouštění nedůvěryhodného kódu a používá dynamické relace (relace interpretu kódu) v Azure Container Apps. Každá relace je izolovaná Hyper-V hranicí.

Klíčové chování při plánování:

  • Region: Sandbox interpretu kódu běží ve stejné oblasti Azure jako váš projekt Foundry.
  • Životnost relace: Relace interpretu kódu je aktivní až jednu hodinu s časovým limitem nečinnosti (viz Důležitá poznámka na začátku tohoto článku).
  • Izolace: Každá relace se spouští v izolovaném prostředí. Pokud váš agent vyvolá interpret kódu souběžně v různých konverzacích, vytvoří se samostatné relace.
  • Izolace sítě a přístup k internetu: Sandbox nedědí konfiguraci podsítě agenta a dynamické relace nemůžou provádět odchozí síťové požadavky.
  • Soubory v sandboxu: Modul runtime Python v izolovaném prostoru má přístup k souborům, které připojíte k analýze. Interpret kódu může také generovat soubory, jako jsou grafy, a vracet je jako výstupy ke stažení.

Pokud potřebujete větší kontrolu nad modulem runtime sandboxu nebo potřebujete jiný model izolace, přečtěte si téma Vlastní nástroj pro interpret kódu pro agenty.

Související obsah

  • Last updated on