Agentlooping

Importera looptyper och omslut alla AIAgent med LoopAgent. Standardvärdet är 10 agentanrop:

using Microsoft.Agents.AI;
using Microsoft.Extensions.AI;

AIAgent baseAgent = chatClient.AsAIAgent();
AIAgent agent = new LoopAgent(
    baseAgent,
    new CompletionMarkerLoopEvaluator("DONE"),
    new LoopAgentOptions { MaxIterations = 5 });

Importera AgentLoopMiddleware och lägg till den i en vanlig Agent. Det förinställda maxvärdet är 10 agentkörningar:

from agent_framework import Agent, AgentLoopMiddleware


def needs_more_work(*, last_result, **kwargs):
    return "DONE" not in last_result.text


agent = Agent(
    client=client,
    middleware=[
        AgentLoopMiddleware(
            needs_more_work,
            max_iterations=5,
        )
    ],
)

Predikatet kan vara synkront eller asynkront. Gå tillbaka True för att fortsätta, False stoppa eller (continue, feedback) skicka feedback till nästa iteration.

LoopAgent tar emot en utvärderare eller en ordnad samling:

När flera utvärderare har konfigurerats körs de i ordning. Den första utvärderaren som begär en annan iteration ger sin feedback. -loopen stoppas endast när alla utvärderare avböjer att fortsätta.

Använda en AI-domare

Domaren får den ursprungliga begäran och det senaste agentsvaret. Om den hittar en lucka blir analysen feedback för nästa iteration:

var evaluator = new AIJudgeLoopEvaluator(
    judgeClient,
    new AIJudgeLoopEvaluatorOptions
    {
        Criteria =
        [
            "Answer every part of the request.",
            "Support conclusions with evidence.",
        ],
    });

AIAgent loopAgent = new LoopAgent(
    agent,
    evaluator,
    new LoopAgentOptions { MaxIterations = 4 });

Använd endast en domarslutpunkt som du litar på med den ursprungliga begäran och det genererade svaret.

Kontrollera kontext och utdata

Som standard LoopAgent återanvänder en session och skickar den vinnande utvärderarens senaste feedback som nästa indata. FreshContextPerIteration = true bygger i stället upp varje omgång från den ursprungliga begäran samt en logg över aggregerad återkoppling och nollställer eller återställer sessionen.

Körningar utan strömning returnerar som standard en sammanställd transkription. Ange NonStreamingReturnsLastResponseOnly = true att endast returnera det slutliga svaret. Direktuppspelning genererar alltid varje iteration och alla synliga feedbackmeddelanden som visas på uppdrag av feedbackmeddelanden.

Predikatet tar emot nyckelordsargument som iteration, last_result, messages, original_messages, session, , agent, progressoch feedback. Hjälparna todos_remaining() och background_tasks_running() tillhandahåller inbyggda villkor för todo och bakgrundsuppgifter. Para ihop dem med todos_remaining_message eller background_tasks_running_message för att generera nästa riktade indata.

Använda en AI-domare

AgentLoopMiddleware.with_judge bygger en domardriven loop. Judge-loopar har fem iterationer som standard:

from agent_framework import Agent, AgentLoopMiddleware

loop = AgentLoopMiddleware.with_judge(
    judge_client,
    criteria=[
        "Answer every part of the request.",
        "Support conclusions with evidence.",
    ],
    max_iterations=4,
)

agent = Agent(
    client=client,
    middleware=[loop],
)

Domarens resonemang matas tillbaka till agenten när mer arbete krävs. Använd endast en domarslutpunkt som du litar på med den ursprungliga begäran och det genererade svaret.

Kontrollera kontext, förlopp och utdata

För avancerade loopar skapar du AgentLoopMiddleware direkt:

• record_feedback skapar en kortfattad statuspost efter varje arbetsomgång.
• progress exponerar ackumulerade poster för återanrop.
• inject_progress=True lägger till framsteg i indata för nästa iteration.
• fresh_context=True startar om från den ursprungliga uppgiften och förloppsloggen och återställer en bifogad session till dess ögonblicksbild från före loopen.
• return_final_only=True returnerar endast det senaste svaret för körningar utan streaming.

Godkänn max_iterations=None endast när slutförandepredikatet garanterat avslutas.

De paketerade slutförandevillkoren och domarintegrering som beskrivs på den här sidan är för närvarande inte tillgängliga i Go.

Ange HarnessAgentOptions.LoopEvaluators. Testharnesket använder LoopAgent som sin yttersta agentdekoratör:

using Microsoft.Agents.AI;
using Microsoft.Extensions.AI;

var options = new HarnessAgentOptions
{
    LoopEvaluators =
    [
        new CompletionMarkerLoopEvaluator("DONE"),
    ],
    LoopAgentOptions = new LoopAgentOptions
    {
        MaxIterations = 5,
    },
};

HarnessAgent agent = chatClient.AsHarnessAgent(options);
// Equivalent construction: new HarnessAgent(chatClient, options)
AgentSession session = await agent.CreateSessionAsync();

En tom samling eller en samling med nullLoopEvaluators gör att testselen bara körs en gång.

Godkännande- och sessionsbeteende

LoopAgent avbryts innan dess slutförandevillkor utvärderas när en iteration returnerar en väntande begäran om verktygsgodkännande. Den returnerar begäran till anroparen i stället för att dölja den bakom en annan autonom iteration. När anroparen tillhandahåller godkännandesvaret via det normala verktygets godkännandeflöde kan agenten fortsätta.

LoopAgent lägger inte till själva godkännandehanteringen. Harness-agenten placerar loopen utanför ToolApprovalAgent, vilket gör att väntande begäranden om godkännande kan ta sig ur loopen.

Återanvänd samma AgentSession mellan anrop för att fortsätta konversationen. Loopiterationer delar som standard den sessionen. Med FreshContextPerIteration = true, LoopAgent nollställer eller återställer det sessionstillstånd som tillhandahålls av anroparen där det stöds. Tjänstägd konversationslagring kan behålla historiken när den serialiserade sessionen endast innehåller en fjärrkonversationsidentifierare.

Ange loop_should_continue till create_harness_agent, loop_max_iterations standardvärdet är 10:

from agent_framework import create_harness_agent


def needs_more_work(*, last_result, **kwargs):
    return "DONE" not in last_result.text


agent = create_harness_agent(
    client=client,
    loop_should_continue=needs_more_work,
    loop_max_iterations=5,
)
session = agent.create_session()

loop_next_message anpassar nästa inmatning. Utan loop_should_continue lägger fabriken inte till någon slinga och ignorerar de andra argumenten för slingan.

Godkännande- och sessionsbeteende

AgentLoopMiddleware stoppar innan dess fortsättningspredikat utvärderas när en iteration returnerar en väntande begäran om godkännande av verktyg. Den returnerar begäran till anroparen i stället för att dölja den bakom en annan autonom iteration. När anroparen tillhandahåller godkännandesvaret via det normala verktygets godkännandeflöde kan agenten fortsätta.

AgentLoopMiddleware lägger inte till ToolApprovalMiddleware sig själv. Harness-agenten placerar loopen utanför sitt godkännandemellanprogram, vilket gör att väntande godkännandebegäranden kan undkomma loopen. Skapa och skicka en AgentSession på varje Harness Agent-körning medan automatiskt godkännande av verktyget är aktiverat.

Återanvänd samma AgentSession mellan anrop för att fortsätta konversationen. Iterationerna i loopen delar samma session som standard. Med fresh_context=Trueåterställer mellanprogrammet den anslutna sessionen till dess ögonblicksbild före loopen mellan iterationer. Tjänstägd konversationslagring kan behålla historiken när den serialiserade sessionen endast innehåller en fjärrkonversationsidentifierare.