Kontext

Intelligente Kontextverwaltung für lange Konversationen mit automatischer Komprimierung Lerne die Einrichtungsmuster, APIs und praktischen Beispiele kennen,...

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:

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

// Create an agent with auto context compression enabled
const agent = await Agent.create({
  name: 'ContextAwareAgent',
  model: 'gpt-4o',
  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:

const agent = await Agent.create({
  name: 'ResearchAgent',
  model: 'gpt-4o',
  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:

const agent = await Agent.create({
  name: 'CustomContextAgent',
  model: 'gpt-4o',
  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

Parameter	Type	Default	Description
`autoContextCompression`	`boolean`	`false`	Aktiviert automatische Kontextkomprimierung
`maxContextLength`	`number`	`8000`	Token-Grenzwert, bei dem Komprimierung ausgelöst wird
`preserveLastN`	`number`	`3`	Anzahl der zuletzt behaltenen, unkomprimierten Nachrichten
`compressionRatio`	`number`	`0.3`	Ziel-Komprimierungsverhältnis (0.1 = 90 % Reduktion)
`compressionStrategy`	`string`	`'hybrid'`	Zu verwendender Komprimierungsalgorithmus

Komprimierungsmathematik

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

$\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: $\text{Reduction \%} = (1 - \text{ratio}) \times 100\%$

Bei compressionRatio = 0.3: $\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

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

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

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:

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:

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:

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

// 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:

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:

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:

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:

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:

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:

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:

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:

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:

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

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

Zuletzt aktualisiert: 6. Juli 2026

In diesem Abschnitt

Einführung

Open-Source-KI-Agent-Framework zum Erstellen autonomer Systeme, die reale Aufgaben effektiv lösen.

Installation

Installiere Astreus mit npm, yarn oder pnpm, überprüfe die erforderliche Node.js-Version und bereite ein lokales Projekt für die Entwicklung von KI-Agenten...

Schnellstart

Erstelle deinen ersten KI-Agenten mit Astreus in unter 2 Minuten Lerne die Einrichtungsmuster, APIs und praktischen Beispiele kennen, die du zum Aufbau...

Agent

Zentrale KI-Entität mit modularen Fähigkeiten und dekoratorbasierter Komposition Lerne die Einrichtungsmuster, APIs und praktischen Beispiele kennen, die du...