Tömörítés

A beszélgetések növekedésével a csevegési előzmények tokenszáma meghaladhatja a modellkörnyezet ablakait, vagy növelheti a költségeket. A tömörítési stratégiák csökkentik a beszélgetések előzményeinek méretét, miközben megőrzik a fontos környezetet, így az ügynökök továbbra is működőképesek maradnak a hosszan futó interakciók során.

Important

A tömörítési keretrendszer jelenleg kísérleti. A használatához hozzá kell adnia #pragma warning disable MAAI001.

Important

A tömörítési keretrendszer jelenleg pythonos kísérleti. Tömörítési típusok importálása a fájlból agent_framework.

A Go a agent/compaction csomagon keresztül támogatja a tömörítést. Regisztráljon egy tömörítési stratégiát, agent.ContextProvider hogy minden futtatás előtt tömöríthesse a munkamenetek előzményeit.

Miért fontos a tömörítés?

Az LLM minden hívása tartalmazza a teljes beszélgetési előzményt. Tömörítés nélkül:

Token határok – A beszélgetések végül túllépik a modell kontextusablakát, ami hibákat okoz.
Költség – A nagyobb utasítások több tokeneket használnak fel, növelve az API-költségeket.
Késleltetés – A több bemeneti token lassabb válaszidőt jelent.

A tömörítés a beszélgetés régebbi részeinek szelektív eltávolításával, összecsukásával vagy összegzésével oldja meg ezeket a problémákat.

Alapfogalmak

Alkalmazhatóság: Csak a memóriában lévő előzményügynökök esetén

A tömörítés csak azokra az ügynökökre vonatkozik, amelyek a saját beszélgetési előzményeiket kezelik a memóriában. A szolgáltatás által felügyelt környezetre vagy beszélgetési állapotra támaszkodó ügynökök nem élvezhetik a tömörítés előnyeit, mivel a szolgáltatás már kezeli a környezetkezelést. A szolgáltatás által felügyelt ügynökök például a következők:

Foundry Agents – a környezetet a Microsoft Foundry szolgáltatás szerveroldalon felügyeli.
Az OpenAI szolgáltatás tárolja és kezeli a beszélgetési állapotot tároló és kezelő Válasz API-t(alapértelmezett).
Copilot Studio-ügynökök – a beszélgetési környezetet a Copilot Studio szolgáltatás tartja fenn.

Ezekben az ügynöktípusokban a tömörítési stratégia konfigurálásának nincs hatása. A tömörítés csak akkor lényeges, ha az ügynök fenntartja a saját memórián belüli üzenetlistáját, és minden hívásnál átadja a teljes előzménylistát a modellnek.

A tömörítés a MessageIndex lapos üzenetlista strukturált nézetén működik, amely az üzeneteket atomi egységekbe, úgynevezett MessageGroup példányokba csoportosítja. Minden csoport nyomon követi az üzenetek számát, a bájtok számát és a becsült tokenek számát.

Üzenetcsoportok

A logikailag MessageGroup kapcsolódó üzeneteket jelöli, amelyeket együtt kell tartani vagy el kell távolítani. Az eszközhívásokat és az eszköz eredményüzeneteit tartalmazó segédüzenetek például atomi csoportot alkotnak – az egyik eltávolítása a másik nélkül LLM API-hibákat okozna.

Minden csoportnak van egy MessageGroupKind:

Altípus	Description
`System`	Egy vagy több rendszerüzenet. Mindig meg van őrizve a tömörítés során.
`User`	Egyetlen felhasználói üzenet, amely új fordulót indít el.
`AssistantText`	Egyszerű segítő szöveges válasz (nincs eszközhívás).
`ToolCall`	Segédüzenet eszközhívásokkal és az eszköz eredményüzeneteivel, atomi egységként kezelve.
`Summary`	Az összegző tömörítés által létrehozott tömörített üzenet.

Kiváltó okok

A CompactionTrigger egy delegáló, amely kiértékeli, hogy a tömörítés az aktuális MessageIndex mutatók alapján folytatódjon-e.

public delegate bool CompactionTrigger(MessageIndex index);

Az CompactionTriggers osztály általános gyári metódusokat biztosít:

