Ninetails Memory Engine V4.5: Quantização Int8 + Cache LRU Reduz Memória Local MCP para 60MB

O Ninetails Memory Engine V4.5 aborda o gargalo de memória em ferramentas locais de MCP (Model Context Protocol) implementando quantização escalar Int8 combinada com evicção de cache LRU. A solução mantém todo o processo do mecanismo rodando dentro de um aplicativo desktop Tauri com 40-60MB de RAM.

O Problema de Memória

Um embedding float32 padrão de 1536 dimensões ocupa cerca de 6144 bytes (~6KB). Armazenar 10.000 memórias significa ~60MB apenas para vetores, escalando para ~600MB para 100.000 memórias. Para uma ferramenta local rodando em SQLite, esse consumo de recursos é inaceitável.

Implementação Técnica

Camada 1: Quantização Escalar Int8

Ao comprimir float32 (4 bytes/dim) para int8 (1 byte/dim), o volume de armazenamento é reduzido a um quarto do tamanho original. A implementação calcula o intervalo numérico de cada dimensão, mapeia floats para uma faixa inteira de -128 a 127 e desquantiza de volta para float32 durante a recuperação para similaridade de cosseno.

# Quantizar: float32 → int8
def quantize_vector(vector_fp32, scale, zero_point):
    quantized = np.round(vector_fp32 / scale) + zero_point
    return np.clip(quantized, -128, 127).astype(np.int8)

# Desquantizar: int8 → float32 (Aproximação)
def dequantize_vector(vector_int8, scale, zero_point):
    return (vector_int8.astype(np.float32) - zero_point) * scale

Resultado real: Um vetor de 1536 dimensões cai de 6144 bytes para 1536 bytes. Considerando a sobrecarga de escala global e zero_point, a taxa de compressão real é de cerca de 3,8x - 4,0x.

Camada 2: Evicção de Cache LRU

Vetores quantizados são armazenados em um banco de dados SQLite (vector_cache.sqlite) usando uma estratégia Menos Recentemente Usado com um limite rígido de 10.000 entradas. Vetores de alta frequência permanecem na RAM enquanto os obsoletos são removidos.

Considerações de Precisão

A quantização Int8 é com perdas, mas aceitável para recuperação de memória porque:

• O mecanismo usa busca híbrida: 70% similaridade vetorial + 30% BM25. Mesmo que a quantização distorça levemente a classificação vetorial, a correspondência exata de palavras-chave via BM25 traz as memórias relevantes de volta.
• A recuperação de memória de IA só precisa trazer contexto para os Top-5 resultados, diferentemente de algoritmos de recomendação que precisam de precisão absoluta para a posição #1.

Esclarecimento sobre "TurboQuant"

O mecanismo usa quantização escalar Int8 padrão para armazenamento vetorial em SQLite, não o TurboQuant do Google (ICLR 2026), que é um algoritmo de compressão de 3 bits (PolarQuant + QJL) projetado para KV Cache durante inferência de GPU em LLM. A marcação "TurboQuant Compression" na interface é uma referência à filosofia de redução agressiva de bits.

Stack Tecnológico Completo

• Compressão Vetorial: Quantização Escalar Int8 (~4x compressão real)
• Gerenciamento de Cache: SQLite + Evicção LRU (Limite: 10.000 entradas)
• Mecanismo de Busca: Híbrido: 70% Similaridade Vetorial + 30% BM25
• Gerenciador de Perfil: Extração automática de fatos ESTÁTICOS/DINÂMICOS
• Extração de Fatos: asyncio.to_thread chamadas LLM assíncronas em segundo plano
• Armazenamento de Dados: 3x Bancos de Dados SQLite (100% Local)
• Aplicativo Desktop: Tauri + Vue 3 + sidecar PyInstaller

O mecanismo é de código aberto sob Licença MIT no GitHub: sunhonghua1/ninetails-memory-engine.