Ninetails Memory Engine V4.5 : Quantification Int8 + Cache LRU réduit la mémoire MCP locale à 60 Mo

Le moteur de mémoire Ninetails V4.5 résout le goulot d'étranglement de la mémoire dans les outils MCP (Model Context Protocol) locaux en mettant en œuvre la quantification scalaire Int8 combinée à l'éviction de cache LRU. La solution maintient l'ensemble du processus du moteur fonctionnant dans une application de bureau Tauri avec 40 à 60 Mo de RAM.

Le problème de mémoire

Un plongement standard en float32 de 1536 dimensions occupe environ 6144 octets (~6 Ko). Stocker 10 000 souvenirs signifie ~60 Mo juste pour les vecteurs, passant à ~600 Mo pour 100 000 souvenirs. Pour un outil local fonctionnant sur SQLite, cette consommation de ressources est inacceptable.

Implémentation technique

Couche 1 : Quantification scalaire Int8

En compressant le float32 (4 octets/dim) en int8 (1 octet/dim), le volume de stockage est réduit au quart de sa taille d'origine. L'implémentation calcule la plage numérique de chaque dimension, mappe les flottants à une plage entière de -128 à 127, et déquantifie en float32 lors de la récupération pour la similarité cosinus.

# Quantifier : 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)

# Déquantifier : int8 → float32 (Approximation)
def dequantize_vector(vector_int8, scale, zero_point):
    return (vector_int8.astype(np.float32) - zero_point) * scale

Résultat réel : Un vecteur de 1536 dimensions passe de 6144 octets à 1536 octets. En tenant compte de la surcharge globale de scale et zero_point, le taux de compression réel est d'environ 3,8x - 4,0x.

Couche 2 : Éviction de cache LRU

Les vecteurs quantifiés sont stockés dans une base de données SQLite (vector_cache.sqlite) en utilisant une stratégie Least Recently Used avec une limite stricte de 10 000 entrées. Les vecteurs à haute fréquence restent en RAM tandis que les anciens sont évincés.

Considérations de précision

La quantification Int8 est avec perte mais acceptable pour la récupération de mémoire car :

• Le moteur utilise une recherche hybride : 70 % de similarité vectorielle + 30 % BM25. Même si la quantification modifie légèrement le classement des vecteurs, la correspondance exacte des mots-clés via BM25 ramène les souvenirs pertinents vers le haut.
• La récupération de mémoire IA n'a besoin que de faire remonter le contexte dans les 5 premiers résultats, contrairement aux algorithmes de recommandation qui nécessitent une précision absolue pour la première place.

Clarification sur "TurboQuant"

Le moteur utilise la quantification scalaire Int8 standard pour le stockage vectoriel SQLite, et non le TurboQuant de Google (ICLR 2026), qui est un algorithme de compression 3 bits (PolarQuant + QJL) conçu pour le KV Cache lors de l'inférence GPU des LLM. La mention "TurboQuant Compression" dans l'interface utilisateur est un clin d'œil à la philosophie de réduction agressive des bits.

Stack technique complète

• Compression vectorielle : Quantification scalaire Int8 (~4x compression réelle)
• Gestion du cache : SQLite + Éviction LRU (Limite : 10 000 entrées)
• Moteur de recherche : Hybride : 70 % Similarité vectorielle + 30 % BM25
• Gestionnaire de profil : Extraction automatique de faits STATIC/DYNAMIC
• Extraction de faits : Appels LLM asynchrones en arrière-plan via asyncio.to_thread
• Stockage des données : 3 bases de données SQLite (100 % Local)
• Application de bureau : Tauri + Vue 3 + PyInstaller sidecar

Le moteur est open-source sous licence MIT sur GitHub : sunhonghua1/ninetails-memory-engine.