@digilogiclabs/create-saas-app 1.0.1

package/dist/templates/web/ui-auth-payments-ai-rag/template/hooks/useRAGSystem.ts

@@ -0,0 +1,478 @@
+'use client'
+
+import { useState, useEffect, useCallback, useRef, useMemo } from 'react';
+import { RAGSystem } from '@digilogiclabs/saas-factory-ai';
+import type { 
+  RAGQuery, 
+  RAGResponse, 
+  RAGDocument, 
+  RAGSearchResult,
+  RAGDocumentSchema 
+} from '@digilogiclabs/saas-factory-ai-types';
+import { getRAGConfigForDomain, webRAGOptions } from '../lib/rag/config';
+import { toast } from 'sonner';
+
+interface UseRAGSystemOptions {
+  domain?: string;
+  enableStreaming?: boolean;
+  enableCache?: boolean;
+  autoInitialize?: boolean;
+}
+
+interface RAGState {
+  isInitialized: boolean;
+  isLoading: boolean;
+  isStreaming: boolean;
+  lastSyncAt: Date | null;
+  totalQueries: number;
+  totalDocuments: number;
+  error: string | null;
+  health: 'healthy' | 'degraded' | 'down';
+}
+
+interface StreamingState {
+  isStreaming: boolean;
+  currentResponse: string;
+  sources: RAGSearchResult[];
+  confidence: number;
+}
+
+export function useRAGSystem<TSchema extends RAGDocumentSchema>(
+  options: UseRAGSystemOptions = {}
+) {
+  const {
+    domain = 'generic',
+    enableStreaming = true,
+    enableCache = true,
+    autoInitialize = true
+  } = options;
+
+  const [ragSystem, setRAGSystem] = useState<RAGSystem<TSchema> | null>(null);
+  const [state, setState] = useState<RAGState>({
+    isInitialized: false,
+    isLoading: false,
+    isStreaming: false,
+    lastSyncAt: null,
+    totalQueries: 0,
+    totalDocuments: 0,
+    error: null,
+    health: 'down'
+  });
+
+  const [streamingState, setStreamingState] = useState<StreamingState>({
+    isStreaming: false,
+    currentResponse: '',
+    sources: [],
+    confidence: 0
+  });
+
+  const [queryHistory, setQueryHistory] = useState<RAGQuery[]>([]);
+  const [responseCache, setResponseCache] = useState<Map<string, RAGResponse>>(new Map());
+  
+  const abortControllerRef = useRef<AbortController | null>(null);
+  const statsRef = useRef({ queries: 0, documents: 0, lastSync: null as Date | null });
+
+  // Memoized configuration
+  const ragConfig = useMemo(() => getRAGConfigForDomain(domain), [domain]);
+
+  // Initialize RAG system
+  useEffect(() => {
+    if (!autoInitialize) return;
+
+    const initRAG = async () => {
+      try {
+        setState(prev => ({ ...prev, isLoading: true, error: null }));
+
+        const system = new RAGSystem<TSchema>(ragConfig);
+        await system.initialize();
+        
+        setRAGSystem(system);
+
+        // Load initial stats
+        const stats = await system.getStats();
+        statsRef.current = {
+          queries: stats.totalQueries || 0,
+          documents: stats.totalDocuments || 0,
+          lastSync: stats.lastSync ? new Date(stats.lastSync) : null
+        };
+
+        setState(prev => ({ 
+          ...prev, 
+          isInitialized: true, 
+          isLoading: false,
+          totalQueries: statsRef.current.queries,
+          totalDocuments: statsRef.current.documents,
+          lastSyncAt: statsRef.current.lastSync,
+          health: 'healthy'
+        }));
+
+        toast.success('AI Knowledge System initialized');
+
+      } catch (error) {
+        console.error('RAG initialization error:', error);
+        const errorMessage = error instanceof Error ? error.message : 'Initialization failed';
+        
+        setState(prev => ({ 
+          ...prev, 
+          error: errorMessage,
+          isLoading: false,
+          health: 'down'
+        }));
+
+        toast.error(`Failed to initialize AI system: ${errorMessage}`);
+      }
+    };
+
+    initRAG();
+  }, [ragConfig, autoInitialize]);
+
+  // Cleanup on unmount
+  useEffect(() => {
+    return () => {
+      if (abortControllerRef.current) {
+        abortControllerRef.current.abort();
+      }
+    };
+  }, []);
+
+  // Query function with streaming support
+  const query = useCallback(async (
+    queryText: string, 
+    options?: {
+      category?: string;
+      maxResults?: number;
+      includeMetadata?: boolean;
+      stream?: boolean;
+    }
+  ): Promise<RAGResponse> => {
+    if (!ragSystem) {
+      throw new Error('RAG system not initialized');
+    }
+
+    // Cancel any ongoing request
+    if (abortControllerRef.current) {
+      abortControllerRef.current.abort();
+    }
+    
+    abortControllerRef.current = new AbortController();
+
+    const ragQuery: RAGQuery = {
+      query: queryText,
+      category: options?.category,
+      maxResults: options?.maxResults || 6,
+      includeMetadata: options?.includeMetadata ?? true,
+      timestamp: new Date()
+    };
+
+    const cacheKey = getCacheKey(ragQuery);
+    const shouldStream = enableStreaming && (options?.stream !== false);
+
+    // Check cache first
+    if (enableCache && responseCache.has(cacheKey)) {
+      const cached = responseCache.get(cacheKey)!;
+      toast.success('Retrieved from cache');
+      return { ...cached, fromCache: true };
+    }
+
+    try {
+      setState(prev => ({ ...prev, isLoading: true, error: null }));
+
+      if (shouldStream) {
+        // Initialize streaming state
+        setStreamingState({
+          isStreaming: true,
+          currentResponse: '',
+          sources: [],
+          confidence: 0
+        });
+
+        // Handle streaming response
+        const response = await ragSystem.queryStream(
+          ragQuery,
+          {
+            onChunk: (chunk) => {
+              setStreamingState(prev => ({
+                ...prev,
+                currentResponse: prev.currentResponse + chunk.text,
+                confidence: chunk.confidence || prev.confidence
+              }));
+            },
+            onSources: (sources) => {
+              setStreamingState(prev => ({
+                ...prev,
+                sources
+              }));
+            },
+            signal: abortControllerRef.current?.signal
+          }
+        );
+
+        // Finalize streaming
+        setStreamingState(prev => ({ ...prev, isStreaming: false }));
+
+        return response;
+
+      } else {
+        // Regular non-streaming query
+        const response = await ragSystem.query(ragQuery, {
+          signal: abortControllerRef.current?.signal
+        });
+
+        // Cache successful responses
+        if (enableCache && response.confidence > 0.6) {
+          const newCache = new Map(responseCache);
+          newCache.set(cacheKey, response);
+          
+          // Limit cache size
+          if (newCache.size > 100) {
+            const firstKey = newCache.keys().next().value;
+            newCache.delete(firstKey);
+          }
+          
+          setResponseCache(newCache);
+        }
+
+        return response;
+      }
+
+    } catch (error: any) {
+      if (error.name === 'AbortError') {
+        throw new Error('Query cancelled');
+      }
+      
+      setState(prev => ({ ...prev, error: error.message, health: 'degraded' }));
+      toast.error(`Query failed: ${error.message}`);
+      throw error;
+
+    } finally {
+      setState(prev => ({ 
+        ...prev, 
+        isLoading: false,
+        totalQueries: prev.totalQueries + 1
+      }));
+
+      // Update query history
+      setQueryHistory(prev => [ragQuery, ...prev.slice(0, 19)]);
+      
+      // Reset streaming state if not streaming
+      if (!shouldStream) {
+        setStreamingState({
+          isStreaming: false,
+          currentResponse: '',
+          sources: [],
+          confidence: 0
+        });
+      }
+    }
+  }, [ragSystem, enableStreaming, enableCache, responseCache]);
+
+  // Search knowledge base
+  const searchKnowledge = useCallback(async (
+    searchText: string,
+    filters?: { 
+      category?: string; 
+      limit?: number; 
+      sort?: 'relevance' | 'date' | 'popularity';
+      includeMetadata?: boolean;
+    }
+  ): Promise<RAGSearchResult[]> => {
+    if (!ragSystem) return [];
+
+    try {
+      return await ragSystem.searchDocuments(searchText, {
+        ...filters,
+        limit: filters?.limit || 20
+      });
+    } catch (error) {
+      console.error('Knowledge search error:', error);
+      toast.error('Search failed');
+      return [];
+    }
+  }, [ragSystem]);
+
+  // Add document to knowledge base
+  const addKnowledge = useCallback(async (
+    document: Omit<RAGDocument<TSchema>, 'id' | 'createdAt' | 'updatedAt'>
+  ): Promise<string | null> => {
+    if (!ragSystem) return null;
+
+    try {
+      const id = await ragSystem.addDocument(document as RAGDocument<TSchema>);
+      
+      setState(prev => ({ 
+        ...prev, 
+        totalDocuments: prev.totalDocuments + 1 
+      }));
+      
+      toast.success('Knowledge added successfully');
+      return id;
+
+    } catch (error) {
+      console.error('Add knowledge error:', error);
+      toast.error('Failed to add knowledge');
+      return null;
+    }
+  }, [ragSystem]);
+
+  // Update document
+  const updateKnowledge = useCallback(async (
+    id: string,
+    updates: Partial<RAGDocument<TSchema>>
+  ): Promise<boolean> => {
+    if (!ragSystem) return false;
+
+    try {
+      await ragSystem.updateDocument(id, updates);
+      toast.success('Knowledge updated successfully');
+      return true;
+
+    } catch (error) {
+      console.error('Update knowledge error:', error);
+      toast.error('Failed to update knowledge');
+      return false;
+    }
+  }, [ragSystem]);
+
+  // Delete document
+  const deleteKnowledge = useCallback(async (id: string): Promise<boolean> => {
+    if (!ragSystem) return false;
+
+    try {
+      await ragSystem.deleteDocument(id);
+      
+      setState(prev => ({ 
+        ...prev, 
+        totalDocuments: Math.max(0, prev.totalDocuments - 1) 
+      }));
+      
+      toast.success('Knowledge deleted successfully');
+      return true;
+
+    } catch (error) {
+      console.error('Delete knowledge error:', error);
+      toast.error('Failed to delete knowledge');
+      return false;
+    }
+  }, [ragSystem]);
+
+  // Bulk operations
+  const bulkAddKnowledge = useCallback(async (
+    documents: Omit<RAGDocument<TSchema>, 'id' | 'createdAt' | 'updatedAt'>[]
+  ): Promise<string[]> => {
+    if (!ragSystem) return [];
+
+    try {
+      setState(prev => ({ ...prev, isLoading: true }));
+      
+      const ids = await ragSystem.bulkAddDocuments(documents as RAGDocument<TSchema>[]);
+      
+      setState(prev => ({ 
+        ...prev, 
+        totalDocuments: prev.totalDocuments + ids.length,
+        isLoading: false
+      }));
+      
+      toast.success(`Added ${ids.length} knowledge documents`);
+      return ids;
+
+    } catch (error) {
+      setState(prev => ({ ...prev, isLoading: false }));
+      console.error('Bulk add error:', error);
+      toast.error('Bulk add operation failed');
+      return [];
+    }
+  }, [ragSystem]);
+
+  // Sync knowledge base
+  const syncKnowledgeBase = useCallback(async (): Promise<void> => {
+    if (!ragSystem) return;
+
+    try {
+      setState(prev => ({ ...prev, isLoading: true }));
+      
+      await ragSystem.sync(state.lastSyncAt);
+      
+      const stats = await ragSystem.getStats();
+      
+      setState(prev => ({ 
+        ...prev, 
+        lastSyncAt: new Date(),
+        totalDocuments: stats.totalDocuments || prev.totalDocuments,
+        isLoading: false,
+        health: 'healthy'
+      }));
+
+      toast.success('Knowledge base synchronized');
+
+    } catch (error) {
+      setState(prev => ({ ...prev, isLoading: false, health: 'degraded' }));
+      console.error('Sync error:', error);
+      toast.error('Synchronization failed');
+    }
+  }, [ragSystem, state.lastSyncAt]);
+
+  // Cancel current operation
+  const cancelOperation = useCallback(() => {
+    if (abortControllerRef.current) {
+      abortControllerRef.current.abort();
+      setStreamingState({
+        isStreaming: false,
+        currentResponse: '',
+        sources: [],
+        confidence: 0
+      });
+      setState(prev => ({ ...prev, isLoading: false }));
+      toast.info('Operation cancelled');
+    }
+  }, []);
+
+  // Clear cache
+  const clearCache = useCallback(() => {
+    setResponseCache(new Map());
+    setQueryHistory([]);
+    toast.success('Cache cleared');
+  }, []);
+
+  // Get analytics data
+  const getAnalytics = useCallback(async (timeRange: string = '7d') => {
+    if (!ragSystem) return null;
+
+    try {
+      return await ragSystem.getAnalytics(timeRange);
+    } catch (error) {
+      console.error('Analytics error:', error);
+      return null;
+    }
+  }, [ragSystem]);
+
+  // Helper functions
+  const getCacheKey = (query: RAGQuery): string => {
+    return `${query.query}:${query.category || 'all'}:${query.maxResults}`;
+  };
+
+  return {
+    // State
+    ...state,
+    ragSystem,
+    queryHistory,
+    streamingState,
+    cacheSize: responseCache.size,
+
+    // Actions
+    query,
+    searchKnowledge,
+    addKnowledge,
+    updateKnowledge,
+    deleteKnowledge,
+    bulkAddKnowledge,
+    syncKnowledgeBase,
+    cancelOperation,
+    clearCache,
+    getAnalytics,
+
+    // Utilities
+    isReady: state.isInitialized && !state.isLoading && state.health !== 'down',
+    canQuery: state.isInitialized && state.health !== 'down',
+    hasError: !!state.error,
+  };
+}