Kontext

Intelligente Kontextverwaltung für lange Konversationen mit automatischer Komprimierung

Übersicht#

Die automatische Kontextkomprimierung in Astreus bietet intelligentes Konversationsmanagement, indem lange Konversationsverläufe automatisch verarbeitet werden. Das System komprimiert ältere Nachrichten unter Beibehaltung wichtiger Informationen, sodass Agenten kohärente lange Konversationen führen können, ohne die Token-Limits des Modells zu überschreiten.

Grundlegende Verwendung#

Aktiviere die automatische Kontextkomprimierung, um automatisches Konversationsmanagement zu erhalten:

typescript
import { Agent } from '@astreus-ai/astreus';

// Create an agent with auto context compression enabled
const agent = await Agent.create({
  name: 'ContextAwareAgent',
  model: 'gpt-6-astra',
  autoContextCompression: true  // Enable smart context management
});

// Long conversations are automatically managed
for (let i = 1; i <= 50; i++) {
  const response = await agent.ask(`Tell me fact #${i} about TypeScript`);
  console.log(`Fact ${i}:`, response);
}

// Agent can still reference early conversation through compressed context
const summary = await agent.ask('What was the first fact you told me?');
console.log(summary); // System retrieves from compressed context

Beispiel mit Tasks#

Die automatische Kontextkomprimierung funktioniert sowohl bei direkten Konversationen als auch bei Tasks:

typescript
const agent = await Agent.create({
  name: 'ResearchAgent',
  model: 'gpt-6-astra',
  autoContextCompression: true,
  memory: true // Often used together with memory
});

// Create multiple related tasks
const task1 = await agent.createTask({
  prompt: "Research the latest trends in AI development"
});

const result1 = await agent.executeTask(task1.id);

const task2 = await agent.createTask({
  prompt: "Based on the research, what are the key opportunities?"
});

const result2 = await agent.executeTask(task2.id);
// Task can reference previous context even if it was compressed

Die automatische Kontextkomprimierung stellt sicher, dass Agenten Konversationen und Tasks beliebiger Länge verarbeiten können, während Kohärenz gewahrt bleibt und die Token-Limits eingehalten werden.

Konfigurationsoptionen#

Du kannst das Verhalten der automatischen Kontextkomprimierung mit diesen Parametern anpassen:

typescript
const agent = await Agent.create({
  name: 'CustomContextAgent',
  model: 'gpt-6-astra',
  autoContextCompression: true,
  
  // Context compression configuration
  maxContextLength: 4000,           // Trigger compression at 4000 tokens
  preserveLastN: 5,                 // Keep last 5 messages uncompressed
  compressionRatio: 0.4,            // Target 40% size reduction
  compressionStrategy: 'hybrid',    // Use hybrid compression strategy
  
  memory: true,
});

Konfigurationsparameter#

ParameterTypeDefaultDescription
autoContextCompressionbooleanfalseAktiviert automatische Kontextkomprimierung
maxContextLengthnumber8000Token-Grenzwert, bei dem Komprimierung ausgelöst wird
preserveLastNnumber3Anzahl der zuletzt behaltenen, unkomprimierten Nachrichten
compressionRationumber0.3Ziel-Komprimierungsverhältnis (0.1 = 90 % Reduktion)
compressionStrategystring'hybrid'Zu verwendender Komprimierungsalgorithmus

Komprimierungsmathematik#

Das Komprimierungsverhältnis bestimmt, wie stark der Kontext reduziert wird:

Compression Ratio=compressed tokensoriginal tokens\text{Compression Ratio} = \frac{\text{compressed tokens}}{\text{original tokens}}

Beispiel mit einem Verhältnis von 0.3:

  • Original: 1000 Tokens
  • Komprimiert: 300 Tokens
  • Reduktion: 70 %

Der Prozentsatz der Token-Reduktion wird wie folgt berechnet: Reduction %=(1−ratio)×100%\text{Reduction \%} = (1 - \text{ratio}) \times 100\%

Bei compressionRatio = 0.3: Reduction=(1−0.3)×100%=70%\text{Reduction} = (1 - 0.3) \times 100\% = 70\%

Komprimierungsstrategien#

Wähle die Komprimierungsstrategie, die am besten zu deinem Anwendungsfall passt:

'summarize' - Textzusammenfassung#

  • Am besten geeignet für: Allgemeine Konversationen, Q&A, Diskussionen
  • Funktionsweise: Erstellt prägnante Zusammenfassungen von Nachrichtengruppen
  • Vorteile: Erhält den Gesprächsfluss, gut für die meisten Anwendungsfälle
  • Nachteile: Kann spezifische Details verlieren
typescript
const agent = await Agent.create({
  name: 'SummarizingAgent',
  autoContextCompression: true,
  compressionStrategy: 'summarize',
  preserveLastN: 4
});

