Przejdź do głównej treści
Polski— Wybierz język
Menu

Zaawansowane buforowanie promptów

Lekcja 13 z 20 Zaktualizowano 28 lipca 2026 Zaawansowany
Na tej stronie
  1. Poza automatycznym buforowaniem
  2. Architektura promptów maksymalizująca buforowanie
  3. Trzy wzorce, które robią różnicę
  4. Co to oznacza w skali masowej
  5. Kluczowe wnioski

Poza automatycznym buforowaniem

Poznałeś podstawy buforowania promptów w Lekcji 3. Wydawało się wtedy, że buforowanie to mechanizm automatyczny, który działa na Twoją korzyść bez żadnego wysiłku z Twojej strony. Jest to prawdą tylko wtedy, gdy Twoja aplikacja wysyła dobrze uporządkowane żądania. Rzeczywistość produkcyjna jest bardziej chaotyczna: wielu użytkowników uderza w to samo API jednocześnie, każdy z własnym folderem, dokumentami i pytaniami. Wspólny prefiks kurczy się wtedy do zera, a wskaźnik trafień w pamięci podręcznej (cache hit rate) załamuje się niezauważenie, ponieważ nic nie przestaje działać – rośnie jedynie rachunek.

Wielu użytkowników, wiele dokumentów, potoki przetwarzania: zajmiemy się tymi złożonymi scenariuszami po kolei, aby zmaksymalizować wskaźnik trafień w pamięci podręcznej. Zasada przewodnia mieści się w jednym zdaniu: buforowanie nie jest czymś, co Ci się przydarza; to coś, co projektujesz.

Architektura promptów maksymalizująca buforowanie

Buforowanie dotyczy najdłuższego wspólnego prefiksu we wszystkich Twoich żądaniach. Im jest on dłuższy i stabilniejszy, tym więcej oszczędzasz. Praktyczną konsekwencją jest to, że prompt musi być zorganizowany od elementów najbardziej stabilnych do najbardziej zmiennych, niczym książka, której pierwsze strony nigdy się nie zmieniają, a jedynie ostatni rozdział jest przepisywany w każdym wydaniu.

Poniższy przykład stosuje tę zasadę do asystenta analizy dokumentów dla kancelarii prawnej. Trzy warstwy następują po sobie: instrukcje globalne (zamrożone), baza wiedzy (aktualizowana raz w miesiącu) oraz akta sprawy i pytanie (zmieniające się przy każdym wywołaniu).

import openai

client = openai.OpenAI()

# Architektura warstwowa: od najbardziej stabilnych do najbardziej zmiennych

# Warstwa 1: Instrukcje globalne (nigdy się nie zmieniają)
GLOBAL_INSTRUCTIONS = """
You are a document analysis assistant for a law firm.
Rules:
- Always respond in French
- Cite relevant legal articles
- Structure as: Analysis / Risks / Recommendations
- Be factual and precise
"""

# Warstwa 2: Baza wiedzy (zmienia się rzadko)
KNOWLEDGE_BASE = """
[Insert 5,000+ tokens of case law, legal articles,
 analysis templates here—this content changes at most once a month]
"""

# Warstwa 3: Kontekst sprawy (zmienia się dla każdego klienta)
def build_prompt(case_context: str, question: str) -> str:
    return f"""{GLOBAL_INSTRUCTIONS}

{KNOWLEDGE_BASE}

--- Current Case ---
{case_context}

--- Question ---
{question}"""

Klasycznym błędem jest umieszczanie nazwy klienta lub dzisiejszej daty na początku promptu systemowego w celu jego „spersonalizowania“. Pojedynczy zmienny znak na początkowej pozycji wystarczy, aby uczynić prefiks unikalnym, co redukuje wskaźnik trafień w pamięci podręcznej do zera dla wszystkich kolejnych warstw. Wszystko, co zmienne, musi trafić na koniec.

Oczywiście musisz zweryfikować, czy teoria przekłada się na liczby. Poniższy monitor odczytuje input_tokens_details.cached_tokens z każdej odpowiedzi i kumuluje pomiary, dając Ci użyteczną średnią zamiast polegać na przeczuciach.

class CacheMonitor:
    """Monitoruje efektywność buforowania promptów."""

    def __init__(self):
        self.calls: list[dict] = []

    def record(self, usage) -> dict:
        total_input = usage.input_tokens
        cached_tokens = getattr(
            usage.input_tokens_details, "cached_tokens", 0
        )
        rate = cached_tokens / total_input if total_input > 0 else 0

        entry = {
            "total_input": total_input,
            "cached_tokens": cached_tokens,
            "cache_rate": rate,
        }
        self.calls.append(entry)
        return entry

    @property
    def average_rate(self) -> float:
        if not self.calls:
            return 0.0
        return sum(a["cache_rate"] for a in self.calls) / len(self.calls)

    def report(self) -> str:
        if not self.calls:
            return "Brak wywołań."
        return (
            f"Wywołania: {len(self.calls)} | "
            f"Średni wskaźnik cache: {self.average_rate:.1%} | "
            f"Zaoszczędzone tokeny: "
            f"{sum(a['cached_tokens'] for a in self.calls):,}"
        )

monitor = CacheMonitor()

