Dela via

Skapa strukturerade utdata med agenter

Det här självstudiesteget visar hur du skapar strukturerade utdata med en agent, där agenten bygger på tjänsten Azure OpenAI Chat Completion.

Viktigt!

Alla agenttyper stöder inte strukturerade utdata. I det här steget används en ChatClientAgent, som stöder strukturerade utdata.

Förutsättningar

Förutsättningar och installation av NuGet-paket finns i steget Skapa och kör en enkel agent i den här självstudien.

Skapa agenten med strukturerade utdata

ChatClientAgent bygger på någon IChatClient-implementering. ChatClientAgent Använder stöd för strukturerade utdata som tillhandahålls av den underliggande chattklienten.

När du skapar agenten har du möjlighet att ange den standardinstans ChatOptions som ska användas för den underliggande chattklienten. Med den här ChatOptions instansen kan du välja en önskad ChatResponseFormat.

Det finns olika alternativ för ResponseFormat :

I det här exemplet skapas en agent som producerar strukturerade utdata i form av ett JSON-objekt som överensstämmer med ett specifikt schema.

Det enklaste sättet att skapa schemat är att definiera en typ som representerar strukturen för de utdata som du vill använda från agenten och sedan använda AIJsonUtilities.CreateJsonSchema metoden för att skapa ett schema från typen.

using System.Text.Json;
using System.Text.Json.Serialization;
using Microsoft.Extensions.AI;

public class PersonInfo
{
    public string? Name { get; set; }
    public int? Age { get; set; }
    public string? Occupation { get; set; }
}

JsonElement schema = AIJsonUtilities.CreateJsonSchema(typeof(PersonInfo));

Du kan sedan skapa en ChatOptions instans som använder det här schemat för svarsformatet.

using Microsoft.Extensions.AI;

ChatOptions chatOptions = new()
{
    ResponseFormat = ChatResponseFormat.ForJsonSchema(
        schema: schema,
        schemaName: "PersonInfo",
        schemaDescription: "Information about a person including their name, age, and occupation")
};

Den här ChatOptions instansen kan användas när agenten skapas.

using System;
using Azure.AI.OpenAI;
using Azure.Identity;
using Microsoft.Agents.AI;
using OpenAI;

AIAgent agent = new AzureOpenAIClient(
    new Uri("https://<myresource>.openai.azure.com"),
    new AzureCliCredential())
        .GetChatClient("gpt-4o-mini")
        .CreateAIAgent(new ChatClientAgentOptions()
        {
            Name = "HelpfulAssistant",
            Instructions = "You are a helpful assistant.",
            ChatOptions = chatOptions
        });

Nu kan du bara köra agenten med viss textinformation som agenten kan använda för att fylla i de strukturerade utdata.

var response = await agent.RunAsync("Please provide information about John Smith, who is a 35-year-old software engineer.");

Agentsvaret kan sedan deserialiseras till PersonInfo klassen med hjälp av Deserialize<T> metoden för svarsobjektet.

var personInfo = response.Deserialize<PersonInfo>(JsonSerializerOptions.Web);
Console.WriteLine($"Name: {personInfo.Name}, Age: {personInfo.Age}, Occupation: {personInfo.Occupation}");

Vid direktuppspelning strömmas agentsvaret som en serie uppdateringar och du kan bara deserialisera svaret när alla uppdateringar har tagits emot. Du måste sammanställa alla uppdateringar i ett enda svar innan du deserialiserar det.

var updates = agent.RunStreamingAsync("Please provide information about John Smith, who is a 35-year-old software engineer.");
personInfo = (await updates.ToAgentRunResponseAsync()).Deserialize<PersonInfo>(JsonSerializerOptions.Web);

Det här självstudiesteget visar hur du skapar strukturerade utdata med en agent, där agenten bygger på tjänsten Azure OpenAI Chat Completion.

Viktigt!

Alla agenttyper stöder inte strukturerade utdata. Stöder strukturerade utdata när de används med kompatibla chattklienter ChatAgent .

Förutsättningar

Förutsättningar och installation av paket finns i steget Skapa och kör en enkel agent i den här självstudien.

Skapa agenten med strukturerade utdata

ChatAgent Bygger på alla implementeringar av chattklienten som stöder strukturerade utdata. ChatAgent Använder parametern response_format för att ange önskat utdataschema.

När du skapar eller kör agenten kan du ange en Pydantisk modell som definierar strukturen för förväntade utdata.

Olika svarsformat stöds baserat på de underliggande chattklientfunktionerna.

Det här exemplet skapar en agent som producerar strukturerade utdata i form av ett JSON-objekt som överensstämmer med ett Pydantic-modellschema.

Definiera först en pydantisk modell som representerar strukturen för de utdata som du vill ha från agenten:

from pydantic import BaseModel

class PersonInfo(BaseModel):
    """Information about a person."""
    name: str | None = None
    age: int | None = None
    occupation: str | None = None

Nu kan du skapa en agent med hjälp av Azure OpenAI Chat Client:

from agent_framework.azure import AzureOpenAIChatClient
from azure.identity import AzureCliCredential

# Create the agent using Azure OpenAI Chat Client
agent = AzureOpenAIChatClient(credential=AzureCliCredential()).create_agent(
    name="HelpfulAssistant",
    instructions="You are a helpful assistant that extracts person information from text."
)

Nu kan du köra agenten med viss textinformation och ange det strukturerade utdataformatet med hjälp av parametern response_format :

response = await agent.run(
    "Please provide information about John Smith, who is a 35-year-old software engineer.",
    response_format=PersonInfo
)

Agentsvaret innehåller strukturerade utdata i value egenskapen, som kan nås direkt som en Pydantic-modellinstans:

if response.value:
    person_info = response.value
    print(f"Name: {person_info.name}, Age: {person_info.age}, Occupation: {person_info.occupation}")
else:
    print("No structured data found in response")

Vid strömning strömmas agentsvaret som en serie uppdateringar. För att få de strukturerade utdata måste du samla in alla uppdateringar och sedan komma åt det slutliga svarsvärdet:

from agent_framework import AgentRunResponse

# Get structured response from streaming agent using AgentRunResponse.from_agent_response_generator
# This method collects all streaming updates and combines them into a single AgentRunResponse
final_response = await AgentRunResponse.from_agent_response_generator(
    agent.run_stream(query, response_format=PersonInfo),
    output_format_type=PersonInfo,
)

if final_response.value:
    person_info = final_response.value
    print(f"Name: {person_info.name}, Age: {person_info.age}, Occupation: {person_info.occupation}")

Nästa steg

Använda en agent som ett funktionsverktyg

  • Last updated on