cc-viewer 1.5.45 → 1.6.0

package/concepts/ar/KVCacheContent.md

@@ -0,0 +1,42 @@
+# محتوى KV-Cache
+
+## ما هو KV-Cache؟
+
+KV-Cache (ذاكرة التخزين المؤقت للمفتاح والقيمة) هو آلية تسريع أساسية في استدلال نماذج اللغة الكبيرة. عندما تتحدث مع Claude، يرسل كل طلب السجل الكامل للمحادثة (موجه النظام + تعريفات الأدوات + الرسائل السابقة). إذا كان يجب إعادة حساب كل شيء من الصفر في كل مرة، فسيكون بطيئًا جدًا ومكلفًا.
+
+يعمل KV-Cache بهذه الطريقة: يخزن المحتوى المحسوب بالفعل في الذاكرة المؤقتة ويعيد استخدامه في الطلبات التالية، مما يتخطى الحسابات المتكررة.
+
+## كيفية عمل التخزين المؤقت
+
+يجمع prompt caching من Anthropic مفاتيح الذاكرة المؤقتة بترتيب ثابت:
+
+```
+System Prompt → Tools → Messages (حتى نقطة فاصل الذاكرة المؤقتة)
+```
+
+طالما أن هذا البادئة متطابقة تمامًا مع الطلب السابق، فإن API يصل إلى الذاكرة المؤقتة (ويعيد `cache_read_input_tokens`)، مما يقلل بشكل كبير من الكمون والتكلفة.
+
+## ما هو "محتوى KV-Cache الحالي"؟
+
+"محتوى KV-Cache الحالي" المعروض في cc-viewer يتم استخراجه من آخر طلب MainAgent ويتم وضع علامة عليه كمحتوى مخزن مؤقتًا. يتضمن بشكل محدد:
+
+- **System Prompt**: تعليمات النظام الخاصة بـ Claude Code، بما في ذلك CLAUDE.md الخاص بك، وصف المشروع، معلومات البيئة، إلخ.
+- **Messages**: الجزء من سجل المحادثة الذي يتم تخزينه مؤقتًا (عادة الرسائل السابقة)
+- **Tools**: قائمة تعريفات الأدوات المتاحة (مثل Read و Write و Bash وأدوات MCP وما إلى ذلك)
+
+يتم وضع علامة على هذا المحتوى في نص طلب API من خلال `cache_control: { type: "ephemeral" }` للإشارة إلى حدود الذاكرة المؤقتة.
+
+## لماذا تعرض محتوى الذاكرة المؤقتة؟
+
+1. **فهم السياق**: اعرف ما يتذكره Claude حاليًا، مما يساعدك على تحديد ما إذا كان سلوكه يطابق التوقعات
+2. **تحسين التكاليف**: عند الوصول إلى الذاكرة المؤقتة، تكون التكلفة أقل بكثير من إعادة الحساب. يساعدك عرض محتوى الذاكرة المؤقتة على فهم سبب قيام طلبات معينة بتشغيل إعادة بناء الذاكرة المؤقتة
+3. **تصحيح أخطاء المحادثة**: عندما لا تكون إجابة Claude كما هو متوقع، يؤكد فحص محتوى الذاكرة المؤقتة ما إذا كان موجه النظام والرسائل السابقة صحيحة
+4. **التنقل في تعليمات المستخدم**: من خلال قائمة رسائل المستخدم في محتوى الذاكرة المؤقتة، يمكنك الانتقال بسرعة إلى أي نقطة في المحادثة
+5. **مراقبة جودة السياق**: أثناء تصحيح الأخطاء اليومي وتعديل إعدادات Claude Code وتعديل المحفزات، يوفر KV-Cache-Text عرضًا مركزيًا، مما يساعدك على التأكد بسرعة من عدم حدوث تدهور في السياق الأساسي أو تلويث بمحتوى غير متوقع — دون الحاجة إلى مراجعة الرسائل الأولية
+
+## دورة حياة الذاكرة المؤقتة
+
+- **الإنشاء**: عند الطلب الأول أو بعد إبطال الذاكرة المؤقتة، ينشئ API ذاكرة مؤقتة جديدة (`cache_creation_input_tokens`)
+- **الوصول**: في الطلبات اللاحقة ذات البادئة المتطابقة، يتم إعادة استخدام الذاكرة المؤقتة (`cache_read_input_tokens`)
+- **انتهاء الصلاحية**: الذاكرة المؤقتة لها TTL (وقت البقاء) مدته 5 دقائق وتنتهي صلاحيتها تلقائيًا بعد هذه الفترة
+- **إعادة البناء**: عندما يتغير موجه النظام أو قائمة الأدوات أو النموذج أو الرسائل، لا يتطابق مفتاح الذاكرة المؤقتة، مما يؤدي إلى إعادة البناء

package/concepts/da/KVCacheContent.md