Trzy wzorce, które robią różnicę

Pierwszy wzorzec dotyczy kolejności przetwarzania. Gdy przetwarzasz partię niejednorodnych żądań, uruchamianie ich w kolejności przybycia powoduje przeplatanie się prefiksów i uniemożliwia utrzymanie pamięci podręcznej w stanie gotowości („warm“). Grupowanie według wspólnego kontekstu rozwiązuje ten problem: najpierw zbierz, potem wykonuj, aby każda grupa skorzystała z prefiksu przygotowanego przez pierwsze żądanie.

from collections import defaultdict

def group_by_context(
    requests: list[dict],
) -> dict[str, list[dict]]:
    """Grupuje żądania według wspólnego prefiksu."""
    groups = defaultdict(list)

    for request in requests:
        # Klucz = hash wspólnego kontekstu
        key = hash(request.get("shared_context", ""))
        groups[key].append(request)

    return dict(groups)

def process_by_cohort(requests: list[dict]):
    """Przetwarza zgrupowane żądania, aby zmaksymalizować buforowanie."""
    groups = group_by_context(requests)

    for key, group in groups.items():
        # Wszystkie żądania w grupie dzielą ten sam prefiks
        for request in group:
            response = client.responses.create(
                model="gpt-5.6-terra",
                instructions=request["shared_context"],
                input=request["question"],
            )
            monitor.record(response.usage)

Drugi wzorzec obsługuje „zimne starty“ (cold starts). Pierwsze żądanie w serii płaci pełną cenę, ponieważ nic nie jest jeszcze w pamięci podręcznej; jeśli to pierwsze żądanie pochodzi od rzeczywistego użytkownika w poniedziałek rano o 9:00, to on ponosi koszt opóźnienia. Żądanie rozgrzewające wysłane przed uruchomieniem usługi przenosi ten koszt tam, gdzie nikomu nie przeszkadza. Zwróć uwagę na warunek na początku funkcji: poniżej 1024 tokenów buforowanie nie ma zastosowania, a wstępne rozgrzewanie byłoby czystym wydatkiem.

def warm_up_cache(system_prompt: str):
    """Wysyła minimalne żądanie, aby przygotować pamięć podręczną."""
    if len(system_prompt) // 4 < 1024:
        print("Prompt zbyt krótki do buforowania (< 1024 tokenów)")
        return

    response = client.responses.create(
        model="gpt-5.6-terra",
        instructions=system_prompt,
        input="Confirm that you are ready.",
        max_output_tokens=10,
    )

    usage = response.usage
    print(
        f"Pamięć podręczna przygotowana: {usage.input_tokens} tokenów wejściowych, "
        f"{getattr(usage.input_tokens_details, 'cached_tokens', 0)} w buforze"
    )

Trzeci wzorzec czynni unieważnianie pamięci podręcznej widocznym. Naprawienie przecinka w systemowym prompcie liczącym 5000 tokenów wydaje się trywialne, jednak ten przecinek czyści pamięć podręczną dla wszystkich. Dołączając odcisk palca (fingerprint) do treści, wykrywasz zmianę w momencie wdrożenia, a nie następnego dnia na fakturze, i możesz natychmiast podjąć działania rozgrzewające.

import hashlib

class VersionedPrompt:
    """Zarządza wersjami promptów w celu kontrolowania buforowania."""

    def __init__(self, content: str):
        self.content = content
        self.version = hashlib.md5(content.encode()).hexdigest()[:8]

    def is_same_version(self, other: "VersionedPrompt") -> bool:
        return self.version == other.version

# Jeśli wersja się zmieni, pamięć podręczna zostanie unieważniona
prompt_v1 = VersionedPrompt("Instructions v1...")
prompt_v2 = VersionedPrompt("Instructions v2 modified...")

if not prompt_v1.is_same_version(prompt_v2):
    print("Ostrzeżenie: prompt zmieniony, pamięć podręczna zostanie unieważniona")
    warm_up_cache(prompt_v2.content)

Co to oznacza w skali masowej

Weźmy rzeczywisty przypadek 10 000 wywołań dziennie z systemowym promptem liczącym 3000 tokenów. Bez buforowania fakturowanych jest 10 000 × 3000, czyli 30 milionów tokenów wejściowych każdego dnia. Przy wskaźniku trafień wynoszącym 80%, 6 milionów tokenów pozostaje w pełnej cenie, a 24 miliony spada do połowy ceny, co przynosi oszczędności rzędu 40% na tokenach wejściowych. Kwota ta może wydawać się skromna w odniesieniu do pojedynczego wywołania; jednak w ciągu roku pracy produkcyjnej zmienia ona strukturę kosztów aplikacji.

Kluczowe wnioski

  • Strukturyzuj swoje prompty warstwowo, od najbardziej stabilnych do najbardziej zmiennych
  • Grupuj żądania według wspólnego kontekstu, aby utrzymać pamięć podręczną w stanie gotowości
  • Rozgrzewaj pamięć podręczną przed szczytami ruchu
  • Monitoruj wskaźnik buforowania za pomocą input_tokens_details.cached_tokens
  • Wersjonuj swoje prompty, aby przewidzieć unieważnienia pamięci podręcznej