Udostępnij za pośrednictwem

Kompakcja

Wraz ze wzrostem liczby konwersacji liczba tokenów w historii czatów może przekraczać okna kontekstu modelu lub zwiększać koszty. Strategie kompaktowania zmniejszają rozmiar historii konwersacji przy zachowaniu ważnego kontekstu, dzięki czemu agenci mogą nadal działać w długotrwałych interakcjach.

Ważna

Struktura kompaktowania jest obecnie eksperymentalna. Aby go użyć, należy dodać #pragma warning disable MAAI001.

Ważna

Struktura kompaktowania jest obecnie eksperymentalna w języku Python. Zaimportuj strategie z programu agent_framework._compaction.

Dlaczego kompaktowanie ma znaczenie

Każde wywołanie usługi LLM obejmuje pełną historię konwersacji. Bez kompaktowania:

  • Limity tokenów — konwersacje ostatecznie przekraczają okno kontekstu modelu, powodując błędy.
  • Koszt — większe wezwania zużywają więcej tokenów, zwiększając koszty interfejsu API.
  • Opóźnienie — więcej tokenów wejściowych oznacza wolniejsze czasy odpowiedzi.

Kompaktowanie rozwiązuje te problemy przez selektywne usuwanie, zwijanie lub podsumowywanie starszych części konwersacji.

Podstawowe pojęcia

Zastosowanie: tylko agenci historii pamięci operacyjnej

Kompaktowanie dotyczy tylko agentów, którzy zarządzają własną historią konwersacji w pamięci. Agenci korzystający z kontekstu zarządzanego przez usługę lub stanu konwersacji nie korzystają z kompaktowania, ponieważ usługa obsługuje już zarządzanie kontekstem. Przykłady agentów zarządzanych przez usługę obejmują:

  • Agenci usługi Foundry — kontekst jest zarządzany po stronie serwera w usłudze Azure AI Foundry.
  • API odpowiedzi z włączoną obsługą magazynowania (ustawienie domyślne) — stan konwersacji jest przechowywany i zarządzany przez usługę OpenAI.
  • Agenci Copilot Studio — kontekst konwersacji jest obsługiwany przez usługę Copilot Studio.

W przypadku tych typów agentów konfigurowanie strategii kompaktowania nie ma wpływu. Kompaktowanie jest istotne tylko wtedy, gdy agent utrzymuje własną listę komunikatów w pamięci i przekazuje pełną historię do modelu przy każdym wywołaniu.

Kompaktowanie działa na obiekcie MessageIndex — ustrukturyzowanym widoku płaskiej listy komunikatów, która grupuje komunikaty w niepodzielne jednostki nazywane MessageGroup wystąpieniami. Każda grupa śledzi liczbę komunikatów, liczbę bajtów i szacowaną liczbę tokenów.

Grupy komunikatów

Element MessageGroup reprezentuje logicznie powiązane komunikaty, które muszą być przechowywane lub usuwane razem. Na przykład, wiadomość asystenta zawierająca wywołania narzędzi i odpowiadające im wiadomości wynikowe narzędzi tworzą grupę atomową — usunięcie jednej bez drugiej spowodowałoby błędy w interfejsie API LLM.

Każda grupa ma element MessageGroupKind:

Rodzaj Opis
System Co najmniej jeden komunikat systemowy. Zawsze zachowywane podczas kompaktowania.
User Jeden komunikat użytkownika, który rozpoczyna nowy obrót.
AssistantText Zwykła odpowiedź tekstowa asystenta (bez wywołań narzędzi).
ToolCall Komunikat asystenta z wywołaniami narzędzi oraz odpowiednimi komunikatami wynikowymi, traktowany jako jedność niepodzielna.
Summary Skondensowany komunikat stworzony poprzez łączenie treści w zwięzłe podsumowanie.

Triggers

Element CompactionTrigger to delegat, który ocenia, czy kompaktowanie powinno być kontynuowane na podstawie bieżących MessageIndex metryk:

public delegate bool CompactionTrigger(MessageIndex index);

Klasa CompactionTriggers udostępnia typowe metody fabryczne:

