nextjs-chatbot-ui 1.4.0 → 1.5.0

package/scripts/setup.js

@@ -0,0 +1,550 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+
+console.log('🚀 Setting up nextjs-chatbot-ui API routes...\n');
+
+const projectRoot = process.cwd();
+const isAppRouter = fs.existsSync(path.join(projectRoot, 'app'));
+
+if (!isAppRouter && !fs.existsSync(path.join(projectRoot, 'pages'))) {
+  console.error('❌ Error: Next.js project not found. Please run this in a Next.js project directory.');
+  process.exit(1);
+}
+
+const apiDir = isAppRouter 
+  ? path.join(projectRoot, 'app', 'api')
+  : path.join(projectRoot, 'pages', 'api');
+
+// Create API directory if it doesn't exist
+if (!fs.existsSync(apiDir)) {
+  fs.mkdirSync(apiDir, { recursive: true });
+}
+
+// API route templates
+const routes = {
+  'chat': `import { NextRequest, NextResponse } from 'next/server';
+import { ChromaClient } from 'chromadb';
+import OpenAI from 'openai';
+
+const openai = new OpenAI({
+  apiKey: process.env.OPENAI_API_KEY,
+});
+
+const chromaClient = new ChromaClient({
+  path: process.env.CHROMADB_URL || 'http://localhost:8000',
+});
+
+export async function POST(request: NextRequest) {
+  try {
+    const { message, userInfo } = await request.json();
+    
+    if (!message) {
+      return NextResponse.json(
+        { error: 'Message is required' },
+        { status: 400 }
+      );
+    }
+    
+    if (!process.env.OPENAI_API_KEY) {
+      return NextResponse.json(
+        { error: 'OPENAI_API_KEY is not set in environment variables' },
+        { status: 500 }
+      );
+    }
+    
+    // Get query embedding
+    const queryEmbedding = await openai.embeddings.create({
+      model: 'text-embedding-3-small',
+      input: message,
+    });
+    
+    // Search in ChromaDB
+    const collectionName = process.env.CHROMA_COLLECTION_NAME || 'db_default';
+    let chromaCollection;
+    
+    try {
+      chromaCollection = await chromaClient.getCollection({
+        name: collectionName,
+      });
+    } catch (error) {
+      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.',
+      });
+    }
+    
+    const results = await chromaCollection.query({
+      queryEmbeddings: [queryEmbedding.data[0].embedding],
+      nResults: 5,
+    });
+    
+    const contexts = results.documents[0] || [];
+    const contextText = contexts.length > 0 
+      ? contexts.join('\\n\\n') 
+      : 'No relevant context found.';
+    
+    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:\`,
+        },
+      ],
+      temperature: 0.7,
+      max_tokens: 500,
+    });
+    
+    const answer = completion.choices[0].message.content;
+    
+    return NextResponse.json({
+      message: answer,
+      response: answer,
+    });
+  } catch (error: any) {
+    console.error('Chat error:', error);
+    return NextResponse.json(
+      { 
+        message: error.message || 'Failed to process message',
+        response: error.message || 'Failed to process message',
+      },
+      { status: 500 }
+    );
+  }
+}
+`,
+  'database/test': `import { NextRequest, NextResponse } from 'next/server';
+import { MongoClient } from 'mongodb';
+import { Client } from 'pg';
+
+export async function POST(request: NextRequest) {
+  try {
+    const { databaseType, connection } = await request.json();
+    
+    if (!databaseType || !connection) {
+      return NextResponse.json(
+        { success: false, message: 'Database type and connection details are required' },
+        { status: 400 }
+      );
+    }
+    
+    if (databaseType === 'mongodb') {
+      try {
+        const uri = connection.connectionString || 
+          \`mongodb://\${connection.username ? \`\${connection.username}:\${connection.password}@\` : ''}\${connection.host}:\${connection.port || 27017}/\${connection.database}\`;
+        
+        const client = new MongoClient(uri);
+        await client.connect();
+        await client.db().admin().ping();
+        await client.close();
+        
+        return NextResponse.json({ success: true, message: 'Connection successful' });
+      } catch (error: any) {
+        return NextResponse.json(
+          { success: false, message: error.message || 'MongoDB connection failed' },
+          { status: 500 }
+        );
+      }
+    } else if (databaseType === 'postgresql') {
+      try {
+        const client = new Client({
+          host: connection.host,
+          port: connection.port || 5432,
+          database: connection.database,
+          user: connection.username,
+          password: connection.password,
+        });
+        
+        await client.connect();
+        await client.query('SELECT 1');
+        await client.end();
+        
+        return NextResponse.json({ success: true, message: 'Connection successful' });
+      } catch (error: any) {
+        return NextResponse.json(
+          { success: false, message: error.message || 'PostgreSQL connection failed' },
+          { status: 500 }
+        );
+      }
+    } else {
+      return NextResponse.json(
+        { success: false, message: 'Unsupported database type' },
+        { status: 400 }
+      );
+    }
+  } catch (error: any) {
+    console.error('Test connection error:', error);
+    return NextResponse.json(
+      { success: false, message: error.message || 'Connection test failed' },
+      { status: 500 }
+    );
+  }
+}
+`,
+  'database/collections': `import { NextRequest, NextResponse } from 'next/server';
+import { MongoClient } from 'mongodb';
+import { Client } from 'pg';
+
+export async function POST(request: NextRequest) {
+  try {
+    const { databaseType, connection } = await request.json();
+    
+    if (!databaseType || !connection) {
+      return NextResponse.json(
+        { collections: [], tables: [] },
+        { status: 400 }
+      );
+    }
+    
+    if (databaseType === 'mongodb') {
+      try {
+        const uri = connection.connectionString || 
+          \`mongodb://\${connection.username ? \`\${connection.username}:\${connection.password}@\` : ''}\${connection.host}:\${connection.port || 27017}/\${connection.database}\`;
+        
+        const client = new MongoClient(uri);
+        await client.connect();
+        const db = client.db(connection.database);
+        const collections = await db.listCollections().toArray();
+        await client.close();
+        
+        return NextResponse.json({
+          collections: collections.map(c => c.name),
+          tables: collections.map(c => c.name),
+        });
+      } catch (error: any) {
+        return NextResponse.json(
+          { collections: [], tables: [], error: error.message },
+          { status: 500 }
+        );
+      }
+    } else if (databaseType === 'postgresql') {
+      try {
+        const client = new Client({
+          host: connection.host,
+          port: connection.port || 5432,
+          database: connection.database,
+          user: connection.username,
+          password: connection.password,
+        });
+        
+        await client.connect();
+        const result = await client.query(\`
+          SELECT table_name 
+          FROM information_schema.tables 
+          WHERE table_schema = 'public'
+        \`);
+        await client.end();
+        
+        const tables = result.rows.map(row => row.table_name);
+        
+        return NextResponse.json({
+          collections: tables,
+          tables: tables,
+        });
+      } catch (error: any) {
+        return NextResponse.json(
+          { collections: [], tables: [], error: error.message },
+          { status: 500 }
+        );
+      }
+    } else {
+      return NextResponse.json(
+        { collections: [], tables: [] },
+        { status: 400 }
+      );
+    }
+  } catch (error: any) {
+    console.error('Fetch collections error:', error);
+    return NextResponse.json(
+      { collections: [], tables: [], error: error.message },
+      { status: 500 }
+    );
+  }
+}
+`,
+  'database/columns': `import { NextRequest, NextResponse } from 'next/server';
+import { MongoClient } from 'mongodb';
+import { Client } from 'pg';
+
+export async function POST(request: NextRequest) {
+  try {
+    const { databaseType, connection, collection } = await request.json();
+    
+    if (!databaseType || !connection || !collection) {
+      return NextResponse.json(
+        { columns: [] },
+        { status: 400 }
+      );
+    }
+    
+    if (databaseType === 'mongodb') {
+      try {
+        const uri = connection.connectionString || 
+          \`mongodb://\${connection.username ? \`\${connection.username}:\${connection.password}@\` : ''}\${connection.host}:\${connection.port || 27017}/\${connection.database}\`;
+        
+        const client = new MongoClient(uri);
+        await client.connect();
+        const db = client.db(connection.database);
+        const mongoCollection = db.collection(collection);
+        
+        const sampleDoc = await mongoCollection.findOne({});
+        await client.close();
+        
+        const columns = sampleDoc ? Object.keys(sampleDoc).filter(key => key !== '_id') : [];
+        
+        return NextResponse.json({ columns });
+      } catch (error: any) {
+        return NextResponse.json(
+          { columns: [], error: error.message },
+          { status: 500 }
+        );
+      }
+    } else if (databaseType === 'postgresql') {
+      try {
+        const client = new Client({
+          host: connection.host,
+          port: connection.port || 5432,
+          database: connection.database,
+          user: connection.username,
+          password: connection.password,
+        });
+        
+        await client.connect();
+        const result = await client.query(\`
+          SELECT column_name 
+          FROM information_schema.columns 
+          WHERE table_schema = 'public' 
+          AND table_name = $1
+        \`, [collection]);
+        await client.end();
+        
+        const columns = result.rows.map(row => row.column_name);
+        
+        return NextResponse.json({ columns });
+      } catch (error: any) {
+        return NextResponse.json(
+          { columns: [], error: error.message },
+          { status: 500 }
+        );
+      }
+    } else {
+      return NextResponse.json(
+        { columns: [] },
+        { status: 400 }
+      );
+    }
+  } catch (error: any) {
+    console.error('Fetch columns error:', error);
+    return NextResponse.json(
+      { columns: [], error: error.message },
+      { status: 500 }
+    );
+  }
+}
+`,
+  'database/process-embeddings': `import { NextRequest, NextResponse } from 'next/server';
+import { MongoClient } from 'mongodb';
+import { Client } from 'pg';
+import { ChromaClient } from 'chromadb';
+import OpenAI from 'openai';
+
+const openai = new OpenAI({
+  apiKey: process.env.OPENAI_API_KEY,
+});
+
+const chromaClient = new ChromaClient({
+  path: process.env.CHROMADB_URL || 'http://localhost:8000',
+});
+
+export async function POST(request: NextRequest) {
+  try {
+    const { connection, collections, columnSelection } = await request.json();
+    
+    if (!process.env.OPENAI_API_KEY) {
+      return NextResponse.json(
+        { success: false, message: 'OPENAI_API_KEY is not set in environment variables' },
+        { status: 500 }
+      );
+    }
+    
+    if (!connection || !collections || !Array.isArray(collections) || collections.length === 0) {
+      return NextResponse.json(
+        { success: false, message: 'Connection and collections are required' },
+        { status: 400 }
+      );
+    }
+    
+    const databaseType = connection.type || 'mongodb';
+    const dbName = connection.database;
+    
+    let db: any;
+    let client: any;
+    
+    if (databaseType === 'mongodb') {
+      const uri = connection.connectionString || 
+        \`mongodb://\${connection.username ? \`\${connection.username}:\${connection.password}@\` : ''}\${connection.host}:\${connection.port || 27017}/\${dbName}\`;
+      client = new MongoClient(uri);
+      await client.connect();
+      db = client.db(dbName);
+    } else if (databaseType === 'postgresql' || databaseType === 'postgres') {
+      client = new Client({
+        host: connection.host,
+        port: connection.port || 5432,
+        database: dbName,
+        user: connection.username,
+        password: connection.password,
+      });
+      await client.connect();
+    } else {
+      return NextResponse.json(
+        { success: false, message: 'Unsupported database type' },
+        { status: 400 }
+      );
+    }
+    
+    const collectionName = process.env.CHROMA_COLLECTION_NAME || \`db_\${dbName}\`;
+    let chromaCollection;
+    try {
+      chromaCollection = await chromaClient.getOrCreateCollection({
+        name: collectionName,
+      });
+    } catch (error) {
+      chromaCollection = await chromaClient.createCollection({
+        name: collectionName,
+      });
+    }
+    
+    let totalProcessed = 0;
+    
+    for (const collConfig of collections) {
+      const { collection: collName, columns } = collConfig;
+      
+      if (!columns || columns.length === 0) continue;
+      
+      let documents: any[] = [];
+      
+      if (databaseType === 'mongodb') {
+        const mongoCollection = db.collection(collName);
+        documents = await mongoCollection.find({}).toArray();
+      } else if (databaseType === 'postgresql' || databaseType === 'postgres') {
+        const query = \`SELECT \${columns.join(', ')} FROM \${collName}\`;
+        const result = await client.query(query);
+        documents = result.rows;
+      }
+      
+      for (const doc of documents) {
+        const text = columns
+          .map((col: string) => {
+            const value = doc[col];
+            return value !== null && value !== undefined ? \`\${col}: \${value}\` : '';
+          })
+          .filter(Boolean)
+          .join(' ');
+        
+        if (!text.trim()) continue;
+        
+        try {
+          const embeddingResponse = await openai.embeddings.create({
+            model: 'text-embedding-3-small',
+            input: text,
+          });
+          
+          const embedding = embeddingResponse.data[0].embedding;
+          const docId = \`\${collName}_\${doc._id || doc.id || Date.now()}_\${totalProcessed}\`;
+          
+          await chromaCollection.add({
+            ids: [docId],
+            embeddings: [embedding],
+            documents: [text],
+            metadatas: [{
+              collection: collName,
+              documentId: (doc._id || doc.id || totalProcessed).toString(),
+              columns: columns.join(','),
+            }],
+          });
+          
+          totalProcessed++;
+        } catch (error: any) {
+          console.error(\`Error processing document in \${collName}:\`, error);
+        }
+      }
+    }
+    
+    if (databaseType === 'mongodb') {
+      await client.close();
+    } else if (databaseType === 'postgresql' || databaseType === 'postgres') {
+      await client.end();
+    }
+    
+    return NextResponse.json({
+      success: true,
+      message: \`Successfully processed \${totalProcessed} documents\`,
+      totalProcessed,
+    });
+  } catch (error: any) {
+    console.error('Process embeddings error:', error);
+    return NextResponse.json(
+      { success: false, message: error.message || 'Failed to process embeddings' },
+      { status: 500 }
+    );
+  }
+}
+`,
+};
+
+// Create routes
+let createdCount = 0;
+for (const [routePath, content] of Object.entries(routes)) {
+  const routeDir = path.join(apiDir, routePath);
+  const routeFile = isAppRouter 
+    ? path.join(routeDir, 'route.ts')
+    : path.join(routeDir, 'index.ts');
+  
+  // Create directory if it doesn't exist
+  if (!fs.existsSync(routeDir)) {
+    fs.mkdirSync(routeDir, { recursive: true });
+  }
+  
+  // Check if file already exists
+  if (fs.existsSync(routeFile)) {
+    console.log(\`⏭️  Skipping \${routePath} (already exists)\`);
+    continue;
+  }
+  
+  // Write route file
+  fs.writeFileSync(routeFile, content, 'utf8');
+  console.log(\`✅ Created \${routePath}\`);
+  createdCount++;
+}
+
+// Create .env.example if it doesn't exist
+const envExamplePath = path.join(projectRoot, '.env.example');
+if (!fs.existsSync(envExamplePath)) {
+  const envExample = \`# OpenAI API Key
+OPENAI_API_KEY=your_openai_api_key_here
+
+# ChromaDB URL (default: http://localhost:8000)
+CHROMADB_URL=http://localhost:8000
+
+# Optional: ChromaDB Collection Name (default: db_<database_name>)
+# CHROMA_COLLECTION_NAME=db_default
+
+# Optional: OpenAI Model (default: gpt-3.5-turbo)
+# OPENAI_MODEL=gpt-3.5-turbo
+\`;
+  fs.writeFileSync(envExamplePath, envExample, 'utf8');
+  console.log('✅ Created .env.example');
+}
+
+console.log(\`\\n✨ Setup complete! \${createdCount} API route(s) created.\`);
+console.log('\\n📝 Next steps:');
+console.log('1. Copy .env.example to .env.local and add your API keys');
+console.log('2. Install dependencies: npm install mongodb pg chromadb openai');
+console.log('3. Use <Chatbot /> and <AdminSetup /> components in your app');
+console.log('\\n🎉 You\\'re all set!');