@@ -0,0 +1,42 @@
+# KV-Cache-indhold
+
+## Hvad er KV-Cache?
+
+KV-Cache (Key-Value Cache) er en central accelerationsmekanisme under inferens i store sprogmodeller. Når du chatter med Claude, sender hver anmodning den komplette samtalehistorik (system prompt + værktøjsdefinitioner + tidligere meddelelser). Hvis alt skulle genberegnes fra bunden hver gang, ville det være ekstremt langsomt og dyrt.
+
+KV-Cache's rolle er: at cache-lagre allerede beregnet indhold, så det kan genbruges ved den næste anmodning og springe gentagne beregninger over.
+
+## Hvordan caching fungerer
+
+Anthropics prompt caching sammenkæder cache-nøgler i en fast rækkefølge:
+
+```
+System Prompt → Tools → Messages (til cache breakpoint)
+```
+
+Så længe dette præfiks er helt identisk med den forrige anmodning, rammer API'en cachen (returnerer `cache_read_input_tokens`), hvilket betydeligt reducerer latens og omkostninger.
+
+## Hvad er "Aktuelt KV-Cache-indhold"?
+
+Det "Aktuelle KV-Cache-indhold" vist i cc-viewer udtrækkes fra den seneste MainAgent-anmodning og markeres som cachelagret indhold. Det omfatter specifikt:
+
+- **System Prompt**: Claude Codes systeminstruktioner, herunder din CLAUDE.md, projektbeskrivelse, miljøinformation osv.
+- **Messages**: Den del af samtalehistorikken, der er cachelagret (normalt tidligere meddelelser)
+- **Tools**: Listen over tilgængelige værktøjsdefinitioner (såsom Read, Write, Bash, MCP-værktøjer osv.)
+
+Dette indhold markeres i API-anmodningens body gennem `cache_control: { type: "ephemeral" }` for at angive cache-grænser.
+
+## Hvorfor se cache-indholdet?
+
+1. **Forstå konteksten**: Vid hvad Claude i øjeblikket "husker", og hjælp dig selv med at vurdere, om dens adfærd matcher forventningerne
+2. **Omkostningsoptimering**: Når cache rammes, er omkostningen meget lavere end genberegning. At se cache-indholdet hjælper dig med at forstå, hvorfor visse anmodninger udløste cache-genopbygning (cache rebuild)
+3. **Fejlfinding af samtale**: Når Claudes svar ikke er som forventet, bekræfter kontrol af cache-indholdet, om system prompt og tidligere meddelelser er korrekte
+4. **Navigation i brugerinstruktioner**: Gennem listen over brugermeddelelser i cache-indholdet kan du hurtigt springe til ethvert punkt i samtalen
+5. **Overvågning af kontekstkvalitet**: Under daglig fejlfinding, ændring af Claude Code-konfiguration eller justering af prompts giver KV-Cache-Text et centraliseret overblik, der hjælper dig med hurtigt at bekræfte, at kernekonteksten ikke er forringet eller forurenet med uventet indhold — uden at skulle gennemgå rå meddelelser én efter én
+
+## Cache-livscyklus
+
+- **Oprettelse**: Ved første anmodning eller efter cache-udløb opretter API'en en ny cache (`cache_creation_input_tokens`)
+- **Ramning**: Ved efterfølgende anmodninger med identisk præfiks genbruges cachen (`cache_read_input_tokens`)
+- **Udløb**: Cachen har en TTL (time-to-live) på 5 minutter og udløber automatisk efter denne periode
+- **Genopbygning**: Når system prompt, værktøjsliste, model eller meddelelser ændres, matcher cache-nøglen ikke, hvilket udløser genopbygning

package/concepts/de/KVCacheContent.md

@@ -0,0 +1,42 @@
+# KV-Cache-Inhalte
+
+## Was ist KV-Cache?
+
+KV-Cache (Key-Value Cache) ist ein zentraler Beschleunigungsmechanismus beim Inferenzprozess großer Sprachmodelle. Wenn du mit Claude kommunizierst, wird bei jeder Anfrage die vollständige Gesprächshistorie gesendet (System Prompt + Tool-Definitionen + historische Nachrichten). Wenn diese Inhalte jedes Mal von Grund auf neu berechnet würden, wäre das sehr zeitaufwändig und teuer.
+
+Die Funktion von KV-Cache besteht darin, bereits berechnete Inhalte zu speichern und bei der nächsten Anfrage direkt wiederzuverwenden, um wiederholte Berechnungen zu vermeiden.
+
+## Wie der Cache funktioniert
+
+Anthropics Prompt Caching verkettet Cache-Schlüssel in einer festen Reihenfolge:
+
+```
+System Prompt → Tools → Messages (bis zum Cache-Breakpoint)
+```
+
+Solange dieses Präfix mit der vorherigen Anfrage vollständig übereinstimmt, trifft die API den Cache (gibt `cache_read_input_tokens` zurück) und reduziert Latenz und Kosten erheblich.
+
+## Was ist „aktueller KV-Cache-Inhalt"?
+
+Der in cc-viewer angezeigte „aktuelle KV-Cache-Inhalt" wird aus der letzten MainAgent-Anfrage extrahiert und als gecacht markiert. Dies umfasst speziell:
+
+- **System Prompt**: Die Systeminstruktionen von Claude Code, einschließlich deiner CLAUDE.md, Projektbeschreibung, Umgebungsinformationen usw.
+- **Messages**: Der gecachte Teil der Gesprächshistorie (normalerweise frühere Nachrichten)
+- **Tools**: Die Liste der aktuell verfügbaren Tool-Definitionen (wie Read, Write, Bash, MCP-Tools usw.)
+
+Diese Inhalte werden im Body der API-Anfrage durch `cache_control: { type: "ephemeral" }` gekennzeichnet, um die Cache-Grenzen anzuzeigen.
+
+## Warum sollte man Cache-Inhalte ansehen?
+
+1. **Kontext verstehen**: Erfahre, welche Inhalte Claude derzeit „merkt", um sein Verhalten besser einschätzen zu können
+2. **Kostenoptimierung**: Cache-Treffer sind deutlich günstiger als Neuberechnungen. Das Ansehen von Cache-Inhalten hilft dir zu verstehen, warum bestimmte Anfragen einen Cache-Rebuild ausgelöst haben
+3. **Gesprächs-Debugging**: Wenn Claudes Antworten nicht wie erwartet ausfallen, kannst du durch Überprüfung der Cache-Inhalte bestätigen, dass System Prompt und historische Nachrichten korrekt sind
+4. **Navigation durch Benutzeranweisungen**: Über die Liste der Benutzernachrichten in den Cache-Inhalten kannst du schnell zu jeder Position im Gespräch springen
+5. **Überwachung der Kontextqualität**: Bei täglichem Debugging, Änderungen an Claude Code-Konfigurationen oder Prompt-Anpassungen bietet KV-Cache-Text eine zentrale Perspektive, um schnell zu bestätigen, dass der Kernkontext nicht beeinträchtigt wurde oder durch unerwartete Inhalte verschmutzt wurde – ohne rohe Nachrichten einzeln durchzusehen
+
+## Lebenszyklus des Cache
+
+- **Erstellung**: Bei der ersten Anfrage oder nach Cache-Ungültigkeit erstellt die API einen neuen Cache (`cache_creation_input_tokens`)
+- **Treffer**: Bei nachfolgenden Anfragen mit konsistentem Präfix wird der Cache wiederverwendet (`cache_read_input_tokens`)
+- **Ablauf**: Der Cache hat eine TTL (Time To Live) von 5 Minuten und verfällt automatisch nach Ablauf
+- **Rebuild**: Wenn sich System Prompt, Tool-Liste, Modell oder Nachrichten ändern, stimmt der Cache-Schlüssel nicht überein und löst einen Rebuild aus

