أنماط التطبيقات الوكالية

هناك نهجان عامان لبناء تطبيقات وكلاء باستخدام الذكاء الاصطناعي:

  • سير العمل الحتمي — كودك يحدد تدفق التحكم. تكتب تسلسل الخطوات، والتفرع، والتوازي، والتعامل مع الأخطاء باستخدام البنى البرمجية القياسية. يقوم نموذج اللغة الكبيرة بالعمل داخل كل خطوة لكنه لا يتحكم في التدفق العام.
  • سير العمل الموجه من قبل الوكيل (حلقات الوكيل) — يقود نموذج اللغة الكبيرة تدفق التحكم. يقرر الوكيل الأدوات التي يستدعيها، وبأي ترتيب، ومتى تكتمل المهمة. أنت توفر أدوات وتعليمات، لكن الوكيل هو من يحدد مسار التنفيذ أثناء التشغيل.

كلا النهجين يستفيدان من التنفيذ الدائم ويمكن تنفيذهما باستخدام نموذج برمجة المهام الدائمة. توضح هذه المقالة كيفية بناء كل نمط باستخدام عينات كود جاهزة للاستخدام بلغات C#، Python، JavaScript/TypeScript، وJava.

نصيحة

Prerequisites: قبل استخدام هذه الأنماط، قم بإعداد مجموعات تطوير المهام المتينة أو Durable Functions. راجع نظرة عامة SDK أو Durable Functions العامة للبدء.

في هذه الصفحة:

  • تسلسل الأوامر — خطوات نموذج اللغة الكبيرة التتابعية مع بوابات التحقق
  • التوجيه — التصنيف والإرسال إلى الوكلاء المتخصصين
  • التوازي — خروج المكثف/الانتقال للمهام الفرعية المستقلة
  • العاملون في التنسيق — تفويض المهام الفرعية الديناميكي المخطط له بواسطة نموذج اللغة الكبيرة
  • المقيم المحسن — التوليد التكراري وحلقة التنقيح
  • حلقات الوكيل — حلقات استدعاء الأدوات الموجهة بواسطة نماذج اللغة الكبيرة (تعتمد على التنسيق أو الكيان)

نصيحة

تتماشى هذه الأنماط مع تصاميم سير العمل الوكالاتي الموصوفة في كتاب أنثروبيك لبناء وكلاء فعالين. نموذج برمجة المهام المتطورة يتوافق بشكل طبيعي مع هذه الأنمط: التنسيقات تحدد تدفق التحكم في سير العمل ويتم وضع نقاط التحقق تلقائيا، بينما تغطي الأنشطة عمليات غير حتمية مثل استدعاءات نماذج اللغة الكبيرة (LLM)، استدعاءات الأدوات، وطلبات واجهة برمجة التطبيقات (API).

اختر نهجا

يساعدك الجدول التالي في تحديد متى تستخدم كل منهج.

استخدم سير عمل حتمي عندما... استخدم حلقات الوكيل عندما...
تسلسل الخطوات معروف مسبقا. المهمة مفتوحة ولا يمكن التنبؤ بالخطوات.
تحتاج إلى حواجز واضحة لسلوك العملاء. تريد من النموذج الكبير أن يقرر الأدوات التي ستستخدمها ومتى.
يتطلب الامتثال أو التدقيق تدفق تحكم قابل للمراجعة. يحتاج الوكيل إلى تعديل نهجه بناء على النتائج الوسيطة.
تريد دمج عدة أطر عمل للذكاء الاصطناعي في سير عمل واحد. أنت تبني وكيل حواري يمتلك قدرات استدعاء الأدوات.

توفر كلا النهجين نقاط التحقق التلقائية، وسياسات إعادة المحاولة، والتوسع الموزع، ودعم البشر في الحلقة من خلال تنفيذ مستدام.

أنماط سير العمل الحتمية

في سير عمل حتمي، يتحكم كودك في مسار التنفيذ. يتم استدعاء نموذج اللغة الكبيرة كخطوة ضمن سير العمل لكنه لا يقرر ما سيحدث بعد ذلك. نموذج برمجة المهام المتطورة يتوافق بشكل طبيعي مع هذا النهج:

  • تحدد التنسيقات تدفق التحكم في سير العمل (التسلسل، التفرع، التوازي، التعامل مع الأخطاء) ويتم وضع نقاط التحقق تلقائيا.
  • تغطي الأنشطة العمليات غير الحتمية مثل استدعاءات نماذج اللغة الكبيرة (LLM)، واستدعاءات الأدوات، وطلبات واجهات برمجة التطبيقات. يمكن تشغيل الأنشطة على أي نسخة حوسبة متاحة.

الأمثلة التالية تستخدم Durable Functions، والتي تعمل على دالات Azure مع استضافة بدون خادم.

الأمثلة التالية تستخدم SDKs Durable Task SDKs المحمولة، والتي تعمل على أي حوسبة مضيفة بما في ذلك Azure Container Apps أو Kubernetes أو الآلات الافتراضية أو محليا.

