Etken uygulama desenleri

Yapay zeka ile aracı uygulamalar oluşturmaya yönelik iki genel yaklaşım vardır:

  • Deterministic iş akışları — Kodunuz denetim akışını tanımlar. Standart programlama yapılarını kullanarak adım dizisini, dallanmayı, paralelliği ve hata işlemeyi yazarsınız. LLM her adımda çalışma gerçekleştirir ancak genel akışı denetlemez.
  • Aracı tarafından yönlendirilen iş akışları (aracı döngüleri) — DENETIM akışını LLM yönetir. Ajan, hangi araçları çağıracağına, hangi sırayla ve görevin ne zaman tamamlanacağına karar verir. Araçlar ve yönergeler sağlarsınız, ancak etken çalışma zamanı icra yolunu belirler.

Her iki yaklaşım da dayanıklı yürütmeden yararlanılır ve Dayanıklı Görev programlama modeli kullanılarak uygulanabilir. Bu makalede C#, Python, JavaScript/TypeScript ve Java'de kullanıma hazır kod örnekleriyle her desenin nasıl derlenmeleri gösterilmektedir.

Tavsiye

Prerequisites: Bu desenleri kullanmadan önce Dayanıklı Görev SDK'larını veya Dayanıklı İşlevler ayarlayın. Başlamak için bkz. SDK'ye genel bakış veya Dayanıklı İşlevler genel bakış.

Bu sayfada:

Tavsiye

Bu desenler, Antropik'in Etkili Aracılar Oluşturma bölümünde açıklanan aracı iş akışı tasarımlarıyla uyumludur. Dayanıklı Görev programlama modeli doğal olarak şu desenlerle eşlenir: düzenlemeler iş akışı denetim akışını tanımlar ve otomatik olarak denetim noktalarına eklenirken etkinlikler LLM çağrıları, araç çağrıları ve API istekleri gibi belirlenimci olmayan işlemleri sarmalar.

Bir yaklaşım seçin

Aşağıdaki tablo, her yaklaşımı ne zaman kullanacağınıza karar vermenize yardımcı olur.

Belirleyici iş akışlarını şu durumlarda kullan:... Aracı döngülerini şu durumlarda kullan:...
Adım dizisi önceden bilinir. Görev açık uçludur ve adımlar tahmin edilemez.
Aracı davranışı üzerinde açık korumalara ihtiyacınız vardır. LLM'nin hangi araçların ve ne zaman kullanılacağına karar vermesini istiyorsunuz.
Uyumluluk veya denetlenebilirlik, gözden geçirilebilir denetim akışı gerektirir. Ajanın yaklaşımını ara sonuçlara göre uyarlaması gerekir.
Birden çok yapay zeka çerçevesini tek bir iş akışında birleştirmek istiyorsunuz. Araç arama özelliklerine sahip bir konuşma aracısı oluşturuyorsunuz.

Her iki yaklaşım da dayanıklı yürütme aracılığıyla otomatik denetim noktası oluşturma, yeniden deneme ilkeleri, dağıtılmış ölçeklendirme ve döngüde insan desteği sağlar.

Deterministik iş akışı desenleri

Belirleyici bir iş akışında kodunuz yürütme yolunu denetler. LLM, iş akışı içinde bir adım olarak çağrılır, ancak bundan sonra ne olacağına karar vermez. Dayanıklı Görev programlama modeli doğal olarak bu yaklaşımla eşler:

  • Düzenlemeler iş akışı denetim akışını (sıra, dallanma, paralellik, hata işleme) tanımlar ve otomatik olarak denetim noktaları oluşturulur.
  • Etkinlikler LLM çağrıları, araç çağrıları ve API istekleri gibi belirlenimci olmayan işlemleri sarmalar. Etkinlikler kullanılabilir herhangi bir işlem örneğinde çalıştırılabilir.

Aşağıdaki örneklerde sunucusuz barındırma ile Azure İşlevleri üzerinde çalışan Dayanıklı İşlevler kullanılır.

Aşağıdaki örneklerde, Azure Container Apps, Kubernetes, sanal makineler veya yerel olarak dahil olmak üzere tüm konak işlemlerinde çalışan taşınabilir Durable Görev SDK'ları kullanılır.

İstem zincirleme deseni

