Strumento di interprete del codice per gli agenti Microsoft Foundry

Esempio di uso dell'agente con lo strumento di interprete del codice in Python SDK

L'esempio Python seguente illustra come creare un agente con lo strumento dell'interprete del codice, caricare un file CSV per l'analisi e richiedere un grafico a barre in base ai dati. Illustra un flusso di lavoro completo: caricare un file, creare un agente con l'interprete del codice abilitato, richiedere la visualizzazione dei dati e scaricare il grafico generato.

Impostare queste variabili di ambiente:

• FOUNDRY_PROJECT_ENDPOINT
• FOUNDRY_MODEL_DEPLOYMENT_NAME

import os
from dotenv import load_dotenv
from azure.identity import DefaultAzureCredential
from azure.ai.projects import AIProjectClient
from azure.ai.projects.models import PromptAgentDefinition, CodeInterpreterTool, CodeInterpreterContainerAuto

load_dotenv()

# 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")
)

endpoint = os.environ["FOUNDRY_PROJECT_ENDPOINT"]

with (
    DefaultAzureCredential() as credential,
    AIProjectClient(endpoint=endpoint, credential=credential) as project_client,
    project_client.get_openai_client() as openai_client,
):

    # Upload the CSV file for the code interpreter to use
    file = openai_client.files.create(purpose="assistants", file=open(asset_file_path, "rb"))
    print(f"File uploaded (id: {file.id})")

    # Create agent with code interpreter tool
    agent = project_client.agents.create_version(
        agent_name="MyAgent",
        definition=PromptAgentDefinition(
            model=os.environ["FOUNDRY_MODEL_DEPLOYMENT_NAME"],
            instructions="You are a helpful assistant.",
            tools=[CodeInterpreterTool(container=CodeInterpreterContainerAuto(file_ids=[file.id]))],
        ),
        description="Code interpreter agent for data analysis and visualization.",
    )
    print(f"Agent created (id: {agent.id}, name: {agent.name}, version: {agent.version})")

    # Create a conversation for the agent interaction
    conversation = openai_client.conversations.create()
    print(f"Created conversation (id: {conversation.id})")

    # Send request to create a chart and generate a file
    response = openai_client.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"}},
    )
    print(f"Response completed (id: {response.id})")

    # 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})")

    print("\nCleaning up...")
    project_client.agents.delete_version(agent_name=agent.name, agent_version=agent.version)
    print("Agent deleted")

    # Download the generated file if available
    if file_id and filename:
        file_content = openai_client.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")

Output previsto

Il codice di esempio genera un output simile all'esempio seguente:

File uploaded (id: file-xxxxxxxxxxxxxxxxxxxx)
Agent created (id: agent-xxxxxxxxxxxxxxxxxxxx, name: MyAgent, version: 1)
Created conversation (id: conv-xxxxxxxxxxxxxxxxxxxx)
Response completed (id: resp-xxxxxxxxxxxxxxxxxxxx)
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

L'agente carica il file CSV in Archiviazione di Azure, crea un ambiente Python in modalità sandbox, analizza i dati per filtrare i record del settore dei trasporti, genera un grafico a barre PNG che mostra i profitti operativi per trimestre e scarica il grafico nella directory locale. Le annotazioni di file nella risposta forniscono l'ID file e le informazioni sul contenitore necessarie per recuperare il grafico generato.

Esempio di uso dell'agente con interprete del codice e allegato di file in C# SDK

L'esempio C# seguente illustra come creare un agente con lo strumento dell'interprete del codice e chiedergli di risolvere un'equazione matematica. Sostituire i valori delle variabili di ambiente (FOUNDRY_PROJECT_ENDPOINT, FOUNDRY_MODEL_DEPLOYMENT_NAME) con i dettagli effettivi della risorsa. L'agente esegue il codice Python in un contenitore in modalità sandbox per calcolare la soluzione. Il codice usa chiamate sincrone per semplicità. Per l'utilizzo asincrono, vedere l'esempio di codice nel repository Azure SDK per .NET in GitHub.

// Create project client and read the environment variables, which will be used in the next steps.
var projectEndpoint = System.Environment.GetEnvironmentVariable("FOUNDRY_PROJECT_ENDPOINT");
var modelDeploymentName = System.Environment.GetEnvironmentVariable("FOUNDRY_MODEL_DEPLOYMENT_NAME");
AIProjectClient projectClient = new(endpoint: new Uri(projectEndpoint), tokenProvider: new DefaultAzureCredential());

// Create Agent, capable to use Code Interpreter to answer questions.
PromptAgentDefinition agentDefinition = new(model: modelDeploymentName)
{
    Instructions = "You are a helpful agent that can help fetch data from files you know about.",
    Tools = {
        ResponseTool.CreateCodeInterpreterTool(
            new CodeInterpreterToolContainer(
                CodeInterpreterToolContainerConfiguration.CreateAutomaticContainerConfiguration(
                    fileIds: []
                )
            )
        ),
    }
};
AgentVersion agentVersion = projectClient.Agents.CreateAgentVersion(
    agentName: "myAgent",
    options: new(agentDefinition));

