Migrieren zur neuen Agents-Entwicklerumgebung

pip install "azure-ai-projects>=2.0.0"

dotnet add package Azure.AI.Projects --prerelease
dotnet add package Azure.AI.Projects.OpenAI --prerelease
dotnet add package Azure.Identity

npm install @azure/ai-projects@2.0.0
npm install @azure/identity

<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-ai-agents</artifactId>
    <version>2.0.0-beta.2</version>
</dependency>
<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-identity</artifactId>
    <version>1.15.4</version>
</dependency>

from azure.identity import DefaultAzureCredential
from azure.ai.projects import AIProjectClient

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

project = AIProjectClient(
    endpoint=PROJECT_ENDPOINT,
    credential=DefaultAzureCredential(),
)
openai = project.get_openai_client()

using Azure.AI.Projects;
using Azure.AI.Projects.OpenAI;
using Azure.Identity;

AIProjectClient projectClient = new(
    new Uri(Environment.GetEnvironmentVariable(
        "PROJECT_ENDPOINT")!),
    new DefaultAzureCredential());

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

const projectClient = new AIProjectClient(
    process.env["PROJECT_ENDPOINT"],
    new DefaultAzureCredential()
);
const openAIClient = await projectClient
    .getOpenAIClient();

import com.azure.ai.agents.AgentsClient;
import com.azure.ai.agents.AgentsClientBuilder;
import com.azure.identity.DefaultAzureCredentialBuilder;

AgentsClient agentsClient =
    new AgentsClientBuilder()
        .credential(
            new DefaultAzureCredentialBuilder()
                .build())
        .endpoint(System.getenv(
            "PROJECT_ENDPOINT"))
        .buildAgentsClient();

thread = client.agents.threads.create( 
     messages=[{"role": "user", "content": "Tell me a one line funny story about unicorns"}], 
     metadata={"agent": "my-awesome-agent"}, 
) 

AgentThread thread =
    await agentsClient.CreateThreadAsync(
        messages: new[]
        {
            new ThreadMessageOptions(
                MessageRole.User,
                "Tell me a one line funny "
                + "story about unicorns")
        },
        metadata:
            new Dictionary<string, string>
        {
            ["agent"] = "my-awesome-agent"
        });

const thread =
    await client.agents.createThread({
        messages: [
            {
                role: "user",
                content:
                    "Tell me a one line funny "
                    + "story about unicorns",
            },
        ],
        metadata: {
            agent: "my-awesome-agent",
        },
    });

AgentThread thread =
    agentsClient.createThread(
        new CreateThreadOptions()
            .setMessages(Arrays.asList(
                new ThreadMessageOptions(
                    MessageRole.USER,
                    "Tell me a one line "
                    + "funny story about "
                    + "unicorns")))
            .setMetadata(Map.of(
                "agent",
                "my-awesome-agent")));

conversation = openai.conversations.create(
    items=[
        {
            "type": "message",
            "role": "user",
            "content": "Tell me a one line funny "
                       "story about unicorns",
        }
    ],
    metadata={"agent": "my-awesome-agent"},
)

ProjectResponsesClient responsesClient =
    projectClient.OpenAI
        .GetProjectResponsesClientForAgent(
            new AgentReference
            {
                Name = "my-awesome-agent"
            });

var result = responsesClient.CreateResponse(
    "Tell me a one line funny story "
    + "about unicorns");

const conversation =
    await openAIClient.conversations.create({
        items: [
            {
                type: "message",
                role: "user",
                content:
                    "Tell me a one line funny "
                    + "story about unicorns",
            },
        ],
        metadata: { agent: "my-awesome-agent" },
    });

ResponsesClient responsesClient =
    new AgentsClientBuilder()
        .credential(
            new DefaultAzureCredentialBuilder()
                .build())
        .endpoint(System.getenv(
            "PROJECT_ENDPOINT"))
        .buildResponsesClient();

AgentReference agentRef = new AgentReference("my-agent");

