Deploy chatbot to Hugging Face Space

.dockerignore

@@ -0,0 +1,26 @@
+__pycache__
+*.pyc
+*.pyo
+*.pyd
+.Python
+*.so
+*.egg
+*.egg-info
+dist
+build
+.git
+.gitignore
+.env
+.env.local
+*.log
+.DS_Store
+.vscode
+.idea
+*.md
+venv
+env
+.pytest_cache
+.coverage
+htmlcov
+cli_chat.py
+tests

Dockerfile

@@ -0,0 +1,17 @@
+
+# Hugging Face Spaces Dockerfile template
+# Read the doc: https://huggingface.co/docs/hub/spaces-sdks-docker
+FROM python:3.9
+
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+COPY --chown=user . /app
+
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -0,0 +1,306 @@
+# CampVerse Chatbot Microservice
+
+## Quick Start for New Users
+
+
+If you're new and want to run this chatbot microservice, you can choose either Docker or Python. Both methods are described below:
+
+---
+
+### 🚀 Run via Python (Local Development)
+
+1. **Clone the Repository**
+  ```bash
+  git clone https://github.com/CcpC-cuj/CampVerse.git
+  cd CampVerse/ML/chatbot
+  ```
+
+2. **Install Python & Dependencies**
+  Make sure you have Python 3.10+ installed. Then install dependencies:
+  ```bash
+  pip install -r requirements.txt
+  ```
+
+3. **Start the Backend Service**
+   ```bash
+   export BACKEND_URL=http://localhost:5001  # Set backend URL
+   uvicorn app:app_socket --host 0.0.0.0 --port 8000
+   ```4. **Test with CLI Chat Client**
+  Open a new terminal and run:
+  ```bash
+  python cli_chat.py
+  ```
+  Type your questions and interact with the bot.
+
+---
+
+### 🐳 Run via Docker (Containerized)
+
+1. **Build the Docker Image**
+  ```bash
+  docker build -t chatbot-service .
+  ```
+
+2. **Run the Docker Container**
+   ```bash
+   docker run -p 8000:8000 -e BACKEND_URL=http://localhost:5001 chatbot-service
+   ```3. **Test the Service**
+  - REST API: 
+    ```bash
+    curl -X POST http://localhost:8000/chatbot -H "Content-Type: application/json" -d '{"question":"How do I register?"}'
+    ```
+  - Socket.IO: 
+    ```bash
+    python cli_chat.py
+    ```
+
+---
+
+### 🌐 Integrate with Your Web App
+Use REST API or Socket.IO as shown below to connect your frontend.
+
+---
+
+A production-ready chatbot microservice using FastAPI, Socket.IO, and sentence transformers for FAQ-based question answering.
+
+## Features
+
+- 🚀 **FastAPI REST API**: HTTP endpoint for Q&A
+- 🔌 **Socket.IO Real-time**: WebSocket support for live chat
+- 🤖 **AI-Powered**: Uses sentence transformers and FAISS for semantic search
+- 🎯 **Intent Classification**: Detects greetings, event queries, help requests, and more
+- 🔍 **Dynamic Event Discovery**: Fetches and searches live events from backend API
+- 🐳 **Docker Ready**: Containerized for easy deployment
+- 📝 **Logging**: Comprehensive logging for debugging
+- ✅ **Input Validation**: Validates question length and content
+- 🌐 **CORS Enabled**: Ready for frontend integration
+
+## Architecture
+
+```
+┌─────────────────┐
+│   Frontend      │
+│  (React/Web)    │
+└────────┬────────┘
+         │
+         │ HTTP POST /chatbot
+         │ OR Socket.IO
+         │
+┌────────▼────────┐
+│   app.py        │
+│  FastAPI +      │
+│  Socket.IO      │
+└────────┬────────┘
+         │
+         │ Semantic Search
+         │
+┌────────▼────────┐
+│   faq.json      │
+│  (FAQ Database) │
+└─────────────────┘
+```
+
+## API Endpoints
+
+### REST API
+
+**POST /chatbot**
+```json
+Request:
+{
+  "question": "How do I register?"
+}
+
+Response:
+{
+  "question": "How do I register?",
+  "answer": "Click on the Register button..."
+}
+```
+
+### Socket.IO Events
+
+**Client → Server**
+- `user_question`: Send a question
+  ```javascript
+  socket.emit('user_question', { question: 'How do I login?' });
+  ```
+
+**Server → Client**
+- `bot_answer`: Receive answer
+  ```javascript
+  socket.on('bot_answer', (data) => {
+    console.log(data.answer);
+  });
+  ```
+
+## Setup & Installation
+
+### Local Development
+
+1. **Install dependencies:**
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+2. **Run the server:**
+   ```bash
+   uvicorn app:app_socket --host 0.0.0.0 --port 8000
+   ```
+
+3. **Test with CLI client:**
+   ```bash
+   python cli_chat.py
+   ```
+
+### Docker Deployment
+
+1. **Build the image:**
+   ```bash
+   docker build -t chatbot-service .
+   ```
+
+2. **Run the container:**
+   ```bash
+   docker run -p 8000:8000 chatbot-service
+   ```
+
+3. **Test the service:**
+   - REST API: `curl -X POST http://localhost:8000/chatbot -H "Content-Type: application/json" -d '{"question":"How do I register?"}'`
+   - Socket.IO: `python cli_chat.py`
+
+## Project Structure
+
+```
+chatbot/
+├── app.py              # Main backend (FastAPI + Socket.IO)
+├── cli_chat.py         # CLI client for testing
+├── Dockerfile          # Docker configuration
+├── faq.json            # FAQ database
+├── requirements.txt    # Python dependencies
+└── README.md           # This file
+```
+
+## Integration with Frontend
+
+### React Example (Socket.IO)
+
+```javascript
+import io from 'socket.io-client';
+
+const socket = io('http://localhost:8000');
+
+socket.on('connect', () => {
+  console.log('Connected to chatbot');
+});
+
+socket.on('bot_answer', (data) => {
+  console.log('Answer:', data.answer);
+});
+
+// Send question
+socket.emit('user_question', { question: 'How do I login?' });
+```
+
+### React Example (REST API)
+
+```javascript
+const response = await fetch('http://localhost:8000/chatbot', {
+  method: 'POST',
+  headers: { 'Content-Type': 'application/json' },
+  body: JSON.stringify({ question: 'How do I login?' })
+});
+
+const data = await response.json();
+console.log(data.answer);
+```
+
+## Configuration
+
+### Environment Variables
+
+You can configure the service using environment variables:
+
+- `PORT`: Server port (default: 8000)
+- `LOG_LEVEL`: Logging level (default: INFO)
+
+### FAQ Management
+
+Edit `faq.json` to add/update questions and answers:
+
+```json
+[
+  {
+    "question": "How do I register?",
+    "answer": "Click on the Register button on the homepage..."
+  }
+]
+```
+
+After updating, rebuild the Docker image or restart the server.
+
+## Monitoring & Logs
+
+The service logs all:
+- Client connections/disconnections
+- Incoming questions
+- Matched FAQ pairs
+- Errors and warnings
+
+View logs in Docker:
+```bash
+docker logs -f <container-id>
+```
+
+## Security
+
+- CORS is enabled for all origins (configure for production)
+- Input validation (max 512 characters)
+- Error handling to prevent crashes
+- No rate limiting (add if needed for production)
+
+## Testing
+
+### Manual Testing
+
+1. Start the service
+2. Run CLI client: `python cli_chat.py`
+3. Type questions and verify responses
+
+### Testing REST API
+
+```bash
+curl -X POST http://localhost:8000/chatbot \
+  -H "Content-Type: application/json" \
+  -d '{"question":"How do I register?"}'
+```
+
+## Troubleshooting
+
+**Service won't start:**
+- Check if port 8000 is available
+- Verify all dependencies are installed
+- Check logs for errors
+
+**CLI client can't connect:**
+- Ensure service is running on port 8000
+- Check firewall settings
+- Verify `python-socketio` is installed
+
+**No answer returned:**
+- Check if `faq.json` exists and is valid
+- Verify the question exists in FAQ database
+- Check server logs for errors
+
+## Future Enhancements
+
+- [ ] Add rate limiting for production
+- [ ] Add authentication for Socket.IO
+- [ ] Support multiple languages
+- [ ] Add conversation history
+- [ ] Implement fallback responses
+- [ ] Add metrics and analytics
+
+## License
+
+Part of the CampVerse project.