نمط التسلسل الفوري

تسلسل الأوامر هو أبسط نمط وكيل. تقوم بتقسيم مهمة معقدة إلى سلسلة من تفاعلات نماذج اللغة الكبيرة المتسلسلة، حيث يغذي كل خطوة مدخلات الخطوة التالية. نظرا لأن كل استدعاء نشاط يتم التحقق تلقائيا، فإن الانهيار في منتصف خط الأنابيب لا يجبرك على إعادة البدء من الصفر واستهلاك رموز LLM المكلفة — يستأنف التنفيذ من آخر خطوة مكتملة.

يمكنك أيضا إدخال بوابات تحقق برمجية بين الخطوات. على سبيل المثال، بعد إنشاء مخطط يمكنك التحقق من أنه يفي بمدة أو قيد موضوع قبل تمريره إلى خطوة المسودة.

يرتبط هذا النمط مباشرة بنمط تسلسل الدوال في نموذج برمجة المهام المتينة.

متى الاستخدام: خطوط توليد المحتوى، معالجة المستندات متعددة الخطوات، إثراء البيانات التسلسلي، سير العمل الذي يتطلب بوابات تحقق وسيطة.

ملحوظة

في جميع الأمثلة التالية، يتم التحقق تلقائيا من حالة التوزيع عند كل await/yield جملة. إذا تعطل عملية المضيف أو أعاد الجهاز الافتراضي التدوير، يستأنف التنسيق من آخر خطوة مكتملة بدلا من البدء من جديد.

[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

يستخدم التوجيه خطوة تصنيف لتحديد أي وكيل أو نموذج لاحق يجب أن يتعامل مع طلب. تستدعي التنسيق نشاط المصنف أولا، ثم تتفرع إلى المعالج المناسب بناء على النتيجة. تتيح لك هذه الطريقة تخصيص طلب كل معالج ونموذجه ومجموعة أدوات كل معالج بشكل مستقل — على سبيل المثال، توجيه أسئلة الفوترة إلى وكيل متخصص لديه وصول إلى واجهات برمجة تطبيقات الدفع مع إرسال الأسئلة العامة إلى نموذج أخف وزنا.

متى الاستخدام: فرز دعم العملاء، تصنيف النية إلى الوكلاء المتخصصين، اختيار النموذج الديناميكي بناء على تعقيد المهام.

[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),
        };
    }
}

التوازي

عندما يكون لديك عدة مهام فرعية مستقلة، يمكنك إطلاقها كاستدعاءات نشاط متوازي وانتظار جميع النتائج قبل المتابعة. يقوم جدولة المهام الدائمة بتوزيع هذه الأنشطة على جميع مثيلات الحوسبة المتاحة تلقائيا، مما يعني أن إضافة المزيد من العمال تقلل مباشرة من إجمالي وقت ساعة الحائط.

النمط الشائع هو التصويت متعدد النماذج: ترسل نفس الرسالة إلى عدة نماذج (أو نفس النموذج بدرجات حرارة مختلفة) بالتوازي، ثم تجمع أو تختار من بين الردود. نظرا لأن كل فرع متوازي يتم التحقق بشكل مستقل، فإن الفشل المؤقت في فرع واحد لا يؤثر على الفروع الأخرى.

هذا النمط يتوافق مباشرة مع نمط المروحة/المروحة في مهمة التحمل (Durable Task).

متى الاستخدام: تحليل دفعي للمستندات، استدعاءات أدوات متوازية، تقييم متعدد النماذج، مراقبة المحتوى مع عدة مراجعين.

[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;
    }
}

نمط الموزع-العاملين

في هذا النمط، يقوم المنسق المركزي أولا بالاتصال بنموذج اللغة الكبيرة (عبر نشاط) لتخطيط العمل. استنادا إلى مخرجات نموذج اللغة اللغوي، يحدد المنسق المهام الفرعية المطلوبة. ثم يرسل الموزع تلك المهام الفرعية إلى التنسيقات المتخصصة للعمال. الفرق الرئيسي عن التوازي هو أن مجموعة المهام الفرعية ليست ثابتة في وقت التصميم؛ يقوم المنسق بتحديدها ديناميكيا أثناء وقت التشغيل.

يستخدم هذا النمط التنسيقات الفرعية، وهي سير عمل فرعي محدد بشكل مستقل. يمكن لكل تنسيق عامل أن يحتوي على عدة خطوات، ومحاولات، وتوازي متداخل.

متى الاستخدام: خطوط أنابيب بحث عميقة، وسير عمل الوكلاء المبرمجة الذين يعدل عدة ملفات، وتعاون متعدد الوكلاء حيث لكل وكيل دور مميز.

[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;
    }
}

نمط المقيم والمحسن

يقوم نمط المقيم والمحسن بإقران وكيل مولد مع وكيل مقيم في حلقة تنقية. ينتج المولد المخرج، ويقيمه المقيم وفقا لمعايير الجودة ويقدم التغذية الراجعة، وتتكرر الحلقة حتى يمر الناتج أو يصل إلى أقصى عدد تكرار. لأن كل تكرار في الحلقة يكون بنقطة تفتيش، فإن الانهيار بعد ثلاث جولات ناجحة من التحسين لن يفقد هذا التقدم.