Response result = responsesClient.createWithAgent(
    agentRef,
    ResponseCreateParams.builder()
        .input("Tell me a one line funny story about unicorns"));

message = client.agents.messages.create(
    thread_id=thread.id,
    role="user",
    content="Follow-up question about the same topic",
)

ThreadMessage message =
    await agentsClient.CreateMessageAsync(
        thread.Id,
        MessageRole.User,
        "Follow-up question about "
        + "the same topic");

const message =
    await client.agents.createMessage(
        thread.id,
        {
            role: "user",
            content:
                "Follow-up question about "
                + "the same topic",
        }
    );

ThreadMessage message =
    agentsClient.createMessage(
        thread.getId(),
        new CreateMessageOptions(
            MessageRole.USER,
            "Follow-up question about "
            + "the same topic"));

openai.conversations.items.create(
    conversation_id=conversation.id,
    items=[
        {
            "type": "message",
            "role": "user",
            "content": "Follow-up question "
                       "about the same topic",
        }
    ],
)

// In C#, send follow-up input directly
// through the responses client.
var followUp = responsesClient.CreateResponse(
    "Follow-up question about the same topic");

await openAIClient.conversations.items.create(
    conversation.id,
    {
        items: [
            {
                type: "message",
                role: "user",
                content:
                    "Follow-up question "
                    + "about the same topic",
            },
        ],
    }
);

// In Java, send follow-up input directly
AgentReference agentRef = new AgentReference("my-agent");

Response result = responsesClient.createWithAgent(
    agentRef,
    ResponseCreateParams.builder()
        .input("Follow-up question "
        + "about the same topic"));

thread_id = "thread_abcd1234" 
assistant_id = "asst_efgh5678" 
run = project_client.agents.runs.create( 
  thread_id=thread_id,  
  agent_id=assistant_id, 
  additional_instructions="Please address the user as Jane Doe. The user has a premium account" 
) 
while run.status in ("queued", "in_progress"): 
  time.sleep(1) 
  run = project_client.agents.runs.get(thread_id=thread_id, run_id=run.id) 

string threadId = "thread_abcd1234";
string assistantId = "asst_efgh5678";

ThreadRun run =
    await agentsClient.CreateRunAsync(
        threadId, assistantId);

while (run.Status == RunStatus.Queued
    || run.Status ==
        RunStatus.InProgress)
{
    await Task.Delay(1000);
    run = await agentsClient.GetRunAsync(
        threadId, run.Id);
}

const threadId = "thread_abcd1234";
const assistantId = "asst_efgh5678";

let run = await client.agents.createRun(
    threadId, assistantId);

while (run.status === "queued"
    || run.status === "in_progress") {
    await new Promise(
        (r) => setTimeout(r, 1000));
    run = await client.agents.getRun(
        threadId, run.id);
}

String threadId = "thread_abcd1234";
String assistantId = "asst_efgh5678";

ThreadRun run =
    agentsClient.createRun(
        threadId, assistantId);

while (RunStatus.QUEUED
        .equals(run.getStatus())
    || RunStatus.IN_PROGRESS
        .equals(run.getStatus())) {
    Thread.sleep(1000);
    run = agentsClient.getRun(
        threadId, run.getId());
}

conversation_id = "conv_11112222AAAABBBB"

response = openai.responses.create(
    input="Hi, Agent! Draw a graph for a line "
          "with a slope of 4 and "
          "y-intercept of 9.",
    conversation=conversation_id,
    extra_body={
        "agent_reference": {
            "name": "my-agent",
            "type": "agent_reference",
        }
    },
)

ProjectResponsesClient responsesClient =
    projectClient.OpenAI
        .GetProjectResponsesClientForAgent(
            new AgentReference
            {
                Name = "my-agent"
            });

var result = responsesClient.CreateResponse(
    "Hi, Agent! Draw a graph for a line "
    + "with a slope of 4 and "
    + "y-intercept of 9.");

const conversationId =
    "conv_11112222AAAABBBB";

