Agentlussen

Agentlusing roept een agent opnieuw aan totdat aan een voltooiingsvoorwaarde wordt voldaan. Gebruik het voor iteratieve verfijning, voltooiing van taken, wachten op achtergrondtaken of evalueren of een antwoord voldoet aan expliciete criteria.

Altijd gebonden autonome lussen. Een voltooiingsvoorwaarde kan mislukken, een model kan vastlopen en een evaluator kan probabilistisch zijn.

Important

Agentlussen zijn experimenteel.

Lus handmatig instellen

Gebruik de directe samenstellings-API als u lus wilt uitvoeren zonder de andere Harness Agent-standaardwaarden.

Importeer de lustypen en verpakt deze AIAgent met LoopAgent. Het standaard maximum is 10 agent-aanroepen:

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

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

Importeer AgentLoopMiddleware en voeg het toe aan een gewone Agent. Het standaard maximum is 10 agentuitvoeringen:

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,
        )
    ],
)

Het predicaat kan synchroon of asynchroon zijn. Ga terug True om door te gaan, False om te stoppen of (continue, feedback) om feedback door te geven aan de volgende iteratie.

Opmerking

De functionaliteit voor verpakte lussen die op deze pagina worden beschreven, is momenteel niet beschikbaar in Go.

Een voltooiingsvoorwaarde kiezen

LoopAgent accepteert één evaluator of een geordende verzameling:

Beoordelaar Gaat door terwijl
CompletionMarkerLoopEvaluator Het meest recente antwoord bevat niet de geconfigureerde markering.
TodoCompletionLoopEvaluator Een opgelost item TodoProvider bevat nog steeds onvolledige items, optioneel in de geselecteerde agentmodi.
BackgroundTaskCompletionLoopEvaluator Een opgeloste BackgroundAgentsProvider taak heeft nog steeds actieve taken.
AIJudgeLoopEvaluator Een afzonderlijke rechterclient zegt dat de oorspronkelijke aanvraag niet volledig wordt beantwoord.
DelegateLoopEvaluator Uw callback retourneert LoopEvaluation.Continue(...).

Wanneer meerdere evaluators zijn geconfigureerd, worden ze op volgorde uitgevoerd. De eerste evaluator die een andere iteratie vraagt, levert zijn feedback; de lus stopt alleen wanneer alle evaluators weigeren om door te gaan.

Een AI-rechter gebruiken

De rechter ontvangt het oorspronkelijke verzoek en de meest recente reactie van de agent. Als er een hiaat wordt gevonden, wordt de analyse feedback voor de volgende iteratie:

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

Gebruik alleen een rechtereindpunt dat u vertrouwt met de oorspronkelijke aanvraag en het gegenereerde antwoord.

Context en uitvoer beheren

LoopAgent Standaard wordt één sessie opnieuw gebruikt en wordt de meest recente feedback van de winnende evaluator verzonden als de volgende invoer. FreshContextPerIteration = true in plaats daarvan wordt elke pas opnieuw opgebouwd uit de oorspronkelijke aanvraag plus een samengevoegd feedbacklogboek en wordt de sessie opnieuw ingesteld of hersteld.

Niet-streaminguitvoeringen retourneren standaard een geaggregeerde transcriptie. Ingesteld NonStreamingReturnsLastResponseOnly = true om alleen het uiteindelijke antwoord te retourneren. Streaming verzendt altijd elke iteratie en eventuele zichtbare berichten namens feedback.

Het predicaat ontvangt trefwoordargumenten, waaronder , , , , , , agenten feedbackprogress. sessionoriginal_messagesmessageslast_resultiteration De helpers todos_remaining() en background_tasks_running() bieden ingebouwde taken en achtergrondtaken. Koppel ze aan todos_remaining_message of background_tasks_running_message genereer een gerichte volgende invoer.

Een AI-rechter gebruiken

AgentLoopMiddleware.with_judge bouwt een rechtergestuurde lus. Rechterlussen zijn standaard ingesteld op vijf iteraties:

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],
)

De redenering van de rechter wordt teruggegeven aan de agent wanneer er meer werk nodig is. Gebruik alleen een rechtereindpunt dat u vertrouwt met de oorspronkelijke aanvraag en het gegenereerde antwoord.

Context, voortgang en uitvoer beheren

