ADD ULTIMATE ALU BRAIN - 58 comprehensive entries covering ALL student needs: academics, career, health, safety, immigration, financial aid, clubs, events, resources, emergency procedures, mental health support, disability services, and much more

comprehensive_converter.py

@@ -0,0 +1,188 @@
+"""
+Comprehensive Knowledge Base Converter
+Converts the full ALU knowledge base to ALU Brain JSON format
+"""
+
+import json
+import re
+from pathlib import Path
+
+def parse_section(section_text, section_title):
+    """Parse a section and create multiple entries"""
+    entries = []
+    
+    # Split into subsections
+    subsections = re.split(r'\n###\s+', section_text)
+    
+    for subsection in subsections:
+        if not subsection.strip():
+            continue
+            
+        lines = subsection.split('\n')
+        subtitle = lines[0].strip() if lines else ""
+        content = '\n'.join(lines[1:]).strip()
+        
+        if not content:
+            continue
+        
+        # Create entry for this subsection
+        entry = {
+            "id": f"alu_kb_{len(entries)}_{subtitle.lower().replace(' ', '_')[:30]}",
+            "question": f"{section_title}: {subtitle}" if subtitle else section_title,
+            "answer": content,
+            "type": "text",
+            "keywords": extract_keywords(section_title + " " + subtitle + " " + content),
+            "category": categorize_section(section_title),
+            "source": "ALU Comprehensive Knowledge Base"
+        }
+        entries.append(entry)
+    
+    return entries
+
+def extract_keywords(text):
+    """Extract relevant keywords from text"""
+    # Common words to exclude
+    stopwords = {'the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for', 'of', 'with', 'by', 'from', 'as', 'is', 'are', 'was', 'were', 'be', 'been', 'being', 'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would', 'should', 'could', 'may', 'might', 'must', 'can', 'this', 'that', 'these', 'those', 'i', 'you', 'he', 'she', 'it', 'we', 'they', 'what', 'which', 'who', 'when', 'where', 'why', 'how', 'all', 'each', 'every', 'both', 'few', 'more', 'most', 'other', 'some', 'such', 'no', 'nor', 'not', 'only', 'own', 'same', 'so', 'than', 'too', 'very'}
+    
+    # Extract words
+    words = re.findall(r'\b[a-z]{3,}\b', text.lower())
+    
+    # Filter and get unique keywords
+    keywords = list(set([w for w in words if w not in stopwords]))[:15]  # Limit to 15 keywords
+    
+    return keywords
+
+def categorize_section(title):
+    """Categorize section based on title"""
+    title_lower = title.lower()
+    
+    if any(word in title_lower for word in ['calendar', 'academic', 'term', 'schedule']):
+        return "Academic Calendar"
+    elif any(word in title_lower for word in ['spd', 'internship', 'career', 'job', 'placement']):
+        return "Career Services"
+    elif any(word in title_lower for word in ['immigration', 'visa', 'permit']):
+        return "Immigration Support"
+    elif any(word in title_lower for word in ['insurance', 'medical', 'health', 'eden care']):
+        return "Health & Wellness"
+    elif any(word in title_lower for word in ['student life', 'club', 'residential', 'housing']):
+        return "Campus Life"
+    elif any(word in title_lower for word in ['program', 'bel', 'degree', 'module', 'course']):
+        return "Academic Programs"
+    elif any(word in title_lower for word in ['policy', 'conduct', 'disciplinary', 'code']):
+        return "Policies & Conduct"
+    elif any(word in title_lower for word in ['event', 'student-led']):
+        return "Student Events"
+    elif any(word in title_lower for word in ['faq', 'question', 'frequently']):
+        return "FAQs"
+    else:
+        return "General Information"
+
+def convert_comprehensive_kb():
+    """Main conversion function"""
+    
+    print("=" * 70)
+    print("🧠 COMPREHENSIVE KNOWLEDGE BASE CONVERTER")
+    print("=" * 70)
+    print()
+    
+    # Read the comprehensive KB
+    kb_file = Path("data/alu_knowledge/alu_ultimate_knowledge_base.txt")
+    
+    if not kb_file.exists():
+        print(f"❌ Knowledge base file not found: {kb_file}")
+        return False
+    
+    print(f"📖 Reading knowledge base from: {kb_file}")
+    with open(kb_file, 'r', encoding='utf-8') as f:
+        content = f.read()
+    
+    print(f"✅ Loaded {len(content)} characters")
+    print()
+    
+    # Split by major sections (## headers)
+    sections = re.split(r'\n##\s+', content)
+    
+    all_entries = []
+    entry_id = 1
+    
+    print("🔄 Processing sections...")
+    for i, section in enumerate(sections[1:], 1):  # Skip first empty section
+        if not section.strip():
+            continue
+        
+        lines = section.split('\n')
+        section_title = lines[0].strip()
+        section_content = '\n'.join(lines[1:])
+        
+        print(f"  {i}. Processing: {section_title[:50]}...")
+        
+        # Parse this section
+        section_entries = parse_section(section_content, section_title)
+        
+        # Add unique IDs
+        for entry in section_entries:
+            entry['id'] = f"alu_kb_{entry_id:04d}"
+            entry_id += 1
+        
+        all_entries.extend(section_entries)
+    
+    print()
+    print(f"✅ Created {len(all_entries)} knowledge base entries")
+    print()
+    
+    # Create the brain JSON structure
+    brain_data = {
+        "category": "comprehensive_knowledge",
+        "description": "Complete ALU Knowledge Base - Academic Calendar, SPD Hub, Immigration, Programs, Policies, and More",
+        "version": "2.0",
+        "last_updated": "2024-11-20",
+        "total_entries": len(all_entries),
+        "entries": all_entries
+    }
+    
+    # Save to alu_brain directory
+    output_file = Path("alu_brain/comprehensive_knowledge.json")
+    print(f"💾 Saving to: {output_file}")
+    
+    with open(output_file, 'w', encoding='utf-8') as f:
+        json.dump(brain_data, f, indent=2, ensure_ascii=False)
+    
+    print(f"✅ Successfully saved {len(all_entries)} entries")
+    print()
+    
+    # Show statistics
+    categories = {}
+    for entry in all_entries:
+        cat = entry['category']
+        categories[cat] = categories.get(cat, 0) + 1
+    
+    print("📊 Entries by Category:")
+    for cat, count in sorted(categories.items(), key=lambda x: x[1], reverse=True):
+        print(f"  • {cat}: {count} entries")
+    
+    print()
+    print("=" * 70)
+    print("✅ CONVERSION COMPLETE!")
+    print("=" * 70)
+    print()
+    print("📝 Sample entries:")
+    for entry in all_entries[:5]:
+        print(f"  • {entry['question'][:60]}...")
+    
+    print()
+    print("🚀 Next steps:")
+    print("  1. Review the generated JSON file")
+    print("  2. Commit and push to Hugging Face")
+    print("  3. Restart the Space")
+    print("  4. Test with questions like:")
+    print("     - 'How to create a club at ALU?'")
+    print("     - 'Who founded ALU?'")
+    print("     - 'When is the next term?'")
+    print()
+    
+    return True
+
+if __name__ == "__main__":
+    convert_comprehensive_kb()
+
+