const response =
    await openAIClient.responses.create({
        input:
            "Hi, Agent! Draw a graph for a "
            + "line with a slope of 4 and "
            + "y-intercept of 9.",
        conversation: conversationId,
        agent_reference: {
            name: "my-agent",
            type: "agent_reference",
        },
    });

AgentReference agentRef = new AgentReference("my-agent");

Response result = responsesClient.createWithAgent(
    agentRef,
    ResponseCreateParams.builder()
        .input("Hi, Agent! Draw a graph for a line "
        + "with a slope of 4 and "
        + "y-intercept of 9."));

agent = client.agents.create_agent( 
    model="gpt-4.1", 
    name="my-agent",  # Name of the agent 
    instructions="You politely help with math questions. Use the Code Interpreter tool when asked to visualize numbers.",  # Instructions for the agent 
    tools=code_interpreter.definitions,  # Attach the tool 
) 

Agent agent =
    await agentsClient.CreateAgentAsync(
        model: "gpt-4.1",
        name: "my-agent",
        instructions:
            "You politely help with "
            + "math questions. Use the "
            + "Code Interpreter tool "
            + "when asked to visualize "
            + "numbers.",
        tools: new List<ToolDefinition>
        {
            new CodeInterpreterToolDefinition()
        });

const agent =
    await client.agents.createAgent(
        "gpt-4.1",
        {
            name: "my-agent",
            instructions:
                "You politely help with "
                + "math questions. Use "
                + "the Code Interpreter "
                + "tool when asked to "
                + "visualize numbers.",
            tools: [
                { type: "code_interpreter" },
            ],
        }
    );

Agent agent =
    agentsClient.createAgent("gpt-4.1",
        new CreateAgentOptions()
            .setName("my-agent")
            .setInstructions(
                "You politely help with "
                + "math questions. Use the "
                + "Code Interpreter tool "
                + "when asked to visualize "
                + "numbers.")
            .setTools(Arrays.asList(
                new CodeInterpreterToolDefinition())));

from azure.ai.projects.models import (
    CodeInterpreterTool,
    PromptAgentDefinition,
)

agent = project.agents.create_version(
    agent_name="my-agent",
    definition=PromptAgentDefinition(
        model="gpt-4.1",
        instructions=(
            "You politely help with math "
            "questions. Use the Code "
            "Interpreter tool when asked to "
            "visualize numbers."
        ),
        tools=[CodeInterpreterTool()],
    ),
)

var agent = await projectClient.Agents
    .CreateAgentVersionAsync(
        agentName: "my-agent",
        options: new(
            new PromptAgentDefinition("gpt-4.1")
            {
                Instructions =
                    "You politely help with math "
                    + "questions. Use the Code "
                    + "Interpreter tool when asked "
                    + "to visualize numbers.",
                Tools =
                {
                    new CodeInterpreterToolDefinition()
                },
            }));

const agent =
    await projectClient.agents.createVersion(
        "my-agent",
        {
            kind: "prompt",
            model: "gpt-4.1",
            instructions:
                "You politely help with math "
                + "questions. Use the Code "
                + "Interpreter tool when asked "
                + "to visualize numbers.",
            tools: [
                { type: "code_interpreter" },
            ],
        }
    );

import com.azure.ai.agents.models.PromptAgentDefinition;
import com.azure.ai.agents.models.CodeInterpreterTool;

PromptAgentDefinition definition =
    new PromptAgentDefinition("gpt-4.1");
definition.setInstructions(
    "You politely help with math questions. "
    + "Use the Code Interpreter tool when "
    + "asked to visualize numbers.");
definition.setTools(Arrays.asList(
    new CodeInterpreterTool()));

var agent = agentsClient.createAgentVersion(
    "my-agent", definition);

assistant = client.beta.assistants.create( 
    model="gpt-4.1", 
    name="my-assistant", 
    instructions="You politely help with math questions. Use the Code Interpreter tool when asked to visualize numbers.",  # Instructions for the agent 
    tools=[{"type": "code_interpreter"}], 
) 