İstem zincirleme en basit aracı desendir. Karmaşık bir görevi, her adımın çıkışının bir sonraki adımın girişine beslendiği sıralı LLM etkileşimleri dizisine bölersiniz. Her etkinlik çağrısı otomatik olarak denetim noktası oluşturulduğundan, işlem hattı boyunca meydana gelen bir çökme sizi sıfırdan yeniden başlatmaya ve pahalı LLM belirteçlerini yeniden tüketmeye zorlamaz; yürütme, son tamamlanan adımdan devam eder.

Adımlar arasına programlı doğrulama geçitleri de ekleyebilirsiniz. Örneğin, bir ana hat oluşturarak taslak oluşturma adımına geçirmeden önce bir uzunluk veya konu kısıtlamasını karşıladığını doğrulayabilirsiniz.

Bu desen, Dayanıklı Görev programlama modelindeki işlev zincirleme desenine doğrudan eşler.

Ne zaman kullanılır: İçerik oluşturma işlem hatları, çok adımlı belge işleme, sıralı veri zenginleştirme, ara doğrulama geçitleri gerektiren iş akışları.

Uyarı

Aşağıdaki tüm örneklerde, düzenleme durumu her await/yield deyimde otomatik olarak denetlendi. Ana işlem kilitlenir ve VM yeniden başlarsa, orkestrasyon baştan başlamak yerine son tamamlanan adımdan devam eder.

[Function(nameof(PromptChainingOrchestration))]
public async Task<string> PromptChainingOrchestration(
    [OrchestrationTrigger] TaskOrchestrationContext context)
{
    var topic = context.GetInput<string>();

    // Step 1: Generate research outline
    string outline = await context.CallActivityAsync<string>(
        nameof(GenerateOutlineAgent), topic);

    // Step 2: Write first draft from outline
    string draft = await context.CallActivityAsync<string>(
        nameof(WriteDraftAgent), outline);

    // Step 3: Refine and polish the draft
    string finalContent = await context.CallActivityAsync<string>(
        nameof(RefineDraftAgent), draft);

    return finalContent;
}

[DurableTask]
public class PromptChainingOrchestration : TaskOrchestrator<string, string>
{
    public override async Task<string> RunAsync(
        TaskOrchestrationContext context, string topic)
    {
        // Step 1: Generate research outline
        string outline = await context.CallActivityAsync<string>(
            nameof(GenerateOutlineAgent), topic);

        // Step 2: Write first draft from outline
        string draft = await context.CallActivityAsync<string>(
            nameof(WriteDraftAgent), outline);

        // Step 3: Refine and polish the draft
        string finalContent = await context.CallActivityAsync<string>(
            nameof(RefineDraftAgent), draft);

        return finalContent;
    }
}

Routing

Yönlendirme, hangi aşağı akış aracısının veya modelinin isteği işlemesi gerektiğini belirlemek için bir sınıflandırma adımı kullanır. Orkestrasyon önce bir sınıflandırıcı etkinliğini çalıştırır, ardından sonucu temel alarak uygun işleyiciye yönlendirir. Bu yaklaşım, her işleyicinin istemini, modelini ve araç takımını bağımsız olarak uyarlamanıza olanak tanır. Örneğin, faturalama sorularını ödeme API'lerine erişimi olan özel bir aracıya yönlendirirken genel soruları daha hafif bir modele gönderirsiniz.

Ne zaman kullanılır: Müşteri desteği önceliklendirmesi, özel aracılara amaç sınıflandırması, görev karmaşıklığını temel alan dinamik model seçimi.

[Function(nameof(RoutingOrchestration))]
public async Task<string> RoutingOrchestration(
    [OrchestrationTrigger] TaskOrchestrationContext context)
{
    var request = context.GetInput<SupportRequest>();

    // Classify the request type
    string category = await context.CallActivityAsync<string>(
        nameof(ClassifyRequestAgent), request.Message);

    // Route to the appropriate specialized agent
    return category switch
    {
        "billing" => await context.CallActivityAsync<string>(
            nameof(BillingAgent), request),
        "technical" => await context.CallActivityAsync<string>(
            nameof(TechnicalSupportAgent), request),
        "general" => await context.CallActivityAsync<string>(
            nameof(GeneralInquiryAgent), request),
        _ => await context.CallActivityAsync<string>(
            nameof(GeneralInquiryAgent), request),
    };
}

