ChatSmith - AI-Powered Chatbot Platform

Build Intelligent Chatbots from PDFs

A comprehensive AI chatbot platform that transforms documents into intelligent conversational agents. Upload PDFs, create custom chatbots, and deploy them instantly.

---

📋 Table of Contents

• About ChatSmith
• Features
• Tech Stack
• Project Structure
• Getting Started
• Environment Setup
• Database Configuration
• ChatSmith Platform Screenshots
• Use Cases
• API Documentation
• Deployment

---

🎯 About ChatSmith

ChatSmith is an intelligent chatbot platform that allows you to create AI-powered chatbots from your PDF documents. Simply upload a PDF, and ChatSmith automatically:

• 📄 Extracts text content from your documents
• 🧠 Processes and chunks the content intelligently
• 🔍 Embeds content using advanced AI models
• 💬 Creates a conversational AI chatbot
• 🚀 Deploys instantly for immediate use

Key Capabilities

• RAG (Retrieval Augmented Generation) - Accurate, context-aware responses
• Vector Search - Fast, semantic document retrieval
• Multi-Chatbot Management - Create unlimited chatbots
• Tone Customization - Adjust chatbot personality
• Real-time Chat - Instant responses with conversation history
• User & Admin Dashboards - Complete management interface

---

✨ Features

🤖 Core Platform Features

• PDF Upload & Processing

  • Automatic text extraction from PDFs
  • Intelligent document chunking
  • Vector embedding generation
  • Metadata preservation

• Chatbot Management

  • Create multiple chatbots
  • Edit chatbot details
  • Delete chatbots and associated data
  • View chatbot analytics

• Advanced AI Chat

  • Context-aware responses
  • Conversation history tracking
  • Tone adjustment (professional, casual, friendly, etc.)
  • Real-time streaming responses

• User Interface

  • Modern, responsive design
  • Dark mode support
  • Intuitive chat interface
  • Admin & user dashboards
  • File upload with progress tracking

🔐 Security & Authentication

• Role-based access control (Admin/User)
• Secure API endpoints
• Data encryption
• Session management

---

🛠 Tech Stack

Frontend

• Next.js 16.0.0 - React framework with Turbopack
• React 19.2.0 - UI library
• TypeScript 5.0 - Type safety
• Tailwind CSS - Utility-first CSS
• Radix UI - Accessible component primitives
• Lucide Icons - Beautiful icon set

Backend

• Express 5.1.0 - Node.js web framework
• TypeScript - Type-safe backend
• LangChain 0.3.x - AI orchestration framework
• Cohere AI - Language models & embeddings
• Multer - File upload handling
• CORS - Cross-origin resource sharing

Database & Vector Store

• Supabase - PostgreSQL database & authentication
• pgvector - Vector similarity search
• Supabase Vector Store - LangChain integration

AI & ML

• Cohere Embeddings - Document vectorization (embed-english-v3.0)
• Cohere Chat - Conversational AI
• LangChain - RAG implementation
• PDF Parse - Document processing

---

📁 Project Structure

Hackthrone_gdc_techno/
├── backend/                    # Express.js backend server
│   ├── api/
│   │   ├── chat.ts            # Chat endpoint with RAG
│   │   ├── chatbots.ts        # Chatbot CRUD operations
│   │   ├── upload.ts          # PDF upload & processing
│   │   └── tone.ts            # Tone analysis
│   ├── langchain/
│   │   ├── chains.ts          # LangChain RAG chains
│   │   ├── embeddings.ts      # Cohere embeddings
│   │   ├── loader.ts          # Document loaders
│   │   └── vectorStore.ts     # Vector store setup
│   ├── services/
│   │   ├── memory.ts          # Conversation memory
│   │   └── supabase.ts        # Supabase client
│   ├── uploads/               # Temporary PDF storage
│   ├── main.ts                # Server entry point
│   └── package.json
│
├── main_frontend/             # Main Next.js application
│   ├── app/
│   │   ├── layout.tsx         # Root layout
│   │   ├── page.tsx           # Home page
│   │   └── globals.css        # Global styles
│   ├── components/
│   │   ├── admin-dashboard.tsx
│   │   ├── admin-header.tsx
│   │   ├── chat-interface.tsx      # ✅ Integrated with backend
│   │   ├── chatbot-list.tsx        # ✅ Integrated with backend
│   │   ├── chatbot-card.tsx
│   │   ├── dashboard.tsx
│   │   ├── login-page.tsx
│   │   ├── sidebar.tsx
│   │   ├── user-profile.tsx
│   │   ├── settings-page.tsx
│   │   └── dark-toggle.tsx
│   ├── lib/
│   │   ├── auth-context.tsx   # Authentication context
│   │   └── utils.ts           # Utility functions
│   └── package.json
│
├── frontend/                  # Alternative frontend (legacy)
│   ├── app/
│   ├── components/
│   └── lib/
│
├── .env                       # Environment variables (create this)
├── SETUP_GUIDE.md            # Detailed setup instructions
├── BACKEND_INTEGRATION_SETUP.md
└── README.md                 # This file

