Contexto

Gestión inteligente de contexto para conversaciones largas con compresión automática Aprende los patrones de configuración, las APIs y los ejemplos...

Gestión inteligente de contexto para conversaciones largas con compresión automática

Descripción general

La compresión automática de contexto en Astreus ofrece una gestión inteligente de las conversaciones al manejar automáticamente historiales largos. El sistema comprime los mensajes más antiguos mientras conserva la información importante, garantizando que los agentes puedan mantener conversaciones largas y coherentes sin superar los límites de tokens del modelo.

Uso básico

Habilita la compresión automática de contexto para obtener una gestión automática de la conversación:

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

Ejemplo con tareas

La compresión automática de contexto funciona tanto con conversaciones directas como con tareas:

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 compresión automática de contexto garantiza que los agentes puedan gestionar conversaciones y tareas de cualquier longitud manteniendo la coherencia y respetando los límites de tokens.

Opciones de configuración

Puedes personalizar el comportamiento de la compresión automática de contexto con estos parámetros:

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

Parámetros de configuración

Parámetro	Tipo	Valor por defecto	Descripción
`autoContextCompression`	`boolean`	`false`	Habilita la compresión automática de contexto
`maxContextLength`	`number`	`8000`	Límite de tokens antes de que se active la compresión
`preserveLastN`	`number`	`3`	Número de mensajes recientes que se mantienen sin comprimir
`compressionRatio`	`number`	`0.3`	Ratio de compresión objetivo (0.1 = 90% de reducción)
`compressionStrategy`	`string`	`'hybrid'`	Algoritmo de compresión a utilizar

Matemáticas de la compresión

El ratio de compresión determina cuánto se reduce el contexto:

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

Por ejemplo, con un ratio de 0.3:

Original: 1000 tokens
Comprimido: 300 tokens
Reducción: 70%

El porcentaje de reducción de tokens se calcula como: $\text{Reduction \%} = (1 - \text{ratio}) \times 100\%$

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

Estrategias de compresión

Elige la estrategia de compresión que mejor se adapte a tu caso de uso:

`'summarize'` - Resumen de texto

Ideal para: conversaciones generales, preguntas y respuestas, debates
Cómo funciona: crea resúmenes concisos de grupos de mensajes
Ventajas: mantiene el flujo del contexto, adecuado para la mayoría de los casos
Desventajas: puede perder detalles específicos

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

`'selective'` - Selección de mensajes importantes

Ideal para: conversaciones orientadas a tareas, debates técnicos
Cómo funciona: usa IA para identificar y conservar los mensajes importantes
Ventajas: mantiene intacta la información crucial
Desventajas: puede consumir más recursos

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

`'hybrid'` - Enfoque combinado (recomendado)

Ideal para: la mayoría de las aplicaciones, enfoque equilibrado
Cómo funciona: combina el resumen con la preservación selectiva
Ventajas: equilibrio entre preservación del contexto y eficiencia
Desventajas: ninguna significativa

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

Uso avanzado

Ajustes de compresión personalizados según el caso de uso

Conversaciones de alta frecuencia

Para chatbots o agentes interactivos con muchos mensajes cortos:

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

Creación de contenido extenso

Para agentes que trabajan con contenido detallado:

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

Documentación técnica

Para agentes que manejan debates técnicos complejos:

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

Cómo funciona la compresión de contexto

Proceso de compresión

Monitorización de tokens: el agente monitoriza continuamente el número total de tokens en la conversación

Punto de activación: cuando los tokens superan maxContextLength, se activa la compresión

Preservación de mensajes: los últimos preserveLastN mensajes se mantienen sin comprimir

Análisis de contenido: los mensajes más antiguos se analizan según la estrategia elegida

Compresión: los mensajes se comprimen en resúmenes o selecciones

Actualización del contexto: el contexto comprimido reemplaza a los mensajes originales

Qué se conserva

Prompts del sistema: siempre se conservan
Mensajes recientes: los últimos N mensajes según preserveLastN
Contexto importante: información clave identificada por la estrategia de compresión
Resúmenes comprimidos: versiones condensadas de conversaciones anteriores

Ejemplo de flujo de compresión

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

Monitorización y depuración

Información de la ventana de contexto

Obtén detalles sobre el estado actual del contexto:

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

Análisis de contexto

Analiza el contexto para detectar oportunidades de optimización:

const analysis = agent.analyzeContext();

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

Tipos de respuesta

Los métodos de gestión de contexto devuelven objetos detallados para monitorizar y controlar el contexto de la conversación.

Respuesta de la ventana de contexto

Obtén la ventana de contexto actual con métricas de utilización:

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
}

Respuesta de análisis de contexto

Analiza el uso actual del contexto y las necesidades de compresión:

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
}

Respuesta del resultado de compresión

Comprime el contexto y obtén métricas de compresión detalladas:

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

Respuesta del resumen de contexto

Genera un resumen de la conversación impulsado por 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"
  ]
}

Respuesta de obtención de mensajes de contexto

Recupera todos los mensajes de contexto como un array:

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
]

Respuesta de exportación de contexto

La exportación de contexto devuelve una cadena 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}}'

Respuesta de importación/limpieza de contexto

Las operaciones de importación y limpieza devuelven void:

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

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

Última actualización: 6 de julio de 2026

En esta sección

Introducción

Framework de agentes de IA de código abierto para construir sistemas autónomos que resuelven tareas del mundo real de forma eficaz.

Instalación

Instala Astreus con npm, yarn o pnpm, confirma la versión de Node.js requerida y prepara un proyecto local para construir agentes de IA con el framework.

Inicio rápido

Construye tu primer agente de IA con Astreus en menos de 2 minutos Aprende los patrones de configuración, las APIs y los ejemplos prácticos necesarios para...

Agente

Entidad de IA principal con capacidades modulares y composición basada en decoradores Aprende los patrones de configuración, las APIs y los ejemplos...

Memoria

Tarea