Wyzwalacz Uruchamia się, gdy
CompactionTriggers.Always Za każdym razem (bezwarunkowo).
CompactionTriggers.Never Nigdy (wyłącza kompaktowanie).
CompactionTriggers.TokensExceed(maxTokens) Uwzględniona liczba tokenów przekracza próg.
CompactionTriggers.MessagesExceed(maxMessages) Uwzględniona liczba komunikatów przekracza próg.
CompactionTriggers.TurnsExceed(maxTurns) Liczba obrotu uwzględnionych użytkowników przekracza próg.
CompactionTriggers.GroupsExceed(maxGroups) Uwzględniona całkowita liczba grup przekracza próg.
CompactionTriggers.HasToolCalls() Istnieje co najmniej jedna grupa wywołań nieukluczonego narzędzia.

Łączenie wyzwalaczy z CompactionTriggers.All(...) (logicznym I) lub CompactionTriggers.Any(...) (logicznym LUB):

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

Wyzwalacz a element docelowy

Każda strategia ma dwa predykaty:

  • Trigger — określa , kiedy rozpoczyna się kompaktowanie. Jeśli wyzwalacz zwróci wartość false, strategia zostanie całkowicie pominięta.
  • Cel — określa , kiedy kompaktowanie zatrzymuje się. Strategie stopniowo wykluczają grupy i ponownie oceniają cel po każdym kroku, zatrzymując się, jak tylko cel zwróci wartość true.

Jeśli nie określono elementu docelowego, domyślną wartością jest przeciwieństwo działania wyzwalacza — kompaktowanie kończy się natychmiast, gdy warunek wyzwalacza przestanie być spełniony.

Kompaktowanie działa na płaskiej Message liście obiektów. Komunikaty są oznaczone lekkimi adnotacjami metadanych grupowych, a strategie zmieniają te adnotacje na miejscu, aby oznaczyć grupy jako wykluczone przed wyświetleniem listy komunikatów do modelu.

Grupy komunikatów

Komunikaty są grupowane w jednostki atomowe. Każda grupa ma przypisaną wartość GroupKind:

Rodzaj Opis
system Komunikaty systemowe. Zawsze utrzymywane w stanie nienaruszonym podczas procesu kompresji.
user Pojedynczy komunikat użytkownika.
assistant_text Zwykła odpowiedź tekstowa asystenta (brak wywołań funkcji).
tool_call Komunikat asystenta z wywołaniami funkcji oraz odpowiednie komunikaty wynikowe narzędzia, traktowane jako jednostka niepodzielna.

Strategie kompaktowania

A CompactionStrategy jest protokołem — każde async wywołanie, które akceptuje list[Message] element i mutuje go na miejscu, zwracane True po zmianie dowolnych elementów:

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

narzędzie do tokenizacji

Strategie obsługujące tokeny akceptują implementację TokenizerProtocol . CharacterEstimatorTokenizer Wbudowana funkcja używa heurystyki 4-znaków na token:

from agent_framework._compaction import CharacterEstimatorTokenizer

tokenizer = CharacterEstimatorTokenizer()

Przekaż niestandardowy tokenizer, gdy potrzebujesz dokładnych liczb tokenów dla kodowania określonego modelu.

Strategie kompaktowania

Wszystkie strategie dziedziczą po abstrakcyjnej CompactionStrategy klasie bazowej. Każda strategia zachowuje komunikaty systemowe i uwzględnia próg MinimumPreserved, który chroni najbardziej aktualne grupy niesystemowe przed usunięciem.

Strategie kompaktowania importuje się z agent_framework._compaction.

Strategia kompaktowania przez obcinanie

Strategia skrócenia

Najprostsze podejście: usuwa najstarsze grupy komunikatów niesystemowych do momentu spełnienia warunku docelowego.

  • Uwzględnia granice atomowe grupy (wywołanie narzędzia i komunikaty o wynikach są usuwane jednocześnie).
  • Najlepsze dla solidnych zabezpieczeń budżetu tokenów.
  • Właściwość MinimumPreserved domyślnie przyjmuje wartość 32.
// Drop oldest groups when tokens exceed 32K, keeping at least 10 recent groups
TruncationCompactionStrategy truncation = new(
    trigger: CompactionTriggers.TokensExceed(0x8000),
    minimumPreserved: 10);
  • Gdy tokenizer jest dostarczony, metryką jest liczba tokenów; w przeciwnym razie uwzględniana jest liczba wiadomości.
  • Właściwość preserve_system domyślnie przyjmuje wartość 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