[DurableTask]
public class RoutingOrchestration : TaskOrchestrator<SupportRequest, string>
{
    public override async Task<string> RunAsync(
        TaskOrchestrationContext context, SupportRequest request)
    {
        // Classify the request type
        string category = await context.CallActivityAsync<string>(
            nameof(ClassifyRequestAgent), request.Message);

        // Route to the appropriate specialized agent
        return category switch
        {
            "billing" => await context.CallActivityAsync<string>(
                nameof(BillingAgent), request),
            "technical" => await context.CallActivityAsync<string>(
                nameof(TechnicalSupportAgent), request),
            _ => await context.CallActivityAsync<string>(
                nameof(GeneralInquiryAgent), request),
        };
    }
}

Paralelleştirme

Birden çok bağımsız alt göreviniz olduğunda, bunları paralel etkinlik çağrıları olarak dağıtabilir ve devam etmeden önce tüm sonuçları bekleyebilirsiniz. Dayanıklı Görev Zamanlayıcı bu etkinlikleri tüm kullanılabilir işlem örneklerine otomatik olarak dağıtır ve bu da daha fazla çalışan eklenmesinin toplam duvar saati süresini doğrudan azalttığı anlamına gelir.

Yaygın bir varyant çok modelli oylamadır: Aynı talebi birden fazla modele (veya farklı sıcaklıklara sahip aynı modele) paralel olarak gönderirsiniz, ardından yanıtları toplar veya bunlardan birini seçersiniz. Her paralel dal bağımsız olarak denetim noktası olduğundan, bir daldaki geçici bir hata diğerlerini etkilemez.

Bu desen, Durable Task'taki fan-out/fan-in desenine doğrudan karşılık gelir.

Ne zaman kullanılır: Belgelerin toplu analizi, paralel araç çağrıları, çok modelli değerlendirme, birden çok gözden geçirenle içerik moderasyonu.

[Function(nameof(ParallelResearchOrchestration))]
public async Task<string> ParallelResearchOrchestration(
    [OrchestrationTrigger] TaskOrchestrationContext context)
{
    var request = context.GetInput<ResearchRequest>();

    // Fan-out: research multiple subtopics in parallel
    var researchTasks = request.Subtopics
        .Select(subtopic => context.CallActivityAsync<string>(
            nameof(ResearchSubtopicAgent), subtopic))
        .ToList();
    string[] researchResults = await Task.WhenAll(researchTasks);

    // Aggregate: synthesize all research into a single summary
    string summary = await context.CallActivityAsync<string>(
        nameof(SynthesizeAgent),
        new { request.Topic, Research = researchResults });

    return summary;
}

[DurableTask]
public class ParallelResearchOrchestration : TaskOrchestrator<ResearchRequest, string>
{
    public override async Task<string> RunAsync(
        TaskOrchestrationContext context, ResearchRequest request)
    {
        // Fan-out: research multiple subtopics in parallel
        var researchTasks = request.Subtopics
            .Select(subtopic => context.CallActivityAsync<string>(
                nameof(ResearchSubtopicAgent), subtopic))
            .ToList();
        string[] researchResults = await Task.WhenAll(researchTasks);

        // Aggregate: synthesize all research into a single summary
        string summary = await context.CallActivityAsync<string>(
            nameof(SynthesizeAgent),
            new { request.Topic, Research = researchResults });

        return summary;
    }
}

Orchestrator-worker kalıbı

Bu düzende merkezi bir orkestratör, işi planlamak için önce bir LLM'yi (bir etkinlik üzerinden) çağırır. LLM'nin çıkışına bağlı olarak orkestratör, gereken alt görevleri belirler. Düzenleyici daha sonra bu alt görevleri uzmanlaşmış çalışan düzenlemelerine gönderir. Paralelleştirmeden en önemli fark, alt görev kümesinin tasarım zamanında sabitlenmemiş olmasıdır; orchestrator bunları çalışma zamanında dinamik olarak belirler.

Bu düzen, bağımsız olarak kontrol edilen alt iş akışları olan alt orchestrasyonlar kullanır. Her işçi orkestrasyonu, birden fazla adım, yeniden denemeler ve iç içe paralellik içerebilir.

Ne zaman kullanılır: Derin araştırma işlem hatları, birden çok dosyayı değiştiren kodlama aracısı iş akışları, her aracının ayrı bir rolü olduğu çok aracılı işbirliği.

