Deploy chatbot from GitHub Actions

Dockerfile

@@ -7,6 +7,10 @@ RUN useradd -m -u 1000 user
 USER user
 ENV PATH="/home/user/.local/bin:$PATH"
 
+# Environment variables (set via HF Spaces secrets or docker-compose)
+ENV GEMINI_API_KEY=""
+ENV BACKEND_URL=""
+
 WORKDIR /app
 
 COPY --chown=user ./requirements.txt requirements.txt

README.md

@@ -10,8 +10,15 @@ pinned: false
 ---
 # CampVerse Chatbot Microservice
 
-## Quick Start for New Users
+## Features
 
+- **Gemini AI Integration**: Enhanced NLP understanding using Google's Gemini API
+- **Intent Classification**: Smart detection of user intents (event search, greetings, help, etc.)
+- **Semantic Event Search**: Find events using natural language queries
+- **FAQ Support**: Answer common questions about the platform
+- **Real-time Chat**: WebSocket support for live conversations
+
+## 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:
 
@@ -31,11 +38,18 @@ If you're new and want to run this chatbot microservice, you can choose either D
   pip install -r requirements.txt
   ```
 
-3. **Start the Backend Service**
+3. **Set Environment Variables**
+   ```bash
+   export BACKEND_URL=http://localhost:5001  # Backend API URL
+   export GEMINI_API_KEY=your_gemini_api_key  # For enhanced NLP (optional)
+   ```
+
+4. **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**
+   ```
+
+5. **Test with CLI Chat Client**
   Open a new terminal and run:
   ```bash
   python cli_chat.py

app.py

@@ -12,6 +12,7 @@ import os
 # Import custom services
 from event_service import EventService
 from intent_classifier import IntentClassifier
+from gemini_service import get_gemini_service, GeminiService
 
 # --- Logging setup ---
 logging.basicConfig(level=logging.INFO)
@@ -31,6 +32,13 @@ try:
     event_service = EventService(backend_url, model)
     intent_classifier = IntentClassifier()
     
+    # Initialize Gemini service for enhanced NLP
+    gemini_service = get_gemini_service()
+    if gemini_service.is_available():
+        logger.info("✅ Gemini AI service is available for enhanced NLP")
+    else:
+        logger.warning("⚠️ Gemini AI not available, using fallback intent classifier")
+    
     # Fetch events on startup
     event_service.fetch_events()
     
@@ -62,18 +70,64 @@ async def chatbot(req: QuestionRequest, request: Request):
         logger.warning("Question too long.")
         return {"error": "Question too long."}
     try:
-        # Classify intent
+        # Try Gemini for enhanced understanding first
+        if gemini_service.is_available():
+            intent, confidence, entities = gemini_service.classify_intent(question)
+            logger.info(f"Gemini Intent: {intent} (confidence: {confidence}), entities: {entities}")
+            
+            # Quick responses for simple intents
+            quick_response = gemini_service.get_contextual_response(intent)
+            if quick_response:
+                return {
+                    "question": question,
+                    "answer": quick_response,
+                    "intent": intent,
+                    "ai_enhanced": True
+                }
+            
+            # Event search with enhanced understanding
+            if intent in ['event_search', 'event_details']:
+                # Enhance search query using extracted entities
+                search_query = gemini_service.enhance_search_query(question, entities)
+                events = event_service.search_events(search_query, top_k=5)
+                
+                # Generate natural response using Gemini
+                response = gemini_service.generate_response(
+                    question, intent, entities, events
+                )
+                if not response:
+                    response = event_service.format_event_response(events)
+                
+                return {
+                    "question": question,
+                    "answer": response,
+                    "intent": intent,
+                    "events": events,
+                    "ai_enhanced": True
+                }
+            
+            # For other intents, generate contextual response
+            response = gemini_service.generate_response(question, intent, entities)
+            if response:
+                return {
+                    "question": question,
+                    "answer": response,
+                    "intent": intent,
+                    "ai_enhanced": True
+                }
+        
+        # Fallback to original intent classifier
         intent, confidence = intent_classifier.classify(question)
-        logger.info(f"Intent: {intent} (confidence: {confidence})")
+        logger.info(f"Fallback 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
+                "intent": intent,
+                "ai_enhanced": False
             }
         
         # Handle event search
@@ -84,7 +138,8 @@ async def chatbot(req: QuestionRequest, request: Request):
                 "question": question,
                 "answer": response,
                 "intent": intent,
-                "events": events
+                "events": events,
+                "ai_enhanced": False
             }
         
         # Default: FAQ search
@@ -94,11 +149,12 @@ async def chatbot(req: QuestionRequest, request: Request):
         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}")
+        logger.info(f"FAQ match: {question} -> {retrieved_question}")
         return {
             "question": retrieved_question,
             "answer": retrieved_answer,
-            "intent": intent
+            "intent": intent,
+            "ai_enhanced": False
         }
     except Exception as e:
         logger.error(f"Error processing question: {e}")

gemini_service.py

@@ -0,0 +1,201 @@
+"""
+Gemini AI Service for Enhanced NLP Understanding
+Uses Google's Gemini API for better intent detection and conversational responses
+"""
+import os
+import logging
+import json
+import re
+from typing import Dict, List, Optional, Tuple
+
+logger = logging.getLogger("chatbot.gemini")
+
+# Try to import google.generativeai
+try:
+    import google.generativeai as genai
+    GEMINI_AVAILABLE = True
+except ImportError:
+    GEMINI_AVAILABLE = False
+    logger.warning("google-generativeai not installed. Gemini features disabled.")
+
+
+class GeminiService:
+    def __init__(self, api_key: Optional[str] = None):
+        self.api_key = api_key or os.getenv('GEMINI_API_KEY')
+        self.model = None
+        self.initialized = False
+        
+        if GEMINI_AVAILABLE and self.api_key:
+            try:
+                genai.configure(api_key=self.api_key)
+                self.model = genai.GenerativeModel('gemini-1.5-flash')
+                self.initialized = True
+                logger.info("Gemini AI service initialized successfully")
+            except Exception as e:
+                logger.error(f"Failed to initialize Gemini: {e}")
+        else:
+            if not GEMINI_AVAILABLE:
+                logger.warning("Gemini library not available")
+            if not self.api_key:
+                logger.warning("GEMINI_API_KEY not set")
+    
+    def is_available(self) -> bool:
+        """Check if Gemini service is available"""
+        return self.initialized and self.model is not None
+    
+    def classify_intent(self, user_message: str) -> Tuple[str, float, Dict]:
+        """
+        Use Gemini to classify user intent with high accuracy
+        Returns: (intent, confidence, extracted_entities)
+        """
+        if not self.is_available():
+            return 'unknown', 0.0, {}
+        
+        prompt = f"""You are an intent classifier for CampVerse, a college event discovery platform.
+
+Analyze the following user message and classify it into ONE of these intents:
+- greeting: User says hi, hello, hey, good morning, etc.
+- farewell: User says bye, goodbye, see you, etc.
+- thanks: User expresses gratitude
+- event_search: User is looking for events, hackathons, workshops, competitions, etc.
+- event_details: User wants details about a specific event
+- registration_help: User wants help with event registration
+- host_help: User wants to host/organize an event
+- account_help: User has account/profile related questions
+- general_question: General questions about the platform
+- feedback: User giving feedback or suggestions
+
+Also extract any relevant entities like:
+- event_type: hackathon, workshop, seminar, webinar, competition, etc.
+- time_frame: today, tomorrow, this week, upcoming, etc.
+- topic: AI, ML, web development, coding, etc.
+- location: any mentioned location
+
+User message: "{user_message}"
+
+Respond in this exact JSON format:
+{{
+    "intent": "intent_name",
+    "confidence": 0.95,
+    "entities": {{
+        "event_type": null,
+        "time_frame": null,
+        "topic": null,
+        "location": null
+    }},
+    "reasoning": "brief explanation"
+}}"""
+
+        try:
+            response = self.model.generate_content(prompt)
+            response_text = response.text.strip()
+            
+            # Extract JSON from response
+            json_match = re.search(r'\{[\s\S]*\}', response_text)
+            if json_match:
+                result = json.loads(json_match.group())
+                intent = result.get('intent', 'general_question')
+                confidence = result.get('confidence', 0.8)
+                entities = result.get('entities', {})
+                logger.info(f"Gemini classified intent: {intent} ({confidence}) for: {user_message}")
+                return intent, confidence, entities
+            else:
+                logger.warning(f"Could not parse Gemini response: {response_text}")
+                return 'general_question', 0.5, {}
+                
+        except Exception as e:
+            logger.error(f"Gemini intent classification failed: {e}")
+            return 'unknown', 0.0, {}
+    
+    def generate_response(self, user_message: str, intent: str, entities: Dict, 
+                         events: Optional[List[Dict]] = None, context: str = "") -> str:
+        """
+        Generate a natural, conversational response using Gemini
+        """
+        if not self.is_available():
+            return None
+        
+        # Build context about available events
+        events_context = ""
+        if events:
+            events_context = "\n\nAvailable events:\n"
+            for i, event in enumerate(events[:5], 1):
+                title = event.get('title', 'Untitled')
+                date = event.get('date', 'TBA')[:10] if event.get('date') else 'TBA'
+                desc = event.get('description', '')[:100]
+                event_type = event.get('type', 'event')
+                tags = ', '.join(event.get('tags', [])[:3])
+                events_context += f"{i}. {title} ({event_type})\n   Date: {date}\n   Tags: {tags}\n   Description: {desc}...\n\n"
+        
+        prompt = f"""You are CampVerseBot, a friendly and helpful assistant for CampVerse - a college event discovery platform.
+
+User's message: "{user_message}"
+Detected intent: {intent}
+Extracted entities: {json.dumps(entities)}
+{events_context}
+{context}
+
+Guidelines:
+- Be friendly, concise, and helpful
+- If events are provided, recommend them naturally
+- For event searches, list events with dates and brief descriptions
+- Use emojis sparingly for a friendly tone
+- If no events match, suggest alternative searches
+- For greetings, introduce yourself briefly
+- For help requests, explain what you can do
+- Keep responses under 200 words unless listing multiple events
+
+Generate a natural, helpful response:"""
+
+        try:
+            response = self.model.generate_content(prompt)
+            generated_text = response.text.strip()
+            logger.info(f"Gemini generated response for intent: {intent}")
+            return generated_text
+        except Exception as e:
+            logger.error(f"Gemini response generation failed: {e}")
+            return None
+    
+    def enhance_search_query(self, user_message: str, entities: Dict) -> str:
+        """
+        Use Gemini to extract better search keywords from user message
+        """
+        if not self.is_available():
+            return user_message
+        
+        prompt = f"""Extract the main search keywords from this event search query.
+User message: "{user_message}"
+Entities detected: {json.dumps(entities)}
+
+Return only the key search terms separated by spaces (no explanation, just the keywords):"""
+
+        try:
+            response = self.model.generate_content(prompt)
+            keywords = response.text.strip()
+            logger.info(f"Enhanced search query: {keywords}")
+            return keywords if keywords else user_message
+        except Exception as e:
+            logger.error(f"Query enhancement failed: {e}")
+            return user_message
+    
+    def get_contextual_response(self, intent: str) -> Optional[str]:
+        """
+        Get quick responses for simple intents without API call
+        """
+        quick_responses = {
+            'greeting': "Hi there! 👋 I'm CampVerseBot, your campus event assistant. I can help you discover hackathons, workshops, seminars, and more! What are you looking for today?",
+            'farewell': "Goodbye! 👋 Feel free to come back anytime you need help finding events. Have a great day!",
+            'thanks': "You're welcome! 😊 Let me know if there's anything else I can help you with!",
+        }
+        return quick_responses.get(intent)
+
+
+# Singleton instance
+_gemini_service = None
+
+def get_gemini_service() -> GeminiService:
+    """Get or create the singleton Gemini service instance"""
+    global _gemini_service
+    if _gemini_service is None:
+        _gemini_service = GeminiService()
+    return _gemini_service

requirements.txt

@@ -9,3 +9,4 @@ python-engineio==4.10.1
 python-socketio[client]==5.11.4
 requests==2.32.3
 scikit-learn==1.5.2
+google-generativeai==0.8.3