Strategia Przesuwnego Okna

Usuwa starszą zawartość konwersacji, aby zachować tylko najnowsze okno wymiany, szanując jednostki konwersacji logicznej, a nie dowolną liczbę komunikatów. Komunikaty systemowe są zachowywane przez cały czas.

  • Najlepiej nadaje się do przewidywalnego ograniczania długości konwersacji.

Usuwa najstarsze ruchy użytkownika i skojarzone z nimi grupy odpowiedzi, działając na logicznych granicach tur, a nie na poszczególnych grupach.

  • Tura rozpoczyna się od komunikatu użytkownika i obejmuje wszystkie kolejne grupy asystentów oraz wywołań narzędzi aż do następnego komunikatu użytkownika.
  • MinimumPreserved domyślnie ustawione na 1 (zachowuje co najmniej najnowszą grupę niesystemową).
// Keep only the last 4 user turns
SlidingWindowCompactionStrategy slidingWindow = new(
    trigger: CompactionTriggers.TurnsExceed(4));

Utrzymuje tylko najnowsze keep_last_groups grupy niesystemowe, z wyłączeniem wszystkich starszych elementów.

  • Właściwość preserve_system domyślnie przyjmuje wartość True.
from agent_framework._compaction import SlidingWindowStrategy

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

Strategia Kompresji Wyników Narzędzia

Zwija starsze grupy wywołań narzędziowych do kompaktowych komunikatów podsumowujących, zachowując czytelny przebieg bez pełnego obciążenia wiadomości.

  • Nie dotyka komunikatów użytkownika ani zwykłych odpowiedzi asystenta.
  • Najlepiej jako strategia pierwszego podejścia w celu odzyskania miejsca z wyników generowanych przez narzędzie.
  • Zastępuje grupy wywołań narzędzi z wieloma komunikatami (wywołanie asystenta i wyniki narzędzia) krótkim podsumowaniem, na przykład [Tool calls: get_weather, search_docs].
  • MinimumPreserved domyślnie ustawione na 2, zapewniając, że interakcje narzędzi obecnej fazy pozostają widoczne.
// Collapse old tool results when tokens exceed 512
ToolResultCompactionStrategy toolCompaction = new(
    trigger: CompactionTriggers.TokensExceed(0x200));
  • Zwija się do kompaktowych komunikatów podsumowania, takich jak [Tool results: get_weather: sunny, 18°C].
  • Najnowsze keep_last_tool_call_groups grupy wywołań narzędzi pozostają nienaruszone.
from agent_framework._compaction import ToolResultCompactionStrategy

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

StrategiaKompaktowaniaPodsumowań

Strategia Podsumowania

Używa modułu LLM do podsumowania starszych części konwersacji, zastępując je pojedynczym komunikatem podsumowującym.

  • Domyślny monit zachowuje kluczowe fakty, decyzje, preferencje użytkownika i wyniki wywołania narzędzi.
  • Wymaga oddzielnego klienta LLM na potrzeby podsumowania — zaleca się mniejszy, szybszy model.
  • Najlepiej zachować kontekst konwersacyjny przy jednoczesnym znacznym zmniejszeniu liczby tokenów.
  • Możesz podać niestandardowe polecenie do podsumowania.
  • Chroni komunikaty systemowe oraz najbardziej aktualne grupy niesystemowe MinimumPreserved (domyślnie: 4).
  • Wysyła starsze wiadomości do oddzielnego IChatClient, korzystając z monitu do podsumowania, a następnie wstawia podsumowanie jako grupę 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);

Możesz podać niestandardowe polecenie podsumowania:

SummarizationCompactionStrategy summarization = new(
    chatClient: summarizerChatClient,
    trigger: CompactionTriggers.TokensExceed(0x500),
    summarizationPrompt: "Summarize the key decisions and user preferences only.");
  • Uruchamia się, gdy uwzględniona liczba komunikatów niesystemowych przekracza target_count + threshold.
  • Zachowuje najnowsze target_count komunikaty; podsumowuje wszystko starsze.
  • SupportsChatGetResponse Wymaga klienta.
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,
)

Podaj niestandardowy monit podsumowania:

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

