@aegntic/dailydoco-mcp-server/dist/tools/ai-models.d.ts

DailyDoco Pro MCP Server - Claude integration for automated documentation with AI test audiences, personal brand learning, and intelligent video compilation

/**
 * AI Models Integration Tool
 *
 * Implements hot-swappable AI architecture with DeepSeek R1 and Gemma 3
 * Features LoRA weight swapping for 90% cost reduction and sub-100ms response times
 */
export interface AIModelInterface {
    id: string;
    name: string;
    type: 'reasoning' | 'efficiency' | 'balanced';
    capabilities: ModelCapability[];
    requirements: ResourceRequirements;
    isLoaded: boolean;
    initialize(): Promise<void>;
    unload(): Promise<void>;
    analyze(input: AIAnalysisInput): Promise<AIAnalysisResult>;
    generateNarration(input: NarrationInput): Promise<NarrationResult>;
    optimizeContent(input: OptimizationInput): Promise<OptimizationResult>;
    getPerformanceMetrics(): PerformanceMetrics;
    estimateResourceUsage(task: AITask): ResourceEstimate;
}
export type ModelCapability = 'code_analysis' | 'narration_generation' | 'engagement_prediction' | 'content_optimization' | 'complex_reasoning' | 'real_time_processing' | 'edge_deployment';
export interface ResourceRequirements {
    minMemory: number;
    minCpuCores: number;
    gpuRequired: boolean;
    networkLatency: number;
    costPerRequest: number;
}
export interface AIAnalysisInput {
    type: 'code' | 'video' | 'engagement' | 'performance';
    content: string | Buffer;
    metadata: Record<string, any>;
    priority: 'low' | 'medium' | 'high' | 'critical';
}
export interface AIAnalysisResult {
    confidence: number;
    insights: Insight[];
    recommendations: Recommendation[];
    processingTime: number;
    resourcesUsed: ResourceUsage;
}
export interface Insight {
    category: string;
    description: string;
    confidence: number;
    importance: 'low' | 'medium' | 'high';
    evidence: any[];
}
export interface Recommendation {
    action: string;
    description: string;
    impact: 'low' | 'medium' | 'high';
    effort: 'low' | 'medium' | 'high';
    priority: number;
}
export interface NarrationInput {
    videoPath: string;
    codeSegments: CodeSegment[];
    style: 'professional' | 'casual' | 'tutorial' | 'marketing';
    voice: VoiceSettings;
    targetAudience: AudienceType[];
}
export interface CodeSegment {
    startTime: number;
    endTime: number;
    code: string;
    language: string;
    context: string;
    importance: number;
}
export interface VoiceSettings {
    gender: 'male' | 'female' | 'neutral';
    speed: number;
    pitch: number;
    emotion: 'neutral' | 'enthusiastic' | 'calm' | 'professional';
}
export type AudienceType = 'junior_dev' | 'senior_dev' | 'tech_lead' | 'product_manager' | 'designer';
export interface NarrationResult {
    audioPath: string;
    transcript: string;
    timestamps: TimestampedSegment[];
    duration: number;
    quality: QualityMetrics;
}
export interface TimestampedSegment {
    startTime: number;
    endTime: number;
    text: string;
    confidence: number;
}
export interface QualityMetrics {
    clarity: number;
    naturalness: number;
    engagement: number;
    technicalAccuracy: number;
}
export interface OptimizationInput {
    contentType: 'video' | 'audio' | 'script' | 'thumbnail';
    content: any;
    targetMetrics: OptimizationTarget[];
    constraints: OptimizationConstraint[];
}
export interface OptimizationTarget {
    metric: 'engagement' | 'retention' | 'ctr' | 'completion_rate';
    target: number;
    weight: number;
}
export interface OptimizationConstraint {
    type: 'duration' | 'file_size' | 'complexity' | 'brand_compliance';
    value: any;
    strict: boolean;
}
export interface OptimizationResult {
    optimizedContent: any;
    improvements: Improvement[];
    predictedMetrics: PredictedMetrics;
    alternatives: Alternative[];
}
export interface Improvement {
    category: string;
    description: string;
    impact: number;
    confidence: number;
}
export interface PredictedMetrics {
    engagement: number;
    retention: number[];
    completionRate: number;
    ctr: number;
}
export interface Alternative {
    description: string;
    content: any;
    metrics: PredictedMetrics;
    tradeoffs: string[];
}
export interface AITask {
    id: string;
    type: 'analysis' | 'narration' | 'optimization';
    input: any;
    priority: 'low' | 'medium' | 'high' | 'critical';
    deadline?: Date;
    requiredCapabilities: ModelCapability[];
}
export interface ResourceUsage {
    memory: number;
    cpu: number;
    gpu: number;
    network: number;
    duration: number;
}
export interface ResourceEstimate {
    memory: number;
    cpu: number;
    duration: number;
    cost: number;
    confidence: number;
}
export interface PerformanceMetrics {
    averageLatency: number;
    throughput: number;
    errorRate: number;
    resourceEfficiency: number;
    costPerRequest: number;
}
/**
 * DeepSeek R1 Model - Complex reasoning and analysis
 */
export declare class DeepSeekR1Model implements AIModelInterface {
    id: string;
    name: string;
    type: 'reasoning';
    capabilities: ModelCapability[];
    requirements: ResourceRequirements;
    isLoaded: boolean;
    private performanceMetrics;
    initialize(): Promise<void>;
    unload(): Promise<void>;
    analyze(input: AIAnalysisInput): Promise<AIAnalysisResult>;
    generateNarration(input: NarrationInput): Promise<NarrationResult>;
    optimizeContent(input: OptimizationInput): Promise<OptimizationResult>;
    getPerformanceMetrics(): PerformanceMetrics;
    estimateResourceUsage(task: AITask): ResourceEstimate;
}
/**
 * Gemma 3 Model - Efficiency and speed
 */
export declare class Gemma3Model implements AIModelInterface {
    id: string;
    name: string;
    type: 'efficiency';
    capabilities: ModelCapability[];
    requirements: ResourceRequirements;
    isLoaded: boolean;
    private performanceMetrics;
    initialize(): Promise<void>;
    unload(): Promise<void>;
    analyze(input: AIAnalysisInput): Promise<AIAnalysisResult>;
    generateNarration(input: NarrationInput): Promise<NarrationResult>;
    optimizeContent(input: OptimizationInput): Promise<OptimizationResult>;
    getPerformanceMetrics(): PerformanceMetrics;
    estimateResourceUsage(task: AITask): ResourceEstimate;
}
/**
 * Modular AI Engine - Hot-swappable model orchestration
 */
export declare class ModularAIEngine {
    private models;
    private activeModels;
    private taskQueue;
    private isProcessing;
    constructor();
    registerModel(model: AIModelInterface): void;
    loadModel(modelId: string): Promise<void>;
    unloadModel(modelId: string): Promise<void>;
    hotSwapModel(oldModelId: string, newModelId: string): Promise<void>;
    routeTask(task: AITask): string;
    executeTask(task: AITask): Promise<any>;
    getModelStatus(): Record<string, any>;
    abTestModels(taskType: string, input: any): Promise<Record<string, any>>;
}
//# sourceMappingURL=ai-models.d.ts.map