app.py

@@ -0,0 +1,176 @@
+import pandas as pd
+from sentence_transformers import SentenceTransformer
+import faiss
+import numpy as np
+from fastapi import FastAPI, Request
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+import socketio
+import logging
+import os
+
+# Import custom services
+from event_service import EventService
+from intent_classifier import IntentClassifier
+
+# --- Logging setup ---
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger("chatbot")
+
+# --- Load resources ---
+try:
+    df = pd.read_json('faq.json')
+    model = SentenceTransformer('all-MiniLM-L6-v2')
+    question_embeddings = model.encode(df['question'].tolist(), convert_to_tensor=True)
+    index = faiss.IndexFlatL2(question_embeddings.shape[1])
+    index.add(question_embeddings.cpu().numpy())
+    
+    # Initialize event service and intent classifier
+    backend_url = os.getenv('BACKEND_URL', 'http://localhost:5000')
+    event_service = EventService(backend_url, model)
+    intent_classifier = IntentClassifier()
+    
+    # Fetch events on startup
+    event_service.fetch_events()
+    
+    logger.info("Resources loaded successfully.")
+except Exception as e:
+    logger.error(f"Error loading resources: {e}")
+    raise
+
+# --- FastAPI REST API ---
+app = FastAPI()
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+class QuestionRequest(BaseModel):
+    question: str
+
+@app.post("/chatbot")
+async def chatbot(req: QuestionRequest, request: Request):
+    question = req.question.strip()
+    if not question:
+        logger.warning("Received empty question.")
+        return {"error": "Question cannot be empty."}
+    if len(question) > 512:
+        logger.warning("Question too long.")
+        return {"error": "Question too long."}
+    try:
+        # Classify intent
+        intent, confidence = intent_classifier.classify(question)
+        logger.info(f"Intent: {intent} (confidence: {confidence})")
+        
+        # Handle specific intents
+        if intent in ['greeting', 'farewell', 'thanks', 'help', 'host_help']:
+            response = intent_classifier.get_response_for_intent(intent)
+            logger.info(f"Response for {intent}: {repr(response)}")  # Debug log
+            return {
+                "question": question,
+                "answer": response,
+                "intent": intent
+            }
+        
+        # Handle event search
+        if intent == 'event_search':
+            events = event_service.search_events(question, top_k=5)
+            response = event_service.format_event_response(events)
+            return {
+                "question": question,
+                "answer": response,
+                "intent": intent,
+                "events": events
+            }
+        
+        # Default: FAQ search
+        user_question_embedding = model.encode(question, convert_to_tensor=True)
+        user_question_embedding_np = user_question_embedding.cpu().numpy().reshape(1, -1)
+        distances, indices = index.search(user_question_embedding_np, k=1)
+        best_match_index = indices[0][0]
+        retrieved_answer = df.iloc[best_match_index]['answer']
+        retrieved_question = df.iloc[best_match_index]['question']
+        logger.info(f"Answered question: {question} -> {retrieved_question}")
+        return {
+            "question": retrieved_question,
+            "answer": retrieved_answer,
+            "intent": intent
+        }
+    except Exception as e:
+        logger.error(f"Error processing question: {e}")
+        return {"error": "Internal server error."}
+
+# --- Socket.IO real-time API ---
+sio = socketio.AsyncServer(async_mode='asgi', cors_allowed_origins='*')
+app_socket = socketio.ASGIApp(sio, app)
+
+@sio.event
+def connect(sid, environ):
+    logger.info(f"Client connected: {sid}")
+
+@sio.event
+def disconnect(sid):
+    logger.info(f"Client disconnected: {sid}")
+
+@sio.event
+async def user_question(sid, data):
+    question = data.get('question', '').strip()
+    if not question:
+        await sio.emit('bot_answer', {'error': 'Question cannot be empty.'}, to=sid)
+        logger.warning(f"Empty question from {sid}")
+        return
+    if len(question) > 512:
+        await sio.emit('bot_answer', {'error': 'Question too long.'}, to=sid)
+        logger.warning(f"Long question from {sid}")
+        return
+    try:
+        # Classify intent
+        intent, confidence = intent_classifier.classify(question)
+        logger.info(f"Intent: {intent} (confidence: {confidence})")
+        
+        # Handle specific intents
+        if intent in ['greeting', 'farewell', 'thanks', 'help', 'host_help']:
+            response = intent_classifier.get_response_for_intent(intent)
+            await sio.emit('bot_answer', {
+                'question': question,
+                'answer': response,
+                'intent': intent
+            }, to=sid)
+            return
+        
+        # Handle event search
+        if intent == 'event_search':
+            events = event_service.search_events(question, top_k=5)
+            response = event_service.format_event_response(events)
+            await sio.emit('bot_answer', {
+                'question': question,
+                'answer': response,
+                'intent': intent
+            }, to=sid)
+            logger.info(f"SocketIO event search: {question}")
+            return
+        
+        # Default: FAQ search
+        user_question_embedding = model.encode(question, convert_to_tensor=True)
+        user_question_embedding_np = user_question_embedding.cpu().numpy().reshape(1, -1)
+        distances, indices = index.search(user_question_embedding_np, k=1)
+        best_match_index = indices[0][0]
+        retrieved_answer = df.iloc[best_match_index]['answer']
+        retrieved_question = df.iloc[best_match_index]['question']
+        await sio.emit('bot_answer', {
+            'question': retrieved_question,
+            'answer': retrieved_answer,
+            'intent': intent
+        }, to=sid)
+        logger.info(f"SocketIO answered: {question} -> {retrieved_question}")
+    except Exception as e:
+        await sio.emit('bot_answer', {'error': 'Internal server error.'}, to=sid)
+        logger.error(f"SocketIO error for {sid}: {e}")
+
+# --- For Uvicorn ---
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app_socket, host="0.0.0.0", port=8000)

