Verdichting

Go ondersteunt compressie via het agent/compaction pakket. Registreer een compressiestrategie als een agent.ContextProvider strategie zodat deze sessiegeschiedenis kan comprimeren voordat elke uitvoering wordt uitgevoerd.

Compressie werkt op een MessageIndex — een gestructureerde weergave van de platte berichtenlijst die berichten groepeert in atomische eenheden, genaamd MessageGroup exemplaren. Elke groep houdt het aantal berichten, het aantal byte en het geschatte aantal tokens bij.

Berichtgroepen

A MessageGroup vertegenwoordigt logisch gerelateerde berichten die samen moeten worden bewaard of verwijderd. Een assistentbericht met hulpprogrammaaanroepen en de bijbehorende berichten over het resultaat van het hulpprogramma vormen bijvoorbeeld een atomische groep. Als u een bericht verwijdert zonder de andere, zou dat fouten met de LLM-API veroorzaken.

Elke groep heeft een MessageGroupKind:

Triggers

A CompactionTrigger is een gemachtigde die evalueert of compressie moet worden voortgezet op basis van de huidige MessageIndex metrische gegevens:

public delegate bool CompactionTrigger(MessageIndex index);

De CompactionTriggers klasse biedt veelgebruikte factorymethoden:

Triggers combineren met CompactionTriggers.All(...) (logische AND) of CompactionTriggers.Any(...) (logische OF):

// Compact only when there are tool calls AND tokens exceed 2000
CompactionTrigger trigger = CompactionTriggers.All(
    CompactionTriggers.HasToolCalls(),
    CompactionTriggers.TokensExceed(2000));

Trigger versus doel

Elke strategie heeft twee predicaten:

• Trigger : hiermee bepaalt u wanneer de compressie begint. Als de trigger false retourneert, wordt de strategie volledig overgeslagen.
• Doel — Regelt wanneer compacte stopt. Strategieën sluiten incrementeel groepen uit en evalueren het doel na elke stap opnieuw, stoppen zodra het doel retourneert true.

Wanneer er geen doel is opgegeven, wordt standaard de inverse van de triggerconditie gebruikt. Compactie stopt zodra de triggervoorwaarde niet meer wordt geactiveerd.

Compressie werkt op een platte lijst Message met objecten. Berichten worden geannoteerd met lichtgewicht groepsmetagegevens en strategieën muteren deze aantekeningen om groepen te markeren als uitgesloten voordat de berichtenlijst naar het model wordt geprojecteerd.

Berichtgroepen

Berichten worden gegroepeerd in atomische eenheden. Aan elke groep wordt een GroupKind:

Compressiestrategieën

A CompactionStrategy is een protocol: elk async aanroepbaar dat een list[Message] accepteert en het ter plekke muteert, retourneert True wanneer het iets wijzigt:

class CompactionStrategy(Protocol):
    async def __call__(self, messages: list[Message]) -> bool: ...

Tokenizer

Tokenbewuste strategieën accepteren een TokenizerProtocol implementatie. De ingebouwde CharacterEstimatorTokenizer maakt gebruik van een heuristiek van 4 tekens per token:

from agent_framework import CharacterEstimatorTokenizer

tokenizer = CharacterEstimatorTokenizer()

Geef een aangepaste tokenizer door wanneer u nauwkeurige tokenaantallen nodig hebt voor de codering van een specifiek model.

Compaction fungeert als contextprovider. Strategieën kunnen sessiegeschiedenis controleren voordat elke uitvoering wordt uitgevoerd en oudere berichtgroepen verminderen, terwijl de nieuwste context behouden blijft.

Het Go-pakket bevat strategietypen zoals ToolResultStrategy, SlidingWindowStrategyen PipelineStrategy, plus trigger-helpers zoals MessagesExceed en TurnsExceed.

Alle strategieën nemen over van de abstracte CompactionStrategy basisklasse. Elke strategie behoudt systeemberichten en respecteert een MinimumPreserved vloer die de meest recente niet-systeemgroepen beschermt tegen verwijdering.

Compressiestrategieën worden geïmporteerd uit agent_framework.

Compressiestrategieën worden geïmporteerd uit github.com/microsoft/agent-framework-go/agent/compaction.

TruncationCompactionStrategy

TruncationStrategy

• MinimumPreserved wordt standaard ingesteld op 32.