---

🚀 Getting Started

Prerequisites

• Node.js 16.x or higher
• npm or yarn package manager
• Supabase account (free tier available)
• Cohere API account (free trial with credits)

Quick Start

1. Clone the repository

   git clone <repository-url>
   cd Hackthrone_gdc_techno

2. Install dependencies

   Backend:

   cd backend
   npm install

   Frontend:

   cd main_frontend
   npm install

3. Set up environment variables

   Create backend/.env:

   # Supabase Configuration
   SUPABASE_URL=your_supabase_project_url
   SUPABASE_ANON_KEY=your_supabase_anon_key
   
   # Cohere API Key
   COHERE_API_KEY=your_cohere_api_key
   
   # Server Port
   PORT=8000

4. Set up Supabase Database

   See Database Configuration section below.

5. Start the servers

   Backend (in one terminal):

   cd backend
   npm run dev

   Frontend (in another terminal):

   cd main_frontend
   npm run dev

6. Access the application

   • Frontend: http://localhost:3000
   • Backend API: http://localhost:8000

---

🔧 Environment Setup

Backend Environment Variables

Create a backend/.env file with:

Variable	Description	Required	Example
SUPABASE_URL	Supabase project URL	✅ Yes	https://xxx.supabase.co
SUPABASE_ANON_KEY	Supabase anonymous key	✅ Yes	eyJhbGciOiJIUzI1NiIs...
COHERE_API_KEY	Cohere API key	✅ Yes	your_api_key_here
PORT	Backend server port	❌ No	8000 (default)

Frontend Environment Variables

Create a main_frontend/.env.local file (optional):

Variable	Description	Required	Example
NEXT_PUBLIC_BACKEND_API_URL	Backend API URL	❌ No	http://localhost:8000

Note: The frontend automatically falls back to http://localhost:8000 if not set.

Getting API Keys

Supabase Setup

1. Go to supabase.com
2. Create a new project (free tier available)
3. Navigate to Settings → API
4. Copy:
   • Project URL → SUPABASE_URL
   • anon/public key → SUPABASE_ANON_KEY

Cohere Setup

1. Go to cohere.ai
2. Sign up (free trial with credits)
3. Navigate to API Keys
4. Copy your API key → COHERE_API_KEY

---

💾 Database Configuration

Supabase Database Setup

1. Enable pgvector extension

   In Supabase SQL Editor:

   CREATE EXTENSION IF NOT EXISTS vector;

2. Create chatbots table

   CREATE TABLE chatbots (
     id UUID PRIMARY KEY,
     name TEXT NOT NULL,
     description TEXT,
     pdf_name TEXT,
     created_at TIMESTAMP DEFAULT NOW(),
     message_count INTEGER DEFAULT 0
   );

3. Create documents table (vector embeddings)

   CREATE TABLE documents (
     id BIGSERIAL PRIMARY KEY,
     content TEXT,
     metadata JSONB,
     embedding VECTOR(1024),
     chatbot_id UUID REFERENCES chatbots(id) ON DELETE CASCADE
   );
   
   -- Create index for faster similarity search
   CREATE INDEX ON documents 
   USING ivfflat (embedding vector_cosine_ops)
   WITH (lists = 100);

4. Create chat_messages table

   CREATE TABLE chat_messages (
     id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
     chatbot_id UUID REFERENCES chatbots(id) ON DELETE CASCADE,
     role TEXT NOT NULL,
     content TEXT NOT NULL,
     created_at TIMESTAMP DEFAULT NOW()
   );

5. Create vector search function

   CREATE OR REPLACE FUNCTION match_documents(
     query_embedding VECTOR(1024),
     match_chatbot_id UUID,
     match_count INT DEFAULT 5
   )
   RETURNS TABLE (
     id BIGINT,
     content TEXT,
     metadata JSONB,
     similarity FLOAT
   )
   LANGUAGE plpgsql
   AS $$
   BEGIN
     RETURN QUERY
     SELECT
       documents.id,
       documents.content,
       documents.metadata,
       1 - (documents.embedding <=> query_embedding) AS similarity
     FROM documents
     WHERE documents.chatbot_id = match_chatbot_id
     ORDER BY documents.embedding <=> query_embedding
     LIMIT match_count;
   END;
   $$;

