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

Buforowanie promptów: Ponowne wykorzystanie obliczeń

Lekcja 3 z 20 Zaktualizowano 28 lipca 2026 Zaawansowany
Na tej stronie
  1. Czym jest buforowanie promptów?
  2. Jak to działa
  3. Strukturyzowanie w celu maksymalizacji cache’u
  4. Kluczowe wnioski

Czym jest buforowanie promptów?

Gdy wielokrotnie wysyłasz ten sam prefiks promptu – długi prompt systemowy, szczegółowe instrukcje lub dokument referencyjny – OpenAI może automatycznie zbuforować ten prefiks. Kolejne wywołania współdzielące ten prefiks korzystają ze skróconego czasu do pierwszego tokenu (TTFT) i niższych kosztów za tokeny wejściowe. Innymi słowy, praca związana z ingestowaniem stabilnego kontekstu nie jest powtarzana dla każdego żądania.

Buforowanie promptów jest automatyczne od 2025 roku: nie musisz niczego włączać. OpenAI wykrywa identyczne prefiksy i je buforuje. Twoim zadaniem nie jest więc włączanie lub wyłączanie tej funkcji, lecz konstruowanie promptów tak, aby mechanizm mógł zadziałać. To kwestia struktury, a nie konfiguracji, i właśnie tutaj większość zespołów traci pieniądze.

Jak to działa

Pamięć podręczna dotyczy prefiksów promptu: pierwsze tokeny muszą być ściśle identyczne od jednego wywołania do drugiego, a dopasowanie kończy się przy pierwszym różniącym się znaku. Aby uruchomić buforowanie, wymagana jest minimalna wielkość 1024 tokenów, co natychmiast wyklucza krótkie prompty systemowe. Pamięć podręczna jest współdzielona w ramach jednej organizacji, co oznacza, że wiele usług w Twojej firmie wywołujących ten sam prefiks wzajemnie sobie pomaga. Czas życia cache’u wynosi od kilku minut do kilku godzin, bez ścisłych gwarancji, a osiągnięta redukcja kosztów wynosi około 50% dla zbuforowanych tokenów wejściowych.

Praktyczną konsekwencją zasady prefiksu jest konieczność umieszczania elementów stabilnych na początku promptu, a zmiennych na końcu. Usługa, która wstawia dzisiejszą datę lub identyfikator sesji na początek swojego promptu systemowego, unieważnia swój cache przy każdym wywołaniu, nawet o tym nie wiedząc.

import openai

client = openai.OpenAI()

# ✅ Dobra struktura: najpierw elementy stabilne
SYSTEM_PROMPT = """Jesteś asystentem prawnym specjalizującym się we francuskim
prawie umów. Analizujesz klauzule umowne zgodnie z
Kodeksem cywilnym i najnowszym orzecznictwem. Zawsze odpowiadasz,
strukturyzując swoją analizę: 1) Identyfikacja klauzuli,
2) Analiza prawna, 3) Potencjalne ryzyka, 4) Rekomendacje.

Oto referencyjna umowa do analizy:
[Wstaw tutaj dokument liczący ponad 2000 tokenów, który nie zmienia się między wywołaniami]
"""

def analyze_clause(clause: str) -> str:
    """Każde wywołanie ponownie wykorzystuje cache promptu systemowego."""
    response = client.responses.create(
        model="gpt-5.6-terra",
        instructions=SYSTEM_PROMPT,  # Stabilny prefiks = buforowany
        input=f"Przeanalizuj tę klauzulę: {clause}",  # Część zmienna
    )
    return response.output_text

W tym przykładzie umowa referencyjna i ramy analizy stanowią blok niezmienny, podczas gdy analizowana klauzula zmienia się przy każdym wywołaniu. Przeanalizuj czterdzieści klauzul z tej samej umowy, a za kontekst zapłacisz raz po pełnej stawce.

Weryfikacja cache’u

Optymalizacja, której nie mierzysz, to optymalizacja, którą tylko wydaje Ci się, że masz. API zwraca informacje o wykorzystaniu cache’u w odpowiedzi:

response = client.responses.create(
    model="gpt-5.6-terra",
    instructions=SYSTEM_PROMPT,
    input="Przeanalizuj klauzulę o zakazie konkurencji.",
)