[Function(nameof(OrchestratorWorkersOrchestration))]
public async Task<string> OrchestratorWorkersOrchestration(
    [OrchestrationTrigger] TaskOrchestrationContext context)
{
    var request = context.GetInput<ResearchRequest>();

    // Central orchestrator: determine what research is needed
    string[] subtasks = await context.CallActivityAsync<string[]>(
        nameof(PlanResearchAgent), request.Topic);

    // Delegate to worker orchestrations in parallel
    var workerTasks = subtasks
        .Select(subtask => context.CallSubOrchestratorAsync<string>(
            nameof(ResearchWorkerOrchestration), subtask))
        .ToList();
    string[] results = await Task.WhenAll(workerTasks);

    // Synthesize results
    string finalReport = await context.CallActivityAsync<string>(
        nameof(SynthesizeAgent),
        new { request.Topic, Research = results });

    return finalReport;
}

[DurableTask]
public class OrchestratorWorkersOrchestration : TaskOrchestrator<ResearchRequest, string>
{
    public override async Task<string> RunAsync(
        TaskOrchestrationContext context, ResearchRequest request)
    {
        // Central orchestrator: determine what research is needed
        string[] subtasks = await context.CallActivityAsync<string[]>(
            nameof(PlanResearchAgent), request.Topic);

        // Delegate to worker orchestrations in parallel
        var workerTasks = subtasks
            .Select(subtask => context.CallSubOrchestratorAsync<string>(
                nameof(ResearchWorkerOrchestration), subtask))
            .ToList();
        string[] results = await Task.WhenAll(workerTasks);

        // Synthesize results
        string finalReport = await context.CallActivityAsync<string>(
            nameof(SynthesizeAgent),
            new { request.Topic, Research = results });

        return finalReport;
    }
}

Değerlendirici-iyileştirici deseni

Değerlendirici-iyileştirici deseni, bir geliştirme döngüsündeki bir değerlendirici aracısı ile bir oluşturucu aracısını eşleştirir. Oluşturucu çıktı üretir, değerlendirici kalite ölçütlerine göre puanlar ve geri bildirim sağlar ve çıkış geçene veya maksimum yineleme sayısına ulaşılana kadar döngü yineler. Her döngü yinelemesi kontrol edildiği için, üç başarılı iyileştirme turundan sonra meydana gelen bir çökme, bu ilerlemenin kaybolmasına neden olmaz.

Bu düzen özellikle kalite program aracılığıyla ölçülebiliyorsa (örneğin, oluşturulan kodun derlendiğini doğrulamak veya çevirinin adlandırılmış varlıkları koruduğu durumlarda) yararlıdır.

Ne zaman kullanılır: Otomatik inceleme, edebi çeviri, yinelemeli içerik iyileştirme, birden çok çözümleme turu gerektiren karmaşık arama görevleri ile kod oluşturma.

[Function(nameof(EvaluatorOptimizerOrchestration))]
public async Task<string> EvaluatorOptimizerOrchestration(
    [OrchestrationTrigger] TaskOrchestrationContext context)
{
    var request = context.GetInput<ContentRequest>();
    int maxIterations = 5;
    string content = "";
    string feedback = "";

    for (int i = 0; i < maxIterations; i++)
    {
        // Generate or refine content
        content = await context.CallActivityAsync<string>(
            nameof(GenerateContentAgent),
            new { request.Prompt, PreviousContent = content, Feedback = feedback });

        // Evaluate quality
        var evaluation = await context.CallActivityAsync<EvaluationResult>(
            nameof(EvaluateContentAgent), content);

        if (evaluation.MeetsQualityBar)
            return content;

        feedback = evaluation.Feedback;
    }

    return content; // Return best effort after max iterations
}

[DurableTask]
public class EvaluatorOptimizerOrchestration : TaskOrchestrator<ContentRequest, string>
{
    public override async Task<string> RunAsync(
        TaskOrchestrationContext context, ContentRequest request)
    {
        int maxIterations = 5;
        string content = "";
        string feedback = "";

        for (int i = 0; i < maxIterations; i++)
        {
            // Generate or refine content
            content = await context.CallActivityAsync<string>(
                nameof(GenerateContentAgent),
                new { request.Prompt, PreviousContent = content, Feedback = feedback });

            // Evaluate quality
            var evaluation = await context.CallActivityAsync<EvaluationResult>(
                nameof(EvaluateContentAgent), content);

            if (evaluation.MeetsQualityBar)
                return content;

            feedback = evaluation.Feedback;
        }

        return content; // Return best effort after max iterations
    }
}

Ajan döngüleri

Tipik bir yapay zeka aracısı uygulamasında, bir LLM döngü içinde çağrılır, araçlar çağrılır ve görev tamamlanana veya durdurma koşuluna ulaşılana kadar kararlar alınır. Belirleyici iş akışlarından farklı olarak yürütme yolu önceden tanımlanmış değildir. Aracı, önceki adımlardan alınan sonuçlara göre her adımda ne yapacağını belirler.