package/concepts/en/KVCacheContent.md

@@ -0,0 +1,42 @@
+# KV-Cache Content
+
+## What is KV-Cache?
+
+KV-Cache (Key-Value Cache) is a core acceleration mechanism for large language model inference. When you chat with Claude, each request sends the complete conversation history (system prompt + tool definitions + historical messages). If we recalculated this content from scratch every time, it would be extremely time-consuming and expensive.
+
+KV-Cache works by caching already-computed content and reusing it on the next request, skipping redundant calculations.
+
+## How Caching Works
+
+Anthropic's prompt caching concatenates the cache key in a fixed order:
+
+```
+System Prompt → Tools → Messages (up to cache breakpoint)
+```
+
+As long as this prefix matches the previous request exactly, the API returns a cache hit (`cache_read_input_tokens`), significantly reducing latency and cost.
+
+## What is "Current KV-Cache Content"?
+
+The "Current KV-Cache Content" displayed in cc-viewer is extracted from the most recent MainAgent request and marked as cached. It specifically includes:
+
+- **System Prompt**: Claude Code's system instructions, containing your CLAUDE.md, project instructions, environment information, etc.
+- **Messages**: The portion of conversation history that is cached (typically earlier messages)
+- **Tools**: The current list of available tool definitions (such as Read, Write, Bash, MCP tools, etc.)
+
+These contents are marked with cache boundaries in the API request body via `cache_control: { type: "ephemeral" }`.
+
+## Why View Cache Content?
+
+1. **Understand Context**: See what Claude currently "remembers" to help you judge whether its behavior matches expectations
+2. **Cost Optimization**: Cache hits cost far less than recalculation. Viewing cache content helps you understand why certain requests triggered cache rebuilds
+3. **Debug Conversations**: When Claude's responses don't match expectations, checking cache content confirms whether the system prompt and historical messages are correct
+4. **User Instruction Navigation**: Through the user message list in cached content, you can quickly jump to any position in the conversation
+5. **Context Quality Monitoring**: During daily debugging, modifying Claude Code configuration, or adjusting prompts, KV-Cache-Text provides a centralized view to quickly confirm whether core context has degraded or been unexpectedly polluted—without manually reviewing raw messages
+
+## Cache Lifecycle
+
+- **Creation**: On first request or after cache expiration, the API creates a new cache (`cache_creation_input_tokens`)
+- **Hit**: Subsequent requests with matching prefixes reuse the cache (`cache_read_input_tokens`)
+- **Expiration**: Cache has a 5-minute TTL (time-to-live) and automatically expires after timeout
+- **Rebuild**: When system prompt, tool list, model, or messages change, the cache key no longer matches, triggering a rebuild

package/concepts/es/KVCacheContent.md

@@ -0,0 +1,42 @@
+# Contenido de la Caché KV
+
+## ¿Qué es KV-Cache?
+
+KV-Cache (Key-Value Cache) es un mecanismo de aceleración central en la inferencia de grandes modelos de lenguaje. Cuando te comunicas con Claude, cada solicitud envía el historial completo de la conversación (prompt del sistema + definiciones de herramientas + mensajes históricos). Si estos contenidos se recalcularan cada vez, sería muy costoso en tiempo y recursos.
+
+El propósito de KV-Cache es almacenar en caché los contenidos ya calculados y reutilizarlos directamente en la siguiente solicitud, evitando cálculos repetidos.
+
+## Cómo funciona la caché
+
+El almacenamiento en caché de prompts de Anthropic concatena las claves de caché en un orden fijo:
+
+```
+Prompt del sistema → Herramientas → Mensajes (hasta el punto de ruptura de caché)
+```
+
+Mientras este prefijo coincida exactamente con la solicitud anterior, la API accede a la caché (devuelve `cache_read_input_tokens`) y reduce significativamente la latencia y los costos.
+
+## ¿Qué es el «contenido actual de la caché KV»?
+
+El «contenido actual de la caché KV» mostrado en cc-viewer se extrae de la última solicitud de MainAgent y se marca como almacenado en caché. Incluye específicamente:
+
+- **Prompt del sistema**: Las instrucciones del sistema de Claude Code, incluyendo tu CLAUDE.md, descripción del proyecto, información del entorno, etc.
+- **Mensajes**: La parte del historial de conversación que está almacenada en caché (generalmente mensajes anteriores)
+- **Herramientas**: La lista de definiciones de herramientas actualmente disponibles (como Read, Write, Bash, herramientas MCP, etc.)
+
+Estos contenidos se marcan en el cuerpo de la solicitud de API mediante `cache_control: { type: "ephemeral" }` para indicar los límites de la caché.
+
+## ¿Por qué consultar el contenido de la caché?
+
+1. **Entender el contexto**: Saber qué contenidos «recuerda» Claude actualmente para evaluar mejor su comportamiento
+2. **Optimización de costos**: Los accesos a caché cuestan mucho menos que los recálculos. Consultar el contenido de la caché te ayuda a entender por qué ciertas solicitudes desencadenaron una reconstrucción de caché
+3. **Depuración de conversación**: Cuando las respuestas de Claude no son las esperadas, verificar el contenido de la caché te permite confirmar que el prompt del sistema y los mensajes históricos son correctos
+4. **Navegación por instrucciones del usuario**: A través de la lista de mensajes del usuario en el contenido de la caché, puedes saltar rápidamente a cualquier punto de la conversación
+5. **Monitoreo de la calidad del contexto**: Durante la depuración diaria, cambios en las configuraciones de Claude Code o ajustes de prompts, KV-Cache-Text proporciona una perspectiva centralizada para confirmar rápidamente que el contexto principal no se ha degradado o contaminado con contenido inesperado – sin necesidad de revisar los mensajes brutos uno por uno
+
+## Ciclo de vida de la caché
+
+- **Creación**: En la primera solicitud o después de la invalidación de caché, la API crea una nueva caché (`cache_creation_input_tokens`)
+- **Acceso**: En solicitudes posteriores con un prefijo consistente, se reutiliza la caché (`cache_read_input_tokens`)
+- **Expiración**: La caché tiene un TTL (tiempo de vida) de 5 minutos y expira automáticamente después de ese tiempo
+- **Reconstrucción**: Cuando el prompt del sistema, la lista de herramientas, el modelo o los mensajes cambian, la clave de caché no coincide y desencadena una reconstrucción