cli_chat.py

@@ -0,0 +1,54 @@
+import socketio
+import sys
+import threading
+import time
+
+sio = socketio.Client()
+user_can_input = threading.Event()
+user_can_input.set()
+
+@sio.event
+def connect():
+    print("\n✅ Connected to CampVerse Chatbot!")
+    print("Type your questions below. Press Ctrl+C to exit.\n")
+
+@sio.event
+def disconnect():
+    print("\n❌ Disconnected from chatbot backend.")
+
+@sio.event
+def bot_answer(data):
+    print("\n------------------------------")
+    if 'error' in data:
+        print(f"❌ Error: {data['error']}")
+    else:
+        print(f"🤖 Bot says: {data['answer']}")
+        print(f"   (Matched FAQ: {data['question']})")
+    print("------------------------------\n")
+    time.sleep(2)
+    user_can_input.set()
+
+def ask_user():
+    while True:
+        user_can_input.wait()
+        question = input("You: ")
+        if question.strip():
+            sio.emit('user_question', {'question': question})
+        else:
+            print("⚠️  Please enter a valid question.\n")
+        user_can_input.clear()
+
+try:
+    sio.connect('http://localhost:8000')
+    user_thread = threading.Thread(target=ask_user)
+    user_thread.daemon = True
+    user_thread.start()
+    while True:
+        pass
+except KeyboardInterrupt:
+    print("\n👋 Goodbye!")
+    sio.disconnect()
+    sys.exit(0)
+except Exception as e:
+    print(f"❌ Error: {e}")
+    sys.exit(1)