// Ask the agent a question, which requires running python code in the container.
AgentReference agentReference = new(name: agentVersion.Name, version: agentVersion.Version);
ProjectResponsesClient responseClient = projectClient.OpenAI.GetProjectResponsesClientForAgent(agentReference);

ResponseResult response = responseClient.CreateResponse("I need to solve the equation sin(x) + x^2 = 42");

// Write out the output of a response, raise the exception if the request was not successful.
Assert.That(response.Status, Is.EqualTo(ResponseStatus.Completed));
Console.WriteLine(response.GetOutputText());

// Clean up resources by deleting conversations and the Agent.
projectClient.Agents.DeleteAgentVersion(agentName: agentVersion.Name, agentVersion: agentVersion.Version);

Output previsto

Il codice di esempio genera un output simile all'esempio seguente:

Response completed (id: resp-xxxxxxxxxxxxxxxxxxxx)
The solution to the equation sin(x) + x^2 = 42 is approximately x = 6.324555320336759

L'agente crea una sessione dell'interprete del codice, scrive codice Python per risolvere l'equazione numericamente, esegue il codice in un ambiente in modalità sandbox e restituisce il risultato calcolato. L'agente affina in modo iterativo il relativo approccio se il codice iniziale non produce una soluzione valida.

Esempio di uso dell'agente con lo strumento di interprete del codice in TypeScript SDK

L'esempio TypeScript seguente illustra come creare un agente con lo strumento dell'interprete del codice, caricare un file CSV per l'analisi e richiedere un grafico a barre in base ai dati. Per una versione JavaScript, vedere l'esempio JavaScript nel repository Azure SDK per JavaScript in GitHub.

Impostare queste variabili di ambiente:

• FOUNDRY_PROJECT_ENDPOINT
• FOUNDRY_MODEL_DEPLOYMENT_NAME

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";
import "dotenv/config";

const projectEndpoint = process.env["FOUNDRY_PROJECT_ENDPOINT"] || "<project endpoint>";
const deploymentName =
  process.env["FOUNDRY_MODEL_DEPLOYMENT_NAME"] || "<model deployment name>";

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

export async function main(): Promise<void> {
  // Create AI Project client
  const project = new AIProjectClient(projectEndpoint, new DefaultAzureCredential());
  const openAIClient = await project.getOpenAIClient();

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

  console.log("Uploading CSV file...");
  const uploadedFile = await openAIClient.files.create({
    file: fileStream,
    purpose: "assistants",
  });
  console.log(`File uploaded (id: ${uploadedFile.id})`);

  // Create agent with Code Interpreter tool
  console.log("Creating agent with Code Interpreter tool...");
  const agent = await project.agents.createVersion("MyAgent", {
    kind: "prompt",
    model: deploymentName,
    instructions: "You are a helpful assistant.",
    tools: [
      {
        type: "code_interpreter",
        container: {
          type: "auto",
          file_ids: [uploadedFile.id],
        },
      },
    ],
  });
  console.log(`Agent created (id: ${agent.id}, name: ${agent.name}, version: ${agent.version})`);

  // Create a conversation
  const conversation = await openAIClient.conversations.create();
  console.log(`Created conversation (id: ${conversation.id})`);

  // Request chart generation
  console.log("\nRequesting chart generation...");
  const response = await openAIClient.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" } },
    },
  );
  console.log(`Response completed (id: ${response.id})`);

  // 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 openAIClient.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
  console.log("\nCleaning up...");
  await project.agents.deleteVersion(agent.name, agent.version);
  console.log("Agent deleted");

  console.log("\nCode Interpreter sample completed!");
}

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

Output previsto

Il codice di esempio genera un output simile all'esempio seguente:

Uploading CSV file...
File uploaded (id: file-xxxxxxxxxxxxxxxxxxxx)
Creating agent with Code Interpreter tool...
Agent created (id: agent-xxxxxxxxxxxxxxxxxxxx, name: MyAgent, version: 1)
Created conversation (id: conv-xxxxxxxxxxxxxxxxxxxx)

Requesting chart generation...
Response completed (id: resp-xxxxxxxxxxxxxxxxxxxx)
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

Cleaning up...
Agent deleted

Code Interpreter sample completed!

L'agente carica il file CSV in Archiviazione di Azure, crea un ambiente Python in modalità sandbox, analizza i dati per filtrare i record del settore dei trasporti, genera un grafico a barre PNG che mostra i profitti operativi per trimestre e scarica il grafico nella directory locale. Le annotazioni di file nella risposta forniscono l'ID file e le informazioni sul contenitore necessarie per recuperare il grafico generato.