Komprimierung

Go unterstützt die Komprimierung über das agent/compaction Paket. Registrieren Sie eine Komprimierungsstrategie als agent.ContextProvider, damit sie den Sitzungsverlauf vor jeder Ausführung komprimieren kann.

Die Komprimierung arbeitet auf einer MessageIndex strukturierten Ansicht der flachen Nachrichtenliste, die Nachrichten in atomare Einheiten gruppiert, die als MessageGroup-Instanzen bezeichnet werden. Jede Gruppe verfolgt die Nachrichtenanzahl, byteanzahl und die geschätzte Tokenanzahl nach.

Nachrichtengruppen

Ein MessageGroup stellt logisch zusammengehörige Nachrichten dar, die zusammen beibehalten oder entfernt werden müssen. Eine Assistentennachricht, die Toolaufrufe enthält, und die entsprechenden Toolergebnismeldungen bilden beispielsweise eine atomische Gruppe – das Entfernen eines Ohne den anderen würde ZU LLM-API-Fehlern führen.

Jede Gruppe hat ein MessageGroupKind:

Trigger

Ein CompactionTrigger ist ein Delegat, der auswertet, ob die Komprimierung auf Basis der aktuellen MessageIndex Metriken fortgesetzt werden soll.

public delegate bool CompactionTrigger(MessageIndex index);

Die CompactionTriggers Klasse stellt allgemeine Fabrikmethoden bereit:

Kombinieren von Triggern mit CompactionTriggers.All(...) (logisches UND) oder CompactionTriggers.Any(...) (logisches ODER):

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

Trigger im Vergleich zum Ziel

Jede Strategie hat zwei Prädikate:

• Trigger – Steuerelemente , wenn die Komprimierung beginnt. Wenn der Trigger false zurückgibt, wird die gesamte Strategie übersprungen.
• Ziel – Steuert , wenn die Komprimierung beendet wird. Strategien schließen Gruppen schrittweise aus und bewerten das Ziel nach jedem Schritt neu, wobei der Prozess endet, sobald das Ziel zurückkehrt true.

Wenn kein Ziel angegeben wird, wird standardmäßig das Gegenteil des Triggers verwendet: Die Verdichtung wird beendet, sobald die Triggerbedingung nicht mehr erfüllt ist.

Komprimierung wird auf einer flachen Liste von Message Objekten ausgeführt. Nachrichten werden mit einfachen Gruppenmetadaten versehen, und Strategien mutieren diese Anmerkungen, um Gruppen als ausgeschlossen zu markieren, bevor die Nachrichtenliste auf das Modell projiziert wird.

Nachrichtengruppen

Nachrichten werden in atome Einheiten gruppiert. Jedem Gruppe wird ein GroupKind zugewiesen.

Komprimierungsstrategien

Ein CompactionStrategy ist ein Protokoll – jedes async aufrufbares Element, das es list[Message] annehmen und direkt verändern kann, zurückkehrt True, sobald etwas geändert wurde:

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

Tokenisierer

Tokenfähige Strategien akzeptieren eine TokenizerProtocol Implementierung. Das integrierte System CharacterEstimatorTokenizer verwendet eine Heuristik mit 4 Zeichen pro Token:

from agent_framework import CharacterEstimatorTokenizer

tokenizer = CharacterEstimatorTokenizer()

Übergeben Sie einen benutzerdefinierten Tokenizer, wenn Sie genaue Tokenanzahlen für die Codierung eines bestimmten Modells benötigen.

Komprimierung wird als Kontextanbieter ausgeführt. Strategien können den Sitzungsverlauf vor jeder Ausführung prüfen und ältere Nachrichtengruppen reduzieren und gleichzeitig den neuesten Kontext beibehalten.

Das Go-Paket enthält Strategietypen wie ToolResultStrategy, SlidingWindowStrategy und PipelineStrategy sowie Trigger-Hilfsfunktionen wie MessagesExceed und TurnsExceed.

Alle Strategien erben von der abstrakten CompactionStrategy Basisklasse. Jede Strategie behält Systemmeldungen bei und respektiert eine MinimumPreserved Schwelle, die die neuesten Nicht-System-Gruppen vor der Entfernung schützt.

Komprimierungsstrategien werden aus agent_frameworkimportiert.

Komprimierungsstrategien werden aus github.com/microsoft/agent-framework-go/agent/compactionimportiert.

Trunkierungs-Kompressionsstrategie

Abkürzungsstrategie

• Der Standardwert von MinimumPreserved ist 32.

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

• Wenn ein tokenizer Wert angegeben wird, ist die Metrik die Tokenanzahl. Andernfalls wird die Nachrichtenanzahl eingeschlossen.
• Der Standardwert von preserve_system ist 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

Gleitfensterstrategie

Entfernt die ältesten Benutzer turns und ihre zugehörigen Antwortgruppen, wobei logische Abgrenzungen der Turns verwendet werden und nicht auf einzelne Gruppen abgezielt wird.

