Contexte

Gestion intelligente du contexte pour les longues conversations avec compression automatique

Gestion intelligente du contexte pour les longues conversations avec compression automatique

Vue d'ensemble

La compression automatique du contexte dans Astreus offre une gestion intelligente des conversations en traitant automatiquement les longs historiques de conversation. Le système compresse les anciens messages tout en préservant les informations importantes, garantissant que les agents peuvent maintenir des conversations longues et cohérentes sans dépasser les limites de tokens du modèle.

Utilisation de base

Activez la compression automatique du contexte pour obtenir une gestion automatique des conversations :

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

Exemple avec des tâches

La compression automatique du contexte fonctionne aussi bien avec les conversations directes qu'avec les tâches :

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

La compression automatique du contexte garantit que les agents peuvent gérer des conversations et des tâches de n'importe quelle longueur tout en maintenant leur cohérence et en respectant les limites de tokens.

Options de configuration

Vous pouvez personnaliser le comportement de la compression automatique du contexte avec ces paramètres :

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,
});

Paramètres de configuration

Paramètre	Type	Défaut	Description
`autoContextCompression`	`boolean`	`false`	Active la compression automatique du contexte
`maxContextLength`	`number`	`8000`	Limite de tokens avant le déclenchement de la compression
`preserveLastN`	`number`	`3`	Nombre de messages récents à conserver non compressés
`compressionRatio`	`number`	`0.3`	Taux de compression cible (0.1 = 90% de réduction)
`compressionStrategy`	`string`	`'hybrid'`	Algorithme de compression à utiliser

Mathématiques de la compression

Le taux de compression détermine dans quelle mesure le contexte est réduit :

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

Par exemple, avec un taux de 0.3 :

Original : 1000 tokens
Compressé : 300 tokens
Réduction : 70%

Le pourcentage de réduction de tokens est calculé comme suit : $\text{Reduction \%} = (1 - \text{ratio}) \times 100\%$

Avec compressionRatio = 0.3 : $\text{Reduction} = (1 - 0.3) \times 100\% = 70\%$

Stratégies de compression

Choisissez la stratégie de compression la plus adaptée à votre cas d'usage :

`'summarize'` - Résumé de texte

Idéal pour : conversations générales, questions-réponses, discussions
Fonctionnement : crée des résumés concis de groupes de messages
Avantages : maintient la fluidité du contexte, adapté à la plupart des cas d'usage
Inconvénients : peut perdre des détails spécifiques

const agent = await Agent.create({
  name: 'SummarizingAgent',
  autoContextCompression: true,
  compressionStrategy: 'summarize',
  preserveLastN: 4
});

`'selective'` - Sélection des messages importants

Idéal pour : conversations orientées tâches, discussions techniques
Fonctionnement : utilise l'IA pour identifier et préserver les messages importants
Avantages : conserve intactes les informations cruciales
Inconvénients : peut être plus gourmand en ressources

const agent = await Agent.create({
  name: 'SelectiveAgent',
  autoContextCompression: true,
  compressionStrategy: 'selective',
  preserveLastN: 3
});

`'hybrid'` - Approche combinée (recommandée)

Idéal pour : la plupart des applications, approche équilibrée
Fonctionnement : combine résumé et préservation sélective
Avantages : équilibre entre préservation du contexte et efficacité
Inconvénients : aucun inconvénient notable

const agent = await Agent.create({
  name: 'HybridAgent',
  autoContextCompression: true,
  compressionStrategy: 'hybrid', // Default and recommended
});

Utilisation avancée

Paramètres de compression personnalisés selon le cas d'usage

Conversations à haute fréquence

Pour les chatbots ou agents interactifs avec de nombreux messages courts :

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'
});

Création de contenu long format

Pour les agents travaillant avec du contenu détaillé :

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'
});

Documentation technique

Pour les agents traitant des discussions techniques complexes :

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

Fonctionnement de la compression du contexte

Processus de compression

Surveillance des tokens : l'agent surveille en continu le nombre total de tokens dans la conversation

Point de déclenchement : lorsque les tokens dépassent maxContextLength, la compression est déclenchée

Préservation des messages : les preserveLastN messages récents sont conservés non compressés

Analyse du contenu : les anciens messages sont analysés selon la stratégie choisie

Compression : les messages sont compressés en résumés ou en sélections

Mise à jour du contexte : le contexte compressé remplace les messages originaux

Ce qui est préservé

Invites système : toujours préservées
Messages récents : les N derniers messages selon preserveLastN
Contexte important : informations clés identifiées par la stratégie de compression
Résumés compressés : versions condensées des conversations plus anciennes

Exemple de flux de compression

// 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...' },
]

Surveillance et débogage

Informations sur la fenêtre de contexte

Obtenez des détails sur l'état actuel du contexte :

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);

Analyse du contexte

Analysez le contexte pour identifier des opportunités d'optimisation :

const analysis = agent.analyzeContext();

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

Types de réponse

Les méthodes de gestion du contexte retournent des objets détaillés pour surveiller et contrôler le contexte de la conversation.

Réponse Context Window

Obtenez la fenêtre de contexte actuelle avec des métriques d'utilisation :

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
}

Réponse Context Analysis

Analysez l'utilisation actuelle du contexte et les besoins de compression :

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
}

Réponse Compression Result

Compressez le contexte et obtenez des métriques de compression détaillées :

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"
}

Réponse Context Summary

Générez un résumé de la conversation propulsé par l'IA :

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"
  ]
}

Réponse Get Context Messages

Récupérez tous les messages de contexte sous forme de tableau :

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
]

Réponse Export Context

L'export du contexte retourne une chaîne JSON :

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}}'

Réponse Import/Clear Context

Les opérations d'import et de clear ne retournent rien (void) :

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

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

Dernière mise à jour : 6 juillet 2026

Dans cette section

Introduction

Framework d'agent IA open-source pour construire des systèmes autonomes qui résolvent efficacement des tâches concrètes.

Installation

Installez Astreus avec npm, yarn ou pnpm, vérifiez la version requise de Node.js, et préparez un projet local pour créer des agents IA avec le framework.

Démarrage rapide

Créez votre premier agent IA avec Astreus en moins de 2 minutes Découvrez les schémas de configuration, les API et les exemples pratiques nécessaires pour...

Agent

Entité IA centrale avec des capacités modulaires et une composition basée sur des décorateurs

Mémoire

Tâche