Voor geavanceerde lussen maakt u AgentLoopMiddleware rechtstreeks het volgende:

  • record_feedback maakt een beknopte voortgangsvermelding na elke werkiteratie.
  • progress stelt geaccumuleerde vermeldingen beschikbaar voor callbacks.
  • inject_progress=True voegt de voortgang toe aan de invoer van de volgende iteratie.
  • fresh_context=True start opnieuw vanaf het oorspronkelijke taak- en voortgangslogboek en herstelt een gekoppelde sessie aan de momentopname van de pre-lus.
  • return_final_only=True retourneert alleen het laatste antwoord voor niet-streaminguitvoeringen.

Geef alleen door max_iterations=None wanneer het voltooiingspredicaat gegarandeerd wordt beëindigd.

De verpakte voltooiingsvoorwaarden en de integratie van rechters die op deze pagina worden beschreven, zijn momenteel niet beschikbaar in Go.

Lusing gebruiken met Harness Agent

Gebruik de Harness Agent-installatie wanneer u ook de vooraf geconfigureerde geschiedenis, planning, geheugen, goedkeuring en waarneembaarheidspijplijn wilt.

Stel HarnessAgentOptions.LoopEvaluatorsin. De harnas is van toepassing LoopAgent als buitenste agent decorator:

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();

Een lege verzameling of nullLoopEvaluators verzameling laat het harnas single-shot achter.

Goedkeuring en sessiegedrag

LoopAgent stopt voordat de voltooiingsvoorwaarde wordt geëvalueerd wanneer een iteratie een aanvraag voor goedkeuring van het hulpprogramma retourneert. Het retourneert de aanvraag aan de aanroeper in plaats van deze achter een andere autonome iteratie te verbergen. Nadat de beller het goedkeuringsantwoord via de normale goedkeuringsstroom voor het hulpprogramma heeft opgegeven, kan de agent doorgaan.

LoopAgent voegt zelf geen goedkeuringsafhandeling toe. De Harness Agent past de lus buiten ToolApprovalAgenttoe, zodat goedkeuringsaanvragen in behandeling kunnen ontsnappen aan de lus.

Gebruik dezelfde AgentSession gesprekken opnieuw om het gesprek voort te zetten. Herhalende iteraties delen die sessie standaard. Met FreshContextPerIteration = true, LoopAgent resett of herstelt de door de beller opgegeven sessiestatus, waar ondersteund. Opslag van gesprekken in eigendom van de service kan de geschiedenis behouden wanneer de geserialiseerde sessie alleen een externe gespreks-id bevat.

Leveren loop_should_continue aan create_harness_agent; loop_max_iterations standaard ingesteld op 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 past de volgende invoer aan. Zonder nee loop_should_continuevoegt de factory geen lus toe en negeert de andere lusargumenten.

Goedkeuring en sessiegedrag

AgentLoopMiddleware stopt voordat het vervolgpredicaat wordt geëvalueerd wanneer een iteratie een aanvraag voor goedkeuring van het hulpprogramma retourneert. Het retourneert de aanvraag aan de aanroeper in plaats van deze achter een andere autonome iteratie te verbergen. Nadat de beller het goedkeuringsantwoord via de normale goedkeuringsstroom voor het hulpprogramma heeft opgegeven, kan de agent doorgaan.

AgentLoopMiddleware voegt zichzelf niet toe ToolApprovalMiddleware . De Harness Agent plaatst de lus buiten de middleware voor goedkeuring, waardoor goedkeuringsaanvragen in behandeling kunnen ontsnappen aan de lus. Elke Harness Agent-uitvoering maken en doorgeven AgentSession terwijl automatisch goedkeuren van hulpprogramma's is ingeschakeld.

Gebruik dezelfde AgentSession gesprekken opnieuw om het gesprek voort te zetten. Herhalende iteraties delen die sessie standaard. Met fresh_context=Truede middleware wordt de gekoppelde sessie hersteld naar de momentopname van de pre-lus tussen iteraties. Opslag van gesprekken in eigendom van de service kan de geschiedenis behouden wanneer de geserialiseerde sessie alleen een externe gespreks-id bevat.

Opmerking

Harness Agent-lussen zijn momenteel niet beschikbaar in Go, dus het goedkeurings- en sessiegedrag is niet van toepassing.

Volgende stappen 

Werk delegeren aan achtergrondagents

Dieper ingaan

  • Last updated on