'selective' - Auswahl wichtiger Nachrichten#

  • Am besten geeignet für: Aufgabenorientierte Konversationen, technische Diskussionen
  • Funktionsweise: Nutzt KI, um wichtige Nachrichten zu identifizieren und zu erhalten
  • Vorteile: Behält entscheidende Informationen intakt
  • Nachteile: Kann ressourcenintensiver sein
typescript
const agent = await Agent.create({
  name: 'SelectiveAgent',
  autoContextCompression: true,
  compressionStrategy: 'selective',
  preserveLastN: 3
});

'hybrid' - Kombinierter Ansatz (empfohlen)#

  • Am besten geeignet für: Die meisten Anwendungen, ausgewogener Ansatz
  • Funktionsweise: Kombiniert Zusammenfassung und selektive Erhaltung
  • Vorteile: Ausgewogenes Verhältnis zwischen Kontexterhalt und Effizienz
  • Nachteile: Keine nennenswerten
typescript
const agent = await Agent.create({
  name: 'HybridAgent',
  autoContextCompression: true,
  compressionStrategy: 'hybrid', // Default and recommended
});

Fortgeschrittene Verwendung#

Individuelle Komprimierungseinstellungen nach Anwendungsfall#

Hochfrequente Konversationen#

Für Chatbots oder interaktive Agenten mit vielen kurzen Nachrichten:

typescript
const chatbot = await Agent.create({
  name: 'Chatbot',
  autoContextCompression: true,
  maxContextLength: 2000,     // Compress more frequently
  preserveLastN: 8,           // Keep more recent messages
  compressionRatio: 0.5,      // More aggressive compression
  compressionStrategy: 'summarize'
});

Langform-Content-Erstellung#

Für Agenten, die mit detaillierten Inhalten arbeiten:

typescript
const writer = await Agent.create({
  name: 'ContentWriter',
  autoContextCompression: true,
  maxContextLength: 12000,    // Allow longer context
  preserveLastN: 3,           // Keep recent context tight
  compressionRatio: 0.2,      // Gentle compression
  compressionStrategy: 'selective'
});

Technische Dokumentation#

Für Agenten, die komplexe technische Diskussionen führen:

typescript
const techAgent = await Agent.create({
  name: 'TechnicalAssistant',
  autoContextCompression: true,
  maxContextLength: 6000,
  preserveLastN: 5,           
  compressionRatio: 0.3,      
  compressionStrategy: 'hybrid' // Best for mixed content
});

Wie die Kontextkomprimierung funktioniert#

Komprimierungsprozess#

Token-Überwachung: Der Agent überwacht kontinuierlich die Gesamtzahl der Tokens in der Konversation

Auslösepunkt: Wenn die Tokens maxContextLength überschreiten, wird die Komprimierung ausgelöst

Nachrichtenerhalt: Die letzten preserveLastN Nachrichten werden unkomprimiert beibehalten

Inhaltsanalyse: Ältere Nachrichten werden basierend auf der gewählten Strategie analysiert

Komprimierung: Nachrichten werden zu Zusammenfassungen oder Auswahlen komprimiert

Kontextaktualisierung: Der komprimierte Kontext ersetzt die ursprünglichen Nachrichten

Was erhalten bleibt#

  • System-Prompts: Werden immer erhalten
  • Aktuelle Nachrichten: Die letzten N Nachrichten basierend auf preserveLastN
  • Wichtiger Kontext: Wichtige, durch die Komprimierungsstrategie identifizierte Informationen
  • Komprimierte Zusammenfassungen: Verdichtete Versionen älterer Konversationen

Beispiel für einen Komprimierungsablauf#

typescript
// Before compression (1200 tokens)
[
  { role: 'user', content: 'Tell me about TypeScript' },
  { role: 'assistant', content: 'TypeScript is...' },
  { role: 'user', content: 'What about interfaces?' },
  { role: 'assistant', content: 'Interfaces in TypeScript...' },
  { role: 'user', content: 'Show me an example' },
  { role: 'assistant', content: 'Here\'s an example...' },
]

// After compression (400 tokens)
[
  { role: 'system', content: '[Compressed] User asked about TypeScript basics, interfaces, and examples. Assistant provided comprehensive explanations...' },
  { role: 'user', content: 'Show me an example' },
  { role: 'assistant', content: 'Here\'s an example...' },
]

Überwachung und Debugging#

Informationen zum Kontextfenster#

Rufe Details zum aktuellen Kontextzustand ab:

typescript
const contextWindow = agent.getContextWindow();

console.log({
  messageCount: contextWindow.messages.length,
  totalTokens: contextWindow.totalTokens,
  maxTokens: contextWindow.maxTokens,
  utilization: `${contextWindow.utilizationPercentage.toFixed(1)}%`
});

// Check if compression occurred
const hasCompression = contextWindow.messages.some(
  msg => msg.metadata?.type === 'summary'
);
console.log('Context compressed:', hasCompression);

Kontextanalyse#