// Using the OpenAI Assistants API
AzureOpenAIClient azureClient = new(
    new Uri(Environment.GetEnvironmentVariable(
        "AZURE_OPENAI_ENDPOINT")!),
    new DefaultAzureCredential());
AssistantClient assistantClient =
    azureClient.GetAssistantClient();

Assistant assistant =
    await assistantClient
        .CreateAssistantAsync(
            "gpt-4.1",
            new AssistantCreationOptions
            {
                Name = "my-assistant",
                Instructions =
                    "You politely help "
                    + "with math questions. "
                    + "Use the Code "
                    + "Interpreter tool "
                    + "when asked to "
                    + "visualize numbers.",
                Tools =
                {
                    new CodeInterpreterToolDefinition()
                },
            });

// Using the OpenAI Assistants API
const assistant =
    await client.beta.assistants.create({
        model: "gpt-4.1",
        name: "my-assistant",
        instructions:
            "You politely help with math "
            + "questions. Use the Code "
            + "Interpreter tool when "
            + "asked to visualize numbers.",
        tools: [{ type: "code_interpreter" }],
    });

// Using the OpenAI Assistants API
AssistantCreationOptions options =
    new AssistantCreationOptions("gpt-4.1")
        .setName("my-assistant")
        .setInstructions(
            "You politely help with math "
            + "questions. Use the Code "
            + "Interpreter tool when "
            + "asked to visualize numbers.")
        .setTools(Arrays.asList(
            new CodeInterpreterToolDefinition()));

Assistant assistant =
    agentsClient.createAssistant(options);

from azure.ai.projects.models import (
    CodeInterpreterTool,
    PromptAgentDefinition,
)

agent = project.agents.create_version(
    agent_name="my-agent",
    definition=PromptAgentDefinition(
        model="gpt-4.1",
        instructions=(
            "You politely help with math "
            "questions. Use the Code "
            "Interpreter tool when asked to "
            "visualize numbers."
        ),
        tools=[CodeInterpreterTool()],
    ),
)

var agent = await projectClient.Agents
    .CreateAgentVersionAsync(
        agentName: "my-agent",
        options: new(
            new PromptAgentDefinition("gpt-4.1")
            {
                Instructions =
                    "You politely help with math "
                    + "questions. Use the Code "
                    + "Interpreter tool when asked "
                    + "to visualize numbers.",
                Tools =
                {
                    new CodeInterpreterToolDefinition()
                },
            }));

const agent =
    await projectClient.agents.createVersion(
        "my-agent",
        {
            kind: "prompt",
            model: "gpt-4.1",
            instructions:
                "You politely help with math "
                + "questions. Use the Code "
                + "Interpreter tool when asked "
                + "to visualize numbers.",
            tools: [
                { type: "code_interpreter" },
            ],
        }
    );

import com.azure.ai.agents.models.PromptAgentDefinition;
import com.azure.ai.agents.models.CodeInterpreterTool;

PromptAgentDefinition definition =
    new PromptAgentDefinition("gpt-4.1");
definition.setInstructions(
    "You politely help with math questions. "
    + "Use the Code Interpreter tool when "
    + "asked to visualize numbers.");
definition.setTools(Arrays.asList(
    new CodeInterpreterTool()));

var agent = agentsClient.createAgentVersion(
    "my-agent", definition);

agent = project_client.agents.create_agent( 
    model="gpt-4.1", 
    name="my-agent", 
    instructions="You politely help with math questions. Use the Code Interpreter tool when asked to visualize numbers.",  # Instructions for the agent 
    tools=[{"type": "code_interpreter"}] 
) 
thread = project_client.agents.threads.create() 
message = project_client.agents.messages.create( 
    thread_id=thread.id, 
    role="user",  # Role of the message sender 
    content="Hi, Agent! Draw a graph for a line with a rate of change of 4 and y-intercept of 9.",  # Message content 
) 
run = project_client.agents.runs.create_and_process( 
    thread_id=thread.id, 
    agent_id=agent.id, 
    additional_instructions="Please address the user as Jane Doe. The user has a premium account", 
) 
messages = project_client.agents.messages.list(thread_id=thread.id) 
for message in messages: 
    print(f"Role: {message.role}, Content: {message.content}") 