Indító	Akkor aktiválódik, ha
`CompactionTriggers.Always`	Minden alkalommal (feltétel nélkül).
`CompactionTriggers.Never`	Soha (a tömörítés letiltva).
`CompactionTriggers.TokensExceed(maxTokens)`	A belefoglalt tokenek száma meghaladja a küszöbértéket.
`CompactionTriggers.MessagesExceed(maxMessages)`	A belefoglalt üzenetek száma meghaladja a küszöbértéket.
`CompactionTriggers.TurnsExceed(maxTurns)`	A belefoglalt felhasználói fordulók száma meghaladja a küszöbértéket.
`CompactionTriggers.GroupsExceed(maxGroups)`	A belefoglalt csoportok száma meghaladja a küszöbértéket.
`CompactionTriggers.HasToolCalls()`	Legalább egy nem kizárt eszközhívási csoport létezik.

Eseményindítók CompactionTriggers.All(...) kombinálása (logikai ÉS) vagy CompactionTriggers.Any(...) (logikai VAGY):

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

Kiváltó és cél

Minden stratégiának két predikátuma van:

Trigger — Szabályozza, hogy mikor kezdődik a tömörítés. Ha az eseményindító visszatér false, a stratégia teljes egészében ki lesz hagyva.
Cél — Meghatározza mikor áll le a tömörítés. A stratégiák fokozatosan kizárják a csoportokat, és minden lépés után újraértékelik a célt, leáll, amint a cél visszatér true.

Ha nincs megadva cél, az alapértelmezés szerint az eseményindító inverze lesz – a tömörítés leáll, amint az eseményindító feltétel már nem lép működésbe.

A tömörítés az objektumok egysíkú Message listáján működik. Az üzeneteket egyszerű csoport metaadatokkal látják el, és a stratégiák ezeket a megjegyzéseket változtatják meg, hogy a csoportok kizártként legyenek megjelölve, mielőtt az üzenetlistát a modellre vetítenék.

Üzenetcsoportok

Az üzenetek atomi egységekbe vannak csoportosítva. Minden csoporthoz hozzá van rendelve egy GroupKind.

Altípus	Description
`system`	Rendszerüzenetek. Mindig meg van őrizve a tömörítés során.
`user`	Egyetlen felhasználói üzenet.
`assistant_text`	Egyszerű szöveges válasz (függvényhívások nélkül).
`tool_call`	Segédüzenet, amely függvényhívásokat és az eszköz eredményüzeneteit tartalmazza, egy atomi egységként kezelve.

Tömörítési stratégiák

A CompactionStrategy protokoll – a bármely async hívható objektum, amely elfogad egy list[Message] és a helyben módosítja azt, és visszaadja a True értéket, amikor bármit megváltoztatott.

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

Tokenizáló

A jogkivonat-tudatos stratégiák egy TokenizerProtocol implementációt fogadnak el. A beépített CharacterEstimatorTokenizer függvény egy 4 karakteres, tokenenkénti heurisztikát használ:

from agent_framework import CharacterEstimatorTokenizer

tokenizer = CharacterEstimatorTokenizer()

Használjon egyéni tokenizálót, ha pontos tokenszámra van szüksége egy adott modell kódolásához.

A tömörítés kontextusszolgáltatóként fut. A stratégiák minden futtatás előtt megvizsgálhatják a munkamenetek előzményeit, és csökkenthetik a régebbi üzenetcsoportokat a legújabb környezet megőrzése mellett.

A Go csomag olyan stratégiatípusokat tartalmaz, mint a ToolResultStrategy, SlidingWindowStrategy és PipelineStrategy, valamint olyan eseményindító-segédfüggvényeket, mint a MessagesExceed és TurnsExceed.

Tömörítési stratégiák

Minden stratégia öröklődik az absztrakt CompactionStrategy alaposztálytól. Minden stratégia megőrzi a rendszerüzeneteket, és tiszteletben tart egy MinimumPreserved padlót, amely megvédi a legújabb nem rendszercsoportokat az eltávolítástól.

A tömörítési stratégiákat a rendszer importálja.agent_framework

A tömörítési stratégiákat a rendszer importálja.github.com/microsoft/agent-framework-go/agent/compaction