convert_comprehensive_kb.py

@@ -0,0 +1,137 @@
+"""
+Convert comprehensive knowledge base TXT to ALU Brain JSON format
+This will make your knowledge base actually usable by the chatbot!
+"""
+
+import json
+from pathlib import Path
+import re
+
+def parse_comprehensive_kb():
+    """Parse the comprehensive knowledge base text file"""
+    
+    kb_file = Path("data/alu_knowledge/alu_ultimate_knowledge_base.txt")
+    
+    if not kb_file.exists():
+        print(f"❌ Knowledge base file not found: {kb_file}")
+        return None
+    
+    with open(kb_file, 'r', encoding='utf-8') as f:
+        content = f.read()
+    
+    # Split by major sections (## headers)
+    sections = re.split(r'\n##\s+', content)
+    
+    entries = []
+    entry_id = 1
+    
+    for section in sections:
+        if not section.strip():
+            continue
+            
+        lines = section.split('\n')
+        title = lines[0].strip()
+        
+        # Get the content
+        content_lines = []
+        current_subsection = ""
+        
+        for line in lines[1:]:
+            if line.strip():
+                if line.startswith('###'):  # Subsection
+                    current_subsection = line.replace('###', '').strip()
+                elif line.startswith('-') or line.startswith('*'):  # List item
+                    content_lines.append(line.strip())
+                else:
+                    content_lines.append(line.strip())
+        
+        full_content = '\n'.join(content_lines)
+        
+        # Create entry
+        entry = {
+            "id": f"comprehensive_kb_{entry_id}",
+            "question": f"Tell me about {title}",
+            "answer": full_content,
+            "type": "text",
+            "keywords": [word.lower() for word in title.split() if len(word) > 3],
+            "category": "Comprehensive Knowledge Base",
+            "source": "ALU Comprehensive KB"
+        }
+        
+        entries.append(entry)
+        entry_id += 1
+        
+        # Also create entries for common questions
+        if "club" in title.lower():
+            entries.append({
+                "id": f"comprehensive_kb_{entry_id}",
+                "question": "How to create a club at ALU?",
+                "answer": full_content,
+                "type": "text",
+                "keywords": ["club", "create", "start", "society", "organization"],
+                "category": "Campus Life",
+                "source": "ALU Comprehensive KB"
+            })
+            entry_id += 1
+        
+        if "founder" in title.lower() or "leadership" in title.lower():
+            entries.append({
+                "id": f"comprehensive_kb_{entry_id}",
+                "question": "Who founded ALU?",
+                "answer": full_content,
+                "type": "text",
+                "keywords": ["founder", "fred", "swaniker", "leadership", "history"],
+                "category": "About ALU",
+                "source": "ALU Comprehensive KB"
+            })
+            entry_id += 1
+    
+    return entries
+
+def create_brain_json():
+    """Create the ALU Brain JSON file"""
+    
+    print("============================================================")
+    print("🧠 CONVERTING COMPREHENSIVE KB TO ALU BRAIN FORMAT")
+    print("============================================================\n")
+    
+    entries = parse_comprehensive_kb()
+    
+    if not entries:
+        print("❌ No entries created")
+        return False
+    
+    # Create the brain JSON structure
+    brain_data = {
+        "category": "comprehensive_knowledge",
+        "description": "Comprehensive ALU Knowledge Base - All ALU information",
+        "version": "1.0",
+        "last_updated": "2024-11-20",
+        "entries": entries
+    }
+    
+    # Save to alu_brain directory
+    output_file = Path("alu_brain/comprehensive_knowledge.json")
+    with open(output_file, 'w', encoding='utf-8') as f:
+        json.dump(brain_data, f, indent=2, ensure_ascii=False)
+    
+    print(f"✅ Created {len(entries)} entries")
+    print(f"📁 Saved to: {output_file}")
+    print(f"\n📝 Sample entries:")
+    for entry in entries[:3]:
+        print(f"  - {entry['question']}")
+    
+    print("\n============================================================")
+    print("✅ CONVERSION COMPLETE!")
+    print("============================================================")
+    print("\nNext steps:")
+    print("1. Commit and push this file to Hugging Face")
+    print("2. Restart the Space")
+    print("3. The chatbot will now use your comprehensive knowledge!")
+    
+    return True
+
+if __name__ == "__main__":
+    create_brain_json()
+
+

