nextjs-chatbot-ui 1.6.0 → 1.7.1

package/README.md

@@ -76,6 +76,40 @@ OPENAI_API_KEY=your_openai_api_key_here
 CHROMADB_URL=http://localhost:8000
 ```
 
+### Step 2.5: Start ChromaDB (Automatic)
+
+The package includes a script to automatically check and start ChromaDB:
+
+```bash
+# Check and start ChromaDB automatically
+npm run chromadb:check
+
+# Or use Docker Compose
+npm run chromadb:start
+
+# Or manually with Docker
+docker run -d --name chromadb -p 8000:8000 chromadb/chroma
+```
+
+**What the script does:**
+- ✅ Checks if ChromaDB npm package is installed (installs if missing)
+- ✅ Checks if Docker is installed and running
+- ✅ Checks if ChromaDB container is running
+- ✅ Starts ChromaDB container if not running
+- ✅ Verifies ChromaDB is accessible
+
+**Alternative: Using Docker Compose**
+```bash
+# Start ChromaDB
+docker-compose up -d
+
+# Stop ChromaDB
+docker-compose stop
+
+# Restart ChromaDB
+docker-compose restart
+```
+
 ### Step 3: Use Components
 
 ```javascript

package/api/chat.ts

@@ -2,6 +2,13 @@ import { NextRequest, NextResponse } from 'next/server';
 import { ChromaClient } from 'chromadb';
 import OpenAI from 'openai';
 
+// Configuration constants
+const MAX_RETRIES = 3;
+const RETRY_DELAY = 1000;
+const DEFAULT_N_RESULTS = 5;
+const MAX_CONTEXT_LENGTH = 3000; // Max characters for context
+
+// Initialize clients
 const openai = new OpenAI({
   apiKey: process.env.OPENAI_API_KEY,
 });
@@ -10,86 +17,258 @@ const chromaClient = new ChromaClient({
   path: process.env.CHROMADB_URL || 'http://localhost:8000',
 });
 
