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.

Fontos

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

Fontos

A tömörítési keretrendszer jelenleg pythonos kísérleti. Importáljon stratégiákat a agent_framework._compaction.

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 Leírás
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:

Kiváltó 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 Leírás
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._compaction 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.

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._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._compaction 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._compaction 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._compaction 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 legújabb target_count üzeneteket; mindent összefoglal, ami régebbi.
  • Ügyfélre SupportsChatGetResponse van szükség.
from agent_framework._compaction 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.",
)

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:

  1. Összecsukja a régi eszköz eredményeit (gyengéd).
  2. A régebbi (mérsékelt) beszélgetési időtartamokat foglalja össze.
  3. Csak az utolsó 4 felhasználói lépés marad meg (agresszív).
  4. 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._compaction 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._compaction 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:

  1. Összecsukja a régi eszköz eredményeit (gyengéd).
  2. A régebbi (mérsékelt) beszélgetési időtartamokat foglalja össze.
  3. Csak az utolsó 20 csoportot tartja meg (agresszív).
  4. 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));

Jótanács

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

CompactionProvider olyan környezetszolgáltató, amely tömörítési stratégiákat alkalmaz az egyes ügynökök futtatása előtt és után. Adja hozzá az ügynök context_providers listájában egy előzményszolgáltató mellé.

  • before_strategy — a modellhívás előtt fut, és tömöríti a környezetbe már betöltött üzeneteket.
  • after_strategy — a modellhívás után fut, tömörítve az előzményszolgáltató által tárolt üzeneteket, hogy a következő művelet kevesebb adattal induljon.
  • history_source_id — annak az előzményszolgáltatónak a source_id neve, amelynek a tárolt üzeneteit kell tömöríteni (alapértelmezés szerint after_strategy).

Regisztrálás ügynökkel

from agent_framework import Agent, CompactionProvider, InMemoryHistoryProvider
from agent_framework._compaction import (
    CharacterEstimatorTokenizer,
    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),
    ],
)

history = InMemoryHistoryProvider()
compaction = CompactionProvider(
    before_strategy=pipeline,
    history_source_id=history.source_id,
)

agent = Agent(
    client=client,
    name="ShoppingAssistant",
    instructions="You are a helpful shopping assistant.",
    context_providers=[history, compaction],
)

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

Jótanács

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 a következőként before_strategy:

compaction = CompactionProvider(
    before_strategy=SlidingWindowStrategy(keep_last_groups=20),
    history_source_id=history.source_id,
)

Az előzmények tömörítése minden futtatás után

Az after_strategy használható az előzményszolgáltató által tárolt üzenetek összetömörítésére, így a jövőbeli párbeszédek csökkentett kontextussal kezdődhetnek.

compaction = CompactionProvider(
    before_strategy=SlidingWindowStrategy(keep_last_groups=20),
    after_strategy=ToolResultCompactionStrategy(keep_last_tool_call_groups=1),
    history_source_id=history.source_id,
)

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

Stratégia kiválasztása

Stratégia Agresszivitás Megőrzi a kontextust LLM-et igényel A következőkre alkalmas
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 Igen 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 Attól függ. Rétegzett tömörítés több tartalék megoldással
Stratégia Agresszivitás Megőrzi a kontextust LLM-et igényel A következőkre alkalmas
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 Igen 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 Attól függ. Rétegzett tömörítés token-költségvetési céllal és több visszaesési lehetőséggel.

Következő lépések

Middleware

  • Last updated on