Resetting Context

Dlouhé konverzace mohou vést k degradaci kvality. Naučte se kdy a jak resetovat.

Proč reset kontextu?

1. Context Pollution

Turn 1: "Help me with Python code"
Turn 5: "Actually, let's switch to JavaScript"
Turn 10: Claude stále mixuje Python a JS syntax

Problém: Starý kontext interferuje s novými instrukcemi.

2. Contradictory Instructions

Turn 1: "Always use tabs for indentation"
Turn 8: "Use 2-space indentation"
Turn 15: Claude používá mix obojího

3. Context Window Limits

200K tokens = ~150K slov = ~300 stran textu

Ale: Kvalita degraduje dávno před limitem
Prakticky: Po ~50K tokens zvažte reset

Indikátory pro reset

class ContextHealthChecker:
    def __init__(self):
        self.turn_count = 0
        self.total_tokens = 0
        self.contradictions = 0
        self.topic_changes = 0
    
    def should_reset(self) -> tuple[bool, str]:
        # Hard limits
        if self.total_tokens > 50000:
            return True, "Token limit approaching"
        
        if self.turn_count > 30:
            return True, "Too many turns"
        
        # Soft indicators
        if self.contradictions > 3:
            return True, "Too many contradictory instructions"
        
        if self.topic_changes > 5:
            return True, "Too many topic changes"
        
        return False, ""
    
    def on_message(self, message: str, tokens: int, is_topic_change: bool):
        self.turn_count += 1
        self.total_tokens += tokens
        if is_topic_change:
            self.topic_changes += 1

Reset strategie

Strategy 1: Clean Slate

def fresh_start(task: str, key_context: str = ""):
    """Kompletně nová konverzace"""
    
    return client.messages.create(
        model="claude-opus-4-5-20250101",
        messages=[{
            "role": "user",
            "content": f"""
{key_context}

New task: {task}
"""
        }]
    )

Strategy 2: Summarize and Reset

async def summarize_and_reset(conversation_history: list, new_task: str):
    """Shrň důležité a začni znovu"""
    
    # Get summary of important decisions/context
    summary_response = await client.messages.create(
        model="claude-sonnet-4-5-20250101",  # Cheaper for summary
        messages=[
            *conversation_history,
            {
                "role": "user",
                "content": """
Summarize the key decisions and context from our conversation:
- What was decided
- Important constraints
- Current state

Be concise - max 200 words.
"""
            }
        ]
    )
    
    summary = summary_response.content[0].text
    
    # Start fresh with summary as context
    return await client.messages.create(
        model="claude-opus-4-5-20250101",
        messages=[{
            "role": "user",
            "content": f"""
Previous context summary:
{summary}

---

New task: {new_task}
"""
        }]
    )

Strategy 3: System Prompt Refresh

def reset_with_system_prompt(base_system: str, learned_preferences: list):
    """Reset while preserving learned preferences"""
    
    enhanced_system = f"""
{base_system}

LEARNED PREFERENCES (from previous conversation):
{chr(10).join(f'- {pref}' for pref in learned_preferences)}

Start fresh but honor these preferences.
"""
    
    return client.messages.create(
        model="claude-opus-4-5-20250101",
        system=enhanced_system,
        messages=[...]  # Fresh messages
    )

Context Windowing

Pro dlouhé úlohy použijte sliding window:

class SlidingContextManager:
    def __init__(self, max_tokens: int = 30000):
        self.max_tokens = max_tokens
        self.messages = []
        self.system_context = ""  # Always preserved
    
    def add_message(self, role: str, content: str):
        self.messages.append({"role": role, "content": content})
        self._trim_if_needed()
    
    def _trim_if_needed(self):
        total = self._count_tokens()
        
        while total > self.max_tokens and len(self.messages) > 2:
            # Remove oldest user/assistant pair
            # But keep first message (often contains key context)
            if len(self.messages) > 4:
                self.messages = [self.messages[0]] + self.messages[3:]
            else:
                self.messages = self.messages[2:]
            
            total = self._count_tokens()
    
    def _count_tokens(self) -> int:
        # Approximate: 4 chars per token
        total_chars = sum(len(m["content"]) for m in self.messages)
        return total_chars // 4
    
    def get_messages(self) -> list:
        return self.messages

Best Practices

1. Pravidelné checkpointy - Shrňte po každých 10 zprávách
2. Separace concerns - Různé úlohy = různé konverzace
3. Explicitní kontext - Vždy uvádějte klíčový kontext na začátku
4. Clean handoffs - Při změně tématu, explicitně uzavřete předchozí

# Příklad clean handoff
"""
--- CLOSING PREVIOUS TOPIC ---
We decided: Use PostgreSQL with connection pooling.

--- NEW TOPIC ---
Now let's discuss the API authentication approach.
"""

Reset není selhání - je to nástroj pro lepší výsledky.