nextjs-chatbot-ui 1.4.1 → 1.6.0

package/README.md

@@ -1,6 +1,8 @@
 # nextjs-chatbot-ui
 
-A beautiful, configurable chatbot UI component for Next.js with Tailwind CSS. Perfect for customer support, AI assistants, and chat applications.
+A beautiful, **self-contained** chatbot UI component for Next.js with Tailwind CSS. Perfect for customer support, AI assistants, and chat applications.
+
+**✨ All dependencies included!** When you install this package, all required dependencies (`mongodb`, `pg`, `chromadb`, `openai`) are automatically installed - no need to install anything else!
 
 ## ⚡ Super Simple Usage (Just 2 Files!)
 
@@ -54,6 +56,49 @@ This package requires:
 npm install nextjs-chatbot-ui
 ```
 
+## 🚀 Super Simple Setup (Complete RAG Chatbot in 3 Steps!)
+
+**Everything works automatically!** All dependencies are included - just run the setup script and add your `.env` file.
+
+### Step 1: Run Setup Script
+
+```bash
+npx nextjs-chatbot-ui-setup
+```
+
+This automatically creates all API routes needed for the chatbot and admin setup.
+
+### Step 2: Add Environment Variables
+
+Create `.env.local` file:
+```env
+OPENAI_API_KEY=your_openai_api_key_here
+CHROMADB_URL=http://localhost:8000
+```
+
+### Step 3: Use Components
+
+```javascript
+// app/page.tsx
+'use client';
+import { Chatbot, AdminSetup } from 'nextjs-chatbot-ui';
+
+export default function Home() {
+  return (
+    <div>
+      <AdminSetup />
+      <Chatbot config={{ backendUrl: '/api/chat' }} />
+    </div>
+  );
+}
+```
+
+**That's it!** 🎉 
+
+- Use `<AdminSetup />` to connect to your database and process embeddings
+- Use `<Chatbot />` to ask questions about your data
+- Everything else is handled automatically!
+
 ## Quick Start (Minimal Code)
 
 ### Simplest Usage (Just 2 files!)
@@ -569,9 +614,10 @@ React UI → Express API → MongoDB + ChromaDB → OpenAI
 
 ### Quick Start with RAG
 
-1. **Set up backend** (see `server.js` or `example-nextjs-api-routes.md`):
-   - Express server with MongoDB, ChromaDB, and OpenAI integration
-   - Endpoints: `/api/search`, `/api/database/process-embeddings`
+1. **Set up backend** (run the setup script):
+   - Run `npx nextjs-chatbot-ui-setup` to automatically create all API routes
+   - This creates Next.js API routes with MongoDB, ChromaDB, and OpenAI integration
+   - Endpoints: `/api/chat`, `/api/database/test`, `/api/database/collections`, `/api/database/columns`, `/api/database/process-embeddings`
 
 2. **Configure chatbot**:
    ```javascript

package/api/chat.ts

@@ -0,0 +1,97 @@
+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) {
+      // If collection doesn't exist, return a helpful message
+      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,
+    });
+    
+    // Extract context
+    const contexts = results.documents[0] || [];
+    const contextText = contexts.length > 0 
+      ? contexts.join('\n\n') 
+      : 'No relevant context found.';
+    
+    // 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:`,
+        },
+      ],
+      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 }
+    );
+  }
+}

package/api/database/collections.ts

@@ -0,0 +1,80 @@
+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 }
+    );
+  }
+}

package/api/database/columns.ts

@@ -0,0 +1,80 @@
+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);
+        
+        // Get a sample document to extract keys
+        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 }
+    );
+  }
+}

package/api/database/process-embeddings.ts

@@ -0,0 +1,154 @@
+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;
+    
+    // Initialize database connection
+    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 }
+      );
+    }
+    
+    // Get or create ChromaDB collection
+    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;
+    
+    // Process each collection
+    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 {
+          // Generate embedding
+          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}`;
+          
+          // Store in ChromaDB
+          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);
+          // Continue with next document
+        }
+      }
+    }
+    
+    // Close database connection
+    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 }
+    );
+  }
+}

package/api/database/test.ts

@@ -0,0 +1,67 @@
+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 }
+    );
+  }
+}

package/package.json

@@ -1,10 +1,13 @@
 {
   "name": "nextjs-chatbot-ui",
-  "version": "1.4.1",
-  "description": "A configurable chatbot UI component for Next.js with Tailwind CSS",
+  "version": "1.6.0",
+  "description": "A self-contained, configurable chatbot UI component for Next.js with Tailwind CSS - Complete RAG chatbot with automatic setup. All dependencies included!",
   "main": "./index.tsx",
   "module": "./index.tsx",
   "types": "./types/index.ts",
+  "bin": {
+    "nextjs-chatbot-ui-setup": "./scripts/setup.js"
+  },
   "exports": {
     ".": {
       "types": "./types/index.ts",
@@ -40,13 +43,16 @@
     "types",
     "utils",
     "hooks",
+    "api",
+    "scripts",
     "index.tsx",
     "README.md"
   ],
   "scripts": {
     "build": "echo 'Package is ready to use. Source files are included.'",
     "prepare": "npm run build",
-    "type-check": "tsc --noEmit"
+    "type-check": "tsc --noEmit",
+    "setup": "node scripts/setup.js"
   },
   "keywords": [
     "chatbot",
@@ -64,10 +70,15 @@
     "next": "^13.0.0 || ^14.0.0 || ^15.0.0"
   },
   "dependencies": {
-    "clsx": "^2.1.0"
+    "clsx": "^2.1.0",
+    "mongodb": "^6.0.0",
+    "pg": "^8.11.0",
+    "chromadb": "^1.8.0",
+    "openai": "^4.0.0"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",
+    "@types/pg": "^8.10.0",
     "@types/react": "^18.0.0",
     "@types/react-dom": "^18.0.0",
     "autoprefixer": "^10.4.16",

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!');