Adım sayısının veya sırasının öngörülemediği görevler için aracı döngüleri çok uygundur. Yaygın örnekler açık uçlu kodlama aracıları, otonom araştırmalar ve araç arama özelliklerine sahip konuşma botlarıdır.

Dayanıklı Görev programlama modeliyle aracı döngüleri uygulamak için önerilen iki yaklaşım vardır:

Yaklaşım Açıklama Ne zaman kullanılır?
Orkestrasyon tabanlı Ajans döngüsü dayanıklı bir düzenlemedir. Araç çağrıları etkinliklerdir; insan girişi dış olayları kullanır. Ayrıntılı denetim, araç başına yeniden deneme ilkeleri, dağıtılmış araç yürütme, IDE hata ayıklama.
Varlık tabanlı Her bir etmen örneği dayanıklı bir varlıktır. Ajana çerçevesi döngüyü yönetir; varlık oturum sürekliliği sağlar. Zaten aracı döngüsü olan bir çerçeve (Microsoft Agent Framework gibi) kullanıyorsunuz ve en az değişiklikle dayanıklılık eklemek istiyorsunuz.

Orkestrasyon tabanlı ajan döngüleri

Orkestrasyon tabanlı bir aracı döngüsü, çeşitli Dayanıklı Görev özelliklerini birleştirir: belleği sınırlı tutmak için sonsuz orkestrasyonlar (yeni olarak devam etme), paralel araç çalıştırma için fan-out/fan-in ve insan-döngü etkileşimleri için dış olaylar. Döngünün her yinelemesi:

  1. Geçerli konuşma bağlamını bir etkinlik veya durumlu varlık aracılığıyla LLM'ye gönderir.
  2. LLM tarafından verilen, araç çağrılarını içerebilecek yanıtı alır.
  3. Mevcut hesaplama kaynaklarına dağıtılarak araç çağrılarını etkinlik olarak çalıştırır.
  4. İsteğe bağlı olarak dış olayları kullanarak insan girişi bekler.
  5. Döngüye güncelleştirilmiş durumla devam eder ya da aracı işlemi tamamladığında döngüyü tamamlar.
[Function(nameof(AgentLoopOrchestration))]
public async Task<string> AgentLoopOrchestration(
    [OrchestrationTrigger] TaskOrchestrationContext context)
{
    // Get state from input (supports continue-as-new)
    var state = context.GetInput<AgentState>() ?? new AgentState();

    int maxIterations = 100;
    while (state.Iteration < maxIterations)
    {
        // Send conversation history to the LLM
        var llmResponse = await context.CallActivityAsync<LlmResponse>(
            nameof(CallLlmAgent), state.Messages);

        state.Messages.Add(llmResponse.Message);

        // If the LLM returned tool calls, execute them in parallel
        if (llmResponse.ToolCalls is { Count: > 0 })
        {
            var toolTasks = llmResponse.ToolCalls
                .Select(tc => context.CallActivityAsync<ToolResult>(
                    nameof(ExecuteTool), tc))
                .ToList();
            ToolResult[] toolResults = await Task.WhenAll(toolTasks);

            foreach (var result in toolResults)
                state.Messages.Add(result.ToMessage());
        }
        // If the LLM needs human input, wait for it
        else if (llmResponse.NeedsHumanInput)
        {
            string humanInput = await context.WaitForExternalEvent<string>("HumanInput");
            state.Messages.Add(new Message("user", humanInput));
        }
        // LLM is done
        else
        {
            return llmResponse.FinalAnswer;
        }

        state.Iteration++;

        // Periodically continue-as-new to keep the history bounded
        if (state.Iteration % 10 == 0)
        {
            context.ContinueAsNew(state);
            return null!; // Orchestration will restart with updated state
        }
    }

    return "Max iterations reached.";
}