TruncationCompactionStrategy

CsonkításStratégia

A legegyszerűbb módszer: eltávolítja a legrégebbi, rendszeren kívüli üzenetcsoportokat, amíg a célfeltétel nem teljesül.

Tiszteletben tartja az atomi csoport határait (az eszközhívás és az eredményüzenetek együtt törlődnek).
Legjobb megoldás a szigorú token-költségvetési korlátokhoz.

MinimumPreserved alapértelmezés szerint 32.

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

Ha meg van adva a tokenizer, a metrika a tokenszám; ellenkező esetben az üzenetszám lesz a metrika.
preserve_system alapértelmezés szerint 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

Csúszóablak-stratégia

Eltávolítja a régebbi beszélgetési tartalmakat, hogy csak a legutóbbi csereablakot tartsa meg, és ne az tetszőleges üzenetszámokat, hanem a logikai beszélgetési egységeket tartsa tiszteletben. A rendszerüzenetek teljes egészében megmaradnak.

A legjobb megoldás a beszélgetés hosszának kiszámítható behatárolásához.

Eltávolítja a legrégebbi felhasználói fordulatokat és a hozzájuk tartozó válaszcsoportokat, és nem az egyes csoportokat, hanem a logikai fordulók határait használják.

A turn egy felhasználói üzenettel kezdődik, és az összes további segéd- és eszközhívási csoportot tartalmazza a következő felhasználói üzenetig.
MinimumPreserved alapértelmezés szerint 1 (legalább a legújabb nem rendszercsoportot megőrzi).

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

Csak a legújabb keep_last_groups , rendszeren kívüli csoportokat tartja meg, kivéve az összes régebbit.

preserve_system alapértelmezés szerint True.

from agent_framework import SlidingWindowStrategy

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

ToolResultCompactionStrategy

Összecsukja a régebbi eszközhívási csoportokat tömör összefoglaló üzenetekké, így a teljes üzenetterhelés nélkül megőrizhető az olvasható nyomkövetés.

Nem érinti a felhasználói üzeneteket és az egyszerű asszisztensi válaszokat.
Legjobb első lépésként használható stratégia, amely a részletes eszközeredményekből visszanyeri a helyet.

A többüzenetes eszközhívási csoportokat (segédhívás + eszközeredmények) egy rövid összefoglalóra cseréli, például [Tool calls: get_weather, search_docs]: .
MinimumPreserved alapértelmezettként a 2-re, biztosítva, hogy az aktuális kör eszköz-interakciói láthatóak maradjanak.

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

Összecsukható tömör összefoglaló üzenetekké, például [Tool results: get_weather: sunny, 18°C].
A legutóbbi keep_last_tool_call_groups eszközhívási csoportok érintetlenek maradnak.

from agent_framework import ToolResultCompactionStrategy

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

SummarizationCompactionStrategy

Összegzési stratégia

Egy LLM használatával összegzi a beszélgetés régebbi részeit, és egyetlen összefoglaló üzenetre cseréli őket.

Az alapértelmezett kérés megőrzi a legfontosabb tényeket, döntéseket, felhasználói beállításokat és eszközhívási eredményeket.
Az összegzéshez külön LLM-ügyfél szükséges – kisebb, gyorsabb modell használata ajánlott.
A legjobb megoldás a beszélgetés kontextusának megőrzésére, miközben jelentősen csökkenti a tokenek számát.
Megadhat egy egyéni összegzési kérést.

Védi a rendszerüzeneteket és a legújabb MinimumPreserved nem rendszercsoportokat (alapértelmezés: 4).
A régebbi üzeneteket egy külön IChatClient címzettel ellátott összefoglalási felhívással küldi el, majd beszúrja az összefoglalót csoportként 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);

Megadhat egy egyéni összegzési kérést:

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