For detailed setup instructions, see SETUP_GUIDE.md.

---

📸 ChatSmith Platform Screenshots

Login & Authentication

Secure login with role-based authentication (Admin/User)

User Chatbot Management

Manage your AI chatbots - create, edit, and organize all in one place

Live Chat Interface

Real-time chat with AI chatbots powered by RAG technology

User Profile

Manage your account and preferences

Analytics Dashboard

Track chatbot performance and usage metrics

Settings Panel

Configure chatbot behavior, appearance, and integrations

Admin Dashboard

Comprehensive admin panel for managing users and chatbots

---

🎯 Use Cases

ChatSmith can be used to build various AI-powered applications:

1. VitaData - Healthcare Platform 🏥

An integrated healthcare platform built using ChatSmith's chatbot technology.

Features:

• Patient portal with AI health assistant
• Doctor dashboard with clinical decision support
• Guardian access for family health monitoring
• Pharmacy integration with prescription chatbots
• Health records Q&A
• Medication adherence tracking with AI reminders

Tech Stack:

• React + Vite + TypeScript
• MongoDB for patient data
• ChatSmith chatbots for health consultations
• Real-time notifications

Learn More: See the VitaData section at the end of this README.

2. Customer Support Bot

• Upload product manuals and documentation
• Instant customer support responses
• 24/7 availability

3. Educational Assistant

• Upload textbooks and study materials
• Interactive learning experience
• Question answering system

4. Legal Document Assistant

• Upload legal documents and contracts
• Quick document search
• Legal Q&A

5. HR Knowledge Base

• Company policies and procedures
• Employee handbook chatbot
• Onboarding assistant

---

📚 API Documentation

Base URL

http://localhost:8000

Endpoints

1. Upload PDF & Create Chatbot

POST /upload
Content-Type: multipart/form-data

Body:
- file: PDF file
- name: Chatbot name

Response:
{
  "message": "PDF processed and chatbot created",
  "chatbotId": "uuid",
  "name": "Chatbot Name",
  "createdAt": "ISO timestamp"
}

2. Get All Chatbots

GET /chatbots

Response:
[
  {
    "id": "uuid",
    "name": "Chatbot Name",
    "description": "Description",
    "pdf_name": "document.pdf",
    "created_at": "timestamp",
    "message_count": 0
  }
]

3. Delete Chatbot

DELETE /chatbots/:chatbotId

Response:
{
  "message": "Chatbot and all related data deleted."
}

4. Chat with Chatbot

POST /chat
Content-Type: application/json

Body:
{
  "chatbotId": "uuid",
  "message": "Your question here",
  "history": [
    { "role": "user", "content": "Previous question" },
    { "role": "ai", "content": "Previous answer" }
  ],
  "tone": "professional" // optional
}

Response:
{
  "id": "message-id",
  "content": "AI response here",
  "sources": [...] // optional
}

5. Analyze Tone

POST /tone
Content-Type: application/json

Body:
{
  "text": "Text to analyze"
}

Response:
{
  "tone": "professional",
  "confidence": 0.95
}

---

📜 Available Scripts

Backend

# Development server with hot reload
npm run dev

# Build TypeScript
npm run build

# Start production server
npm start

# Type checking
npm run lint

Frontend

# Development server
npm run dev

# Build for production
npm run build

# Start production server
npm start

# Linting
npm run lint

---

🚢 Deployment

Backend Deployment (Railway/Render)

1. Push code to GitHub
2. Connect repository to Railway/Render
3. Add environment variables in dashboard
4. Deploy automatically

Frontend Deployment (Vercel)

1. Push code to GitHub
2. Import project in Vercel
3. Set environment variables
4. Deploy automatically

Environment Variables for Production

Make sure to set all required environment variables in your deployment platform:

• SUPABASE_URL
• SUPABASE_ANON_KEY
• COHERE_API_KEY
• NEXT_PUBLIC_BACKEND_API_URL (frontend only)

---

🎨 Features Implemented

✅ Backend Integration Complete

• PDF upload and processing
• Vector embeddings with Cohere
• Chatbot CRUD operations
• RAG-based chat with context
• Conversation history
• Tone customization
• Supabase vector store integration

✅ Frontend Integration Complete

• Chatbot list with real data
• Create chatbot with PDF upload
• Delete chatbot functionality
• Chat interface with backend
• Loading states and error handling
• Responsive design
• Dark mode support
• User authentication (mock)
• Admin dashboard

