Update space

README.md

@@ -1,13 +1,18 @@
----
-title: Test
-emoji: 💬
-colorFrom: yellow
-colorTo: purple
-sdk: gradio
-sdk_version: 5.0.1
-app_file: app.py
-pinned: false
-short_description: Testimng
----
+# Brock University Events Assistant
 
-An example chatbot using [Gradio](https://gradio.app), [`huggingface_hub`](https://huggingface.co/docs/huggingface_hub/v0.22.2/en/index), and the [Hugging Face Inference API](https://huggingface.co/docs/api-inference/index).
+A chatbot that helps you discover events at Brock University. Built using:
+- Gradio for the interface
+- Sentence Transformers for semantic search
+- ChromaDB for vector storage
+- ExperienceBU's event feed for data
+
+## Features
+- Natural language queries about events
+- Real-time event information
+- Category-based searching
+- Date-based filtering
+
+## Example Questions
+- "What events are happening this week?"
+- "Are there any academic workshops?"
+- "Tell me about orientation events"

app.py

@@ -1,64 +1,259 @@
 import gradio as gr
-from huggingface_hub import InferenceClient
+from sentence_transformers import SentenceTransformer
+import chromadb
+import feedparser
+from bs4 import BeautifulSoup
+import requests
+from datetime import datetime
+from time import mktime
+from typing import List, Dict
+import os
 
-"""
-For more information on `huggingface_hub` Inference API support, please check the docs: https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
-"""
-client = InferenceClient("HuggingFaceH4/zephyr-7b-beta")
+class BrockEventsRAG:
+    def __init__(self):
+        self.model = SentenceTransformer('all-MiniLM-L6-v2')
+        # Use persistent storage for Hugging Face Spaces
+        self.chroma_client = chromadb.PersistentClient(path="./chroma_db")
+        
+        try:
+            self.collection = self.chroma_client.get_collection(name="brock_events")
+        except ValueError:
+            self.collection = self.chroma_client.create_collection(
+                name="brock_events",
+                metadata={"description": "Brock University Events Database"}
+            )
+        # Initialize the database on startup
+        self.update_database()
 
+            # [Previous methods remain the same as in the last artifact]
+    # fetch_events(), update_database(), query() methods are identical
+        def fetch_events(self) -> List[Dict]:
+        """Fetch events from ExperienceBU RSS feed"""
+        events = []
+        feed_url = "https://experiencebu.brocku.ca/events.rss"
+        
+        try:
+            feed = feedparser.parse(feed_url)
+            
+            # Check for feed errors
+            if hasattr(feed, 'bozo_exception'):
+                print(f"Warning: Feed might have issues: {feed.bozo_exception}")
+            
+            for entry in feed.entries:
+                # Extract categories and join them into a single string
+                categories = [tag.term for tag in entry.get('tags', [])]
+                categories_str = '; '.join(categories) if categories else 'No categories'
+                
+                event = {
+                    'title': entry.title,
+                    'description': BeautifulSoup(entry.description, 'html.parser').get_text(),
+                    'date': datetime.fromtimestamp(
+                        mktime(entry.published_parsed)
+                    ).strftime('%Y-%m-%d %H:%M'),
+                    'link': entry.link,
+                    'categories': categories_str  # Now a string instead of a list
+                }
+                
+                # Fetch additional details from the event page
+                try:
+                    response = requests.get(entry.link)
+                    if response.status_code == 200:
+                        soup = BeautifulSoup(response.text, 'html.parser')
+                        location_elem = soup.find('div', {'class': 'location'})
+                        if location_elem:
+                            event['location'] = location_elem.get_text().strip()
+                except Exception as e:
+                    print(f"Warning: Could not fetch details for {entry.link}: {e}")
+                
+                events.append(event)
+                
+        except Exception as e:
+            print(f"Error fetching events: {e}")
+            
+        return events
+    
+    def update_database(self):
+        """Update the vector database with current events"""
+        events = self.fetch_events()
+        
+        if not events:
+            print("Warning: No events fetched, database not updated")
+            return
+        
+        documents = []
+        metadata = []
+        ids = []
+        
+        for i, event in enumerate(events):
+            # Create rich text representation
+            doc_text = f"""
+            Event: {event['title']}
+            Date: {event['date']}
+            Location: {event.get('location', 'Location not specified')}
+            Description: {event['description']}
+            Categories: {event['categories']}
+            """
+            
+            # Ensure all metadata values are strings or simple types
+            metadata_entry = {
+                'title': str(event['title']),
+                'date': str(event['date']),
+                'link': str(event['link']),
+                'categories': str(event['categories'])  # Now safely a string
+            }
+            
+            documents.append(doc_text)
+            metadata.append(metadata_entry)
+            ids.append(f"event_{i}")
+        
+        try:
+            # Generate embeddings
+            embeddings = self.model.encode(documents)
+            
+            # First, try to delete existing entries if any
+            try:
+                self.collection.delete(ids=ids)
+            except Exception:
+                pass  # Ignore if no existing entries
+            
+            # Add new entries
+            self.collection.add(
+                documents=documents,
+                embeddings=embeddings.tolist(),
+                metadatas=metadata,
+                ids=ids
+            )
+            print(f"Successfully updated database with {len(documents)} events")
+            
+        except Exception as e:
+            print(f"Error updating database: {e}")
+            print("Metadata sample:", metadata[0] if metadata else "No metadata")
+    
+    def query(self, question: str, n_results: int = 3) -> Dict:
+        """Query the database with a natural language question"""
+        try:
+            question_embedding = self.model.encode(question)
+            
+            results = self.collection.query(
+                query_embeddings=[question_embedding.tolist()],
+                n_results=n_results,
+                include=['documents', 'metadatas', 'distances']
+            )
+            
+            return results
+        except Exception as e:
+            print(f"Error during query: {e}")
+            return {"documents": [[]], "metadatas": [[]], "distances": [[]]}
 
-def respond(
-    message,
-    history: list[tuple[str, str]],
-    system_message,
-    max_tokens,
-    temperature,
-    top_p,
-):
-    messages = [{"role": "system", "content": system_message}]
-
-    for val in history:
-        if val[0]:
-            messages.append({"role": "user", "content": val[0]})
-        if val[1]:
-            messages.append({"role": "assistant", "content": val[1]})
-
-    messages.append({"role": "user", "content": message})
-
-    response = ""
-
-    for message in client.chat_completion(
-        messages,
-        max_tokens=max_tokens,
-        stream=True,
-        temperature=temperature,
-        top_p=top_p,
-    ):
-        token = message.choices[0].delta.content
-
-        response += token
-        yield response
-
-
-"""
-For information on how to customize the ChatInterface, peruse the gradio docs: https://www.gradio.app/docs/chatinterface
-"""
-demo = gr.ChatInterface(
-    respond,
-    additional_inputs=[
-        gr.Textbox(value="You are a friendly Chatbot.", label="System message"),
-        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
-        gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
-        gr.Slider(
-            minimum=0.1,
-            maximum=1.0,
-            value=0.95,
-            step=0.05,
-            label="Top-p (nucleus sampling)",
-        ),
-    ],
-)
+   def get_chat_response(self, message: str, history: List[List[str]]) -> str:
+        """
+        Generate a response for the chat interface
+        """
+        try:
+            # Different response types based on message content
+            if "update" in message.lower() and "database" in message.lower():
+                self.update_database()
+                return "I've updated my knowledge of Brock University events!"
+                
+            elif any(word in message.lower() for word in ["hi", "hello", "hey"]):
+                return ("Hello! I can help you find information about Brock University events. "
+                       "You can ask me about specific events, dates, or topics you're interested in!")
+                
+            else:
+                # Query the database
+                results = self.query(message)
+                response = create_formatted_response(results)
+                
+                # If no relevant results, provide a helpful response
+                if "couldn't find any relevant events" in response:
+                    return ("I couldn't find any exactly matching events, but you can try:\n"
+                           "- Being more specific about what type of event you're looking for\n"
+                           "- Asking about a particular date or time period\n"
+                           "- Asking about specific categories (academic, social, workshops, etc.)")
+                return response
+                
+        except Exception as e:
+            return f"I encountered an error while processing your request. Please try again or rephrase your question. Error: {str(e)}"
 
+def create_demo():
+    """
+    Create the Gradio interface for the Brock Events chatbot
+    """
+    # Initialize the RAG system
+    rag_system = BrockEventsRAG()
+    
+    # Custom CSS for better appearance
+    custom_css = """
+    .gradio-container {max-width: 800px !important}
+    .chat-message {font-size: 16px !important}
+    """
+    
+    # Create the Gradio interface
+    with gr.Blocks(css=custom_css) as demo:
+        gr.Markdown("""
+        # 🎓 Brock University Events Assistant
+        
+        Welcome! I can help you discover events at Brock University. Ask me about:
+        - Upcoming events
+        - Events by category (academic, social, workshops)
+        - Events on specific dates
+        - Event details and locations
+        
+        *Data is sourced from ExperienceBU's events feed*
+        """)
+        
+        chatbot = gr.Chatbot(
+            label="Chat History",
+            height=400,
+            bubble_full_width=False
+        )
+        
+        with gr.Row():
+            msg = gr.Textbox(
+                label="Your Question",
+                placeholder="Ask about events at Brock University...",
+                scale=4
+            )
+            submit = gr.Button("Send", variant="primary", scale=1)
+        
+        # Clear chat button
+        clear = gr.Button("Clear Chat")
+        
+        # Example questions
+        gr.Examples(
+            examples=[
+                "What events are happening this week?",
+                "Are there any academic workshops coming up?",
+                "Tell me about orientation events",
+                "What events are happening in the library?",
+                "Are there any career-related events?"
+            ],
+            inputs=msg,
+            label="Example Questions"
+        )
+        
+        def respond(message, chat_history):
+            bot_message = rag_system.get_chat_response(message, chat_history)
+            chat_history.append((message, bot_message))
+            return "", chat_history
+        
+        # Set up event handlers
+        msg.submit(respond, [msg, chatbot], [msg, chatbot])
+        submit.click(respond, [msg, chatbot], [msg, chatbot])
+        clear.click(lambda: None, None, chatbot, queue=False)
+        
+        # Add footer with link to source
+        gr.Markdown("""
+        ---
+        *Built with ❤️ using Gradio and Sentence Transformers. 
+        [View source on GitHub](https://github.com/yourusername/brock-events-assistant)*
+        """)
+    
+    return demo
 
 if __name__ == "__main__":
+    demo = create_demo()
+    # For local testing
     demo.launch()
+    # For Hugging Face Spaces, uncomment:
+    # demo.launch(share=True)    

requirements.txt

@@ -1 +1,7 @@
-huggingface_hub==0.25.2
+huggingface_hub==0.25.2
+gradio>=4.0.0
+sentence-transformers
+chromadb
+feedparser
+beautifulsoup4
+requests