smart-thinking-mcp/build/verification-memory.d.ts

Un serveur MCP avancé pour le raisonnement multi-dimensionnel, adaptatif et collaboratif

import { VerificationStatus } from './types';
import { EmbeddingService } from './embedding-service';
/**
 * Résultat d'une recherche de vérification
 */
export interface VerificationSearchResult {
    id: string;
    status: VerificationStatus;
    confidence: number;
    sources: string[];
    timestamp: Date;
    similarity: number;
    text: string;
}
/**
 * Classe qui gère la mémoire des vérifications avec recherche vectorielle efficace
 * pour assurer leur persistance à travers les différentes étapes du raisonnement
 * AMÉLIORÉ: Meilleure gestion des similarités et persistance des vérifications
 */
export declare class VerificationMemory {
    private static instance;
    private embeddingService?;
    private verifications;
    private sessionIndex;
    private similarityCache;
    /**
     * Méthode statique pour implémenter le singleton
     *
     * @returns L'instance unique de VerificationMemory
     */
    static getInstance(): VerificationMemory;
    /**
     * Constructeur privé pour empêcher l'instanciation directe
     */
    private constructor();
    /**
     * Définit le service d'embedding à utiliser pour la similarité sémantique
     *
     * @param embeddingService Service d'embedding à utiliser
     */
    setEmbeddingService(embeddingService: EmbeddingService): void;
    /**
     * Ajoute une nouvelle vérification à la mémoire
     * AMÉLIORÉ: Meilleure détection des duplicatas avec cache de similarité
     *
     * @param text Texte de l'information vérifiée
     * @param status Statut de vérification
     * @param confidence Niveau de confiance
     * @param sources Sources utilisées pour la vérification
     * @param sessionId Identifiant de la session
     * @param ttl Durée de vie en millisecondes (optionnel)
     * @returns Identifiant de la vérification ajoutée
     */
    addVerification(text: string, status: VerificationStatus, confidence: number, sources?: string[], sessionId?: string, ttl?: number): Promise<string>;
    /**
     * Recherche une vérification existante identique pour éviter les doublons
     * AMÉLIORÉ: Utilisation du cache de similarité pour des recherches plus rapides
     *
     * @param text Texte à rechercher
     * @param sessionId ID de session
     * @returns L'entrée existante si trouvée, null sinon
     */
    private findExactDuplicate;
    /**
     * NOUVEAU: Obtient une similarité mise en cache
     *
     * @param key Clé du cache
     * @returns Similarité mise en cache ou undefined si non trouvée
     */
    private getCachedSimilarity;
    /**
     * NOUVEAU: Définit une similarité dans le cache
     *
     * @param key Clé du cache
     * @param similarity Valeur de similarité à mettre en cache
     */
    private setCachedSimilarity;
    /**
     * Recherche une vérification existante similaire à l'information fournie
     * AMÉLIORÉ: Recherche plus efficace avec seuils de similarité ajustés
     *
     * @param text Texte de l'information à rechercher
     * @param sessionId Identifiant de la session
     * @param similarityThreshold Seuil de similarité
     * @returns La vérification trouvée, ou null si aucune correspondance
     */
    findVerification(text: string, sessionId?: string, similarityThreshold?: number): Promise<VerificationSearchResult | null>;
    /**
     * Méthode de secours pour la recherche basée sur le texte
     * AMÉLIORÉ: Recherche textuelle plus flexible
     *
     * @param text Texte à rechercher
     * @param sessionId ID de session
     * @returns Résultat de recherche ou null
     */
    private fallbackToTextSearch;
    /**
     * NOUVEAU: Normalise un texte pour la recherche textuelle
     *
     * @param text Texte à normaliser
     * @returns Texte normalisé
     */
    private normalizeText;
    /**
     * Récupère les entrées pour une session donnée
     *
     * @param sessionId ID de session
     * @returns Tableau des entrées pour cette session
     */
    private getSessionEntriesArray;
    /**
     * Récupère toutes les vérifications pour une session donnée
     * avec pagination et filtrage
     *
     * @param sessionId Identifiant de la session
     * @param offset Position de départ (pour pagination)
     * @param limit Nombre maximum de résultats
     * @param statusFilter Filtre sur le statut (optionnel)
     * @returns Tableau des vérifications pour cette session
     */
    getSessionVerifications(sessionId?: string, offset?: number, limit?: number, statusFilter?: VerificationStatus): {
        text: string;
        status: VerificationStatus;
        confidence: number;
        sources: string[];
        timestamp: Date;
        id: string;
    }[];
    /**
     * Recherche des vérifications par similarité vectorielle
     *
     * @param text Texte de référence
     * @param sessionId ID de session
     * @param limit Nombre maximum de résultats
     * @param minSimilarity Seuil minimal de similarité
     * @returns Liste de résultats triés par similarité
     */
    searchSimilarVerifications(text: string, sessionId?: string, limit?: number, minSimilarity?: number): Promise<VerificationSearchResult[]>;
    /**
     * Nettoie les vérifications d'une session spécifique
     *
     * @param sessionId Identifiant de la session à nettoyer
     */
    clearSession(sessionId: string): void;
    /**
     * Nettoie les entrées expirées
     */
    private cleanExpiredEntries;
    /**
     * NOUVEAU: Nettoie le cache de similarité
     */
    private cleanSimilarityCache;
    /**
     * Nettoie toutes les vérifications (utilisé pour les tests)
     */
    clearAll(): void;
    /**
     * Obtient des statistiques sur la mémoire de vérification
     */
    getStats(): {
        totalEntries: number;
        sessionCount: number;
        cacheSize: number;
        entriesByStatus: Record<VerificationStatus, number>;
    };
}