Eseményindítók, ha a rendszeren kívüli üzenetek száma meghaladja target_count + thresholda elemet.
Megtartja a legutóbbi üzeneteket a közelben target_count, az üzenetcsoport határainak függvényében; összegzi a legrégebbi teljes csoportokat, amelyek illeszkednek az összegző bemeneti költségvetéséhez.
Ügyfélre SupportsChatGetResponse van szükség.
Alapértelmezés szerint 8000 becsült jogkivonatra köti az összegző kérést és az átiratot. A teljes üzenetcsoportokat választja ki, így a csoportok soha nem lesznek felosztva a költségvetésnek megfelelően.
Állítsa be max_summary_input_tokens=None úgy, hogy letiltsa az összegző bemenetét, vagy ha tokenizer= modellspecifikus tokenszámlálásra van szüksége. Ha a teljes csoport nem fér el, a program kihagyja az összegzést, és a meglévő előzmények változatlanok maradnak.

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

Adjon meg egy egyéni összegzési kérést:

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

Az összegző kérelem költségvetésének szabályozása a megőrzött előzménycéltól függetlenül:

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

Több stratégiát állít össze egy szekvenciális folyamatba. Minden stratégia az előző eredmény alapján működik, így a réteges tömörítés a gyengédtől az agresszívig folyik.

A folyamat saját eseményindítója – CompactionTriggers.Always minden gyermekstratégia önállóan értékeli ki a saját eseményindítóját.
A stratégiák sorrendben hajtanak végre, ezért a leggyengédebb stratégiákat helyezze az első helyre.

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

Ez a csővezeték:

Összecsukja a régi eszköz eredményeit (gyengéd).
A régebbi (mérsékelt) beszélgetési időtartamokat foglalja össze.
Csak az utolsó 4 felhasználói lépés marad meg (agresszív).
Elveti a legrégebbi csoportokat, ha még mindig túl van a költségvetésen (vészhelyzeti backstop).

SelectiveToolCallCompactionStrategy

Teljes mértékben kizárja a régebbi eszközhívási csoportokat, és csak az utolsót keep_last_tool_call_groupstartja meg.

Nem érinti a felhasználói vagy egyszerű asszisztensi üzeneteket.
A legjobb, ha az eszközcsevegés uralja a tokenhasználatot, és nincs szükség a teljes eszközelőzményekre.

from agent_framework import SelectiveToolCallCompactionStrategy

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

TokenBudget összetett stratégia

Több stratégiát kombinál egy számítási költségvetés által vezérelt szekvenciális csővezetékbe. Az egyes gyermekstratégiák sorrendben futnak, és a költségvetés teljesülése után korán leállnak. A beépített tartalék kizárja a legrégebbi csoportokat, ha a stratégiák önmagukban nem tudják elérni a célt.

A stratégiák végrehajtása sorrendben történik; a leggyengédebb stratégiákat kell elsőként elhelyezni.
early_stop=True (az alapértelmezett) leáll, amint a tokenkeret teljesül.

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

Ez a csővezeték:

Összecsukja a régi eszköz eredményeit (gyengéd).
A régebbi (mérsékelt) beszélgetési időtartamokat foglalja össze.
Csak az utolsó 20 csoportot tartja meg (agresszív).
Visszaesik a legrégebbi első kizárásra, ha még mindig túl van a költségvetésen (vészhelyzeti backstop).

Tömörítés használata ügynökkel

Tömörítési stratégia becsomagolása egy -ba, és regisztrálása formájában. Adjon át egyetlen stratégiát vagy egy PipelineCompactionStrategy-t a konstruktornak.

Regisztráció a builder API-val

Regisztrálja a szolgáltatót a ChatClientBuilder a UseAIContextProviders használatával. A szolgáltató az eszközhívási cikluson belül fut, és minden LLM-hívás előtt tömöríti az üzeneteket.

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

Tip

Használjon egy kisebb, olcsóbb modellt (például gpt-4o-mini) az összegző csevegőügyfél számára a költségek csökkentéséhez az összefoglaló minőség fenntartása mellett.

Ha csak egy stratégiára van szükség, adja át közvetlenül a CompactionProvider, anélkül, hogy a PipelineCompactionStrategy-be ágyazná.

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

Regisztráció `ChatClientAgentOptions` által

A szolgáltató közvetlenül megadható a következőn is: ChatClientAgentOptions.AIContextProviders.

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

Megjegyzés:

Amikor regisztrálva van a ChatClientAgentOptions-n keresztül, a CompactionProvidernem aktiválódik az eszközhívási ciklus során. Az ügynökszintű kontextusszolgáltatók a csevegési előzmények tárolása előtt futnak, így az általuk CompactionProvider létrehozott szintetikus összefoglaló üzenetek a ChatHistoryProvider használata során a tárolt előzmények részévé válhatnak. Ha csak a repülés közbeni kérelemkörnyezetet szeretné tömöríteni az eredeti tárolt előzmények megőrzése mellett, regisztrálja a szolgáltatót a ChatClientBuilder via-on UseAIContextProviders(...) .

Alkalmi tömörítés

CompactionProvider.CompactAsync stratégiát alkalmaz egy tetszőleges üzenetlistára aktív ügynöki munkamenet nélkül:

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

Konfigurálja közvetlenül a kiválasztott tömörítési stratégiát és tokenizert.Agent Az ügynökszintű értékek felülbírálják az alapul szolgáló csevegőügyfél alapértelmezett beállításait, és egyetlen agent.run(...) hívás újra felülbírálhatja mindkettőt.

Regisztrálás ügynökkel

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

Tip

Használjon egy kisebb, olcsóbb modellt (például gpt-4o-mini) az összegző ügyfélhez a költségek csökkentéséhez az összefoglaló minőség fenntartása mellett.

Ha csak egy stratégiára van szükség, adja át közvetlenül:

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

Tömörítés felülbírálása egy futtatáshoz

Adja át és tokenizer adja megcompaction_strategy, agent.run(...) ha egy kérésnek más szabályzatra van szüksége:

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

Alkalmi tömörítés

apply_compaction stratégiát alkalmaz egy tetszőleges üzenetlistára egy aktív ügynök-munkameneten kívül:

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

Hozzon létre egy tömörítési környezetszolgáltatót, és adja hozzá az ügynök környezetszolgáltatóihoz:

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

Tip

A teljes futtatható példáért tekintse meg a tömörítési folyamat mintáját .

Tömörítés használata a Hámügynökkel

A fenti manuális beállítással teljes mértékben szabályozható a tömörítési szolgáltató futási helye. A Harness Agent ehelyett a szolgáltatásonkénti híváselőzmények folyamatába köti a tömörítést, így a hosszú eszközhívási ciklusok tömöríthetők a modellhívások között.

A tömörítés alapértelmezés szerint ki van kapcsolva. Állítsa be mindkettőt HarnessAgentOptions.MaxContextWindowTokens , és MaxOutputTokens hozzon létre egy alapértelmezettet ContextWindowCompactionStrategy, vagy állítsa be CompactionStrategy a saját stratégiáját.

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

A hám a feloldott stratégiát futtatja a függvényhívási ciklus minden modellhívása előtt. Amikor az alapértelmezettet InMemoryChatHistoryProvideris létrehozza, konfigurálja a szolgáltatót a stratégia csevegéscsökkentőjével. A rendszer egy egyénit ChatHistoryProvider használ a megadott módon. DisableCompaction = true felülbírálja a jogkivonat beállításait, és CompactionStrategy; MaxOutputTokens továbbra is be van állítva ChatOptions.MaxOutputTokens , ha a tömörítés engedélyezve van vagy le van tiltva.

chatClient.AsHarnessAgent(options) és new HarnessAgent(chatClient, options) használja ugyanazt HarnessAgentOptions.

A tömörítés alapértelmezés szerint ki van kapcsolva, kivéve, ha mindkettő max_context_window_tokensmax_output_tokens be van állítva, vagy egy egyéni fázisstratégia van megadva.

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

A jogkivonat-beállításokkal a heveder mindkét fázishoz újra felhasznál egyet ContextWindowCompactionStrategy : az előző fázis az eszközhurok minden modellhívása előtt fut, míg az azt követő fázis tömörítése a futtatás után is megmarad. Bírálja felül a fázisokat egymástól függetlenül before_compaction_strategy egy egyéni jogkivonat-tárolóhoz, egy másik előzménytárolóhoz, history_provider= vagy after_compaction_strategytokenizer=disable_compaction=True tiltsa le mindkét fázist. max_output_tokens az alapértelmezett max_tokens csevegési lehetőséget is biztosítja.