convert_kb_to_brain.py

@@ -0,0 +1,53 @@
+"""
+Convert comprehensive knowledge base to ALU Brain JSON format
+"""
+
+import json
+from pathlib import Path
+
+def convert_kb_to_brain_format():
+    """Convert the comprehensive KB into ALU Brain JSON entries"""
+    
+    # Read the comprehensive knowledge base
+    kb_file = Path("data/alu_knowledge/alu_ultimate_knowledge_base.txt")
+    
+    if not kb_file.exists():
+        print(f"❌ Knowledge base file not found: {kb_file}")
+        return
+    
+    with open(kb_file, 'r', encoding='utf-8') as f:
+        kb_text = f.read()
+    
+    # Split into sections
+    sections = kb_text.split('\n## ')
+    
+    brain_entries = []
+    
+    for section in sections[1:]:  # Skip first empty section
+        lines = section.split('\n')
+        title = lines[0].strip()
+        content = '\n'.join(lines[1:]).strip()
+        
+        # Create brain entry
+        entry = {
+            "question": f"Tell me about {title}",
+            "answer": content[:500] + "..." if len(content) > 500 else content,  # Limit length
+            "type": "text",
+            "category": "comprehensive_kb",
+            "keywords": title.lower().split()
+        }
+        
+        brain_entries.append(entry)
+    
+    # Save to new JSON file
+    output_file = Path("alu_brain/comprehensive_kb.json")
+    with open(output_file, 'w', encoding='utf-8') as f:
+        json.dump(brain_entries, f, indent=2)
+    
+    print(f"✅ Created {len(brain_entries)} entries in {output_file}")
+    print(f"📝 Sample entry: {brain_entries[0]['question']}")
+
+if __name__ == "__main__":
+    convert_kb_to_brain_format()
+
+