package/concepts/fr/KVCacheContent.md

@@ -0,0 +1,42 @@
+# Contenu du Cache KV
+
+## Qu'est-ce que le KV-Cache ?
+
+Le KV-Cache (Key-Value Cache) est un mécanisme d'accélération central lors de l'inférence des grands modèles de langage. Lorsque tu communiques avec Claude, chaque requête envoie l'historique complet de la conversation (prompt système + définitions d'outils + messages historiques). Si ces contenus étaient recalculés à chaque fois, ce serait très coûteux en temps et en ressources.
+
+Le rôle du KV-Cache est de mettre en cache les contenus déjà calculés et de les réutiliser directement lors de la prochaine requête, en évitant les calculs répétés.
+
+## Comment fonctionne le cache
+
+Le prompt caching d'Anthropic concatène les clés de cache dans un ordre fixe :
+
+```
+Prompt système → Outils → Messages (jusqu'au point de rupture du cache)
+```
+
+Tant que ce préfixe correspond exactement à la requête précédente, l'API atteint le cache (retourne `cache_read_input_tokens`) et réduit considérablement la latence et les coûts.
+
+## Qu'est-ce que le « contenu actuel du cache KV » ?
+
+Le « contenu actuel du cache KV » affiché dans cc-viewer est extrait de la dernière requête MainAgent et marqué comme mis en cache. Il comprend spécifiquement :
+
+- **Prompt système** : Les instructions système de Claude Code, incluant ton CLAUDE.md, la description du projet, les informations d'environnement, etc.
+- **Messages** : La partie mise en cache de l'historique de conversation (généralement les messages antérieurs)
+- **Outils** : La liste des définitions d'outils actuellement disponibles (comme Read, Write, Bash, outils MCP, etc.)
+
+Ces contenus sont marqués dans le corps de la requête API par `cache_control: { type: "ephemeral" }` pour indiquer les limites du cache.
+
+## Pourquoi consulter le contenu du cache ?
+
+1. **Comprendre le contexte** : Savoir quels contenus Claude « se souvient » actuellement pour mieux évaluer son comportement
+2. **Optimisation des coûts** : Les accès au cache coûtent beaucoup moins cher que les recalculs. Consulter le contenu du cache t'aide à comprendre pourquoi certaines requêtes ont déclenché une reconstruction du cache
+3. **Débogage de conversation** : Quand les réponses de Claude ne sont pas comme prévu, vérifier le contenu du cache te permet de confirmer que le prompt système et les messages historiques sont corrects
+4. **Navigation par instructions utilisateur** : Via la liste des messages utilisateur dans le contenu du cache, tu peux rapidement sauter à n'importe quel point de la conversation
+5. **Surveillance de la qualité du contexte** : Lors du débogage quotidien, des modifications des configurations de Claude Code ou des ajustements de prompt, KV-Cache-Text offre une perspective centralisée pour confirmer rapidement que le contexte principal n'a pas été dégradé ou pollué par du contenu inattendu – sans avoir à examiner les messages bruts un par un
+
+## Cycle de vie du cache
+
+- **Création** : Lors de la première requête ou après l'invalidation du cache, l'API crée un nouveau cache (`cache_creation_input_tokens`)
+- **Accès** : Lors des requêtes suivantes avec un préfixe cohérent, le cache est réutilisé (`cache_read_input_tokens`)
+- **Expiration** : Le cache a une TTL (durée de vie) de 5 minutes et expire automatiquement après ce délai
+- **Reconstruction** : Quand le prompt système, la liste des outils, le modèle ou les messages changent, la clé du cache ne correspond plus et déclenche une reconstruction

package/concepts/it/KVCacheContent.md

