Contexto

Gerenciamento inteligente de contexto para conversas longas com compressão automática Aprenda os padrões de configuração, as APIs e os exemplos práticos...

Gerenciamento inteligente de contexto para conversas longas com compressão automática

Visão Geral

A compressão automática de contexto no Astreus fornece um gerenciamento inteligente de conversação, tratando automaticamente históricos de conversa longos. O sistema comprime mensagens mais antigas enquanto preserva informações importantes, garantindo que os agentes possam manter conversas longas e coerentes sem exceder os limites de tokens do modelo.

Uso Básico

Habilite a compressão automática de contexto para obter gerenciamento automático de conversação:

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

Exemplo com Tasks

A compressão automática de contexto funciona tanto com conversas diretas quanto com tarefas:

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

A compressão automática de contexto garante que os agentes possam lidar com conversas e tarefas de qualquer duração, mantendo a coerência e respeitando os limites de tokens.

Opções de Configuração

Você pode personalizar o comportamento da compressão automática de contexto com estes 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 Configuração

Parameter	Type	Default	Description
`autoContextCompression`	`boolean`	`false`	Habilita a compressão automática de contexto
`maxContextLength`	`number`	`8000`	Limite de tokens antes de acionar a compressão
`preserveLastN`	`number`	`3`	Número de mensagens recentes a manter sem compressão
`compressionRatio`	`number`	`0.3`	Taxa de compressão alvo (0.1 = 90% de redução)
`compressionStrategy`	`string`	`'hybrid'`	Algoritmo de compressão a ser usado

Matemática da Compressão

A taxa de compressão determina o quanto o contexto é reduzido:

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

Por exemplo, com uma taxa de 0.3:

Original: 1000 tokens
Comprimido: 300 tokens
Redução: 70%

O percentual de redução de tokens é calculado como: $\text{Reduction \%} = (1 - \text{ratio}) \times 100\%$

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

Estratégias de Compressão

Escolha a estratégia de compressão que melhor se adapta ao seu caso de uso:

`'summarize'` - Sumarização de Texto

Melhor para: Conversas gerais, perguntas e respostas, discussões
Como funciona: Cria resumos concisos de grupos de mensagens
Prós: Mantém o fluxo do contexto, bom para a maioria dos casos de uso
Contras: Pode perder detalhes específicos

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

`'selective'` - Seleção de Mensagens Importantes

Melhor para: Conversas orientadas a tarefas, discussões técnicas
Como funciona: Usa IA para identificar e preservar mensagens importantes
Prós: Mantém informações cruciais intactas
Contras: Pode exigir mais recursos

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

`'hybrid'` - Abordagem Combinada (Recomendado)

Melhor para: A maioria das aplicações, abordagem equilibrada
Como funciona: Combina sumarização e preservação seletiva
Prós: Equilíbrio entre preservação de contexto e eficiência
Contras: Nenhum significativo

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

Uso Avançado

Configurações de Compressão Personalizadas por Caso de Uso

Conversas de Alta Frequência

Para chatbots ou agentes interativos com muitas mensagens curtas:

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

Criação de Conteúdo Longo

Para agentes que trabalham com conteúdo detalhado:

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

Documentação Técnica

Para agentes que lidam com discussões técnicas complexas:

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

Como Funciona a Compressão de Contexto

Processo de Compressão

Monitoramento de Tokens: O agente monitora continuamente a contagem total de tokens na conversa

Ponto de Ativação: Quando os tokens excedem maxContextLength, a compressão é acionada

Preservação de Mensagens: As últimas preserveLastN mensagens são mantidas sem compressão

Análise de Conteúdo: Mensagens mais antigas são analisadas com base na estratégia escolhida

Compressão: As mensagens são comprimidas em resumos ou seleções

Atualização do Contexto: O contexto comprimido substitui as mensagens originais

O Que É Preservado

Prompts de sistema: Sempre preservados
Mensagens recentes: Últimas N mensagens com base em preserveLastN
Contexto importante: Informações-chave identificadas pela estratégia de compressão
Resumos comprimidos: Versões condensadas de conversas mais antigas

Exemplo de Fluxo de Compressão

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

Monitoramento e Depuração

Informações da Janela de Contexto

Obtenha detalhes sobre o estado atual do 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álise de Contexto

Analise o contexto em busca de oportunidades de otimização:

const analysis = agent.analyzeContext();

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

Tipos de Resposta

Os métodos de gerenciamento de contexto retornam objetos detalhados para monitorar e controlar o contexto da conversa.

Resposta da Janela de Contexto

Obtenha a janela de contexto atual com métricas de utilização:

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
}

Resposta da Análise de Contexto

Analise o uso atual do contexto e as necessidades de compressão:

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
}

Resposta do Resultado de Compressão

Comprima o contexto e obtenha métricas detalhadas de compressão:

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

Resposta do Resumo de Contexto

Gere um resumo da conversa com apoio de 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"
  ]
}

Resposta de Obtenção de Mensagens de Contexto

Recupere todas as mensagens de contexto como um 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
]

Resposta de Exportação de Contexto

A exportação de contexto retorna uma string 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}}'

Resposta de Importação/Limpeza de Contexto

As operações de importação e limpeza retornam void:

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

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

Última atualização: 6 de julho de 2026

Nesta seção

Introdução

Framework de agentes de IA open-source para construir sistemas autônomos que resolvem tarefas do mundo real de forma eficaz.

Instalação

Instale o Astreus com npm, yarn ou pnpm, confirme a versão necessária do Node.js e prepare um projeto local para construir agentes de IA com o framework.

Início Rápido

Construa seu primeiro agente de IA com Astreus em menos de 2 minutos Aprenda os padrões de configuração, as APIs e os exemplos práticos necessários para...

Agente

Entidade central de IA com capacidades modulares e composição baseada em decorators Aprenda os padrões de configuração, as APIs e os exemplos práticos...

Memória

Tarefa