# Sprawdź wykorzystanie cache'u
usage = response.usage
print(f"Tokeny wejściowe: {usage.input_tokens}")
print(f"Tokeny wejściowe (buforowane): {usage.input_tokens_details.cached_tokens}")
print(f"Tokeny wyjściowe: {usage.output_tokens}")

# Jeśli cached_tokens > 0: cache został użyty
cache_ratio = usage.input_tokens_details.cached_tokens / usage.input_tokens
print(f"Współczynnik cache'u: {cache_ratio:.1%}")

Loguj ten współczynnik w środowisku produkcyjnym, zamiast sprawdzać go raz w fazie deweloperskiej. Nagły spadek wskaźnika cache’u jest najbardziej niezawodnym symptomem niezamierzonej zmiany w konstrukcji promptu – zauważysz to, zanim miesięczny rachunek Cię o tym poinformuje.

Strukturyzowanie w celu maksymalizacji cache’u

Pierwszym podejściem jest celowe wzbogacenie promptu systemowego. Może to wydawać się kontrintuicyjne, gdy starasz się redukować liczbę tokenów, ale jest zgodne z zasadą progu: prompt systemowy liczący 900 tokenów nigdy nie zostanie zbuforowany, podczas gdy ten sam prompt wzbogacony o przykłady few-shot i dokument referencyjny przekracza granicę i przełącza się na obniżoną stawkę dla zbuforowanej części.

# Wzbogać prompt systemowy, aby zmaksymalizować cache
ENRICHED_PROMPT = """
[Szczegółowe instrukcje - ponad 500 tokenów]
[Przykłady few-shot - ponad 500 tokenów]
[Dokument referencyjny - ponad 1000 tokenów]
---
Łącznie > 1024 tokeny = kwalifikuje się do cache'u
"""

W rozmowie wieloturowej mechanizm działa na Twoją korzyść bez dodatkowego wysiłku: skumulowana historia tworzy naturalnie stabilny prefiks, który rośnie z każdą wymianą. Dopóki zawsze reinjektujesz wiadomości w tej samej kolejności, dziesiąty tur korzysta z cache’u zbudowanego przez poprzednie dziewięć.

def conversation_with_cache(history: list[dict], new_message: str):
    """Rosnąca historia automatycznie maksymalizuje cache."""
    history.append({"role": "user", "content": new_message})

    response = client.responses.create(
        model="gpt-5.6-terra",
        instructions=SYSTEM_PROMPT,
        input=history,
    )

    history.append({
        "role": "assistant",
        "content": response.output_text,
    })
    return response.output_text

Na koniec, skoro czas życia cache’u mierzy się w minutach, grupowanie żądań współdzielących prefiks staje się decyzją harmonogramową. Przetwarzanie czterdziestu klauzul z umowy jedna po drugiej utrzymuje cache „gorący“; rozłożenie ich w ciągu dnia z przeplataniem innych plików pozwala mu wygasnąć między wywołaniami.

import asyncio

async def batch_with_cache(clauses: list[str]) -> list[str]:
    """Wysyła żądania szybko, aby wykorzystać cache."""
    results = []
    for clause in clauses:
        result = analyze_clause(clause)
        results.append(result)
    return results

Trzy błędy niweczą całą tę pracę i wyglądają podobnie: modyfikacja początku promptu, nawet o jeden znak, unieważnia cache dla całego żądania; randomizacja kolejności instrukcji, na przykład przez budowanie promptu z nieuporządkowanego słownika, produces ten sam efekt okresowo, przez co trudno go zdiagnozować; a oczekiwanie zysków poniżej progu 1024 tokenów oznacza próbę optymalizacji czegoś, co nigdy się nie uruchamia.

Kluczowe wnioski

  • Buforowanie promptów jest automatyczne w OpenAI – umieszczaj elementy stabilne na początku promptu
  • Minimalny próg: 1024 identycznych tokenów w prefiksie
  • Zysk: ~50% na zbuforowanych tokenach wejściowych + skrócony TTFT
  • Sprawdź usage.input_tokens_details.cached_tokens, aby potwierdzić działanie cache’u