@@ -0,0 +1,42 @@
+# Contenuto della Cache KV
+
+## Cos'è KV-Cache?
+
+KV-Cache (Key-Value Cache) è un meccanismo di accelerazione centrale durante l'inferenza dei grandi modelli di linguaggio. Quando comunichi con Claude, ogni richiesta invia la cronologia completa della conversazione (prompt di sistema + definizioni degli strumenti + messaggi storici). Se questi contenuti venissero ricalcolati ogni volta, sarebbe molto costoso in termini di tempo e risorse.
+
+Lo scopo di KV-Cache è memorizzare nella cache i contenuti già calcolati e riutilizzarli direttamente nella richiesta successiva, evitando calcoli ripetuti.
+
+## Come funziona la cache
+
+Il prompt caching di Anthropic concatena le chiavi della cache in un ordine fisso:
+
+```
+Prompt di sistema → Strumenti → Messaggi (fino al punto di interruzione della cache)
+```
+
+Finché questo prefisso corrisponde esattamente alla richiesta precedente, l'API accede alla cache (restituisce `cache_read_input_tokens`) e riduce significativamente la latenza e i costi.
+
+## Cos'è il «contenuto attuale della cache KV»?
+
+Il «contenuto attuale della cache KV» visualizzato in cc-viewer viene estratto dall'ultima richiesta di MainAgent e contrassegnato come memorizzato nella cache. Include specificamente:
+
+- **Prompt di sistema**: Le istruzioni di sistema di Claude Code, inclusi il tuo CLAUDE.md, la descrizione del progetto, le informazioni sull'ambiente, ecc.
+- **Messaggi**: La parte della cronologia della conversazione memorizzata nella cache (generalmente messaggi precedenti)
+- **Strumenti**: L'elenco delle definizioni degli strumenti attualmente disponibili (come Read, Write, Bash, strumenti MCP, ecc.)
+
+Questi contenuti sono contrassegnati nel corpo della richiesta API mediante `cache_control: { type: "ephemeral" }` per indicare i limiti della cache.
+
+## Perché consultare il contenuto della cache?
+
+1. **Comprendere il contesto**: Sapere quali contenuti Claude «ricorda» attualmente per valutare meglio il suo comportamento
+2. **Ottimizzazione dei costi**: Gli accessi alla cache costano molto meno dei ricalcoli. Consultare il contenuto della cache ti aiuta a capire perché certe richieste hanno attivato una ricostruzione della cache
+3. **Debug della conversazione**: Quando le risposte di Claude non sono come previsto, verificare il contenuto della cache ti consente di confermare che il prompt di sistema e i messaggi storici sono corretti
+4. **Navigazione per istruzioni dell'utente**: Attraverso l'elenco dei messaggi dell'utente nel contenuto della cache, puoi saltare rapidamente a qualsiasi punto della conversazione
+5. **Monitoraggio della qualità del contesto**: Durante il debug quotidiano, i cambiamenti nelle configurazioni di Claude Code o gli aggiustamenti dei prompt, KV-Cache-Text fornisce una prospettiva centralizzata per confermare rapidamente che il contesto principale non è stato degradato o contaminato da contenuti inaspettati – senza dover esaminare i messaggi grezzi uno per uno
+
+## Ciclo di vita della cache
+
+- **Creazione**: Alla prima richiesta o dopo l'invalidazione della cache, l'API crea una nuova cache (`cache_creation_input_tokens`)
+- **Accesso**: Nelle richieste successive con un prefisso coerente, la cache viene riutilizzata (`cache_read_input_tokens`)
+- **Scadenza**: La cache ha un TTL (time to live) di 5 minuti e scade automaticamente dopo tale periodo
+- **Ricostruzione**: Quando il prompt di sistema, l'elenco degli strumenti, il modello o i messaggi cambiano, la chiave della cache non corrisponde e attiva una ricostruzione

package/concepts/ja/KVCacheContent.md

@@ -0,0 +1,42 @@
+# KV-Cache キャッシュ内容
+
+## KV-Cache とは？
+
+KV-Cache（Key-Value Cache）は大規模言語モデルの推論時における中核的な高速化メカニズムです。Claude と会話するたびに、完全な会話履歴（system prompt + ツール定義 + 過去のメッセージ）を送信します。毎回これらの内容をゼロから計算すると、非常に時間がかかり、コストも高くなります。
+
+KV-Cache の役割は、既に計算済みの内容をキャッシュに保存し、次のリクエスト時に直接再利用して、重複計算をスキップすることです。
+
+## キャッシュの動作原理
+
+Anthropic の prompt caching は固定順序でキャッシュキーを連結します：
+
+```
+System Prompt → Tools → Messages（キャッシュブレークポイントまで）
+```
+
+このプレフィックスが前回のリクエストと完全に一致する限り、API はキャッシュにヒット（`cache_read_input_tokens` を返す）し、レイテンシーとコストを大幅に削減します。
+
+## 「現在の KV-Cache キャッシュ内容」とは？
+
+cc-viewer に表示される「現在の KV-Cache キャッシュ内容」は、最新の MainAgent リクエストから抽出された、キャッシュとしてマークされた内容です。具体的には以下を含みます：
+
+- **System Prompt**：Claude Code のシステム指示。あなたの CLAUDE.md、プロジェクト説明、環境情報などを含む
+- **Messages**：会話履歴でキャッシュされた部分（通常は初期のメッセージ）
+- **Tools**：現在利用可能なツール定義リスト（Read、Write、Bash、MCP ツールなど）
+
+これらの内容は API リクエストの body 内で `cache_control: { type: "ephemeral" }` でマークされ、キャッシュ境界を示します。
+
+## キャッシュ内容を確認する理由
+
+1. **コンテキストの理解**：Claude が現在「記憶している」内容を把握し、その動作が期待通りかどうかを判断するのに役立つ
+2. **コスト最適化**：キャッシュヒット時のコストは再計算より大幅に低い。キャッシュ内容を確認することで、特定のリクエストがキャッシュ再構築（cache rebuild）をトリガーした理由を理解できる
+3. **会話のデバッグ**：Claude の回答が期待と異なる場合、キャッシュ内容を確認して system prompt と過去のメッセージが正しいかを確認できる
+4. **ユーザー指示ナビゲーション**：キャッシュ内容のユーザーメッセージリストを通じて、会話内の任意の位置に素早くジャンプできる
+5. **コンテキスト品質監視**：日常的なデバッグ、Claude Code 設定の変更、prompt 調整の過程で、KV-Cache-Text は統合ビューを提供し、コア コンテキストが劣化していないか、予期しない内容で汚染されていないかを素早く確認できます——元のメッセージを1つずつ確認する必要がありません
+
+## キャッシュのライフサイクル
+
+- **作成**：初回リクエストまたはキャッシュ無効化後、API は新しいキャッシュを作成（`cache_creation_input_tokens`）
+- **ヒット**：後続リクエストのプレフィックスが一致する場合、キャッシュを再利用（`cache_read_input_tokens`）
+- **期限切れ**：キャッシュは 5 分の TTL（存続時間）を持ち、タイムアウト後は自動的に無効化
+- **再構築**：system prompt、ツールリスト、モデル、またはメッセージが変更されると、キャッシュキーが一致せず、再構築がトリガーされる

package/concepts/ko/KVCacheContent.md