• Ein Vorgang beginnt mit einer Benutzernachricht und umfasst alle nachfolgenden Assistenten- und Werkzeugaufrufgruppen bis zur nächsten Benutzernachricht.
• MinimumPreserved wird standardmäßig auf 1 gesetzt (behält mindestens die neueste nicht-systemdefinierte Gruppe bei).

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

Behält nur die neuesten keep_last_groups Nicht-Systemgruppen bei, mit Ausnahme aller älteren Gruppen.

• Der Standardwert von preserve_system ist True.

from agent_framework import SlidingWindowStrategy

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

• Ersetzt Tool-Anrufgruppen mit mehreren Nachrichten (Assistentenanruf + Ergebnisse der Werkzeuge) durch eine kurze Zusammenfassung, wie [Tool calls: get_weather, search_docs].
• MinimumPreserved wird standardmäßig auf 2 zurückgesetzt, wodurch sichergestellt wird, dass die Toolinteraktionen des aktuellen Zuges sichtbar bleiben.

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

• Reduziert sich in kompakte Zusammenfassungsmeldungen wie [Tool results: get_weather: sunny, 18°C]z. B. .
• Die neuesten keep_last_tool_call_groups Toolanrufgruppen bleiben unberührt.

from agent_framework import ToolResultCompactionStrategy

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

SummarizationCompactionStrategy

Strategie zur Zusammenfassung

• Schützt Systemmeldungen und die neuesten MinimumPreserved Nicht-Systemgruppen (Standard: 4).
• Sendet die älteren Nachrichten an separates IChatClient mit einer Aufforderung zur Zusammenfassung und fügt dann die Zusammenfassung als MessageGroupKind.Summary Gruppe ein.

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

Sie können eine benutzerdefinierte Zusammenfassungsaufforderung bereitstellen:

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

• Trigger, wenn die Anzahl der nicht systemfremden target_count + thresholdNachrichten überschreitet.
• Behält zuletzt verwendete Nachrichten in der Nähe target_countbei, vorbehaltlich von Nachrichtengruppengrenzen; fasst die ältesten vollständigen Gruppen zusammen, die dem Zusammenfassungseingabebudget entsprechen.
• Erfordert einen SupportsChatGetResponse Client.
• Begrenzt die Zusammenfassungsaufforderung und transkription standardmäßig auf 8.000 geschätzte Token. Sie wählt vollständige Nachrichtengruppen aus, sodass eine Gruppe niemals auf das Budget aufgeteilt wird.
• Legen Sie fest max_summary_input_tokens=None , dass die gebundene Zusammenfassungseingabe deaktiviert oder übergeben tokenizer= wird, wenn Sie modellspezifische Tokenzählung benötigen. Wenn keine vollständige Gruppe passt, wird die Zusammenfassung übersprungen, und der vorhandene Verlauf bleibt unverändert.

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

Geben Sie eine benutzerdefinierte Zusammenfassungsaufforderung an:

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

Steuern Sie das Zusammenfassungsanforderungsbudget unabhängig vom Ziel "Aufbewahrungsverlauf":

from agent_framework import CharacterEstimatorTokenizer, SummarizationStrategy

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

Pipeline-Verdichtungsstrategie

Kombiniert mehrere Strategieansätze zu einer sequenziellen Pipeline. Jede Strategie basiert auf dem Ergebnis der vorherigen, wodurch eine abgestufte Komprimierung von sanft bis aggressiv ermöglicht wird.

• Der eigene Trigger der Pipeline lautet CompactionTriggers.Always – jede untergeordnete Strategie wertet ihren eigenen Trigger unabhängig aus.
• Strategien werden in der Reihenfolge ausgeführt, also setzen Sie die sanftsten Strategien zuerst.

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

Diese Pipeline:

1. Klappt alte Werkzeugergebnisse auf sanfte Weise zusammen.
2. Fasst ältere Gesprächszeiträume (mäßig) zusammen.
3. Behält nur die letzten 4 Benutzerwechsel bei (aggressiv).
4. Entfernt älteste Gruppen, wenn das Budget noch überschritten ist (Notfall-Backstop).

Selektive Werkzeuganruf-Komprimierungsstrategie

Ältere Werkzeugaufrufgruppen werden vollständig ausgeschlossen, wobei nur die letzte keep_last_tool_call_groups beibehalten wird.

• Berührt weder Benutzer- noch einfache Assistenten-Nachrichten.
• Am besten, wenn Der Toolchatter die Tokenverwendung dominiert und der vollständige Toolverlauf nicht benötigt wird.

from agent_framework import SelectiveToolCallCompactionStrategy

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

TokenBudgetVerbundStrategie

Kombiniert mehrere Strategien in einer von einem Token-Budget gesteuerten sequenziellen Pipeline. Jede untergeordnete Strategie wird in der Reihenfolge ausgeführt und frühzeitig beendet, sobald das Budget erfüllt ist. Ein integrierter Fallback schließt die ältesten Gruppen aus, wenn die Strategien allein das Ziel nicht erreichen können.