[DurableTask]
public class AgentLoopOrchestration : TaskOrchestrator<AgentState, string>
{
    public override async Task<string> RunAsync(
        TaskOrchestrationContext context, AgentState? state)
    {
        state ??= new AgentState();

        int maxIterations = 100;
        while (state.Iteration < maxIterations)
        {
            // Send conversation history to the LLM
            var llmResponse = await context.CallActivityAsync<LlmResponse>(
                nameof(CallLlmAgent), state.Messages);

            state.Messages.Add(llmResponse.Message);

            // If the LLM returned tool calls, execute them
            if (llmResponse.ToolCalls is { Count: > 0 })
            {
                var toolTasks = llmResponse.ToolCalls
                    .Select(tc => context.CallActivityAsync<ToolResult>(
                        nameof(ExecuteTool), tc))
                    .ToList();
                ToolResult[] toolResults = await Task.WhenAll(toolTasks);

                foreach (var result in toolResults)
                    state.Messages.Add(result.ToMessage());
            }
            // If the LLM needs human input, wait for it
            else if (llmResponse.NeedsHumanInput)
            {
                string humanInput = await context.WaitForExternalEvent<string>("HumanInput");
                state.Messages.Add(new Message("user", humanInput));
            }
            // LLM is done
            else
            {
                return llmResponse.FinalAnswer;
            }

            state.Iteration++;

            // Periodically continue-as-new to keep the history bounded
            if (state.Iteration % 10 == 0)
            {
                context.ContinueAsNew(state);
                return null!;
            }
        }

        return "Max iterations reached.";
    }
}

Varlık tabanlı aracı döngüleri

Kendi aracı döngüsünü zaten uygulayan bir aracı çerçevesi kullanıyorsanız, döngü mantığını yeniden yazmadan dayanıklılık eklemek için bunu dayanıklı bir varlığa sarmalayabilirsiniz. Her varlık örneği tek bir ajan oturumunu temsil eder. Varlık iletileri alır, görevleri ajan çerçevesine dahili olarak devreder ve etkileşimler arasında konuşma durumunu kalıcı hale getirir.

Bu yaklaşımın temel avantajı basitliktir: Aracınızı tercih ettiğiniz çerçevede yazar ve aracınızın kontrol akışını yeniden tasarlamak yerine barındırma aşamasında dayanıklılık eklersiniz. Bileşen, oturum kalıcılığını ve kurtarmayı otomatik olarak işleyerek dayanıklı bir sarmalayıcı görevi görür.

Aşağıdaki örnekler, mevcut bir agent SDK'sını dayanıklı bir varlık olarak nasıl sarmalayacağını göstermektedir. Varlık, istemcilerin çağırdığı bir kullanıcı girdisi göndermek için bir message işlemi sunar. Dahili olarak, bileşen kendi araç çağırma döngüsünü yöneten aracı çerçevesine delege eder.

// Define the entity that wraps an existing agent SDK
public class ChatAgentEntity : TaskEntity<ChatAgentState>
{
    private readonly IChatClient _chatClient;

    public ChatAgentEntity(IChatClient chatClient)
    {
        _chatClient = chatClient;
    }

    // Called by clients to send a message to the agent
    public async Task<string> Message(string userMessage)
    {
        // Add the user message to the conversation history
        State.Messages.Add(new ChatMessage(ChatRole.User, userMessage));

        // Delegate to the agent SDK for the LLM call (with tool loop)
        ChatResponse response = await _chatClient.GetResponseAsync(
            State.Messages, State.Options);

        // Persist the response in the entity state
        State.Messages.AddRange(response.Messages);

        return response.Text;
    }

    // Azure Functions entry point for the entity
    [Function(nameof(ChatAgentEntity))]
    public Task RunEntityAsync([EntityTrigger] TaskEntityDispatcher dispatcher)
    {
        return dispatcher.DispatchAsync<ChatAgentEntity>();
    }
}

// Define the entity that wraps an existing agent SDK
[DurableTask(Name = "ChatAgent")]
public class ChatAgentEntity : TaskEntity<ChatAgentState>
{
    private readonly IChatClient _chatClient;

    public ChatAgentEntity(IChatClient chatClient)
    {
        _chatClient = chatClient;
    }

    // Called by clients to send a message to the agent
    public async Task<string> Message(string userMessage)
    {
        // Add the user message to the conversation history
        State.Messages.Add(new ChatMessage(ChatRole.User, userMessage));

        // Delegate to the agent SDK for the LLM call (with tool loop)
        ChatResponse response = await _chatClient.GetResponseAsync(
            State.Messages, State.Options);

        // Persist the response in the entity state
        State.Messages.AddRange(response.Messages);

        return response.Text;
    }
}

Microsoft Agent Framework için Durable Task uzantısı bu yaklaşımı kullanır. Microsoft Agent Framework aracılarını dayanıklı varlıklar olarak sarmalar ve tek bir yapılandırma satırıyla kalıcı oturumlar, otomatik denetim noktaları ve yerleşik API uç noktaları sağlar.

Sonraki Adımlar

  • Last updated on