Strategia kompaktowania potoku

Łączy wiele strategii w potok sekwencyjny. Każda strategia działa na wynikach działania poprzedniej strategii, co umożliwia warstwowe zagęszczanie od delikatnego do agresywnego.

  • Wyzwalacz pipeline'u to CompactionTriggers.Always — każda strategia podrzędna niezależnie ocenia swój wyzwalacz.
  • Strategie wykonują się w określonej kolejności, dlatego najpierw stosuj najdelikatniejsze strategie.
PipelineCompactionStrategy pipeline = new(
    new ToolResultCompactionStrategy(CompactionTriggers.TokensExceed(0x200)),
    new SummarizationCompactionStrategy(summarizerChatClient, CompactionTriggers.TokensExceed(0x500)),
    new SlidingWindowCompactionStrategy(CompactionTriggers.TurnsExceed(4)),
    new TruncationCompactionStrategy(CompactionTriggers.TokensExceed(0x8000)));

Ten potok:

  1. Zawija stare wyniki narzędzia (łagodnie).
  2. Podsumowuje starsze segmenty rozmów (umiarkowane).
  3. Utrzymuje tylko ostatnie 4 odpowiedzi użytkownika (agresywny).
  4. Usuwa najstarsze grupy, jeśli nadal przekracza budżet (zabezpieczenie awaryjne).

StrategiaKompaktowaniaWywołańNarzędziSelective

Całkowicie wyklucza starsze grupy wywołań narzędzi, zachowując tylko ostatni element keep_last_tool_call_groups.

  • Nie dotyka wiadomości użytkownika ani podstawowych wiadomości asystenta.
  • Najlepiej, gdy czatter narzędzi dominuje w użyciu tokenu, a pełna historia narzędzi nie jest potrzebna.
from agent_framework._compaction import SelectiveToolCallCompactionStrategy

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

StrategiaZłożonegoBudżetuTokenowego

Komponuje wiele strategii w sekwencyjny potok oparty na budżecie tokenów. Każda strategia podrzędna jest uruchamiana w kolejności, zatrzymując się przedwcześnie, gdy budżet zostanie wyczerpany. Wbudowany mechanizm awaryjny wyklucza najstarsze grupy, jeśli strategie nie mogą samodzielnie osiągnąć celu.

  • Strategie są wykonywane w kolejności; najpierw wykonywane są najdelikatniejsze strategie.
  • early_stop=True (wartość domyślna) zatrzymuje się natychmiast po osiągnięciu limitu tokenów.
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),
    ],
)

Ten potok:

  1. Zwija stare wyniki narzędzia (ostrożnie).
  2. Podsumowuje wcześniejsze fragmenty konwersacji, umiarkowanie.
  3. Utrzymuje tylko 20 ostatnich grup (agresywnych).
  4. Wraca do wykluczenia według najstarszeństwa, jeśli nadal ponad budżet (awaryjne zabezpieczenie).

Używanie kompresji z agentem

Opakuj strategię kompaktowania w obiekcie CompactionProvider i zarejestruj ją jako AIContextProvider. Przekaż pojedynczą strategię albo PipelineCompactionStrategy konstruktorowi.

Rejestrowanie przy użyciu interfejsu API konstruktora

Zarejestruj dostawcę na ChatClientBuilder używając UseAIContextProviders. Dostawca działa wewnątrz pętli wywoływania narzędzi, kompresując komunikaty przed każdym wywołaniem LLM.

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

Wskazówka

Użyj mniejszego, tańszego modelu (takiego jak gpt-4o-mini) dla klienta czatu podsumowania, aby zmniejszyć koszty przy zachowaniu jakości podsumowania.

Jeśli potrzebna jest tylko jedna strategia, przekaż ją bezpośrednio do CompactionProvider bez umieszczania jej w PipelineCompactionStrategy.

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

Rejestrowanie za pośrednictwem ChatClientAgentOptions

Dostawcę można również określić bezpośrednio na ChatClientAgentOptions.AIContextProviders:

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

Uwaga / Notatka

