Zaawansowane buforowanie promptów
Na tej stronie
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