// Create agent
Agent agent =
    await agentsClient.CreateAgentAsync(
        model: "gpt-4.1",
        name: "my-agent",
        instructions:
            "You politely help with "
            + "math questions. Use the "
            + "Code Interpreter tool "
            + "when asked to visualize "
            + "numbers.",
        tools: new List<ToolDefinition>
        {
            new CodeInterpreterToolDefinition()
        });

// Create thread
AgentThread thread =
    await agentsClient.CreateThreadAsync();

// Create message
await agentsClient.CreateMessageAsync(
    thread.Id,
    MessageRole.User,
    "Hi, Agent! Draw a graph for a "
    + "line with a rate of change "
    + "of 4 and y-intercept of 9.");

// Create run and poll
ThreadRun run =
    await agentsClient.CreateRunAsync(
        thread.Id,
        agent.Id);

while (run.Status ==
        RunStatus.Queued
    || run.Status ==
        RunStatus.InProgress)
{
    await Task.Delay(1000);
    run = await agentsClient.GetRunAsync(
        thread.Id,
        run.Id);
}

// Get messages
var messages = agentsClient.GetMessages(
    thread.Id);
foreach (var msg in messages)
{
    Console.WriteLine(
        $"Role: {msg.Role}, "
        + $"Content: {msg.Content}");
}

// Create agent
const agent =
    await client.agents.createAgent(
        "gpt-4.1",
        {
            name: "my-agent",
            instructions:
                "You politely help with "
                + "math questions. Use "
                + "the Code Interpreter "
                + "tool when asked to "
                + "visualize numbers.",
            tools: [
                { type: "code_interpreter" },
            ],
        }
    );

// Create thread
const thread =
    await client.agents.createThread();

// Create message
await client.agents.createMessage(
    thread.id,
    {
        role: "user",
        content:
            "Hi, Agent! Draw a graph "
            + "for a line with a rate "
            + "of change of 4 and "
            + "y-intercept of 9.",
    }
);

// Create run and poll
let run = await client.agents.createRun(
    thread.id, agent.id);

while (run.status === "queued"
    || run.status === "in_progress") {
    await new Promise(
        (r) => setTimeout(r, 1000));
    run = await client.agents.getRun(
        thread.id, run.id);
}

// Get messages
const messages =
    await client.agents.listMessages(
        thread.id);
for (const msg of messages.data) {
    console.log(
        `Role: ${msg.role}, `
        + `Content: ${msg.content}`);
}

// Create agent
Agent agent =
    agentsClient.createAgent("gpt-4.1",
        new CreateAgentOptions()
            .setName("my-agent")
            .setInstructions(
                "You politely help with "
                + "math questions. Use the "
                + "Code Interpreter tool "
                + "when asked to visualize "
                + "numbers.")
            .setTools(Arrays.asList(
                new CodeInterpreterToolDefinition())));

// Create thread
AgentThread thread =
    agentsClient.createThread();

// Create message
agentsClient.createMessage(
    thread.getId(),
    new CreateMessageOptions(
        MessageRole.USER,
        "Hi, Agent! Draw a graph for "
        + "a line with a rate of change "
        + "of 4 and y-intercept of 9."));

// Create run and poll
ThreadRun run =
    agentsClient.createRun(
        thread.getId(), agent.getId());

while (RunStatus.QUEUED
        .equals(run.getStatus())
    || RunStatus.IN_PROGRESS
        .equals(run.getStatus())) {
    Thread.sleep(1000);
    run = agentsClient.getRun(
        thread.getId(),
        run.getId());
}

// Get messages
PageableList<ThreadMessage> messages =
    agentsClient.listMessages(
        thread.getId());
for (ThreadMessage msg : messages) {
    System.out.printf(
        "Role: %s, Content: %s%n",
        msg.getRole(),
        msg.getContent());
}