event_service.py

@@ -0,0 +1,117 @@
+"""
+Event Discovery Service
+Fetches and searches events from the backend API
+"""
+import requests
+import logging
+from typing import List, Dict, Optional
+from sentence_transformers import SentenceTransformer
+import numpy as np
+from sklearn.metrics.pairwise import cosine_similarity
+
+logger = logging.getLogger("chatbot.events")
+
+class EventService:
+    def __init__(self, backend_url: str, model: SentenceTransformer):
+        self.backend_url = backend_url
+        self.model = model
+        self.events_cache = []
+        self.events_embeddings = None
+        
+    def fetch_events(self) -> List[Dict]:
+        """Fetch all approved public events from backend"""
+        try:
+            response = requests.get(f"{self.backend_url}/api/events", timeout=5)
+            if response.status_code == 200:
+                data = response.json()
+                self.events_cache = data.get("data", {}).get("events", [])
+                logger.info(f"Fetched {len(self.events_cache)} events from backend")
+                
+                # Pre-compute embeddings for all events
+                self._compute_event_embeddings()
+                return self.events_cache
+            else:
+                logger.error(f"Failed to fetch events: {response.status_code}")
+                return []
+        except Exception as e:
+            logger.error(f"Error fetching events: {e}")
+            return []
+    
+    def _compute_event_embeddings(self):
+        """Compute embeddings for all events"""
+        if not self.events_cache:
+            return
+        
+        event_texts = []
+        for event in self.events_cache:
+            # Combine title, description, and tags for better matching
+            text = f"{event.get('title', '')} {event.get('description', '')} {' '.join(event.get('tags', []))}"
+            event_texts.append(text)
+        
+        self.events_embeddings = self.model.encode(event_texts, convert_to_tensor=False)
+        logger.info(f"Computed embeddings for {len(event_texts)} events")
+    
+    def search_events(self, query: str, top_k: int = 5) -> List[Dict]:
+        """Search events using semantic similarity"""
+        if not self.events_cache or self.events_embeddings is None:
+            self.fetch_events()
+        
+        if not self.events_cache:
+            logger.warning("No events available in cache")
+            return []
+        
+        # Encode user query
+        query_embedding = self.model.encode([query], convert_to_tensor=False)
+        
+        # Calculate cosine similarity
+        similarities = cosine_similarity(query_embedding, self.events_embeddings)[0]
+        
+        # Log similarity scores for debugging
+        logger.info(f"Query: {query}")
+        logger.info(f"Similarity scores: min={similarities.min():.3f}, max={similarities.max():.3f}, mean={similarities.mean():.3f}")
+        
+        # Get top k indices
+        top_indices = np.argsort(similarities)[::-1][:top_k]
+        
+        # Filter events with similarity > threshold (lowered to 0.15 for better recall)
+        results = []
+        for idx in top_indices:
+            score = similarities[idx]
+            if score > 0.15:  # Lowered threshold
+                event = self.events_cache[idx].copy()
+                event['similarity_score'] = float(score)
+                results.append(event)
+                logger.info(f"  Event '{event.get('title', 'Untitled')}' matched with score {score:.3f}")
+        
+        logger.info(f"Found {len(results)} matching events for query: {query}")
+        return results
+    
+    def format_event_response(self, events: List[Dict]) -> str:
+        """Format events into a conversational response"""
+        if not events:
+            return "Sorry, I couldn't find any events matching your query. Try searching for something like 'hackathon', 'AI workshop', or 'coding competition'."
+        
+        response = f"I found {len(events)} event(s) for you:\n\n"
+        
+        for i, event in enumerate(events, 1):
+            title = event.get('title', 'Untitled Event')
+            date = event.get('date', 'TBA')[:10] if event.get('date') else 'TBA'
+            description = event.get('description', '')
+            
+            # Truncate description
+            if len(description) > 100:
+                description = description[:97] + "..."
+            
+            response += f"{i}. **{title}**\n"
+            response += f"   📅 Date: {date}\n"
+            
+            if description:
+                response += f"   📝 {description}\n"
+            
+            # Add website link if available
+            if event.get('socialLinks', {}).get('website'):
+                response += f"   🔗 [More Info]({event['socialLinks']['website']})\n"
+            
+            response += "\n"
+        
+        return response.strip()

faq.json

