Context Compression

Context Compression im Überblick

Context Compression reduziert die Menge an Text, die an ein LLM gesendet wird, ohne wichtige Informationen zu verlieren. Das ermöglicht längere effektive Kontexte und spart Kosten.

Das Problem:

Kontextfenster: begrenzt
Deine Daten: größer als der verfügbare Kontext
→ Passt nicht vollständig. Was tun?

Option 1: Abschneiden (verliert Infos)
Option 2: Komprimieren (erhält Essenz)

Kompression in Aktion:

Vorher:
"In dem Meeting wurde ausführlich über ein neues Projekt gesprochen. 
Die Projektleitung stellte Budgetrahmen, Zeitplan und technische 
Anforderungen vor. Danach folgte eine längere Diskussion über Risiken, 
Abhängigkeiten und nächste Schritte."

Nachher:
"Meeting: Projekt mit Budgetrahmen, Zeitplan, technischen Anforderungen, 
Risiken, Abhängigkeiten und nächsten Schritten besprochen."

→ deutlich weniger Text, Kerninfos bleiben erhalten

Technisch betrachtet

Kompressionsstrategien

1. Extractive Compression:

def extractive_compress(text, target_ratio):
    """Wichtige Sätze extrahieren"""
    sentences = split_sentences(text)
    
    # Relevanz-Score für jeden Satz
    scores = [compute_importance(s) for s in sentences]
    
    # Wichtigste Sätze behalten
    n_keep = int(len(sentences) * target_ratio)
    top_indices = sorted(range(len(scores)), 
                         key=lambda i: scores[i], 
                         reverse=True)[:n_keep]
    
    # In Original-Reihenfolge
    top_indices.sort()
    return " ".join(sentences[i] for i in top_indices)

2. Abstractive Compression (LLM-basiert):

def abstractive_compress(text, model):
    """LLM fasst zusammen"""
    prompt = f"""Komprimiere den folgenden Text auf die 
    wichtigsten Fakten. Behalte alle Zahlen, Namen und Daten.
    
    Text: {text}
    
    Komprimierte Version:"""
    
    return model.generate(prompt)

3. Token-Level Compression (LLMLingua):

from llmlingua import PromptCompressor

compressor = PromptCompressor(
    model_name="compression-model"
)

compressed = compressor.compress_prompt(
    original_prompt,
    rate=target_compression_rate,
    force_tokens=["wichtig", "deadline", "budget"]  # Behalten
)

Chat-Historie komprimieren

class CompressedMemory:
    def __init__(self, max_tokens):
        self.max_tokens = max_tokens
        self.messages = []
        self.summary = ""
    
    def add_message(self, role, content):
        self.messages.append({"role": role, "content": content})
        
        if self.count_tokens() > self.max_tokens:
            self._compress()
    
    def _compress(self):
        # Ältere Nachrichten zusammenfassen
        old_messages = self.messages[:-recent_message_count]
        
        summary_prompt = f"""
        Bisherige Zusammenfassung: {self.summary}
        
        Neue Nachrichten:
        {format_messages(old_messages)}
        
        Aktualisiere die Zusammenfassung:
        """
        
        self.summary = llm.generate(summary_prompt)
        self.messages = self.messages[-recent_message_count:]
    
    def get_context(self):
        return f"Zusammenfassung: {self.summary}\n\n" + \
               format_messages(self.messages)

RAG mit Compression

def compressed_rag(query, documents, max_context_tokens):
    # 1. Relevante Dokumente abrufen
    relevant_docs = retrieve(query, documents, top_k=retrieval_limit)
    
    # 2. Komprimieren wenn nötig
    total_tokens = sum(count_tokens(d) for d in relevant_docs)
    
    if total_tokens > max_context_tokens:
        # Komprimiere jedes Dokument
        compression_ratio = max_context_tokens / total_tokens
        compressed_docs = [
            compress(d, ratio=compression_ratio) 
            for d in relevant_docs
        ]
    else:
        compressed_docs = relevant_docs
    
    # 3. An LLM senden
    context = "\n\n".join(compressed_docs)
    return llm.generate(f"Context: {context}\n\nFrage: {query}")

Trade-offs