A Hámügynök jelenleg nem érhető el a Go SDK-ban. A tömörítési környezet szolgáltatóinak manuális regisztrálása a fent látható módon.

Stratégia kiválasztása

Strategy	Agresszivitás	Megőrzi a kontextust	LLM-et igényel	Legjobb a számára
`ToolResultCompactionStrategy`	Alacsony	Magas szint – csak az eszközeredmények összecsukása	No	Szabad terület visszanyerése részletes eszközkimenetből
`SummarizationCompactionStrategy`	Medium	Közepes – az előzményeket összefoglalóra cseréli	Yes	Hosszú beszélgetések, ahol a környezet számít
`SlidingWindowCompactionStrategy`	Magas	Alacsony – teljes körök kimaradnak	No	Szigorú fordulatszám-korlátok
`TruncationCompactionStrategy`	Magas	Alacsony – a legrégebbi csoportokat törli	No	Vészhelyzeti token-költségvetési biztosítékok
`PipelineCompactionStrategy`	Configurable	A gyermekstratégiáktól függ	Depends	Rétegzett tömörítés több tartalék megoldással

Strategy	Agresszivitás	Megőrzi a kontextust	LLM-et igényel	Legjobb a számára
`ToolResultCompactionStrategy`	Alacsony	Magas – összecsukja az eszköz eredményeit összefoglaló üzenetekké	No	Szabad terület visszanyerése részletes eszközkimenetből
`SelectiveToolCallCompactionStrategy`	Alacsony–közepes	Közepes – teljesen kizárja a régi eszközhívási csoportokat	No	Eszközelőzmények eltávolítása, ha már nincs szükség eredményekre
`SummarizationStrategy`	Medium	Közepes – az előzményeket összefoglalóra cseréli	Yes	Hosszú beszélgetések, ahol a környezet számít
`SlidingWindowStrategy`	Magas	Alacsony – a legrégebbi csoportokat törli	No	Kemény csoportszámkorlátok
`TruncationStrategy`	Magas	Alacsony – a legrégebbi csoportokat törli	No	Vészhelyzeti üzenet– vagy jogkivonat-költségvetés háttérrendszere
`TokenBudgetComposedStrategy`	Configurable	A gyermekstratégiáktól függ	Depends	Rétegzett tömörítés token-költségvetési céllal és több visszaesési lehetőséggel.

Strategy	Agresszivitás	Megőrzi a kontextust	LLM-et igényel	Legjobb a számára
`ToolResultStrategy`	Alacsony	Magas – összecsukja az eszközök részletes eredményeit	No	Szabad terület visszanyerése részletes eszközkimenetből
`SlidingWindowStrategy`	Magas	Alacsony – megtartja a legutóbbi fordulatokat	No	Szigorú fordulatszám-korlátok
`PipelineStrategy`	Configurable	A gyermekstratégiáktól függ	Depends	Rétegzett tömörítés több tartalék megoldással

Következő lépések

Middleware

Visszajelzés

Hasznosnak találta ezt az oldalt?

Last updated on 2026-08-13

Tömörítés

Miért fontos a tömörítés?

Alapfogalmak

Alkalmazhatóság: Csak a memóriában lévő előzményügynökök esetén

Üzenetcsoportok

Kiváltó okok

Kiváltó és cél

Üzenetcsoportok

Tömörítési stratégiák

Tokenizáló

Tömörítési stratégiák

TruncationCompactionStrategy

CsonkításStratégia

SlidingWindowCompactionStrategy

Csúszóablak-stratégia

ToolResultCompactionStrategy

SummarizationCompactionStrategy

Összegzési stratégia

PipelineCompactionStrategy

SelectiveToolCallCompactionStrategy

TokenBudget összetett stratégia

Tömörítés használata ügynökkel

Regisztráció a builder API-val

Regisztráció ChatClientAgentOptions által

Alkalmi tömörítés

Regisztrálás ügynökkel

Tömörítés felülbírálása egy futtatáshoz

Alkalmi tömörítés

Tömörítés használata a Hámügynökkel

Stratégia kiválasztása

Következő lépések

Visszajelzés

További források

Regisztráció `ChatClientAgentOptions` által