@@ -0,0 +1,373 @@
+[
+  {
+    "question": "How do I register for an event?",
+    "answer": "Visit the Events section, select your event, and click 'Register.' Complete the required details to finish registration."
+  },
+  {
+    "question": "How do I sign up for CampVerse?",
+    "answer": "Welcome! To sign up, just click the 'Register' button on our homepage and fill in your details. We're excited to have you join our community!"
+  },
+  {
+    "question": "Is CampVerse free to use?",
+    "answer": "Yes! CampVerse is free for all users. Some events may have entry fees, but browsing and joining the platform is always free."
+  },
+  {
+    "question": "Can I get help if I'm stuck?",
+    "answer": "Absolutely! If you ever need help, just reach out via our Support page or chat with us here. We're always happy to assist you!"
+  },
+  {
+    "question": "What should I do if I can't find my certificate?",
+    "answer": "No worries! Certificates are usually available in your dashboard after the event. If you can't find yours, contact support and we'll help you out."
+  },
+  {
+    "question": "How do I change my password?",
+    "answer": "To change your password, go to your profile settings and select 'Change Password.' If you forgot your password, use the 'Forgot Password' link on the login page."
+  },
+  {
+    "question": "Can I participate if I'm new to coding?",
+    "answer": "Of course! CampVerse welcomes everyone, whether you're a beginner or an expert. Many events are designed for all skill levels."
+  },
+  {
+    "question": "How do I contact a team member?",
+    "answer": "You can message your team members directly from your dashboard or use the chat feature during events."
+  },
+  {
+    "question": "What happens after I register for an event?",
+    "answer": "After registering, you'll receive a confirmation email and see the event in your dashboard. We'll keep you updated with all the important details!"
+  },
+  {
+    "question": "Can I join more than one team?",
+    "answer": "You can only join one team per event, but you're welcome to participate in multiple events with different teams!"
+  },
+  {
+    "question": "What are the rules for the upcoming hackathon?",
+    "answer": "Rules are available on the event details page or in the official rulebook linked there."
+  },
+  {
+    "question": "When is the deadline for the coding competition?",
+    "answer": "Deadlines are listed on each event page under 'Important Dates.'"
+  },
+  {
+    "question": "Where can I find the results of the last event?",
+    "answer": "Results are posted on the Results page and sent to registered participants via email."
+  },
+  {
+    "question": "Who is eligible to participate?",
+    "answer": "Eligibility criteria are shown on each event’s details page."
+  },
+  {
+    "question": "How do I form a team?",
+    "answer": "You can invite users to join your team during registration or from your dashboard."
+  },
+  {
+    "question": "What are the prizes?",
+    "answer": "Prize details are available on the event page under 'Prizes.'"
+  },
+  {
+    "question": "How do I reset my password?",
+    "answer": "Go to the login page and click 'Forgot Password' to receive reset instructions."
+  },
+  {
+    "question": "How do I contact support?",
+    "answer": "Use the Support page or submit a ticket from your dashboard."
+  },
+  {
+    "question": "Can I edit my registration details?",
+    "answer": "Yes, you can update your registration from your dashboard before the event deadline."
+  },
+  {
+    "question": "How do I upload required documents?",
+    "answer": "Upload documents via the event registration form or your dashboard."
+  },
+  {
+    "question": "Where can I find event schedules?",
+    "answer": "Schedules are listed on each event’s details page."
+  },
+  {
+    "question": "How do I verify my participation?",
+    "answer": "Verification details are sent via email and shown on your dashboard after the event."
+  },
+  {
+    "question": "What is the process for certificate generation?",
+    "answer": "Certificates are generated after event completion and can be downloaded from your dashboard."
+  },
+  {
+    "question": "How do I report a problem or bug?",
+    "answer": "Use the Feedback or Support section to report issues."
+  },
+  {
+    "question": "How do I access the leaderboard?",
+    "answer": "The leaderboard is available on the Results or event details page."
+  },
+  {
+    "question": "Can I participate in multiple events?",
+    "answer": "Yes, you can register for multiple events if eligible."
+  },
+  {
+    "question": "How do I check my eligibility status?",
+    "answer": "Your eligibility status is displayed on your dashboard and event registration page."
+  },
+  {
+    "question": "How do I get notifications about upcoming events?",
+    "answer": "Enable notifications in your profile settings or check the Notifications section."
+  },
+  {
+    "question": "How do I use the platform’s storage service?",
+    "answer": "Refer to the Storage Service Guide in the documentation section."
+  },
+  {
+    "question": "How do I view my achievements?",
+    "answer": "Achievements are listed in your user profile and dashboard."
+  },
+  {
+    "question": "How do I update my profile information?",
+    "answer": "Go to your dashboard and select 'Edit Profile' to update your information."
+  },
+  {
+    "question": "How do I join as a host or institution?",
+    "answer": "Apply through the Host/Institution registration page and follow the instructions."
+  },
+  {
+    "question": "How do I access event analytics?",
+    "answer": "Event analytics are available to hosts and institutions on their dashboard."
+  },
+  {
+    "question": "How do I request a certificate re-issue?",
+    "answer": "Submit a request via the Support or Certificate section in your dashboard."
+  },
+  {
+    "question": "How do I view feedback for events?",
+    "answer": "Feedback is available on the event details page and your dashboard."
+  },
+  {
+    "question": "How do I manage notifications?",
+    "answer": "Notification settings can be managed from your profile page."
+  },
+  {
+    "question": "How do I access secure files?",
+    "answer": "Secure files are available to eligible users via the Secure Files section in your dashboard."
+  },
+  {
+    "question": "How do I check event participation logs?",
+    "answer": "Participation logs are available in your dashboard under 'Event Participation.'"
+  },
+  {
+    "question": "How do I get help with ML features?",
+    "answer": "Refer to the ML Integration documentation or contact support for assistance."
+  },
+  {
+    "question": "How do I use the API?",
+    "answer": "API documentation is available in the docs section."
+  },
+  {
+    "question": "How do I view or download certificates?",
+    "answer": "Certificates can be viewed and downloaded from your dashboard after event completion."
+  },
+  {
+    "question": "How do I check host eligibility status?",
+    "answer": "Host eligibility status is shown on the host dashboard and event registration page."
+  },
+  {
+    "question": "How do I migrate my account or data?",
+    "answer": "Migration instructions are available in the documentation or contact support for help."
+  },
+  {
+    "question": "How do I access business analytics?",
+    "answer": "Business analytics are available to authorized users in the analytics dashboard."
+  },
+  {
+    "question": "How do I validate event modules?",
+    "answer": "Use the validation scripts provided in the scripts folder or contact support."
+  },
+  {
+    "question": "How do I get started as a new user?",
+    "answer": "Check the Getting Started guide in the documentation and follow onboarding steps."
+  },
+  {
+    "question": "How do I access the development approach?",
+    "answer": "Development approach details are available in the DEVELOPMENT_APPROACH.md file."
+  },
+  {
+    "question": "How do I check API endpoints?",
+    "answer": "API endpoints are documented in the swagger documentation and docs section."
+  },
+  {
+    "question": "How do I use socket features?",
+    "answer": "Refer to the socketClient.js example in the examples folder."
+  },
+  {
+    "question": "How do I check system status or downtime?",
+    "answer": "System status updates are posted in the Notifications section and via email."
+  },
+  {
+    "question": "How do I access the platform from mobile?",
+    "answer": "The platform is mobile-friendly and can be accessed via any browser."
+  },
+  {
+    "question": "How do I get help with frontend issues?",
+    "answer": "Refer to the Frontend TODO and error documentation or contact support."
+  },
+  {
+    "question": "How do I check my event certificates?",
+    "answer": "Event certificates are listed in your dashboard under 'Certificates.'"
+  },
+  {
+    "question": "How do I get updates about new features?",
+    "answer": "Updates are announced in the Notifications section and via email."
+  },
+  {
+    "question": "How do I access storage usage details?",
+    "answer": "Storage usage details are available in your dashboard under 'Storage.'"
+  },
+  {
+    "question": "How do I request event verification?",
+    "answer": "Submit a verification request from the event details page or your dashboard."
+  },
+  {
+    "question": "How do I access institution features?",
+    "answer": "Institution features are available to registered institutions via their dashboard."
+  },
+  {
+    "question": "How do I check notification history?",
+    "answer": "Notification history is available in your dashboard under 'Notifications.'"
+  },
+  {
+    "question": "How do I access support tickets?",
+    "answer": "Support tickets can be viewed and managed from your dashboard under 'Support.'"
+  }
+  ,
+  {
+    "question": "hi",
+    "answer": "Hi, I'm CampVerseBot! How can I help you today?"
+  },
+  {
+    "question": "hello",
+    "answer": "Hello! I'm CampVerseBot, here to assist you. What would you like to know?"
+  },
+  {
+    "question": "hey",
+    "answer": "Hey there! How can I help you at CampVerse today?"
+  },
+  {
+    "question": "good morning",
+    "answer": "Good morning! How can I help you today at CampVerse?"
+  },
+  {
+    "question": "good afternoon",
+    "answer": "Good afternoon! What can I do for you at CampVerse?"
+  },
+  {
+    "question": "good evening",
+    "answer": "Good evening! How can I assist you at CampVerse?"
+  },
+  {
+    "question": "bye",
+    "answer": "Goodbye! If you need anything else, just ask. Have a great day!"
+  },
+  {
+    "question": "goodbye",
+    "answer": "Goodbye! Thanks for visiting CampVerse. See you next time!"
+  },
+  {
+    "question": "see you",
+    "answer": "See you! If you have more questions, come back anytime."
+  }
+  ,
+  {
+    "question": "How do I create an account on CampVerse?",
+    "answer": "Click the 'Create Account' button on the homepage and fill in your details. You’ll receive a confirmation email to activate your account."
+  },
+  {
+    "question": "How do I verify my email address?",
+    "answer": "After signing up, check your inbox for a verification email from CampVerse. Click the link in the email to verify your address. If you don’t see it, check your spam folder or request a new verification email from your dashboard."
+  },
+  {
+    "question": "What should I do if I don’t receive a confirmation email?",
+    "answer": "First, check your spam or junk folder. If you still can’t find it, use the 'Resend Confirmation Email' option on the login page or contact support for help."
+  },
+  {
+    "question": "How do I browse and filter events?",
+    "answer": "Go to the Events section from the main menu. You can use filters to search by category, date, or institution to find events that interest you."
+  },
+  {
+    "question": "How do I join the CampVerse community?",
+    "answer": "Sign up with your college email and start participating in events, discussions, and feedback. You can also follow us on social media for updates."
+  },
+  {
+    "question": "How do I use the dashboard?",
+    "answer": "After logging in, your dashboard gives you access to your events, teams, certificates, notifications, and more. Use the sidebar to navigate different sections."
+  },
+  {
+    "question": "How do I contact support from the website?",
+    "answer": "Click the 'Support' or 'Help' link in the website footer or your dashboard to submit a ticket or chat with our support team."
+  },
+  {
+    "question": "What browsers and devices are supported?",
+    "answer": "CampVerse works best on the latest versions of Chrome, Firefox, Edge, and Safari. The platform is mobile-friendly and works on most smartphones and tablets."
+  },
+  {
+    "question": "How do I reset my password from the login page?",
+    "answer": "Click 'Forgot Password?' on the login page, enter your email, and follow the instructions sent to your inbox to reset your password."
+  },
+  {
+    "question": "How do I access event details and schedules?",
+    "answer": "Click on any event card to view its details, including schedule, rules, and prizes. Important dates are highlighted on the event page."
+  },
+  {
+    "question": "How do I use the Browse Events feature?",
+    "answer": "Use the 'Browse Events' button on the homepage or dashboard to see all upcoming and ongoing events. You can filter and sort events as needed."
+  },
+  {
+    "question": "How do I launch my own event on CampVerse?",
+    "answer": "If you’re an institution or host, log in to your dashboard and use the 'Create Event' option. Fill in the event details and submit for approval."
+  },
+  {
+    "question": "How do I access the institution dashboard?",
+    "answer": "Institution representatives can log in and access the institution dashboard from the main menu. Here you can manage events, view analytics, and more."
+  },
+  {
+    "question": "How do I update my profile or settings from the frontend?",
+    "answer": "Go to your dashboard, click on your profile icon, and select 'Edit Profile' to update your information, change your password, or manage notification settings."
+  },
+  {
+    "question": "Why can’t I see some events?",
+    "answer": "Some events may be restricted to certain colleges or require approval to join. Check the event’s eligibility criteria or contact support if you think there’s an error."
+  },
+  {
+    "question": "How do I know if an event is open to my college?",
+    "answer": "Each event page lists eligibility details. Look for 'Open to All' or check if your college is listed in the eligible institutions."
+  },
+  {
+    "question": "How do I join a team for an event?",
+    "answer": "When registering for an event, you can create a new team or join an existing one if the event allows teams. Follow the prompts during registration."
+  },
+  {
+    "question": "How do I leave feedback for an event?",
+    "answer": "After the event, go to the event page or your dashboard and look for the 'Leave Feedback' option. Your feedback helps us improve!"
+  },
+  {
+    "question": "How do I report inappropriate content or users?",
+    "answer": "Use the 'Report' button on user profiles or event pages, or contact support directly. We take all reports seriously and will investigate promptly."
+  },
+  {
+    "question": "How do I stay safe while using CampVerse?",
+    "answer": "Never share your password or sensitive information. Use official communication channels and report any suspicious activity to support."
+  }
+  ,
+  {
+    "question": "How do I get verified as a host?",
+    "answer": "To get verified as a host, register your host account through the dedicated portal. Our team will review your details and may request additional documentation. Once approved, you’ll receive a verification badge and access to host features."
+  },
+  {
+    "question": "What documents are required for host verification?",
+    "answer": "Typically, you’ll need to provide a valid ID and official contact information. Specific requirements are listed during the registration process."
+  },
+  {
+    "question": "How long does host verification take?",
+    "answer": "Host verification usually takes 2-5 business days after submitting all required documents. You’ll be notified by email once your account is verified."
+  },
+  {
+    "question": "What are the benefits of being a verified host?",
+    "answer": "Verified hosts can create and manage events, access advanced analytics, and gain greater visibility on CampVerse. A verification badge also builds trust with participants."
+  }
+]