@@ -0,0 +1,42 @@
+# KV-Cache 캐시 내용
+
+## KV-Cache란?
+
+KV-Cache（Key-Value Cache）는 대규모 언어 모델 추론 시의 핵심 가속 메커니즘입니다. Claude와 대화할 때마다 완전한 대화 이력（system prompt + 도구 정의 + 과거 메시지）을 전송합니다. 매번 이 내용을 처음부터 계산하면 매우 시간이 오래 걸리고 비용도 많이 ���니다.
+
+KV-Cache의 역할은 이미 계산된 내용을 캐시에 저장하고, 다음 요청 시 직접 재사용하여 중복 계산을 건너뛰는 것입니다.
+
+## 캐시의 작동 원리
+
+Anthropic의 prompt caching은 고정된 순서로 캐시 키를 연결합니다:
+
+```
+System Prompt → Tools → Messages（캐시 브레이크포인트까지）
+```
+
+이 접두사가 이전 요청과 완전히 일치하면 API는 캐시에 히트（`cache_read_input_tokens` 반환）하여 지연 시간과 비용을 대폭 줄입니다.
+
+## "현재 KV-Cache 캐시 내용"이란?
+
+cc-viewer에 표시되는 "현재 KV-Cache 캐시 내용"은 최근 MainAgent 요청에서 추출된, 캐시로 표시된 내용입니다. 구체적으로 다음을 포함합니다:
+
+- **System Prompt**：Claude Code의 시스템 지시사항. 당신의 CLAUDE.md, 프로젝트 설명, 환경 정보 등을 포함
+- **Messages**：대화 이력에서 캐시된 부분（일반적으로 초기 메시지）
+- **Tools**：현재 사용 가능한 도구 정의 목록（Read, Write, Bash, MCP 도구 등）
+
+이 내용들은 API 요청의 body에서 `cache_control: { type: "ephemeral" }`로 표시되어 캐시 경계를 나타냅니다.
+
+## 캐시 내용을 확인하는 이유
+
+1. **컨텍스트 이해**：Claude가 현재 "기억하고 있는" 내용을 파악하여 그 동작이 예상대로인지 판단하는 데 도움
+2. **비용 최적화**：캐시 히트 시 비용은 재계산보다 훨씬 낮음. 캐시 내용을 확인하면 특정 요청이 캐시 재구축（cache rebuild）을 트리거한 이유를 이해할 수 있음
+3. **대화 디버깅**：Claude의 답변이 예상과 다를 때, 캐시 내용을 확인하여 system prompt와 과거 메시지가 올바른지 확인 가능
+4. **사용자 지시 네비게이션**：캐시 내용의 사용자 메시지 목록을 통해 대화 내 임의의 위치로 빠르게 이동 가능
+5. **컨텍스트 품질 모니터링**：일상적인 디버깅, Claude Code 설정 변경, prompt 조정 과정에서 KV-Cache-Text는 통합 뷰를 제공하여 핵심 컨텍스트가 저���되지 않았는지, 예상치 못한 내용으로 오염되지 않았는지 빠르게 확인할 수 있습니다——원본 메시지를 하나씩 검토할 필요 없음
+
+## 캐시의 생명주기
+
+- **생성**：초기 요청 또는 캐시 무효화 후 API는 새 캐시를 생성（`cache_creation_input_tokens`）
+- **히트**：후속 요청의 접두사가 일치하면 캐시 재사용（`cache_read_input_tokens`）
+- **만료**：캐시는 5분의 TTL（존속 시간）을 가지며, 타임아웃 후 자동 무효화
+- **재구축**：system prompt, 도구 목록, 모델 또는 메시지가 변경되면 캐시 키가 일치하지 않아 재구축 트리거

package/concepts/no/KVCacheContent.md

@@ -0,0 +1,42 @@
+# KV-Cache-innhold
+
+## Hva er KV-Cache?
+
+KV-Cache (Key-Value Cache) er en kjernemekanisme for akselerasjon under inferens i store språkmodeller. Når du chatter med Claude, sendes hele samtalehistorikken (system prompt + verktøydefinisjon + historiske meldinger) med hver forespørsel. Hvis alt måtte beregnes på nytt hver gang, ville det være svært tidkrevende og kostbart.
+
+KV-Caches rolle er: å lagre allerede beregnet innhold i cache, slik at det kan gjenbrukes ved neste forespørsel og gjentatte beregninger hoppes over.
+
+## Hvordan cachen fungerer
+
+Anthropics prompt caching setter sammen cache-nøkler i en fast rekkefølge:
+
+```
+System Prompt → Tools → Messages (til cache breakpoint)
+```
+
+Så lenge dette prefikset er identisk med forrige forespørsel, vil API-et treffe cachen (returnerer `cache_read_input_tokens`), noe som drastisk reduserer latens og kostnader.
+
+## Hva er "gjeldende KV-Cache-innhold"?
+
+"Gjeldende KV-Cache-innhold" som vises i cc-viewer, er hentet fra den siste MainAgent-forespørselen og merket som cachet innhold. Det inkluderer spesifikt:
+
+- **System Prompt**: Claude Codes systeminstruksjoner, inkludert din CLAUDE.md, prosjektbeskrivelse, miljøinformasjon osv.
+- **Messages**: Den cachede delen av samtalehistorikken (vanligvis tidligere meldinger)
+- **Tools**: Listen over tilgjengelige verktøydefinisjoner (som Read, Write, Bash, MCP-verktøy osv.)
+
+Dette innholdet merkes i API-forespørselens body gjennom `cache_control: { type: "ephemeral" }` for å indikere cache-grensen.
+
+## Hvorfor se på cache-innholdet?
+
+1. **Forstå konteksten**: Vit hvilket innhold Claude for øyeblikket "husker", og hjelp deg selv med å vurdere om atferden er som forventet
+2. **Kostnadsoptimalisering**: Cache-treff koster langt mindre enn omberegning. Å se cache-innholdet hjelper deg med å forstå hvorfor visse forespørsler utløste cache-gjenoppbygging (cache rebuild)
+3. **Feilsøking av samtale**: Når Claudes svar ikke er som forventet, kan du sjekke cache-innholdet for å bekrefte at system prompt og historiske meldinger er korrekte
+4. **Navigering i brukerinstruksjoner**: Gjennom listen over brukermeldinger i cache-innholdet kan du raskt hoppe til hvilken som helst posisjon i samtalen
+5. **Overvåking av kontekstkvalitet**: Under daglig feilsøking, endring av Claude Code-konfigurasjon eller justering av prompts, gir KV-Cache-Text et sentralisert perspektiv som hjelper deg med å raskt bekrefte at kjernekonteksten ikke har forverret seg eller blitt forurenset av uventet innhold — uten å måtte gjennomgå originale meldinger én etter én
+
+## Cache-livssyklus
+
+- **Opprettelse**: Ved første forespørsel eller etter at cache-en er utløpt, oppretter API-et en ny cache (`cache_creation_input_tokens`)
+- **Treff**: Når påfølgende forespørsler har konsistent prefiks, gjenbrukes cachen (`cache_read_input_tokens`)
+- **Utløp**: Cachen har en TTL (levetid) på 5 minutter og utløper automatisk etter dette
+- **Gjenoppbygging**: Når system prompt, verktøyliste, modell eller meldinger endres, samsvarer ikke cache-nøkkelen, noe som utløser gjenoppbygging