Analysiere den Kontext auf Optimierungsmöglichkeiten:

typescript
const analysis = agent.analyzeContext();

console.log({
  compressionNeeded: analysis.compressionNeeded,
  averageTokensPerMessage: analysis.averageTokensPerMessage,
  suggestedCompressionRatio: analysis.suggestedCompressionRatio
});

Antworttypen#

Methoden zur Kontextverwaltung geben detaillierte Objekte zur Überwachung und Steuerung des Konversationskontexts zurück.

Kontextfenster-Antwort#

Ruft das aktuelle Kontextfenster mit Auslastungsmetriken ab:

typescript
const window = agent.getContextWindow();

// Response structure:
{
  messages: [
    {
      role: "user",
      content: "How do I use TypeScript?",
      timestamp: Date('2024-01-15T10:00:00Z'),
      tokens: 8
    },
    {
      role: "assistant",
      content: "TypeScript is a typed superset of JavaScript that compiles to plain JavaScript...",
      timestamp: Date('2024-01-15T10:00:05Z'),
      tokens: 50
    }
    // ... more messages
  ],
  totalTokens: 3500,
  maxTokens: 8000,
  utilizationPercentage: 43.75
}

Kontextanalyse-Antwort#

Analysiert die aktuelle Kontextnutzung und den Komprimierungsbedarf:

typescript
const analysis = agent.analyzeContext();

// Response structure:
{
  totalTokens: 6500,
  messageCount: 15,
  averageTokensPerMessage: 433,
  contextUtilization: 0.8125,              // 81.25% of max context used
  compressionNeeded: true,
  suggestedCompressionRatio: 0.5           // Suggest 50% compression
}

Komprimierungsergebnis-Antwort#

Komprimiert den Kontext und liefert detaillierte Komprimierungsmetriken:

typescript
const compression = await agent.compressContext();

// Response structure:
{
  success: true,
  compressedMessages: [
    {
      role: "system",
      content: "Summary: User asked about TypeScript features. Discussed types, interfaces, and generics...",
      timestamp: Date('2024-01-15T10:05:00Z'),
      tokens: 35
    },
    {
      role: "user",
      content: "Can you explain decorators?",
      timestamp: Date('2024-01-15T10:10:00Z'),
      tokens: 8
    }
    // ... compressed messages (8 instead of 15)
  ],
  tokensReduced: 3250,                     // Tokens saved
  compressionRatio: 0.5,                   // 50% reduction achieved
  strategy: "summarize"                    // Strategy used
}

// On failure:
{
  success: false,
  compressedMessages: [],
  tokensReduced: 0,
  compressionRatio: 0,
  error: "Compression failed: Minimum context threshold not reached"
}

Kontextzusammenfassungs-Antwort#

Erstellt eine KI-gestützte Zusammenfassung der Konversation:

typescript
const summary = await agent.generateContextSummary();

// Response structure:
{
  mainTopics: [
    "TypeScript development",
    "API design patterns",
    "Testing strategies"
  ],
  keyEntities: [
    "Express.js",
    "Jest",
    "PostgreSQL",
    "Docker"
  ],
  conversationFlow: "Discussion started with TypeScript setup and configuration. Moved to API design patterns using Express.js. Covered database integration with PostgreSQL. Concluded with comprehensive testing strategies using Jest and continuous integration.",
  importantFacts: [
    "User prefers functional programming style",
    "Project deadline is March 15th, 2024",
    "Must support Node.js 18+",
    "Team size is 5 developers"
  ],
  actionItems: [
    "Set up Jest test framework with coverage reporting",
    "Create API documentation using OpenAPI/Swagger",
    "Configure Docker containers for development environment",
    "Implement CI/CD pipeline with GitHub Actions"
  ]
}

Kontextnachrichten-Abruf-Antwort#

Ruft alle Kontextnachrichten als Array ab:

typescript
const messages = agent.getContext();
// OR
const messages = agent.getContextMessages();

// Response structure:
[
  {
    role: "user",
    content: "How do I use async/await?",
    timestamp: Date('2024-01-15T09:30:00Z'),
    tokens: 10
  },
  {
    role: "assistant",
    content: "Async/await is syntactic sugar for promises...",
    timestamp: Date('2024-01-15T09:30:15Z'),
    tokens: 85
  }
  // ... more messages
]

Kontext-Export-Antwort#

Der Kontext-Export gibt einen JSON-String zurück:

typescript
const exported = agent.exportContext();

// Response: JSON string
'{"messages":[{"role":"user","content":"...","timestamp":"2024-01-15T10:00:00.000Z","tokens":10},...],"metadata":{"exportedAt":"2024-01-15T11:00:00.000Z","totalTokens":3500}}'

Import/Clear-Context-Antwort#

Import- und Löschoperationen geben void zurück:

typescript
// Import context
agent.importContext(jsonString);
// Returns: void

// Clear context
agent.clearContext();
// Returns: void