intent_classifier.py

@@ -0,0 +1,105 @@
+"""
+Intent Classification Service
+Detects user intent: greeting, event_search, help, thanks, farewell, general_question
+"""
+import re
+import logging
+from typing import Tuple
+
+logger = logging.getLogger("chatbot.intent")
+
+class IntentClassifier:
+    def __init__(self):
+        # Define intent patterns with priority order
+        self.intent_patterns = {
+            'greeting': [
+                r'^(hi|hello|hey|good morning|good afternoon|good evening|greetings|hii|hiii|helllo)[\s!?.]*$',
+                r'\b(hi|hello|hey|good morning|good afternoon|good evening|greetings)\b',
+            ],
+            'farewell': [
+                r'\b(bye|goodbye|see you|farewell|take care|good night)\b',
+            ],
+            'thanks': [
+                r'\b(thank|thanks|appreciate|grateful|thx)\b',
+            ],
+            'host_help': [
+                # Host-specific questions (check before event_search)
+                r'\b(register|create|host|organize|add|post|submit|upload)\b.{0,50}\b(my event|an event|event)\b',
+                r'\b(how to|how can i|how do i)\b.{0,50}\b(register|create|host|organize|add|post)\b.{0,50}\b(event)\b',
+                r'\b(host|organizer|organiser)\b',
+            ],
+            'event_search': [
+                # Direct event queries (search/find only)
+                r'\b(show|find|search|list|get|display|tell|give|want|need|looking for)\b.{0,50}\b(event|hackathon|workshop|competition|seminar|webinar|conference|meetup|contest|fest|festival)\b',
+                # Time-based queries
+                r'\b(upcoming|today|tomorrow|this week|this month|next|future|soon|latest|recent)\b.{0,50}\b(event|hackathon|workshop)\b',
+                # Location-based queries
+                r'\b(at|in|near|on)\b.{0,50}\b(campus|college|university|cuj|ccpc)\b',
+                # Category-based
+                r'\b(ai|ml|tech|coding|programming|software|web|mobile|data|science)\b.{0,50}\b(event|hackathon|workshop)\b',
+                # Simple keywords
+                r'^(event|hackathon|workshop|competition|seminar|webinar|conference|meetup)s?\s*$',
+            ],
+            'help': [
+                r'\b(help|support|assist|guide|what can you do|how does)\b',
+            ],
+        }
+    
+    def classify(self, text: str) -> Tuple[str, float]:
+        """
+        Classify user intent from text
+        Returns: (intent, confidence)
+        Priority: greeting/farewell/thanks > event_search > help > general_question
+        """
+        text_lower = text.lower().strip()
+        
+        # Priority 1: Check for exact greetings (single word)
+        if text_lower in ['hi', 'hello', 'hey', 'hii', 'hiii', 'helllo', 'good morning', 'good afternoon', 'good evening']:
+            logger.info(f"Detected intent: greeting for text: {text}")
+            return 'greeting', 0.95
+        
+        # Priority 2: Check for farewell and thanks
+        for intent in ['farewell', 'thanks']:
+            for pattern in self.intent_patterns[intent]:
+                if re.search(pattern, text_lower, re.IGNORECASE):
+                    logger.info(f"Detected intent: {intent} for text: {text}")
+                    return intent, 0.9
+        
+        # Priority 3: Check for host_help (before event_search to avoid false positives)
+        for pattern in self.intent_patterns['host_help']:
+            if re.search(pattern, text_lower, re.IGNORECASE):
+                logger.info(f"Detected intent: host_help for text: {text}")
+                return 'host_help', 0.9
+        
+        # Priority 4: Check for event_search
+        for pattern in self.intent_patterns['event_search']:
+            if re.search(pattern, text_lower, re.IGNORECASE):
+                logger.info(f"Detected intent: event_search for text: {text}")
+                return 'event_search', 0.85
+        
+        # Priority 5: Check for help
+        for pattern in self.intent_patterns['help']:
+            if re.search(pattern, text_lower, re.IGNORECASE):
+                logger.info(f"Detected intent: help for text: {text}")
+                return 'help', 0.8
+        
+        # Priority 5: Check for greeting (broader match)
+        for pattern in self.intent_patterns['greeting']:
+            if re.search(pattern, text_lower, re.IGNORECASE):
+                logger.info(f"Detected intent: greeting for text: {text}")
+                return 'greeting', 0.85
+        
+        # Default to general question
+        logger.info(f"Detected intent: general_question for text: {text}")
+        return 'general_question', 0.5
+    
+    def get_response_for_intent(self, intent: str) -> str:
+        """Get predefined response for specific intents"""
+        responses = {
+            'greeting': "Hi! I'm CampVerseBot, here to help you discover events and answer your questions. You can ask me about upcoming hackathons, workshops, or any other events!",
+            'farewell': "Goodbye! If you need anything else, just ask. Have a great day!",
+            'thanks': "You're welcome! If you have more questions, feel free to ask.",
+            'help': "I can help you with:\n\n• Finding events (hackathons, workshops, competitions)\n• Answering questions about CampVerse\n• Registration and account help\n\nJust ask me anything!",
+            'host_help': "🎯 To register your event as a host:\n\n1️⃣ Sign Up/Login - Create an account or log in\n\n2️⃣ Go to Dashboard - Navigate to your host dashboard\n\n3️⃣ Create Event - Click 'Create Event' button\n\n4️⃣ Fill Details - Add title, description, date, venue, etc.\n\n5️⃣ Submit - Your event will be reviewed and published\n\n💡 Need more help? Check our Host Guide or contact support!",
+        }
+        return responses.get(intent, "")

requirements.txt

@@ -0,0 +1,11 @@
+fastapi==0.115.0
+uvicorn[standard]==0.32.0
+sentence-transformers==3.3.1
+faiss-cpu==1.9.0.post1
+pandas==2.2.3
+numpy==2.0.2
+python-socketio==5.11.4
+python-engineio==4.10.1
+python-socketio[client]==5.11.4
+requests==2.32.3
+scikit-learn==1.5.2