---

🐛 Troubleshooting

Common Issues

Backend fails to start

• Check if .env file exists in backend/ folder
• Verify all required environment variables are set
• Ensure Supabase URL and key are correct

Frontend can't connect to backend

• Ensure backend is running on port 8000
• Check CORS settings in backend
• Verify API URL in frontend

Chatbot creation fails

• Check Cohere API key is valid
• Ensure Supabase tables are created
• Check PDF file size (should be < 10MB)
• Verify pgvector extension is enabled

Vector search not working

• Run the match_documents function creation SQL
• Ensure embeddings dimension is 1024
• Check index creation on documents table

For detailed troubleshooting, see SETUP_GUIDE.md.

---

🔒 Security Best Practices

1. Never commit .env files - Add to .gitignore
2. Use environment variables - For all sensitive data
3. Validate file uploads - Check file types and sizes
4. Sanitize user inputs - Prevent injection attacks
5. Use HTTPS in production - Secure all connections
6. Implement rate limiting - Prevent abuse
7. Regular security audits - Keep dependencies updated

---

📈 Roadmap

Upcoming Features

• Real-time streaming responses
• Multi-language support
• Voice input/output
• Advanced analytics dashboard
• Chatbot sharing and embedding
• Custom branding options
• Webhook integrations
• API key management
• Usage metrics and billing
• Team collaboration features

---

🤝 Contributing

Contributions are welcome! Please follow these steps:

1. Fork the repository
2. Create a feature branch (git checkout -b feature/amazing-feature)
3. Commit your changes (git commit -m 'Add amazing feature')
4. Push to the branch (git push origin feature/amazing-feature)
5. Open a Pull Request

---

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

---

👥 Team & Support

For questions, issues, or support:

• Create an issue in the repository
• Contact the development team
• Check documentation files

---

🏥 VitaData Use Case - Healthcare Platform

VitaData is a comprehensive healthcare platform built using ChatSmith's AI chatbot technology as its core conversational engine.

Overview

VitaData demonstrates ChatSmith's versatility by implementing:

• AI-powered health consultations
• Medical document Q&A
• Medication reminders and tracking
• Multi-stakeholder platform (patients, doctors, guardians, pharmacies)

Tech Stack

• Frontend: React 18.2 + Vite + TypeScript
• Backend: MongoDB Atlas + Firebase/Supabase
• AI Engine: ChatSmith chatbot platform
• Styling: Tailwind CSS + Framer Motion

Key Features

Four Specialized Portals

1. Patient Portal - Health dashboard, appointments, prescriptions
2. Doctor Dashboard - Patient management, clinical workflows
3. Guardian Portal - Family health monitoring
4. Pharmacy Hub - Prescription processing, delivery

AI-Powered Features (Using ChatSmith)

• Health consultation chatbots
• Medication adherence AI assistant
• Symptom checker
• Medical document Q&A
• Prescription interpretation

Data Management

• Digital health records
• Vitals tracking (BP, blood sugar, temperature)
• Lab reports management
• Appointment scheduling
• Prescription management

VitaData Architecture

VitaData Application
├── Patient/Doctor/Guardian/Pharmacy Portals
├── MongoDB (Patient data, appointments, prescriptions)
├── ChatSmith Integration
│   ├── Medical knowledge chatbots
│   ├── Prescription Q&A bots
│   ├── Health guidance assistants
│   └── Medication tracking bots
└── Real-time Notifications & Reminders

Setup for VitaData

1. Set up ChatSmith platform (this repository)
2. Create medical knowledge chatbots:
   • Upload medical guidelines PDFs
   • Upload medication information
   • Upload hospital procedures
3. Configure VitaData frontend to use ChatSmith API
4. Set up MongoDB for patient data
5. Deploy both applications

Use Case Benefits

✅ 24/7 Health Assistance - AI chatbots always available
✅ Reduced Wait Times - Instant answers to common questions
✅ Better Patient Engagement - Interactive health management
✅ Knowledge Accessibility - Complex medical info simplified
✅ Scalable Solution - Serve unlimited patients simultaneously

---

📸 VitaData Screenshots

Patient Portal & Health Dashboard

Comprehensive patient health management interface

Doctor Dashboard

Clinical workflow and patient management system

Guardian Portal

Family health monitoring and care coordination

Pharmacy Hub

Prescription processing and delivery management

Additional Features

Advanced healthcare platform capabilities

---

Built with ❤️ by the ChatSmith Team

ChatSmith - Transforming Documents into Intelligent Conversations

Documentation • API Docs • Use Cases