يكون هذا النمط مفيدا بشكل خاص عندما يمكن قياس الجودة برمجيا — على سبيل المثال، التحقق من تجميع الكود المولد، أو أن الترجمة تحافظ على الكيانات المسماة.

متى الاستخدام: إنشاء الشيفرة مع مراجعة آلية، ترجمة أدبية، تحسين المحتوى بشكل تكراري، مهام بحث معقدة تتطلب عدة جولات من التحليل.

[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
    }
}

حلقات الوكيل

في تنفيذ وكيل الذكاء الاصطناعي النموذجي، يتم استدعاء نموذج اللغة الكبيرة في حلقة، حيث يستدعي الأدوات ويتخذ قرارات حتى تكتمل المهمة أو يتم الوصول إلى شرط التوقف. على عكس سير العمل الحتمية، فإن مسار التنفيذ ليس محددا مسبقا. يحدد الوكيل ما يجب فعله في كل خطوة بناء على نتائج الخطوات السابقة.

حلقات الوكيل مناسبة جدا للمهام التي لا يمكن التنبؤ بعدد أو ترتيب الخطوات. تشمل الأمثلة الشائعة وكلاء البرمجة المفتوحين، والأبحاث الذاتية، والروبوتات المحادثة التي تمتلك قدرات استدعاء الأدوات.

هناك نهجان موصى به لتنفيذ حلقات الوكيل باستخدام نموذج برمجة المهام الدائمة:

النهج الوصف وقت الاستخدام
تعتمد على التوزيع الموسيقي حلقة الوكيل هي تنسيق قوي. استدعاءات الأدوات هي أنشطة؛ المدخلات البشرية تستخدم أحداثا خارجية. تحكم دقيق، سياسات إعادة محاولة لكل أداة، تنفيذ أدوات موزعة، تصحيح أخطاء بيئة تطوير التطوير.
القائمة على الكيانات كل حالة وكيل هي كيان دائم. إطار عمل الوكيل يدير الحلقة؛ الكيان يوفر استمرارية الجلسة. أنت تستخدم إطار عمل (مثل Microsoft Agent Framework) يحتوي بالفعل على حلقة وكيل وتريد إضافة متانة مع تغييرات قليلة.

حلقات وكلاء تعتمد على التوزيع الموسيقي

تجمع حلقة الوكيل القائمة على التنسيق بين عدة قدرات مهمة دائمة: التنسيقات الأبدية (تستمر كالجديدة) للحفاظ على الذاكرة محدودة، وخروج الخارج/الانتقال لتنفيذ الأدوات المتوازية، والأحداث الخارجية للتفاعلات بين الإنسان في الحلقة. كل تكرار من الحلقة:

  1. يرسل سياق المحادثة الحالي إلى نموذج اللغة الكبير عبر نشاط أو كيان ذو حالة.
  2. يستقبل رد نموذج اللغة الكبيرة، والذي قد يشمل استدعاءات الأدوات.
  3. ينفذ أي استدعاءات أدوات كأنشطة (موزعة عبر الحوسبة المتاحة).
  4. اختياريا ينتظر مدخلات بشرية باستخدام أحداث خارجية.
  5. يستمر في الحلقة بحالة محدثة، أو يكتمل عندما يشير الوكيل إلى الانتهاء.
[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.";
    }
}

حلقات الوكيل القائمة على الكيانات

إذا كنت تستخدم إطار عمل وكيل ينفذ حلقة وكيل خاصة به، يمكنك تغليفه في كيان قوي لإضافة متانة دون إعادة كتابة منطق الحلقة. كل حالة كيان تمثل جلسة وكيل واحدة. يستقبل الكيان الرسائل، ويفوض إلى إطار عمل الوكيل داخليا، ويستمر في حالة المحادثة عبر التفاعلات.

الميزة الرئيسية لهذا النهج هي البساطة: تكتب وكيلك باستخدام الإطار المفضل لديك وتضيف المتانة كعامل استضافة بدلا من إعادة تصميم تدفق التحكم الخاص بالوكيل. يعمل الكيان كغلاف دائم، يتعامل مع استمرارية الجلسة والاسترداد تلقائيا.

الأمثلة التالية توضح كيفية تغليف SDK لوكيل موجود ككيان دائم. يعرض الكيان عملية message يستدعيها العملاء لإرسال مدخلات المستخدم. داخليا، يقوم الكيان بالتفويض إلى إطار عمل الوكيل، الذي يدير حلقة استدعاء الأدوات الخاصة به.

// 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 الوكيل هذا النهج. يجمع وكلاء Microsoft Agent Framework ككيانات دائمة، يوفر جلسات دائمة، ونقاط تحقق تلقائية، ونقاط نهاية API مدمجة مع سطر تكوين واحد.

الخطوات التالية

  • Last updated on