Contexto
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-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 contextEjemplo 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-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 compressedLa 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-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,
});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:
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:
Con compressionRatio = 0.3:
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