Po zarejestrowaniu za pomocą ChatClientAgentOptions, CompactionProvider nie jest zaangażowany podczas pętli wywoływania narzędzi. Dostawcy kontekstu na poziomie agenta działają przed zapisaniem historii czatu, więc wszystkie syntetyczne komunikaty podsumowania generowane przez CompactionProvider mogą stać się częścią utrwalonej historii podczas korzystania z ChatHistoryProvider. Aby skompaktować tylko kontekst żądania w locie przy zachowaniu oryginalnej przechowywanej historii, zarejestruj dostawcę przez UseAIContextProviders(...) na ChatClientBuilder.

Kompaktowanie ad hoc

CompactionProvider.CompactAsync stosuje strategię do dowolnej listy komunikatów bez aktywnej sesji agenta:

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

CompactionProvider jest dostawcą kontekstu, który stosuje strategie kompaktowania przed i po każdym uruchomieniu agenta. Dodaj go obok dostawcy historii na liście agenta context_providers .

  • before_strategy — jest uruchamiany przed wywołaniem modelu, kompaktowanie komunikatów już załadowanych do kontekstu.
  • after_strategy — jest uruchamiany po wywołaniu modelu, kompaktując komunikaty przechowywane przez dostawcę historii, dzięki czemu następna sesja zaczyna się od mniejszej ilości danych.
  • history_source_id source_id — dostawca historii, którego przechowywane komunikaty after_strategy powinny być kompaktowane (domyślnie "in_memory").

Rejestrowanie za pomocą agenta

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

Wskazówka

Użyj mniejszego, tańszego modelu (takiego jak gpt-4o-mini) dla klienta podsumowania, aby zmniejszyć koszty przy zachowaniu jakości podsumowania.

Jeśli potrzebna jest tylko jedna strategia, przekaż ją bezpośrednio jako before_strategy:

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

Kompaktowanie utrwalonej historii po każdym uruchomieniu

Użyj after_strategy, aby skompaktować komunikaty przechowywane przez dostawcę historii, tak aby przyszłe interakcje rozpoczynały się od ograniczonego kontekstu.

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

Kompaktowanie ad hoc

apply_compaction stosuje strategię do dowolnej listy komunikatów poza aktywną sesją agenta:

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

Wybieranie strategii

Strategia Agresywność Zachowuje kontekst Wymaga modułu LLM Najlepsze dla
ToolResultCompactionStrategy Low Wysoki — powoduje jedynie zwijanie wyników narzędziowych Nie. Odzyskiwanie przestrzeni z nadmiernie szczegółowych danych wyjściowych narzędzia
SummarizationCompactionStrategy Średni Średni — zastępuje historię podsumowaniem Yes Długie rozmowy, w których kontekst ma znaczenie
SlidingWindowCompactionStrategy High Niski — spada całe zakręty Nie. Ścisłe limity liczby obrotów
TruncationCompactionStrategy High Niski — usuwa najstarsze grupy Nie. Awaryjne mechanizmy zabezpieczające budżet tokenów
PipelineCompactionStrategy Konfigurowalny Zależy od strategii dzieci Depends Kompaktowanie warstwowe z wieloma mechanizmami zapasowymi
Strategia Agresywność Zachowuje kontekst Wymaga modułu LLM Najlepsze dla
ToolResultCompactionStrategy Low Wysoki — kompresuje wyniki narzędzia do wiadomości podsumowujących Nie. Przywracanie przestrzeni z wielosłownych danych wyjściowych narzędzia
SelectiveToolCallCompactionStrategy Niski–średni Średni — całkowicie wyklucza stare grupy wywołań funkcji sterujących narzędziami Nie. Usuwanie historii narzędzi, gdy wyniki nie są już potrzebne
SummarizationStrategy Średni Średni — zastępuje historię podsumowaniem Yes Długie rozmowy, w których kontekst ma znaczenie
SlidingWindowStrategy High Niski — usuwa najstarsze grupy Nie. Twarde limity liczby grup
TruncationStrategy High Niski — usuwa najstarsze grupy Nie. Środki zapobiegawcze w sytuacjach awaryjnych lub ograniczenia budżetu na tokeny
TokenBudgetComposedStrategy Konfigurowalny Zależy od strategii podrzędnych Depends Kompaktowanie warstwowe z celem budżetowym dotyczącym tokenów i wieloma opcjami rezerwowymi

Następne kroki

Dostawcy kontekstu

Przechowywanie

  • Last updated on