package/concepts/pl/KVCacheContent.md

@@ -0,0 +1,42 @@
+# Zawartość KV-Cache
+
+## Czym jest KV-Cache?
+
+KV-Cache (Key-Value Cache) to kluczowy mechanizm przyspieszenia podczas wnioskowania w dużych modelach językowych. Gdy rozmawiasz z Claude, każde żądanie wysyła pełną historię konwersacji (system prompt + definicje narzędzi + historyczne wiadomości). Gdyby wszystko musiało być obliczane od nowa za każdym razem, byłoby to bardzo czasochłonne i kosztowne.
+
+Rola KV-Cache polega na: przechowywaniu już obliczonej zawartości w pamięci podręcznej, aby mogła być ponownie wykorzystana przy następnym żądaniu, omijając powtórne obliczenia.
+
+## Jak działa pamięć podręczna
+
+Prompt caching Anthropica łączy klucze pamięci podręcznej w stałej kolejności:
+
+```
+System Prompt → Tools → Messages (do cache breakpoint)
+```
+
+Dopóki ten prefiks jest identyczny z poprzednim żądaniem, API trafi w pamięć podręczną (zwraca `cache_read_input_tokens`), drastycznie zmniejszając opóźnienie i koszty.
+
+## Czym jest "bieżąca zawartość KV-Cache"?
+
+"Bieżąca zawartość KV-Cache" wyświetlana w cc-viewer to zawartość wyodrębniona z ostatniego żądania MainAgent i oznaczona jako buforowana. Obejmuje konkretnie:
+
+- **System Prompt**: Instrukcje systemowe Claude Code, w tym twój CLAUDE.md, opis projektu, informacje o środowisku itp.
+- **Messages**: Buforowana część historii konwersacji (zwykle wcześniejsze wiadomości)
+- **Tools**: Lista dostępnych definicji narzędzi (takich jak Read, Write, Bash, narzędzia MCP itp.)
+
+Ta zawartość jest oznaczona w treści żądania API za pomocą `cache_control: { type: "ephemeral" }` w celu wskazania granicy pamięci podręcznej.
+
+## Dlaczego warto przeglądać zawartość pamięci podręcznej?
+
+1. **Zrozumienie kontekstu**: Wiedz, jaką zawartość Claude aktualnie "pamięta", i pomóż sobie ocenić, czy zachowanie jest zgodne z oczekiwaniami
+2. **Optymalizacja kosztów**: Trafienie w pamięć podręczną kosztuje znacznie mniej niż ponowne obliczenia. Przeglądanie zawartości pamięci podręcznej pomaga zrozumieć, dlaczego niektóre żądania wyzwoliły przebudowę pamięci podręcznej (cache rebuild)
+3. **Debugowanie konwersacji**: Gdy odpowiedź Claude nie jest zgodna z oczekiwaniami, sprawdzenie zawartości pamięci podręcznej potwierdza, czy system prompt i historyczne wiadomości są poprawne
+4. **Nawigacja instrukcji użytkownika**: Poprzez listę wiadomości użytkownika w zawartości pamięci podręcznej, możesz szybko przejść do dowolnego miejsca w konwersacji
+5. **Monitorowanie jakości kontekstu**: Podczas codziennego debugowania, zmiany konfiguracji Claude Code lub dostosowywania promptów, KV-Cache-Text zapewnia scentralizowaną perspektywę, która pomaga szybko potwierdzić, że kontekst główny nie uległ pogorszeniu lub nie został zanieczyszczony nieoczekiwaną zawartością — bez konieczności przeglądania oryginalnych wiadomości po kolei
+
+## Cykl życia pamięci podręcznej
+
+- **Tworzenie**: Przy pierwszym żądaniu lub po utracie ważności pamięci podręcznej, API tworzy nową pamięć podręczną (`cache_creation_input_tokens`)
+- **Trafienie**: Gdy kolejne żądania mają spójny prefiks, pamięć podręczna jest ponownie wykorzystywana (`cache_read_input_tokens`)
+- **Wygaśnięcie**: Pamięć podręczna ma TTL (czas życia) wynoszący 5 minut i automatycznie wygasa po upływie tego czasu
+- **Przebudowa**: Gdy system prompt, lista narzędzi, model lub wiadomości się zmienią, klucz pamięci podręcznej nie pasuje, wyzwalając przebudowę

package/concepts/pt-BR/KVCacheContent.md

