mathrok/dist/types/ai/pipeline/hybrid.d.ts

AI-powered symbolic mathematics library combining traditional Computer Algebra System (CAS) capabilities with natural language processing for math problem solving

/**
 * Hybrid Processing Pipeline
 * Combines rule-based and AI processing for optimal performance and accuracy
 */
import { type AIResult, type AIModelConfig } from '../models/manager.js';
export interface NLResult {
    result: any;
    interpretation: string;
    confidence: number;
    alternatives?: string[];
    method?: string;
}
export interface HybridConfig {
    ruleBasedThreshold: number;
    aiThreshold: number;
    enableAI: boolean;
    enableCaching: boolean;
    maxProcessingTime: number;
}
export interface ProcessingResult {
    result: any;
    confidence: number;
    method: 'rule_based' | 'ai' | 'hybrid';
    processingTime: number;
    explanation?: string;
    alternatives?: any[];
    steps?: any[];
    metadata: {
        ruleBasedResult?: NLResult;
        aiResult?: AIResult;
        hybridScore?: number;
        fallbackReason?: string;
    };
}
export interface ProcessingStats {
    totalQueries: number;
    ruleBasedQueries: number;
    aiQueries: number;
    hybridQueries: number;
    averageProcessingTime: number;
    successRate: number;
    cacheHitRate: number;
}
/**
 * Hybrid Processing Pipeline that intelligently routes queries between rule-based and AI processing
 */
export declare class HybridProcessor {
    private mathEngine;
    private contextManager;
    private aiManager;
    private config;
    private stats;
    private cache;
    constructor(config?: Partial<HybridConfig>, aiConfig?: AIModelConfig);
    /**
     * Process a mathematical query using hybrid approach
     */
    process(query: string): Promise<ProcessingResult>;
    /**
     * Initialize AI components
     */
    initialize(): Promise<boolean>;
    /**
     * Get processing statistics
     */
    getStats(): ProcessingStats;
    /**
     * Update configuration
     */
    updateConfig(config: Partial<HybridConfig>): void;
    /**
     * Clear cache and reset stats
     */
    reset(): void;
    private processWithRules;
    private processWithAI;
    private processHybrid;
    private createRuleBasedResult;
    private combineResults;
    private generateExplanation;
    private getFromCache;
    private addToCache;
    private updateStats;
    private interpretQuery;
    private extractExpression;
    private extractVariable;
    private executeInterpretation;
}
//# sourceMappingURL=hybrid.d.ts.map