+// Utility: Sleep function
+const sleep = (ms: number) => new Promise(resolve => setTimeout(resolve, ms));
+
+// Utility: Retry wrapper with exponential backoff
+async function retryWithBackoff<T>(
+  fn: () => Promise<T>,
+  maxRetries: number = MAX_RETRIES,
+  delay: number = RETRY_DELAY
+): Promise<T> {
+  let lastError: Error;
+  
+  for (let attempt = 0; attempt < maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (error: any) {
+      lastError = error;
+      
+      // Don't retry on certain errors
+      if (error.status === 400 || error.status === 401 || error.status === 403) {
+        throw error;
+      }
+      
+      // Exponential backoff
+      const waitTime = delay * Math.pow(2, attempt);
+      console.warn(`[Chat] Attempt ${attempt + 1} failed, retrying in ${waitTime}ms...`, error.message);
+      await sleep(waitTime);
+    }
+  }
+  
+  throw lastError!;
+}
+
+// Utility: Truncate context if too long
+function truncateContext(contexts: string[]): string {
+  let contextText = contexts.join('\n\n');
+  
+  if (contextText.length > MAX_CONTEXT_LENGTH) {
+    // Try to keep complete sentences
+    const truncated = contextText.substring(0, MAX_CONTEXT_LENGTH);
+    const lastPeriod = truncated.lastIndexOf('.');
+    if (lastPeriod > MAX_CONTEXT_LENGTH * 0.8) {
+      contextText = truncated.substring(0, lastPeriod + 1);
+    } else {
+      contextText = truncated + '...';
+    }
+  }
+  
+  return contextText;
+}
+
+// Main chat handler
 export async function POST(request: NextRequest) {
+  const startTime = Date.now();
+  
   try {
-    const { message, userInfo } = await request.json();
+    const { message, userInfo, conversationHistory, nResults } = await request.json();
     
-    if (!message) {
+    // Validation
+    if (!message || typeof message !== 'string' || !message.trim()) {
       return NextResponse.json(
-        { error: 'Message is required' },
+        { 
+          error: 'Message is required',
+          message: 'Please provide a valid message.',
+          response: 'Please provide a valid message.',
+        },
         { status: 400 }
       );
     }
     
     if (!process.env.OPENAI_API_KEY) {
       return NextResponse.json(
-        { error: 'OPENAI_API_KEY is not set in environment variables' },
+        { 
+          error: 'OPENAI_API_KEY is not set in environment variables',
+          message: 'Server configuration error. Please contact support.',
+          response: 'Server configuration error. Please contact support.',
+        },
         { status: 500 }
       );
     }
     
+    console.log(`[Chat] Processing message: "${message.substring(0, 50)}..."`);
+    
     // Get query embedding
-    const queryEmbedding = await openai.embeddings.create({
-      model: 'text-embedding-3-small',
-      input: message,
-    });
+    let queryEmbedding: number[];
+    try {
+      const embeddingResponse = await retryWithBackoff(() =>
+        openai.embeddings.create({
+          model: 'text-embedding-3-small',
+          input: message.trim(),
+        })
+      );
+      
+      queryEmbedding = embeddingResponse.data[0].embedding;
+      console.log('[Chat] Generated query embedding');
+    } catch (error: any) {
+      console.error('[Chat] Failed to generate embedding:', error);
+      return NextResponse.json(
+        { 
+          error: 'Failed to process query',
+          message: 'Sorry, I encountered an error processing your question. Please try again.',
+          response: 'Sorry, I encountered an error processing your question. Please try again.',
+        },
+        { status: 500 }
+      );
+    }
     
     // Search in ChromaDB
     const collectionName = process.env.CHROMA_COLLECTION_NAME || 'db_default';
+    const numResults = nResults || DEFAULT_N_RESULTS;
+    
     let chromaCollection;
+    let searchResults: any;
     
     try {
+      // Try to get collection
       chromaCollection = await chromaClient.getCollection({
         name: collectionName,
       });
-    } catch (error) {
+      console.log(`[Chat] Connected to ChromaDB collection: ${collectionName}`);
+    } catch (error: any) {
       // If collection doesn't exist, return a helpful message
+      console.warn(`[Chat] ChromaDB collection not found: ${collectionName}`);
       return NextResponse.json({
         message: 'Vector database not initialized. Please use AdminSetup to process embeddings first.',
         response: 'Vector database not initialized. Please use AdminSetup to process embeddings first.',
+        error: 'CHROMADB_NOT_INITIALIZED',
       });
     }
     
-    const results = await chromaCollection.query({
-      queryEmbeddings: [queryEmbedding.data[0].embedding],
-      nResults: 5,
-    });
+    // Perform vector search
+    try {
+      searchResults = await retryWithBackoff(() =>
+        chromaCollection.query({
+          queryEmbeddings: [queryEmbedding],
+          nResults: numResults,
+        })
+      );
+      
+      console.log(`[Chat] Found ${searchResults.documents[0]?.length || 0} relevant documents`);
+    } catch (error: any) {
+      console.error('[Chat] Failed to search ChromaDB:', error);
+      return NextResponse.json(
+        { 
+          error: 'Failed to search database',
+          message: 'Sorry, I encountered an error searching the database. Please try again.',
+          response: 'Sorry, I encountered an error searching the database. Please try again.',
+        },
+        { status: 500 }
+      );
+    }
+    
+    // Extract context from search results
+    const contexts = searchResults.documents[0] || [];
+    const metadatas = searchResults.metadatas[0] || [];
+    const distances = searchResults.distances[0] || [];
     
-    // Extract context
-    const contexts = results.documents[0] || [];
-    const contextText = contexts.length > 0 
-      ? contexts.join('\n\n') 
-      : 'No relevant context found.';
+    let contextText: string;
+    
+    if (contexts.length === 0) {
+      contextText = 'No relevant context found in the database.';
+      console.log('[Chat] No relevant context found');
+    } else {
+      // Filter out very low relevance results (high distance)
+      const relevantContexts = contexts.filter((_: string, index: number) => {
+        // ChromaDB returns distances (lower is better)
+        // Filter out results with distance > 1.5 (less relevant)
+        return distances[index] !== undefined && distances[index] < 1.5;
+      });
+      
+      if (relevantContexts.length === 0) {
+        contextText = 'No highly relevant context found. Using available context.';
+        contextText = truncateContext(contexts);
+      } else {
+        contextText = truncateContext(relevantContexts);
+      }
+      
+      console.log(`[Chat] Using ${relevantContexts.length || contexts.length} context document(s)`);
+    }
+    
+    // Build conversation history if provided
+    const messages: any[] = [
+      {
+        role: 'system',
+        content: 'You are a helpful assistant that answers questions based on the provided context from a database. Use the context to provide accurate and relevant answers. If the context does not contain relevant information to answer the question, say so politely and suggest that the user rephrase their question or ask about something else.',
+      },
+    ];
+    
+    // Add conversation history if provided
+    if (conversationHistory && Array.isArray(conversationHistory)) {
+      // Add recent conversation history (last 5 exchanges)
+      const recentHistory = conversationHistory.slice(-10); // Last 10 messages (5 exchanges)
+      recentHistory.forEach((msg: any) => {
+        if (msg.sender === 'user') {
+          messages.push({ role: 'user', content: msg.text });
+        } else if (msg.sender === 'bot') {
+          messages.push({ role: 'assistant', content: msg.text });
+        }
+      });
+    }
+    
+    // Add current query with context
+    messages.push({
+      role: 'user',
+      content: `Context from database:\n${contextText}\n\nUser question: ${message.trim()}\n\nPlease provide a helpful answer based on the context above.`,
+    });
     
     // Generate response with OpenAI
-    const completion = await openai.chat.completions.create({
-      model: process.env.OPENAI_MODEL || 'gpt-3.5-turbo',
-      messages: [
-        {
-          role: 'system',
-          content: 'You are a helpful assistant that answers questions based on the provided context. If the context does not contain relevant information, say so politely.',
-        },
-        {
-          role: 'user',
-          content: `Context:\n${contextText}\n\nQuestion: ${message}\n\nAnswer:`,
+    let answer: string;
+    try {
+      const completion = await retryWithBackoff(() =>
+        openai.chat.completions.create({
+          model: process.env.OPENAI_MODEL || 'gpt-3.5-turbo',
+          messages,
+          temperature: 0.7,
+          max_tokens: parseInt(process.env.OPENAI_MAX_TOKENS || '500'),
+        })
+      );
+      
+      answer = completion.choices[0].message.content || 'Sorry, I could not generate a response.';
+      console.log(`[Chat] Generated response (${answer.length} characters)`);
+    } catch (error: any) {
+      console.error('[Chat] Failed to generate response:', error);
+      return NextResponse.json(
+        { 
+          error: 'Failed to generate response',
+          message: 'Sorry, I encountered an error generating a response. Please try again.',
+          response: 'Sorry, I encountered an error generating a response. Please try again.',
         },
-      ],
-      temperature: 0.7,
-      max_tokens: 500,
-    });
+        { status: 500 }
+      );
+    }
     
-    const answer = completion.choices[0].message.content;
+    const duration = ((Date.now() - startTime) / 1000).toFixed(2);
+    console.log(`[Chat] Request completed in ${duration}s`);
     
     return NextResponse.json({
       message: answer,
       response: answer,
+      contexts: contexts.length > 0 ? contexts : undefined,
+      metadata: {
+        numResults: contexts.length,
+        processingTime: `${duration}s`,
+        collection: collectionName,
+      },
     });
   } catch (error: any) {
-    console.error('Chat error:', error);
+    console.error('[Chat] Fatal error:', error);
     return NextResponse.json(
       { 
-        message: error.message || 'Failed to process message',
-        response: error.message || 'Failed to process message',
+        error: error.message || 'Failed to process message',
+        message: 'Sorry, I encountered an unexpected error. Please try again later.',
+        response: 'Sorry, I encountered an unexpected error. Please try again later.',
       },
       { status: 500 }
     );