// Drop oldest groups when tokens exceed 32K, keeping at least 10 recent groups
TruncationCompactionStrategy truncation = new(
    trigger: CompactionTriggers.TokensExceed(0x8000),
    minimumPreserved: 10);

• Wanneer er een tokenizer wordt opgegeven, wordt het aantal tokens als metriek gebruikt; anders wordt het aantal berichten meegeteld.
• preserve_system wordt standaard ingesteld op True.

from agent_framework import CharacterEstimatorTokenizer, TruncationStrategy

# Exclude oldest groups when tokens exceed 32 000, trimming to 16 000
truncation = TruncationStrategy(
    max_n=32_000,
    compact_to=16_000,
    tokenizer=CharacterEstimatorTokenizer(),
)

SlidingWindowCompactionStrategy

SlidingWindowStrategy

Verwijdert de oudste dialoogbeurten en de bijbehorende antwoordgroepen, die werken op logische grenzen van beurten in plaats van afzonderlijke groepen.

• Een beurt begint met een gebruikersbericht en bevat alle volgende assistent- en hulpprogrammaoproepgroepen tot het volgende gebruikersbericht.
• MinimumPreserved standaard op 1 (behoudt ten minste de meest recente niet-systeemgroep).

// Keep only the last 4 user turns
SlidingWindowCompactionStrategy slidingWindow = new(
    trigger: CompactionTriggers.TurnsExceed(4));

Bewaart alleen de meest recente keep_last_groups niet-systeemgroepen, met uitzondering van alles wat ouder is.

• preserve_system wordt standaard ingesteld op True.

from agent_framework import SlidingWindowStrategy

# Keep only the last 20 non-system groups
sliding_window = SlidingWindowStrategy(keep_last_groups=20)

• Vervangt oproepgroepen met meerdere berichten (assistentgesprek + resultaten) door een korte samenvatting zoals [Tool calls: get_weather, search_docs].
• MinimumPreserved is standaard ingesteld op 2, zodat de interacties van de huidige beurt zichtbaar blijven.

// Collapse old tool results when tokens exceed 512
ToolResultCompactionStrategy toolCompaction = new(
    trigger: CompactionTriggers.TokensExceed(0x200));

• Wordt samengevouwen tot compacte samenvattingsberichten zoals [Tool results: get_weather: sunny, 18°C].
• De meest recente keep_last_tool_call_groups groepen voor het aanroepen van hulpprogramma's blijven ongewijzigd.

from agent_framework import ToolResultCompactionStrategy

# Collapse all but the newest tool-call group
tool_result = ToolResultCompactionStrategy(keep_last_tool_call_groups=1)

SummarizationCompactionStrategie

Samenvattingsstrategie

• Beveiligt systeemberichten en de meest recente MinimumPreserved niet-systeemgroepen (standaard: 4).
• Verzendt de oudere berichten naar een afzonderlijk IChatClient met een samenvattingsprompt en voegt vervolgens de samenvatting in als groep MessageGroupKind.Summary .

// Summarize older messages when tokens exceed 1280, keeping the last 4 groups
SummarizationCompactionStrategy summarization = new(
    chatClient: summarizerChatClient,
    trigger: CompactionTriggers.TokensExceed(0x500),
    minimumPreserved: 4);

U kunt een aangepaste samenvattingsprompt opgeven:

SummarizationCompactionStrategy summarization = new(
    chatClient: summarizerChatClient,
    trigger: CompactionTriggers.TokensExceed(0x500),
    summarizationPrompt: "Summarize the key decisions and user preferences only.");

• Wordt geactiveerd wanneer het aantal niet-systeemberichten groter is dan target_count + threshold.
• Bewaart recente berichten in de buurt target_count, afhankelijk van de grenzen van berichtengroepen; geeft een overzicht van de oudste volledige groepen die passen bij het invoerbudget van de summarizer.
• Hiervoor is een SupportsChatGetResponse client vereist.
• Hiermee wordt de prompt en transcriptie van de summarizer standaard gebonden aan 8.000 geschatte tokens. Het selecteert volledige berichtgroepen, zodat een groep nooit wordt gesplitst om aan het budget te voldoen.
• Stel max_summary_input_tokens=None deze functie in om de invoergrens van de samenvattende waarde uit te schakelen of door te geven tokenizer= wanneer u modelspecifieke tokentelling nodig hebt. Als er geen volledige groep past, wordt de samenvatting overgeslagen en blijft de bestaande geschiedenis ongewijzigd.