• Strategien werden in der Reihenfolge ausgeführt; platzieren Sie die sanftsten Strategien zuerst.
• early_stop=True (Standardeinstellung) wird beendet, sobald das Tokenbudget erfüllt ist.

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

Diese Pipeline:

1. Klappt alte Werkzeugergebnisse auf sanfte Weise zusammen.
2. Fasst ältere Gesprächszeiträume (mäßig) zusammen.
3. Speichert nur die letzten 20 Gruppen (aggressive Vorgehensweise).
4. Fällt auf den ältesten Ausschluss zurück, wenn der Haushalt noch über dem Budget liegt (Notfall-Backstop).

Umschließen Sie eine Komprimierungsstrategie in einer CompactionProvider und registrieren Sie sie als eine AIContextProvider. Übergeben Sie entweder eine einzelne Strategie oder eine PipelineCompactionStrategy an den Konstruktor.

Registrieren mit der Generator-API

Registrieren Sie den Anbieter auf ChatClientBuilder mit UseAIContextProviders. Der Anbieter wird innerhalb der Werkzeugaufrufschleife ausgeführt und komprimiert Nachrichten vor jedem LLM-Aufruf.

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

Wenn nur eine Strategie benötigt wird, übergeben Sie sie direkt an CompactionProvider, ohne dass Sie sie in eine PipelineCompactionStrategy umschließen müssen.

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

Registrieren über ChatClientAgentOptions

Der Anbieter kann auch direkt bei ChatClientAgentOptions.AIContextProviders spezifiziert werden.

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

Ad-hoc-Komprimierung

CompactionProvider.CompactAsync wendet eine Strategie auf eine beliebige Nachrichtenliste ohne aktive Agentsitzung an:

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

Konfigurieren Sie die ausgewählte Komprimierungsstrategie und den Tokenizer direkt auf Agent. Werte auf Agentebene setzen Standardwerte außer Kraft, die auf dem zugrunde liegenden Chatclient konfiguriert sind, und ein einzelner agent.run(...) Anruf kann beides erneut außer Kraft setzen.

Registrieren bei einem 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))

Wenn nur eine Strategie benötigt wird, übergeben Sie sie direkt:

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

Überschreiben der Komprimierung für eine Ausführung

Übergeben compaction_strategy und tokenizer an den Zeitpunkt, an agent.run(...) dem eine Anforderung eine andere Richtlinie benötigt:

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

Ad-hoc-Komprimierung

apply_compaction wendet eine Strategie auf eine beliebige Nachrichtenliste außerhalb einer aktiven Agentsitzung an:

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

Erstellen Sie einen Komprimierungskontextanbieter, und fügen Sie ihn den Kontextanbietern des Agents hinzu:

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

Die Komprimierung ist standardmäßig deaktiviert. Legen Sie sowohl einen HarnessAgentOptions.MaxContextWindowTokensMaxOutputTokens Standardwert ContextWindowCompactionStrategyfest, als auch legen Sie fest CompactionStrategy , dass Sie Ihre eigene Strategie bereitstellen.

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

Die Nutzungsfunktion führt die aufgelöste Strategie vor jedem Modellaufruf in der Funktionsaufrufschleife aus. Wenn er auch den Standardwert InMemoryChatHistoryProvidererstellt, konfiguriert er diesen Anbieter mit dem Chat-Reduzierung der Strategie. Eine Benutzerdefinierte ChatHistoryProvider wird wie angegeben verwendet. DisableCompaction = truesetzt die Tokeneinstellungen außer Kraft und CompactionStrategyMaxOutputTokens legt weiterhin festChatOptions.MaxOutputTokens, wenn die Komprimierung aktiviert oder deaktiviert ist.

chatClient.AsHarnessAgent(options) und new HarnessAgent(chatClient, options) verwenden Sie dasselbe HarnessAgentOptions.

Die Komprimierung ist standardmäßig deaktiviert, es sei denn, beide max_context_window_tokens und max_output_tokens sie werden festgelegt, oder eine benutzerdefinierte Phasenstrategie wird bereitgestellt.

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

Mit den Tokeneinstellungen verwendet die Verwendung eine ContextWindowCompactionStrategy für beide Phasen: Die Vorphase wird vor jedem Modellaufruf innerhalb der Toolschleife ausgeführt, während die Nachphase den Verlauf nach der Ausführung beibehalten hat. Überschreiben Sie entweder eine Phase unabhängig von before_compaction_strategy oder after_compaction_strategy; legen Sie tokenizer= für einen benutzerdefinierten Tokenizer, history_provider= für einen anderen Verlaufsspeicher oder disable_compaction=True zum Deaktivieren beider Phasen fest. max_output_tokens stellt außerdem die Standard-Chatoption max_tokens zur Auswahl.

Der Nutzungs-Agent ist derzeit nicht im Go SDK verfügbar. Registrieren Sie einen Komprimierungskontextanbieter manuell wie oben dargestellt.