ersNgumDownloadsalu-chatbot

@@ -0,0 +1,220 @@
+diff --git a/app.py b/app.py
+index 58d2706..20c00eb 100644
+--- a/app.py
++++ b/app.py
+@@ -1,52 +1,173 @@
+ import os
+ import sys
++from pathlib import Path
++from fastapi import FastAPI, HTTPException
++from fastapi.staticfiles import StaticFiles
++from fastapi.responses import FileResponse, JSONResponse
++from fastapi.middleware.cors import CORSMiddleware
+ 
+-# Set environment variables for Hugging Face
+-os.environ["TRANSFORMERS_CACHE"] = "/tmp/model_cache"
+-os.environ["HF_HOME"] = "/tmp/model_cache"
+-os.environ["SENTENCE_TRANSFORMERS_HOME"] = "/tmp/model_cache"
+-os.environ["PYTHONUNBUFFERED"] = "1"
+-
+-# Print startup diagnostic info
++print("=" * 60)
+ print("=== STARTUP: Beginning application initialization ===")
+-print(f"=== STARTUP: PORT environment variable: {os.environ.get('PORT')} ===")
++print("=" * 60)
+ 
+-# First import just the app from main
+-from main import app
++# Add current directory to Python path so imports work
++current_path = os.path.dirname(__file__)
++if current_path not in sys.path:
++    sys.path.insert(0, current_path)
+ 
+-# THEN import other components
+-from main import conversation_memory
+-from data_integration.alu_api_connector import ALUDataConnector
+-from analytics.conversation_analytics import ConversationAnalytics
++# Ensure required directories exist
++os.makedirs("build/static", exist_ok=True)
++os.makedirs("build/assets", exist_ok=True)
+ 
+-@app.get("/api/alu-events")
+-async def get_alu_events(campus: str = "all", days: int = 7):
+-    """Get upcoming events at ALU"""
++# Load comprehensive knowledge base on startup
++def load_comprehensive_knowledge_base():
++    """Load the comprehensive ALU knowledge base into vector store"""
+     try:
+-        alu_connector = ALUDataConnector()
+-        events = alu_connector.get_upcoming_events(campus, days)
+-        return {"events": events}
++        print("\n🎓 Loading comprehensive ALU knowledge base...")
++        from retrieval_engine import RetrievalEngine
++        
++        # Check for knowledge base files
++        kb_paths = [
++            Path("data/alu_knowledge"),
++            Path("backend/data/alu_knowledge"),
++            Path("/data/alu_knowledge")
++        ]
++        
++        kb_dir = None
++        for path in kb_paths:
++            if path.exists():
++                kb_dir = path
++                break
++        
++        if not kb_dir:
++            print("⚠️  Knowledge base directory not found. Using default ALU Brain.")
++            return False
++        
++        # Find knowledge base file
++        kb_files = [
++            "alu_ultimate_knowledge_base.txt",
++            "alu_knowledge_base.txt"
++        ]
++        
++        kb_file = None
++        for filename in kb_files:
++            file_path = kb_dir / filename
++            if file_path.exists():
++                kb_file = file_path
++                break
++        
++        if not kb_file:
++            print("⚠️  Knowledge base file not found. Using default ALU Brain.")
++            return False
++        
++        print(f"📄 Found knowledge base: {kb_file.name}")
++        
++        # Load and process
++        with open(kb_file, 'r', encoding='utf-8') as f:
++            kb_text = f.read()
++        
++        print(f"✅ Loaded {len(kb_text):,} characters")
++        
++        # Initialize retrieval engine
++        retrieval_engine = RetrievalEngine()
++        
++        # Chunk text
++        chunks = retrieval_engine._chunk_text(kb_text, chunk_size=800, chunk_overlap=100)
++        print(f"✅ Created {len(chunks)} chunks")
++        
++        # Add to vector store
++        print("📥 Adding to vector store...")
++        for i, chunk in enumerate(chunks):
++            chunk_id = f"alu_comprehensive_kb_{i}"
++            metadata = {
++                "source": "ALU Comprehensive Knowledge Base 2024",
++                "chunk_id": i,
++                "type": "comprehensive_kb"
++            }
++            
++            try:
++                retrieval_engine.collection.add(
++                    ids=[chunk_id],
++                    documents=[chunk],
++                    metadatas=[metadata]
++                )
++            except Exception as e:
++                if i == 0:  # Only print error for first chunk
++                    print(f"⚠️  Note: {e}")
++        
++        print(f"✅ Comprehensive knowledge base loaded! ({len(chunks)} chunks)")
++        return True
++        
+     except Exception as e:
+-        print(f"Error fetching ALU events: {e}")
+-        return {"events": [], "error": "Could not fetch events"}
++        print(f"⚠️  Error loading comprehensive KB: {e}")
++        return False
++
++# Load knowledge base (commented out to prevent startup timeout)
++# Uncomment this line once the Space is stable:
++# load_comprehensive_knowledge_base()
++print("⚠️  Comprehensive KB loading disabled to prevent timeout")
++print("💡 The chatbot will use the existing ALU Brain knowledge base")
+ 
+-@app.get("/api/analytics/dashboard")
+-async def get_analytics_dashboard():
+-    """Get analytics dashboard data"""
++# Import your backend app (using minimal version to avoid model loading issues)
++print("\n📦 Importing minimal backend application...")
++try:
++    from minimal_app import app as backend_app
++    print("✅ Minimal backend application imported (no ML models required)")
++except ImportError:
++    print("⚠️  Minimal backend not found, trying lightweight...")
+     try:
+-        if not conversation_memory:
+-            return {"error": "Conversation memory not initialized"}
+-            
+-        analytics = ConversationAnalytics(conversation_memory)
+-        dashboard_data = analytics.generate_dashboard_data()
+-        return dashboard_data
+-    except Exception as e:
+-        print(f"Error generating analytics dashboard: {e}")
+-        return {"error": f"Could not generate analytics: {str(e)}"}
+-
+-# This is needed for Hugging Face Spaces
+-if __name__ == "__main__":
+-    import uvicorn
+-    port = int(os.environ.get("PORT", 7860))  # Hugging Face uses port 7860
+-    print(f"Starting server on port {port}")
+-    uvicorn.run(app, host="0.0.0.0", port=port)
+
++        from main_lightweight import app as backend_app
++        print("✅ Lightweight backend application imported")
++    except ImportError:
++        print("⚠️  Using main backend...")
++        from main import app as backend_app
++        print("✅ Main backend application imported")
++
++app = FastAPI()
++
++# Configure CORS - copy settings from your backend
++allowed_origins = os.getenv("CORS_ALLOWED_ORIGINS", "http://localhost:3000,http://localhost:3001").split(",")
++app.add_middleware(
++    CORSMiddleware,
++    allow_origins=["*"],  # Allow all origins when serving from same domain
++    allow_credentials=True,
++    allow_methods=["*"],
++    allow_headers=["*"],
++)
++
++# Serve static files from React build
++app.mount("/static", StaticFiles(directory="build/static"), name="static")
++app.mount("/assets", StaticFiles(directory="build/assets", check_dir=False), name="assets")
++
++# Mount your backend API - all backend routes will be served under /api
++# IMPORTANT: Mount this AFTER static files but BEFORE catch-all route
++app.mount("/api", backend_app)
++
++# Root endpoint - return JSON instead of trying to serve files
++@app.get("/")
++async def root():
++    return {
++        "status": "running",
++        "message": "ALU Student Companion API",
++        "api_endpoints": {
++            "health": "/health",
++            "chat": "/api/chat",
++            "docs": "/docs"
++        }
++    }
++
++# Health check endpoint
++@app.get("/health")
++async def health():
++    return {"status": "healthy", "api": True, "backend": True}
++
++# Serve React app for specific paths only (not catch-all)
++@app.get("/static/{full_path:path}")
++async def serve_static(full_path: str):
++    file_path = f"build/static/{full_path}"
++    if os.path.exists(file_path):
++        return FileResponse(file_path)
++    return JSONResponse(
++        content={"error": "File not found"},
++        status_code=404
++    )