from azure.ai.projects.models import (
    CodeInterpreterTool,
    PromptAgentDefinition,
)

# Create the agent
agent = project.agents.create_version(
    agent_name="my-agent",
    definition=PromptAgentDefinition(
        model="gpt-4.1",
        instructions=(
            "You politely help with math "
            "questions. Use the Code "
            "Interpreter tool when asked "
            "to visualize numbers."
        ),
        tools=[CodeInterpreterTool()],
    ),
)

# Create a conversation with initial message
conversation = openai.conversations.create(
    items=[
        {
            "type": "message",
            "role": "user",
            "content": (
                "Hi, Agent! Draw a graph "
                "for a line with a rate "
                "of change of 4 and "
                "y-intercept of 9."
            ),
        }
    ],
)

# Send a response with the agent
response = openai.responses.create(
    conversation=conversation.id,
    extra_body={
        "agent_reference": {
            "name": agent.name,
            "type": "agent_reference",
        }
    },
    input=(
        "Please address the user as "
        "Jane Doe. The user has a "
        "premium account"
    ),
)

var agent = await projectClient.Agents
    .CreateAgentVersionAsync(
        agentName: "my-agent",
        options: new(
            new PromptAgentDefinition("gpt-4.1")
            {
                Instructions =
                    "You politely help with math "
                    + "questions. Use the Code "
                    + "Interpreter tool when asked "
                    + "to visualize numbers.",
                Tools =
                {
                    new CodeInterpreterToolDefinition()
                },
            }));

ProjectResponsesClient responsesClient =
    projectClient.OpenAI
        .GetProjectResponsesClientForAgent(
            new AgentReference
            {
                Name = "my-agent"
            });

var result = responsesClient.CreateResponse(
    "Hi, Agent! Draw a graph for a line "
    + "with a rate of change of 4 and "
    + "y-intercept of 9. Please address the "
    + "user as Jane Doe. The user has a "
    + "premium account");

const agent =
    await projectClient.agents.createVersion(
        "my-agent",
        {
            kind: "prompt",
            model: "gpt-4.1",
            instructions:
                "You politely help with math "
                + "questions. Use the Code "
                + "Interpreter tool when asked "
                + "to visualize numbers.",
            tools: [
                { type: "code_interpreter" },
            ],
        }
    );

const openAIClient =
    await projectClient.getOpenAIClient();

const conversation =
    await openAIClient.conversations.create({
        items: [
            {
                type: "message",
                role: "user",
                content:
                    "Hi, Agent! Draw a graph "
                    + "for a line with a rate "
                    + "of change of 4 and "
                    + "y-intercept of 9.",
            },
        ],
    });

const response =
    await openAIClient.responses.create({
        input:
            "Please address the user as "
            + "Jane Doe. The user has a "
            + "premium account",
        conversation: conversation.id,
        agent_reference: {
            name: agent.name,
            type: "agent_reference",
        },
    });

import com.azure.ai.agents.models.PromptAgentDefinition;
import com.azure.ai.agents.models.CodeInterpreterTool;

PromptAgentDefinition definition =
    new PromptAgentDefinition("gpt-4.1");
definition.setInstructions(
    "You politely help with math questions. "
    + "Use the Code Interpreter tool when "
    + "asked to visualize numbers.");
definition.setTools(Arrays.asList(
    new CodeInterpreterTool()));

var agent = agentsClient.createAgentVersion(
    "my-agent", definition);

ResponsesClient responsesClient =
    new AgentsClientBuilder()
        .credential(
            new DefaultAzureCredentialBuilder()
                .build())
        .endpoint(System.getenv(
            "PROJECT_ENDPOINT"))
        .buildResponsesClient();

AgentReference agentRef = new AgentReference("my-agent");

Response result = responsesClient.createWithAgent(
    agentRef,
    ResponseCreateParams.builder()
        .input("Hi, Agent! Draw a graph for a line "
        + "with a rate of change of 4 and "
        + "y-intercept of 9. Please address "
        + "the user as Jane Doe. The user "
        + "has a premium account"));