from agent_framework import SummarizationStrategy

# Summarize when non-system message count exceeds 6, retaining the 4 newest
summarization = SummarizationStrategy(
    client=summarizer_client,
    target_count=4,
    threshold=2,
)

Geef een aangepaste samenvattingsprompt op:

summarization = SummarizationStrategy(
    client=summarizer_client,
    target_count=4,
    prompt="Summarize the key decisions and user preferences only.",
)

Beheer het budget voor de overzichtsaanvraag onafhankelijk van het doel voor de bewaarde geschiedenis:

from agent_framework import CharacterEstimatorTokenizer, SummarizationStrategy

summarization = SummarizationStrategy(
    client=summarizer_client,
    target_count=4,
    threshold=2,
    max_summary_input_tokens=16_000,
    tokenizer=CharacterEstimatorTokenizer(),
)

PipelineCompactionStrategy

Stelt meerdere strategieën samen in een sequentiële pijplijn. Elke strategie werkt op het resultaat van de vorige strategie, waardoor gelaagde compressie van zacht tot agressief mogelijk is.

• De eigen trigger van de pijplijn is CompactionTriggers.Always : elke onderliggende strategie evalueert een eigen trigger onafhankelijk.
• Strategieën worden op volgorde uitgevoerd, dus plaats eerst de zachtste strategieën.

PipelineCompactionStrategy pipeline = new(
    new ToolResultCompactionStrategy(CompactionTriggers.TokensExceed(0x200)),
    new SummarizationCompactionStrategy(summarizerChatClient, CompactionTriggers.TokensExceed(0x500)),
    new SlidingWindowCompactionStrategy(CompactionTriggers.TurnsExceed(4)),
    new TruncationCompactionStrategy(CompactionTriggers.TokensExceed(0x8000)));

Deze pijplijn:

1. Hiermee worden oude toolresultaten samengevouwen (zacht).
2. Geeft een overzicht van oudere gesprekken (gemiddeld).
3. Houdt alleen de laatste vier gebruikersbeurten bij (agressief).
4. De oudste groepen worden verwijderd als ze nog steeds boven het budget zijn (noodmaatregel).

SelectieveGereedschapsAanroepCompactieStrategie

Sluit volledig oudere tool-aanroepgroepen uit en houdt alleen de laatste keep_last_tool_call_groups.

• Raakt geen berichten van de gebruiker of platte assistent aan.
• Het beste wanneer toolchatter het tokengebruik overheerst en de volledige hulpprogrammageschiedenis niet nodig is.

from agent_framework import SelectiveToolCallCompactionStrategy

# Keep only the most recent tool-call group
selective_tool = SelectiveToolCallCompactionStrategy(keep_last_tool_call_groups=1)

TokenBudgetComposedStrategy

Stelt meerdere strategieën samen in een sequentiële pijplijn die wordt aangestuurd door een tokenbudget. Elke kindstrategie wordt in volgorde uitgevoerd en stopt vroeg zodra het budget is gevuld. Een ingebouwde terugval sluit de oudste groepen uit als de strategieën alleen het doel niet kunnen bereiken.

• Strategieën worden op volgorde uitgevoerd; plaats eerst de zachtste strategieën.
• early_stop=True (de standaardinstelling) stopt zodra aan het tokenbudget is voldaan.

from agent_framework import (
    CharacterEstimatorTokenizer,
    SelectiveToolCallCompactionStrategy,
    SlidingWindowStrategy,
    SummarizationStrategy,
    TokenBudgetComposedStrategy,
    ToolResultCompactionStrategy,
)

tokenizer = CharacterEstimatorTokenizer()

pipeline = TokenBudgetComposedStrategy(
    token_budget=16_000,
    tokenizer=tokenizer,
    strategies=[
        ToolResultCompactionStrategy(keep_last_tool_call_groups=1),
        SummarizationStrategy(client=summarizer_client, target_count=4, threshold=2),
        SlidingWindowStrategy(keep_last_groups=20),
    ],
)

Deze pijplijn:

1. Hiermee worden oude toolresultaten samengevouwen (zacht).
2. Geeft een overzicht van oudere gesprekken (gemiddeld).
3. Houdt alleen de laatste 20 groepen (agressief).
4. Valt terug op oudste uitsluiting als het budget nog steeds is overschreden (noodstop).

Verpakt een compressiestrategie in een CompactionProvider en registreer deze als een AIContextProvider. Geef één strategie of een PipelineCompactionStrategy door aan de constructor.

Registreren bij de builder-API

Registreer de provider op de ChatClientBuilder met behulp van UseAIContextProviders. De provider wordt uitgevoerd in de lus voor het aanroepen van hulpprogramma's, waarbij berichten vóór elke LLM-aanroep worden gecomprimeerd.

IChatClient agentChatClient = openAIClient.GetChatClient(deploymentName).AsIChatClient();
IChatClient summarizerChatClient = openAIClient.GetChatClient(deploymentName).AsIChatClient();

PipelineCompactionStrategy compactionPipeline =
    new(
        new ToolResultCompactionStrategy(CompactionTriggers.TokensExceed(0x200)),
        new SummarizationCompactionStrategy(summarizerChatClient, CompactionTriggers.TokensExceed(0x500)),
        new SlidingWindowCompactionStrategy(CompactionTriggers.TurnsExceed(4)),
        new TruncationCompactionStrategy(CompactionTriggers.TokensExceed(0x8000)));

AIAgent agent =
    agentChatClient
        .AsBuilder()
        .UseAIContextProviders(new CompactionProvider(compactionPipeline))
        .BuildAIAgent(
            new ChatClientAgentOptions
            {
                Name = "ShoppingAssistant",
                ChatOptions = new()
                {
                    Instructions = "You are a helpful shopping assistant.",
                    Tools = [AIFunctionFactory.Create(LookupPrice)],
                },
            });

AgentSession session = await agent.CreateSessionAsync();
Console.WriteLine(await agent.RunAsync("What's the price of a laptop?", session));

Als er slechts één strategie nodig is, kunt u deze rechtstreeks aan CompactionProvider doorgeven zonder deze in een PipelineCompactionStrategy:

agentChatClient
    .AsBuilder()
    .UseAIContextProviders(new CompactionProvider(
        new SlidingWindowCompactionStrategy(CompactionTriggers.TurnsExceed(20))))
    .BuildAIAgent(...);

Registreren via ChatClientAgentOptions

De provider kan ook rechtstreeks worden opgegeven op ChatClientAgentOptions.AIContextProviders:

AIAgent agent = agentChatClient
    .AsBuilder()
    .BuildAIAgent(new ChatClientAgentOptions
    {
        AIContextProviders = [new CompactionProvider(compactionPipeline)]
    });

Ad-hoc compressie

CompactionProvider.CompactAsync past een strategie toe op een willekeurige berichtenlijst zonder een actieve agentsessie:

IEnumerable<ChatMessage> compacted = await CompactionProvider.CompactAsync(
    new TruncationCompactionStrategy(CompactionTriggers.TokensExceed(8000)),
    existingMessages);

Configureer de geselecteerde compressiestrategie en tokenizer rechtstreeks op Agent. Waarden op agentniveau overschrijven standaardwaarden die zijn geconfigureerd op de onderliggende chatclient en één agent.run(...) aanroep kan beide opnieuw overschrijven.

Registreren bij een agent

from agent_framework import (
    Agent,
    CharacterEstimatorTokenizer,
    SlidingWindowStrategy,
    SummarizationStrategy,
    TokenBudgetComposedStrategy,
    ToolResultCompactionStrategy,
    TruncationStrategy,
)

tokenizer = CharacterEstimatorTokenizer()

strategy = TokenBudgetComposedStrategy(
    token_budget=16_000,
    tokenizer=tokenizer,
    strategies=[
        ToolResultCompactionStrategy(keep_last_tool_call_groups=1),
        SummarizationStrategy(client=summarizer_client, target_count=4, threshold=2),
        SlidingWindowStrategy(keep_last_groups=20),
    ],
)

agent = Agent(
    client=client,
    name="ShoppingAssistant",
    instructions="You are a helpful shopping assistant.",
    compaction_strategy=strategy,
    tokenizer=tokenizer,
)

session = agent.create_session()
print(await agent.run("What's the price of a laptop?", session=session))

Als er slechts één strategie nodig is, geeft u deze rechtstreeks door:

agent = Agent(
    client=client,
    compaction_strategy=SlidingWindowStrategy(keep_last_groups=20),
    tokenizer=CharacterEstimatorTokenizer(),
)

Compressie van onderdrukking voor één uitvoering

Doorgeven compaction_strategy en tokenizer aan agent.run(...) wanneer één aanvraag een ander beleid nodig heeft:

response = await agent.run(
    "Summarize the rollout risks.",
    compaction_strategy=TruncationStrategy(max_n=8_000, compact_to=4_000),
    tokenizer=tokenizer,
)

Ad-hoc compressie

apply_compaction past een strategie toe op een willekeurige berichtenlijst buiten een actieve agentsessie:

from agent_framework import apply_compaction, TruncationStrategy, CharacterEstimatorTokenizer

tokenizer = CharacterEstimatorTokenizer()

compacted = await apply_compaction(
    messages,
    strategy=TruncationStrategy(
        max_n=8_000,
        compact_to=4_000,
        tokenizer=tokenizer,
    ),
    tokenizer=tokenizer,
)

Maak een compressiecontextprovider en voeg deze toe aan de contextproviders van de agent:

import (
    "github.com/microsoft/agent-framework-go/agent"
    "github.com/microsoft/agent-framework-go/agent/compaction"
    "github.com/microsoft/agent-framework-go/provider/foundryprovider"
)

compactionProvider := compaction.NewContextProvider(compaction.ContextProviderConfig{
    Strategy: &compaction.PipelineStrategy{
        Strategies: []compaction.Strategy{
            &compaction.ToolResultStrategy{
                Trigger:                compaction.MessagesExceed(7),
                MinimumPreservedGroups: 4,
            },
            &compaction.SlidingWindowStrategy{
                Trigger:               compaction.TurnsExceed(4),
                MinimumPreservedTurns: 4,
            },
        },
    },
})

a := foundryprovider.NewAgent(endpoint, token, foundryprovider.ModelDeployment(model), foundryprovider.AgentConfig{
    Config: agent.Config{
        ContextProviders: []agent.ContextProvider{compactionProvider},
    },
})

Compressie is standaard uitgeschakeld. Stel beide in HarnessAgentOptions.MaxContextWindowTokens en MaxOutputTokens maak een standaardinstelling ContextWindowCompactionStrategyof stel deze in CompactionStrategy om uw eigen strategie op te geven.

HarnessAgent agent = chatClient.AsHarnessAgent(new HarnessAgentOptions
{
    MaxContextWindowTokens = 128_000,
    MaxOutputTokens = 16_384,
});

De harness voert de opgeloste strategie uit vóór elke modeloproep in de functie-aanroeplus. Wanneer deze ook de standaardwaarde InMemoryChatHistoryProvidermaakt, wordt die provider geconfigureerd met de chat reducer van de strategie. Een aangepaste ChatHistoryProvider wordt gebruikt zoals opgegeven. DisableCompaction = true overschrijft de tokeninstellingen en CompactionStrategywordt MaxOutputTokens nog steeds ingesteld ChatOptions.MaxOutputTokens wanneer compressie is ingeschakeld of uitgeschakeld.

chatClient.AsHarnessAgent(options) en new HarnessAgent(chatClient, options) gebruik hetzelfde HarnessAgentOptions.

Compressie is standaard uitgeschakeld, tenzij beide max_context_window_tokensmax_output_tokens zijn ingesteld of als er een aangepaste fasestrategie wordt geleverd.

agent = create_harness_agent(
    client,
    max_context_window_tokens=128_000,
    max_output_tokens=16_384,
)

Met de tokeninstellingen hergebruikt het harnas er een ContextWindowCompactionStrategy voor beide fasen: de voorfase wordt uitgevoerd vóór elke modelaanroep in de toollus, terwijl de na fase de geschiedenis na de uitvoering comprimert. Overschrijven van fase onafhankelijk met before_compaction_strategy of ; ingesteld tokenizer= voor een aangepaste tokenizer, history_provider= voor een ander geschiedenisarchief of disable_compaction=True om beide fasen after_compaction_strategyuit te schakelen. max_output_tokens levert ook de standaard max_tokens chatoptie.

Harness Agent is momenteel niet beschikbaar in de Go SDK. Registreer handmatig een compressiecontextprovider zoals hierboven wordt weergegeven.