@@ -0,0 +1,42 @@
+# Conteúdo do KV-Cache
+
+## O que é KV-Cache?
+
+KV-Cache (Key-Value Cache) é um mecanismo central de aceleração durante a inferência de grandes modelos de linguagem. Quando você conversa com Claude, cada requisição envia o histórico completo da conversa (system prompt + definições de ferramentas + mensagens anteriores). Se tudo fosse recalculado do zero a cada vez, seria extremamente demorado e caro.
+
+O papel do KV-Cache é: armazenar em cache o conteúdo já calculado, reutilizando-o na próxima requisição e pulando cálculos repetidos.
+
+## Como o cache funciona
+
+O prompt caching da Anthropic concatena as chaves de cache em uma ordem fixa:
+
+```
+System Prompt → Tools → Messages (até o cache breakpoint)
+```
+
+Enquanto esse prefixo for idêntico ao da requisição anterior, a API acerta o cache (retornando `cache_read_input_tokens`), reduzindo significativamente a latência e o custo.
+
+## O que é o "conteúdo atual do KV-Cache"?
+
+O "conteúdo atual do KV-Cache" exibido no cc-viewer é extraído da requisição mais recente do MainAgent e marcado como conteúdo em cache. Inclui especificamente:
+
+- **System Prompt**: As instruções do sistema do Claude Code, incluindo seu CLAUDE.md, descrição do projeto, informações do ambiente, etc.
+- **Messages**: A parte do histórico de conversa que está em cache (geralmente mensagens mais antigas)
+- **Tools**: A lista de definições de ferramentas disponíveis (como Read, Write, Bash, ferramentas MCP, etc.)
+
+Esse conteúdo é marcado no body da requisição da API através de `cache_control: { type: "ephemeral" }` para indicar os limites do cache.
+
+## Por que visualizar o conteúdo do cache?
+
+1. **Entender o contexto**: Saiba qual conteúdo Claude "lembra" atualmente, ajudando a determinar se seu comportamento está de acordo com o esperado
+2. **Otimização de custos**: O custo quando o cache é acertado é muito menor do que recalcular. Visualizar o conteúdo do cache ajuda a entender por que certas requisições acionaram uma reconstrução do cache (cache rebuild)
+3. **Depuração de conversa**: Quando a resposta do Claude não é a esperada, verificar o conteúdo do cache confirma se o system prompt e as mensagens anteriores estão corretos
+4. **Navegação de instruções do usuário**: Através da lista de mensagens do usuário no conteúdo do cache, você pode pular rapidamente para qualquer ponto da conversa
+5. **Monitoramento da qualidade do contexto**: Durante a depuração diária, modificação de configurações do Claude Code ou ajuste de prompts, o KV-Cache-Text oferece uma visão centralizada, ajudando a confirmar rapidamente se o contexto principal sofreu degradação ou foi contaminado por conteúdo inesperado — sem precisar revisar as mensagens brutas uma a uma
+
+## Ciclo de vida do cache
+
+- **Criação**: Na primeira requisição ou após invalidação do cache, a API cria um novo cache (`cache_creation_input_tokens`)
+- **Acerto**: Quando requisições subsequentes têm prefixo idêntico, o cache é reutilizado (`cache_read_input_tokens`)
+- **Expiração**: O cache tem um TTL (tempo de vida) de 5 minutos e expira automaticamente após esse período
+- **Reconstrução**: Quando o system prompt, lista de ferramentas, modelo ou mensagens mudam, a chave de cache não corresponde, acionando uma reconstrução

package/concepts/ru/KVCacheContent.md

@@ -0,0 +1,42 @@
+# Содержимое KV-Cache
+
+## Что такое KV-Cache?
+
+KV-Cache (Cache ключ-значение) — это ключевой механизм ускорения пр�� выполнении больших языковых моделей. Когда вы общаетесь с Claude, каждый запрос отправляет полную историю диалога (системный промпт + определения инструментов + предыдущие сообщения). Если бы каждый раз пересчитывать всё с нуля, это было бы крайне медленно и дорого.
+
+KV-Cache работает так: он кэширует уже вычисленное содержимое и повторно использует его в следующих запросах, пропуская повторные вычисления.
+
+## Как работает кэширование
+
+Prompt caching от Anthropic объединяет ключи кэша в фиксированном порядке:
+
+```
+System Prompt → Tools → Messages (до точки разрыва кэша)
+```
+
+Если этот префикс полностью совпадает с предыдущим запросом, API попадает в кэш (возвращая `cache_read_input_tokens`), значительно снижая задержку и стоимость.
+
+## Что такое "Текущее содержимое KV-Cache"?
+
+"Текущее содержимое KV-Cache", отображаемое в cc-viewer, извлекается из последнего запроса MainAgent и помечается как кэшированное содержимое. Конкретно включает:
+
+- **System Prompt**: Системные инструкции Claude Code, включая ваш CLAUDE.md, описание проекта, информацию об окружении и т.д.
+- **Messages**: Часть истории диалога, которая находится в кэше (обычно более ранние сообщения)
+- **Tools**: Список определений доступных инструментов (таких как Read, Write, Bash, MCP-инструменты и т.д.)
+
+Это содержимое помечается в теле запроса API через `cache_control: { type: "ephemeral" }` для обозначения границ кэша.
+
+## Зачем просматривать содержимое кэша?
+
+1. **Понимание контекста**: Узнайте, какое содержимое Claude "помнит" в данный момент, помогая вам определить, соответствует ли его поведение ожиданиям
+2. **Оптимизация затрат**: При попадании в кэш стоимость намного ниже, чем при пересчёте. Просмотр содержимого кэша помогает понять, почему определённые запросы вызвали перестроение кэша
+3. **Отладка диалога**: Когда ответ Claude не соответствует ожиданиям, проверка содержимого кэша подтверждает, правильны ли системный промпт и предыдущие сообщения
+4. **Навигация по инструкциям пользователя**: Через список сообщений пользователя в содержимом кэша вы можете быстро перейти к любой точке диалога
+5. **Мониторинг качества контекста**: Во время повседневной отладки, изменения конфигурации Claude Code или корректировки промптов KV-Cache-Text предоставляет централизованное представление, помогая вам быстро подтвердить, не произошла ли деградация основного контекста или загрязнение неожиданным содержимым — без необходимости просмотра исходных сообщений
+
+## Жизненный цикл кэша
+
+- **Создание**: При первом запросе или после инвалидации кэша API создаёт новый кэш (`cache_creation_input_tokens`)
+- **Попадание**: При последующих запросах с идентичным префиксом кэш повторно используется (`cache_read_input_tokens`)
+- **Истечение**: Кэш имеет TTL (время жизни) 5 минут и автоматически истекает по истечении этого периода
+- **Перестроение**: Когда системный промпт, список инструментов, модель или сообщения изменяются, ключ кэша не совпадает, вызывая перестроение