Upload folder using huggingface_hub

.gitignore

@@ -0,0 +1,113 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+tabs/__pycache__/
+.gradio
+
+# Virtual Environment
+.venv/
+.env/
+venv/
+ENV/
+env/
+.venv
+myenv/
+gradio/
+
+# Environment Variables
+.env
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# macOS
+.DS_Store
+.AppleDouble
+.LSOverride
+
+# Windows
+Thumbs.db
+ehthumbs.db
+Desktop.ini
+
+# Jupyter Notebooks
+.ipynb_checkpoints
+
+# AI/ML specific
+chroma_db/
+chromadb/
+*.db
+*.sqlite
+*.sqlite3
+
+# Document storage
+documents/
+uploaded_documents/
+temp_documents/
+
+# Query results and cache
+query_results/
+.cache/
+.streamlit/
+
+# Model downloads and cache
+models/
+.transformers_cache/
+.huggingface/
+sentence_transformers_cache/
+
+# Logs
+*.log
+logs/
+.logs/
+
+# Temporary files
+tmp/
+temp/
+.tmp/
+
+# Coverage reports
+htmlcov/
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+.pytest_cache/
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json

README.md

@@ -1,12 +1,15 @@
 ---
-title: TopEdu Demo
-emoji: 📉
-colorFrom: indigo
-colorTo: gray
+title: TopEdu_Demo
+emoji: 🎓
+colorFrom: blue
+colorTo: green
 sdk: gradio
-sdk_version: 5.42.0
-app_file: app.py
+python_version: 3.11
+sdk_version: "5.42.0"
+app_file: app_gradio.py
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# TopEdu Gradio App
+
+This is a demo of the TopEdu application.

app_gradio.py

@@ -0,0 +1,137 @@
+"""
+PANSEA University Requirements Assistant - Gradio Version (Modular)
+A comprehensive tool for navigating university admission requirements across Southeast Asia.
+"""
+import gradio as gr
+import os
+import sys
+from datetime import datetime
+
+# Add the current directory to Python path for imports
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+
+# Import our RAG system
+from utils.rag_system import DocumentIngestion, RAGSystem
+
+# Import modular tab components
+from tabs.initialize import create_initialize_tab
+from tabs.upload import create_upload_tab
+from tabs.query import create_query_tab
+from tabs.manage import create_manage_tab
+from tabs.help import create_help_tab
+
+def create_interface():
+    """Create the main Gradio interface using modular components"""
+    
+    # Global state management - shared across all tabs
+    global_vars = {
+        'doc_ingestion': None,
+        'rag_system': None,
+        'vectorstore': None
+    }
+    
+    # Custom CSS for better styling
+    custom_css = """
+    .gradio-container {
+        font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+    }
+    .tab-nav button {
+        font-weight: 500;
+        font-size: 14px;
+    }
+    .tab-nav button[aria-selected="true"] {
+        background: linear-gradient(45deg, #1e3a8a, #3b82f6);
+        color: white;
+    }
+    .feedback-box {
+        background: #f8fafc;
+        border: 1px solid #e2e8f0;
+        border-radius: 8px;
+        padding: 16px;
+        margin: 8px 0;
+    }
+    .success-message {
+        background: #dcfce7;
+        color: #166534;
+        border: 1px solid #bbf7d0;
+        padding: 12px;
+        border-radius: 6px;
+        margin: 8px 0;
+    }
+    .error-message {
+        background: #fef2f2;
+        color: #dc2626;
+        border: 1px solid #fecaca;
+        padding: 12px;
+        border-radius: 6px;
+        margin: 8px 0;
+    }
+    """
+    
+    # Create the main interface
+    with gr.Blocks(
+        title="🌏 PANSEA University Assistant",
+        theme=gr.themes.Soft(
+            primary_hue="blue",
+            secondary_hue="slate"
+        ),
+        css=custom_css,
+        analytics_enabled=False
+    ) as interface:
+        
+        # Header
+        gr.Markdown("""
+        # 🌏 TopEdu
+        
+        **Navigate University Admission Requirements Across Southeast Asia with AI-Powered Assistance**
+        
+        Upload university documents, ask questions, and get intelligent answers about admission requirements,
+        programs, deadlines, and more across Southeast Asian universities.
+        
+        ---
+        """)
+        
+        # Main tabs using modular components
+        with gr.Tabs():
+            create_initialize_tab(global_vars)
+            create_upload_tab(global_vars)
+            create_query_tab(global_vars)
+            create_manage_tab(global_vars)
+            create_help_tab(global_vars)
+        
+        # Footer
+        gr.Markdown(f"""
+        ---
+        
+        **🔧 System Status**: Ready | **📅 Session**: {datetime.now().strftime('%Y-%m-%d %H:%M')} | **🔄 Version**: Modular Gradio
+        
+        💡 **Tip**: Start by initializing the system, then upload your university documents, and begin querying!
+        """)
+    
+    return interface
+
+def main():
+    """Launch the application"""
+    interface = create_interface()
+    
+    # Launch configuration
+    interface.launch(
+        share=False,           # Set to True for public sharing
+        server_name="0.0.0.0", # Allow external connections
+        server_port=7860,      # Default Gradio port
+        show_api=False,        # Hide API documentation
+        show_error=True,       # Show detailed error messages
+        quiet=False,           # Show startup messages
+        favicon_path=None,     # Could add custom favicon
+        app_kwargs={
+            "docs_url": None,  # Disable FastAPI docs
+            "redoc_url": None  # Disable ReDoc docs
+        }
+    )
+
+if __name__ == "__main__":
+    print("🚀 Starting PANSEA University Requirements Assistant...")
+    print("📍 Access the application at: http://localhost:7860")
+    print("🔗 For public sharing, set share=True in the launch() method")
+    print("-" * 60)
+    main()

requirements.txt

@@ -0,0 +1,155 @@
+aiofiles==24.1.0
+aiohappyeyeballs==2.6.1
+aiohttp==3.12.15
+aiosignal==1.4.0
+altair==5.5.0
+annotated-types==0.7.0
+anyio==4.10.0
+attrs==25.3.0
+backoff==2.2.1
+bcrypt==4.3.0
+blinker==1.9.0
+Brotli==1.1.0
+build==1.3.0
+cachetools==5.5.2
+certifi==2025.8.3
+charset-normalizer==3.4.3
+chromadb==1.0.16
+click==8.2.1
+coloredlogs==15.0.1
+dataclasses-json==0.6.7
+distro==1.9.0
+durationpy==0.10
+fastapi==0.116.1
+ffmpy==0.6.1
+filelock==3.18.0
+flatbuffers==25.2.10
+frozenlist==1.7.0
+fsspec==2025.7.0
+gitdb==4.0.12
+GitPython==3.1.45
+google-auth==2.40.3
+googleapis-common-protos==1.70.0
+gradio==5.42.0
+gradio_client==1.11.1
+groovy==0.1.2
+grpcio==1.74.0
+h11==0.16.0
+hf-xet==1.1.7
+httpcore==1.0.9
+httptools==0.6.4
+httpx==0.28.1
+httpx-sse==0.4.1
+huggingface-hub==0.34.4
+humanfriendly==10.0
+idna==3.10
+importlib_metadata==8.7.0
+importlib_resources==6.5.2
+Jinja2==3.1.6
+jiter==0.10.0
+joblib==1.5.1
+jsonpatch==1.33
+jsonpointer==3.0.0
+jsonschema==4.25.0
+jsonschema-specifications==2025.4.1
+kubernetes==33.1.0
+langchain==0.3.27
+langchain-community==0.3.27
+langchain-core==0.3.74
+langchain-openai==0.3.29
+langchain-text-splitters==0.3.9
+langsmith==0.4.13
+markdown-it-py==4.0.0
+MarkupSafe==3.0.2
+marshmallow==3.26.1
+mdurl==0.1.2
+mmh3==5.2.0
+mpmath==1.3.0
+multidict==6.6.4
+mypy_extensions==1.1.0
+narwhals==2.1.0
+networkx==3.5
+numpy==2.3.2
+oauthlib==3.3.1
+onnxruntime==1.22.1
+openai==1.99.9
+opentelemetry-api==1.36.0
+opentelemetry-exporter-otlp-proto-common==1.36.0
+opentelemetry-exporter-otlp-proto-grpc==1.36.0
+opentelemetry-proto==1.36.0
+opentelemetry-sdk==1.36.0
+opentelemetry-semantic-conventions==0.57b0
+orjson==3.11.1
+overrides==7.7.0
+packaging==25.0
+pandas==2.3.1
+pillow==11.3.0
+posthog==5.4.0
+propcache==0.3.2
+protobuf==6.31.1
+pyarrow==21.0.0
+pyasn1==0.6.1
+pyasn1_modules==0.4.2
+pybase64==1.4.2
+pycryptodome==3.23.0
+pydantic==2.11.7
+pydantic-settings==2.10.1
+pydantic_core==2.33.2
+pydeck==0.9.1
+pydub==0.25.1
+Pygments==2.19.2
+PyPDF2==3.0.1
+PyPika==0.48.9
+pyproject_hooks==1.2.0
+python-dateutil==2.9.0.post0
+python-dotenv==1.1.1
+python-multipart==0.0.20
+pytz==2025.2
+PyYAML==6.0.2
+referencing==0.36.2
+regex==2025.7.34
+requests==2.32.4
+requests-oauthlib==2.0.0
+requests-toolbelt==1.0.0
+rich==14.1.0
+rpds-py==0.27.0
+rsa==4.9.1
+ruff==0.12.8
+safehttpx==0.1.6
+safetensors==0.6.2
+scikit-learn==1.7.1
+scipy==1.16.1
+semantic-version==2.10.0
+sentence-transformers==5.1.0
+shellingham==1.5.4
+six==1.17.0
+smmap==5.0.2
+sniffio==1.3.1
+SQLAlchemy==2.0.43
+starlette==0.47.2
+streamlit==1.48.0
+sympy==1.14.0
+tenacity==9.1.2
+threadpoolctl==3.6.0
+tiktoken==0.11.0
+tokenizers==0.21.4
+toml==0.10.2
+tomlkit==0.13.3
+torch==2.8.0
+tornado==6.5.2
+tqdm==4.67.1
+transformers==4.55.0
+typer==0.16.0
+typing-inspect==0.9.0
+typing-inspection==0.4.1
+typing_extensions==4.14.1
+tzdata==2025.2
+urllib3==2.5.0
+uvicorn==0.35.0
+uvloop==0.21.0
+watchfiles==1.1.0
+websocket-client==1.8.0
+websockets==15.0.1
+yarl==1.20.1
+zipp==3.23.0
+zstandard==0.23.0

runtime.txt

@@ -0,0 +1 @@
+python-3.11

sample_documents/sample_university_requirements.txt

@@ -0,0 +1,177 @@
+# Sample University Admission Requirements
+
+## National University of Singapore (NUS) - Computer Science Master's Program
+
+### Program Overview
+The Master of Computing (Computer Science) program at NUS is a comprehensive graduate program designed for students seeking advanced knowledge in computer science.
+
+### Admission Requirements
+
+#### Academic Requirements
+- Bachelor's degree in Computer Science, Computer Engineering, or related field
+- Minimum GPA of 3.5/4.0 or equivalent (Second Class Upper Honours)
+- Strong background in mathematics and programming
+
+#### English Proficiency Requirements
+For international students whose native language is not English:
+- IELTS: Minimum overall score of 6.5 (no band less than 6.0)
+- TOEFL iBT: Minimum score of 85 (writing minimum 22)
+- PTE Academic: Minimum score of 65
+
+#### Additional Requirements
+- Statement of Purpose (500-1000 words)
+- Two letters of recommendation from academic or professional referees
+- Resume/CV highlighting relevant experience
+- Portfolio of programming projects (preferred)
+
+### Tuition Fees (2024-2025 Academic Year)
+- Singapore Citizens: S$12,500 per year
+- Singapore Permanent Residents: S$17,500 per year
+- International Students: S$25,000 per year
+
+### Application Deadlines
+- **Priority Round**: November 15, 2024
+- **Regular Round**: January 31, 2025
+- **Late Round**: March 15, 2025 (subject to availability)
+
+### Application Process
+1. Submit online application through NUS Graduate School portal
+2. Upload required documents
+3. Pay application fee of S$50
+4. Submit by deadline
+5. Attend interview if shortlisted (February-April)
+6. Admission results: April-May
+
+### Program Duration
+- Full-time: 1.5 years (3 semesters)
+- Part-time: 2.5 years (5 semesters)
+
+### Financial Aid
+- NUS Graduate Research Scholarship available for qualifying students
+- Teaching assistantships for outstanding applicants
+- Industry sponsorship opportunities
+
+### Contact Information
+- Email: gradsch@nus.edu.sg
+- Phone: +65 6516 2492
+- Website: www.nus.edu.sg/graduateschool
+
+---
+
+## University of Malaya (UM) - Engineering Master's Programs
+
+### Program Overview
+The Faculty of Engineering offers various Master's degree programs in engineering disciplines.
+
+### Admission Requirements
+
+#### Academic Requirements
+- Bachelor's degree in Engineering or related field with minimum CGPA of 3.0/4.0
+- For applicants with CGPA below 3.0, relevant work experience of at least 2 years required
+
+#### English Proficiency Requirements
+For international students:
+- IELTS: Minimum overall score of 6.0 (no band less than 5.5)
+- TOEFL iBT: Minimum score of 80
+- MUET (Malaysian University English Test): Band 4 minimum
+
+#### Program-Specific Requirements
+- **Civil Engineering**: AutoCAD proficiency preferred
+- **Electrical Engineering**: Basic knowledge of circuit analysis
+- **Mechanical Engineering**: Thermodynamics and fluid mechanics background
+
+### Tuition Fees (2024 Academic Year)
+- Malaysian Citizens: RM 8,000 per year
+- International Students: RM 15,000 per year
+- ASEAN Students: RM 12,000 per year (special rate)
+
+### Application Deadlines
+- **Main Intake (September)**: April 30, 2024
+- **Second Intake (February)**: October 31, 2024
+
+### Scholarships Available
+- UM Graduate Merit Scholarship (50% tuition fee waiver)
+- ASEAN Scholarship Program
+- Industry-sponsored scholarships
+
+### Living Costs (Estimated per month)
+- Accommodation: RM 500-800
+- Food: RM 400-600
+- Transportation: RM 100-200
+- Other expenses: RM 200-300
+- **Total: RM 1,200-1,900 per month**
+
+### Application Requirements
+1. Completed application form
+2. Academic transcripts
+3. Bachelor's degree certificate
+4. English proficiency test results
+5. Two reference letters
+6. Research proposal (for research-based programs)
+7. Passport copy
+8. Passport-sized photographs
+
+### Contact Information
+- Email: admission@um.edu.my
+- Phone: +603 7967 3026
+- Address: Faculty of Engineering, University of Malaya, 50603 Kuala Lumpur, Malaysia
+
+---
+
+## Chulalongkorn University - Business Administration Master's (MBA)
+
+### Program Overview
+The Chulalongkorn Business School MBA program is Thailand's premier business education program.
+
+### Admission Requirements
+
+#### Academic Requirements
+- Bachelor's degree from accredited institution
+- Minimum GPA of 2.75/4.0 or equivalent
+- GMAT score of 500+ (preferred) or GRE equivalent
+- Minimum 2 years of work experience
+
+#### English Proficiency Requirements
+- TOEFL iBT: Minimum score of 79
+- IELTS: Minimum overall score of 6.5
+- CU-TEP: Minimum score of 80
+
+### Tuition Fees (2024-2025)
+- Full-time MBA: 850,000 THB (approx. USD 25,000) total program
+- Executive MBA: 1,200,000 THB (approx. USD 35,000) total program
+
+### Application Deadlines
+- **Early Admission**: February 15, 2024
+- **Regular Admission**: April 30, 2024
+- **Final Round**: June 15, 2024
+
+### Program Duration
+- Full-time MBA: 16 months
+- Executive MBA: 18 months (weekend classes)
+
+### Scholarships
+- Merit-based scholarships up to 50% tuition
+- Corporate sponsorship opportunities
+- Government scholarships for ASEAN students
+
+### Application Process
+1. Online application submission
+2. Submit required documents
+3. GMAT/GRE scores
+4. Personal interview
+5. Group discussion assessment
+
+### Career Support
+- Career counseling services
+- Industry networking events
+- Internship placement assistance
+- Alumni network access
+
+### Contact Information
+- Email: mba@cbs.chula.ac.th
+- Phone: +66 2 218 6601
+- Website: www.cbs.chula.ac.th
+
+---
+
+*This document contains sample admission information for demonstration purposes. Please verify all details with the respective universities before applying.*

semantic_chunking.py

@@ -0,0 +1,420 @@
+"""
+Semantic Chunker Module for RAG Systems
+======================================
+
+A drop-in replacement for RecursiveCharacterTextSplitter that uses semantic similarity
+to create more coherent chunks. Designed to work seamlessly with existing LangChain
+and Streamlit RAG systems.
+
+Author: AI Assistant
+Compatible with: LangChain, BGE embeddings, OpenAI embeddings, Streamlit
+"""
+
+import numpy as np
+import re
+from typing import List, Dict, Any, Optional, Union
+from langchain.schema import Document
+import streamlit as st
+from sklearn.metrics.pairwise import cosine_similarity
+import logging
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class SemanticChunker:
+    """
+    Advanced semantic document chunker that creates coherent chunks based on 
+    semantic similarity rather than fixed character counts.
+    
+    Perfect for university documents, research papers, and policy documents
+    where maintaining semantic coherence is crucial.
+    """
+    
+    def __init__(self, 
+                 embeddings_model,
+                 chunk_size: int = 4,
+                 overlap: int = 1,
+                 similarity_threshold: float = 0.75,
+                 min_chunk_size: int = 150,
+                 max_chunk_size: int = 1500,
+                 sentence_split_pattern: Optional[str] = None,
+                 debug: bool = False):
+        """
+        Initialize the semantic chunker.
+        
+        Args:
+            embeddings_model: Your existing embeddings model (BGE, OpenAI, etc.)
+            chunk_size: Base number of sentences per chunk (default: 4)
+            overlap: Number of sentences to overlap between chunks (default: 1)
+            similarity_threshold: Cosine similarity threshold for extending chunks (0.0-1.0)
+            min_chunk_size: Minimum characters per chunk (skip smaller chunks)
+            max_chunk_size: Maximum characters per chunk (prevent overly large chunks)
+            sentence_split_pattern: Custom regex pattern for sentence splitting
+            debug: Enable debug logging and statistics
+        """
+        self.embeddings_model = embeddings_model
+        self.chunk_size = chunk_size
+        self.overlap = overlap
+        self.similarity_threshold = similarity_threshold
+        self.min_chunk_size = min_chunk_size
+        self.max_chunk_size = max_chunk_size
+        self.debug = debug
+        
+        # Default sentence splitting pattern optimized for academic/university documents
+        self.sentence_pattern = sentence_split_pattern or r'[.!?]+\s+'
+        
+        # Statistics tracking
+        self.stats = {
+            "total_documents": 0,
+            "total_chunks": 0,
+            "avg_chunk_size": 0,
+            "chunking_methods": {},
+            "embedding_errors": 0
+        }
+        
+        if self.debug:
+            logger.info(f"Initialized SemanticChunker with threshold={similarity_threshold}")
+    
+    def _detect_embedding_model_type(self) -> str:
+        """Detect the type of embedding model being used."""
+        if hasattr(self.embeddings_model, 'model'):
+            # Likely sentence-transformers model (BGE, etc.)
+            model_name = getattr(self.embeddings_model.model, 'model_name', 'sentence-transformers')
+            return f"sentence-transformers ({model_name})"
+        elif hasattr(self.embeddings_model, 'client'):
+            # Likely OpenAI
+            return "OpenAI"
+        else:
+            return "Unknown"
+    
+    def _preprocess_text_for_splitting(self, text: str) -> str:
+        """
+        Preprocess text to handle common formatting issues in university documents.
+        """
+        # Fix common formatting issues
+        fixes = [
+            # Add space after periods before capital letters
+            (r'([a-z])\.([A-Z])', r'\1. \2'),
+            # Add space after numbers with periods
+            (r'([0-9]+)\.([A-Z])', r'\1. \2'),
+            # Fix missing spaces after question/exclamation marks
+            (r'([a-z])\?([A-Z])', r'\1? \2'),
+            (r'([a-z])\!([A-Z])', r'\1! \2'),
+            # Clean up multiple spaces
+            (r'\s+', ' '),
+            # Fix bullet points
+            (r'•\s*([A-Z])', r'• \1'),
+            (r'-\s*([A-Z])', r'- \1'),
+        ]
+        
+        processed_text = text
+        for pattern, replacement in fixes:
+            processed_text = re.sub(pattern, replacement, processed_text)
+        
+        return processed_text.strip()
+    
+    def _split_into_sentences(self, text: str) -> List[str]:
+        """
+        Advanced sentence splitting optimized for academic documents.
+        """
+        # Preprocess text
+        text = self._preprocess_text_for_splitting(text)
+        
+        # Split on sentence boundaries
+        raw_sentences = re.split(self.sentence_pattern, text)
+        
+        # Clean and filter sentences
+        sentences = []
+        for sentence in raw_sentences:
+            sentence = sentence.strip()
+            
+            # Filter out very short sentences, pure numbers, or empty strings
+            if len(sentence) >= 10 and not sentence.isdigit() and not re.match(r'^[^\w]*$', sentence):
+                sentences.append(sentence)
+        
+        if self.debug:
+            logger.info(f"Split text into {len(sentences)} sentences")
+        
+        return sentences
+    
+    def _get_embeddings(self, texts: List[str]) -> Optional[np.ndarray]:
+        """
+        Get embeddings from the provided model with error handling.
+        """
+        try:
+            if hasattr(self.embeddings_model, 'model'):
+                # sentence-transformers model (BGE, etc.)
+                embeddings = self.embeddings_model.model.encode(texts)
+                return np.array(embeddings)
+            elif hasattr(self.embeddings_model, 'embed_documents'):
+                # OpenAI or similar API-based embeddings
+                embeddings = self.embeddings_model.embed_documents(texts)
+                return np.array(embeddings)
+            else:
+                # Try direct call
+                embeddings = self.embeddings_model(texts)
+                return np.array(embeddings)
+                
+        except Exception as e:
+            self.stats["embedding_errors"] += 1
+            if self.debug:
+                logger.error(f"Error generating embeddings: {e}")
+            
+            # Show warning in Streamlit if available
+            try:
+                st.warning(f"⚠️ Embedding error, falling back to simple chunking: {str(e)[:100]}...")
+            except:
+                pass  # Streamlit not available
+            
+            return None
+    
+    def _calculate_semantic_boundaries(self, embeddings: np.ndarray, sentences: List[str]) -> List[int]:
+        """
+        Find natural semantic boundaries in the text based on embedding similarities.
+        """
+        boundaries = [0]  # Always start with first sentence
+        
+        # Calculate similarities between consecutive sentences
+        similarities = []
+        for i in range(len(embeddings) - 1):
+            sim = cosine_similarity(
+                embeddings[i:i+1], 
+                embeddings[i+1:i+2]
+            )[0][0]
+            similarities.append(sim)
+        
+        # Find significant drops in similarity (topic boundaries)
+        if len(similarities) > 1:
+            mean_sim = np.mean(similarities)
+            std_sim = np.std(similarities)
+            threshold = mean_sim - (0.5 * std_sim)  # Adaptive threshold
+            
+            for i, sim in enumerate(similarities):
+                if sim < threshold:
+                    boundaries.append(i + 1)
+        
+        boundaries.append(len(sentences))  # Always end with last sentence
+        
+        return sorted(list(set(boundaries)))  # Remove duplicates and sort
+    
+    def _create_chunks_from_boundaries(self, sentences: List[str], boundaries: List[int], 
+                                     embeddings: Optional[np.ndarray], metadata: Dict[str, Any]) -> List[Document]:
+        """
+        Create document chunks based on semantic boundaries.
+        """
+        chunks = []
+        
+        for i in range(len(boundaries) - 1):
+            start_idx = boundaries[i]
+            end_idx = boundaries[i + 1]
+            
+            # Create base chunk
+            chunk_sentences = sentences[start_idx:end_idx]
+            
+            # Try to extend chunk if semantically similar
+            if embeddings is not None and end_idx < len(sentences):
+                current_embedding = np.mean(embeddings[start_idx:end_idx], axis=0, keepdims=True)
+                
+                # Check if we can extend the chunk
+                extended_end = end_idx
+                while extended_end < len(sentences):
+                    next_sentence_embedding = embeddings[extended_end:extended_end+1]
+                    similarity = cosine_similarity(current_embedding, next_sentence_embedding)[0][0]
+                    
+                    if similarity > self.similarity_threshold:
+                        # Check size limit
+                        test_chunk = ' '.join(sentences[start_idx:extended_end+1])
+                        if len(test_chunk) <= self.max_chunk_size:
+                            extended_end += 1
+                            # Update current embedding
+                            current_embedding = np.mean(embeddings[start_idx:extended_end], axis=0, keepdims=True)
+                        else:
+                            break
+                    else:
+                        break
+                
+                # Use extended chunk if we found extensions
+                if extended_end > end_idx:
+                    chunk_sentences = sentences[start_idx:extended_end]
+            
+            # Create chunk text
+            chunk_text = ' '.join(chunk_sentences)
+            
+            # Only add chunks that meet minimum size requirement
+            if len(chunk_text) >= self.min_chunk_size:
+                chunk_metadata = metadata.copy()
+                chunk_metadata.update({
+                    "chunk_index": len(chunks),
+                    "sentence_count": len(chunk_sentences),
+                    "start_sentence": start_idx,
+                    "end_sentence": start_idx + len(chunk_sentences) - 1,
+                    "chunking_method": "semantic_boundary",
+                    "similarity_threshold": self.similarity_threshold,
+                    "chunk_size_chars": len(chunk_text)
+                })
+                
+                chunks.append(Document(page_content=chunk_text, metadata=chunk_metadata))
+        
+        return chunks
+    
+    def _create_simple_chunks(self, sentences: List[str], metadata: Dict[str, Any]) -> List[Document]:
+        """
+        Fallback to simple sentence-based chunking when embeddings are unavailable.
+        """
+        chunks = []
+        
+        for i in range(0, len(sentences), max(1, self.chunk_size - self.overlap)):
+            chunk_sentences = sentences[i:i + self.chunk_size]
+            chunk_text = ' '.join(chunk_sentences)
+            
+            if len(chunk_text) >= self.min_chunk_size:
+                chunk_metadata = metadata.copy()
+                chunk_metadata.update({
+                    "chunk_index": len(chunks),
+                    "sentence_count": len(chunk_sentences),
+                    "start_sentence": i,
+                    "end_sentence": i + len(chunk_sentences) - 1,
+                    "chunking_method": "simple_fallback",
+                    "chunk_size_chars": len(chunk_text)
+                })
+                
+                chunks.append(Document(page_content=chunk_text, metadata=chunk_metadata))
+        
+        return chunks
+    
+    def split_documents(self, documents: List[Document]) -> List[Document]:
+        """
+        Main method: Split documents into semantically coherent chunks.
+        
+        Args:
+            documents: List of LangChain Document objects
+            
+        Returns:
+            List of Document objects with semantic chunks
+        """
+        all_chunks = []
+        self.stats["total_documents"] = len(documents)
+        
+        for doc_idx, doc in enumerate(documents):
+            try:
+                # Split document into sentences
+                sentences = self._split_into_sentences(doc.page_content)
+                
+                if not sentences:
+                    if self.debug:
+                        logger.warning(f"No sentences found in document {doc_idx}")
+                    continue
+                
+                # Handle very short documents
+                if len(sentences) < self.chunk_size:
+                    chunk_text = ' '.join(sentences)
+                    if len(chunk_text) >= self.min_chunk_size:
+                        chunk_metadata = doc.metadata.copy()
+                        chunk_metadata.update({
+                            "chunk_index": 0,
+                            "total_chunks": 1,
+                            "sentence_count": len(sentences),
+                            "chunking_method": "single_chunk",
+                            "chunk_size_chars": len(chunk_text)
+                        })
+                        all_chunks.append(Document(page_content=chunk_text, metadata=chunk_metadata))
+                    continue
+                
+                # Generate embeddings
+                embeddings = self._get_embeddings(sentences)
+                
+                if embeddings is not None:
+                    # Create semantic chunks
+                    chunks = self._create_chunks_from_boundaries(sentences, [0, len(sentences)], embeddings, doc.metadata)
+                    method = "semantic"
+                else:
+                    # Fallback to simple chunking
+                    chunks = self._create_simple_chunks(sentences, doc.metadata)
+                    method = "simple_fallback"
+                
+                # Update statistics
+                self.stats["chunking_methods"][method] = self.stats["chunking_methods"].get(method, 0) + 1
+                
+                # Update total chunks count in each chunk's metadata
+                for chunk in chunks:
+                    chunk.metadata["total_chunks"] = len(chunks)
+                    chunk.metadata["source_document_index"] = doc_idx
+                
+                all_chunks.extend(chunks)
+                
+                if self.debug:
+                    logger.info(f"Document {doc_idx}: {len(sentences)} sentences → {len(chunks)} chunks ({method})")
+                    
+            except Exception as e:
+                logger.error(f"Error processing document {doc_idx}: {e}")
+                if self.debug:
+                    st.error(f"Error processing document {doc_idx}: {e}")
+        
+        # Update final statistics
+        self.stats["total_chunks"] = len(all_chunks)
+        if all_chunks:
+            chunk_sizes = [len(chunk.page_content) for chunk in all_chunks]
+            self.stats["avg_chunk_size"] = sum(chunk_sizes) / len(chunk_sizes)
+        
+        if self.debug:
+            logger.info(f"Created {len(all_chunks)} total chunks from {len(documents)} documents")
+        
+        return all_chunks
+    
+    def get_statistics(self) -> Dict[str, Any]:
+        """Get chunking statistics for analysis."""
+        return self.stats.copy()
+    
+    def display_statistics(self):
+        """Display chunking statistics in Streamlit (if available)."""
+        try:
+            with st.expander("📊 Semantic Chunking Statistics"):
+                col1, col2 = st.columns(2)
+                
+                with col1:
+                    st.metric("Total Documents", self.stats["total_documents"])
+                    st.metric("Total Chunks", self.stats["total_chunks"])
+                    
+                with col2:
+                    st.metric("Avg Chunk Size", f"{self.stats['avg_chunk_size']:.0f} chars")
+                    st.metric("Embedding Errors", self.stats["embedding_errors"])
+                
+                if self.stats["chunking_methods"]:
+                    st.write("**Chunking Methods Used:**")
+                    for method, count in self.stats["chunking_methods"].items():
+                        percentage = (count / self.stats["total_documents"]) * 100 if self.stats["total_documents"] > 0 else 0
+                        st.write(f"  - {method}: {count} documents ({percentage:.1f}%)")
+                
+                st.write("**Configuration:**")
+                st.json({
+                    "chunk_size": self.chunk_size,
+                    "overlap": self.overlap,
+                    "similarity_threshold": self.similarity_threshold,
+                    "min_chunk_size": self.min_chunk_size,
+                    "max_chunk_size": self.max_chunk_size,
+                    "embedding_model": self._detect_embedding_model_type()
+                })
+                
+        except ImportError:
+            # Streamlit not available, print to console
+            print("\n=== Semantic Chunking Statistics ===")
+            print(f"Documents processed: {self.stats['total_documents']}")
+            print(f"Chunks created: {self.stats['total_chunks']}")
+            print(f"Average chunk size: {self.stats['avg_chunk_size']:.0f} characters")
+            print(f"Embedding errors: {self.stats['embedding_errors']}")
+            print(f"Chunking methods: {self.stats['chunking_methods']}")
+
+
+def create_semantic_chunker(embeddings_model, **kwargs) -> SemanticChunker:
+    """
+    Convenience function to create a semantic chunker with sensible defaults.
+    
+    Args:
+        embeddings_model: Your existing embeddings model
+        **kwargs: Additional parameters to pass to SemanticChunker
+    
+    Returns:
+        SemanticChunker instance ready to use
+    """
+    return SemanticChunker(embeddings_model=embeddings_model, **kwargs)

styles.css

@@ -0,0 +1,126 @@
+.main-header {
+  text-align: center;
+  padding: 2rem 0;
+  background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+  color: white;
+  margin: -1rem -1rem 2rem -1rem;
+  border-radius: 10px;
+  box-shadow: 0 4px 15px 0 rgba(31, 38, 135, 0.37);
+}
+
+.stApp {
+  background: var(--background-color);
+}
+
+/* Dark theme compatible containers */
+.query-result {
+  background: rgba(255, 255, 255, 0.05);
+  backdrop-filter: blur(10px);
+  border: 1px solid rgba(255, 255, 255, 0.1);
+  padding: 1.5rem;
+  border-radius: 15px;
+  margin: 1rem 0;
+  color: var(--text-color);
+}
+
+.source-doc {
+  background: rgba(31, 119, 180, 0.1);
+  backdrop-filter: blur(5px);
+  padding: 1rem;
+  border-left: 4px solid #1f77b4;
+  border-radius: 8px;
+  margin: 0.5rem 0;
+  color: var(--text-color);
+}
+
+.share-link {
+  background: rgba(46, 204, 113, 0.1);
+  backdrop-filter: blur(5px);
+  padding: 1rem;
+  border-radius: 10px;
+  border-left: 4px solid #2ecc71;
+  color: var(--text-color);
+}
+
+/* Model indicator boxes */
+.model-info {
+  background: rgba(52, 152, 219, 0.15);
+  backdrop-filter: blur(10px);
+  padding: 15px;
+  border-radius: 12px;
+  border-left: 4px solid #3498db;
+  margin: 10px 0;
+}
+
+/* Language selection enhancement */
+.language-selection {
+  background: rgba(155, 89, 182, 0.1);
+  backdrop-filter: blur(10px);
+  padding: 15px;
+  border-radius: 12px;
+  border-left: 4px solid #9b59b6;
+  margin: 10px 0;
+}
+
+/* Upload area enhancement */
+.stFileUploader {
+  background: rgba(230, 126, 34, 0.1);
+  backdrop-filter: blur(10px);
+  padding: 20px;
+  border-radius: 15px;
+  border: 2px dashed #e67e22;
+}
+
+.stFileUploader label {
+  font-size: 1.2rem;
+  font-weight: bold;
+  color: var(--text-color);
+}
+
+/* Button enhancements */
+.stButton > button {
+  background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+  color: white;
+  border: none;
+  border-radius: 10px;
+  padding: 0.6rem 1.5rem;
+  font-weight: 600;
+  transition: all 0.3s ease;
+  box-shadow: 0 4px 15px 0 rgba(31, 38, 135, 0.37);
+}
+
+.stButton > button:hover {
+  transform: translateY(-2px);
+  box-shadow: 0 6px 20px 0 rgba(31, 38, 135, 0.5);
+}
+
+/* Sidebar enhancements */
+.css-1d391kg {
+  background: rgba(255, 255, 255, 0.02);
+  backdrop-filter: blur(10px);
+}
+
+/* Info boxes */
+.stInfo {
+  background: rgba(52, 152, 219, 0.1);
+  backdrop-filter: blur(10px);
+  border-left: 4px solid #3498db;
+}
+
+.stSuccess {
+  background: rgba(46, 204, 113, 0.1);
+  backdrop-filter: blur(10px);
+  border-left: 4px solid #2ecc71;
+}
+
+.stWarning {
+  background: rgba(241, 196, 15, 0.1);
+  backdrop-filter: blur(10px);
+  border-left: 4px solid #f1c40f;
+}
+
+.stError {
+  background: rgba(231, 76, 60, 0.1);
+  backdrop-filter: blur(10px);
+  border-left: 4px solid #e74c3c;
+}

tabs/help.py

@@ -0,0 +1,168 @@
+"""
+Help tab functionality for the Gradio app
+"""
+import gradio as gr
+
+def create_help_tab(global_vars):
+    """Create the Help tab with comprehensive documentation"""
+    with gr.Tab("❓ Help", id="help"):
+        gr.Markdown("""
+        # 🌏 PANSEA University Requirements Assistant - User Guide
+        
+        Welcome to the PANSEA (Pan-Southeast Asian) University Requirements Assistant! This tool helps you navigate university admission requirements across Southeast Asian countries using advanced AI-powered document analysis.
+        
+        ---
+        
+        ## 🚀 Getting Started
+        
+        ### Step 1: Initialize the System
+        1. Go to the **🔧 Initialize** tab
+        2. Click **"Initialize All Systems"**
+        3. Wait for the success message
+        4. The system will set up AI models and document processing capabilities
+        
+        ### Step 2: Upload Documents
+        1. Navigate to the **📤 Upload Documents** tab
+        2. Select one or more PDF files containing university requirement information
+        3. Fill in the document metadata:
+           - **University Name**: Official name of the institution
+           - **Country**: Select from Southeast Asian countries
+           - **Document Type**: Choose the type of document
+           - **Language**: Document language
+        4. Click **"Process Documents"**
+        5. Wait for processing completion
+        
+        ### Step 3: Query Documents
+        1. Go to the **🔍 Query Documents** tab
+        2. Type your question in the query box
+        3. Click **"Search Documents"**
+        4. Review the AI-generated answer and source references
+        5. Use example questions to explore different types of queries
+        
+        ### Step 4: Manage Documents
+        1. Visit the **🗂 Manage Documents** tab
+        2. View all uploaded documents and statistics
+        3. Delete individual documents or clear all documents as needed
+        
+        ---
+        
+        ## 📖 Features Overview
+        
+        ### 🤖 AI-Powered Analysis
+        - Uses advanced SEA-LION AI models optimized for Southeast Asian contexts
+        - Semantic search across your document collection
+        - Contextual answers with source citations
+        - Multi-language document support
+        
+        ### 📚 Document Management
+        - Support for PDF documents
+        - Intelligent text chunking for better search results
+        - Metadata tracking (university, country, document type, language)
+        - Easy document deletion and management
+        
+        ### 🌐 Regional Focus
+        - Specialized for Southeast Asian universities
+        - Supports multiple countries and languages
+        - Culturally aware responses
+        - Up-to-date admission requirement information
+        
+        ---
+        
+        ## 💡 Usage Tips
+        
+        ### Asking Better Questions
+        - **Be Specific**: "What are the English proficiency requirements for Computer Science at NUS?" instead of "What are the requirements?"
+        - **Include Context**: Mention specific programs, countries, or universities you're interested in
+        - **Use Keywords**: Include terms like "admission", "requirements", "GPA", "test scores", etc.
+        
+        ### Document Upload Best Practices
+        - **Quality Documents**: Upload official university brochures, requirement documents, or application guides
+        - **Accurate Metadata**: Fill in all metadata fields correctly for better search results
+        - **Regular Updates**: Replace outdated documents with current versions
+        - **Organized Approach**: Upload documents systematically by country or university
+        
+        ### Managing Your Knowledge Base
+        - **Regular Maintenance**: Remove outdated documents periodically
+        - **Logical Organization**: Group related documents together
+        - **Backup Important Queries**: Save important answers for future reference
+        
+        ---
+        
+        ## 🛠 Troubleshooting
+        
+        ### Common Issues
+        
+        **Problem**: "Please initialize systems first" error
+        - **Solution**: Go to the Initialize tab and click "Initialize All Systems"
+        
+        **Problem**: Document upload fails
+        - **Solution**: Ensure PDF files are not corrupted and contain text (not just images)
+        
+        **Problem**: No search results
+        - **Solution**: Check if documents are uploaded and try different keywords
+        
+        **Problem**: Slow performance
+        - **Solution**: Wait for processing to complete, avoid uploading too many large documents at once
+        
+        ### Technical Requirements
+        - **File Format**: PDF documents only
+        - **File Size**: Reasonable size limits (avoid extremely large files)
+        - **Content**: Text-based PDFs work best (scanned images may not work well)
+        - **Internet**: Required for AI model access
+        
+        ---
+        
+        ## 📊 Understanding Results
+        
+        ### Query Responses
+        - **Answer**: AI-generated response based on your documents
+        - **Sources**: Specific document chunks used to generate the answer
+        - **Confidence**: Implied by the specificity and detail of the response
+        - **Context**: Related information that might be helpful
+        
+        ### Document Statistics
+        - **Total Documents**: Number of unique documents uploaded
+        - **Total Chunks**: Number of text segments for searching
+        - **Metadata**: Information about each document's origin and type
+        
+        ---
+        
+        ## 🌟 Best Practices for University Research
+        
+        ### Research Strategy
+        1. **Start Broad**: Upload general university information first
+        2. **Get Specific**: Add detailed program requirements
+        3. **Compare Options**: Query for comparisons between universities
+        4. **Verify Information**: Cross-reference with official university websites
+        
+        ### Question Types to Try
+        - **Admission Requirements**: "What are the minimum GPA requirements for..."
+        - **Test Scores**: "What IELTS/TOEFL scores are needed for..."
+        - **Application Deadlines**: "When is the application deadline for..."
+        - **Program Details**: "What courses are included in the... program at..."
+        - **Scholarships**: "What scholarship opportunities are available for..."
+        
+        ---
+        
+        ## 🆘 Support & Feedback
+        
+        If you encounter issues or have suggestions for improvement:
+        
+        1. **Check Documentation**: Review this help section first
+        2. **Try Different Approaches**: Rephrase your queries or check document formats
+        3. **Document Issues**: Note specific error messages or unexpected behavior
+        4. **Feature Requests**: Consider what additional functionality would be helpful
+        
+        ---
+        
+        ## 🔄 Version Information
+        
+        **Current Version**: Gradio-based PANSEA Assistant
+        **AI Models**: SEA-LION optimized for Southeast Asian contexts
+        **Document Processing**: Advanced semantic chunking and embedding
+        **Search Technology**: Vector similarity search with contextual ranking
+        
+        ---
+        
+        *Happy university hunting! 🎓 We hope this tool helps you find the perfect educational opportunity in Southeast Asia.*
+        """)

tabs/initialize.py

@@ -0,0 +1,55 @@
+"""
+Initialize tab functionality for the Gradio app
+"""
+import gradio as gr
+from utils.rag_system import DocumentIngestion, RAGSystem
+
+def initialize_systems(global_vars):
+    """Initialize the RAG systems"""
+    try:
+        print("🚀 Initializing document ingestion system...")
+        global_vars['doc_ingestion'] = DocumentIngestion()
+        print("🚀 Initializing RAG system...")
+        global_vars['rag_system'] = RAGSystem()
+        return "✅ Systems initialized successfully! You can now upload documents."
+    except Exception as e:
+        error_msg = f"❌ Error initializing systems: {str(e)}\n\n"
+        
+        if "sentence-transformers" in str(e):
+            error_msg += """
+**Possible solutions:**
+1. Install sentence-transformers: `pip install sentence-transformers`
+2. Or provide OpenAI API key in environment variables
+3. Check that PyTorch is properly installed
+
+**For deployment:**
+- Ensure requirements.txt includes: sentence-transformers, torch, transformers
+"""
+        return error_msg
+
+def create_initialize_tab(global_vars):
+    """Create the Initialize System tab"""
+    with gr.Tab("🚀 Initialize System", id="init"):
+        gr.Markdown("""
+        ### Step 1: Initialize the System
+        Click the button below to initialize the AI models and embedding systems.
+        This may take a few moments on first run as models are downloaded.
+        """)
+        
+        init_btn = gr.Button(
+            "🚀 Initialize Systems", 
+            variant="primary", 
+            size="lg"
+        )
+        
+        init_status = gr.Textbox(
+            label="Initialization Status", 
+            interactive=False, 
+            lines=8,
+            placeholder="Click 'Initialize Systems' to start..."
+        )
+        
+        init_btn.click(
+            lambda: initialize_systems(global_vars),
+            outputs=init_status
+        )

tabs/manage.py

@@ -0,0 +1,237 @@
+"""
+Manage documents tab functionality for the Gradio app
+"""
+import gradio as gr
+
+def manage_documents(global_vars):
+    """Manage uploaded documents - view, delete individual or all documents"""
+    doc_ingestion = global_vars.get('doc_ingestion')
+    
+    if not doc_ingestion:
+        return "❌ Please initialize systems first!", "", ""
+    
+    try:
+        vectorstore = doc_ingestion.load_existing_vectorstore()
+        
+        if not vectorstore:
+            return "⚠️ No documents found. Upload documents first.", "", ""
+        
+        # Get all documents from vectorstore
+        collection = vectorstore._collection
+        all_docs = collection.get(include=["metadatas", "documents"])
+        metadatas = all_docs["metadatas"]
+        ids = all_docs["ids"]
+        documents = all_docs["documents"]
+        
+        # Group by file_id to show unique documents
+        doc_map = {}
+        for meta, doc_id, doc_text in zip(metadatas, ids, documents):
+            file_id = meta.get("file_id", doc_id)
+            if file_id not in doc_map:
+                doc_map[file_id] = {
+                    "source": meta.get("source", "Unknown"),
+                    "university": meta.get("university", "Unknown"),
+                    "country": meta.get("country", "Unknown"),
+                    "document_type": meta.get("document_type", "Unknown"),
+                    "language": meta.get("language", "Unknown"),
+                    "upload_timestamp": meta.get("upload_timestamp", "Unknown"),
+                    "file_id": file_id,
+                    "chunks": []
+                }
+            doc_map[file_id]["chunks"].append(doc_text)
+        
+        if not doc_map:
+            return "ℹ️ No documents found in the system.", "", ""
+        
+        # Create summary
+        total_documents = len(doc_map)
+        total_chunks = sum(len(info["chunks"]) for info in doc_map.values())
+        
+        summary = f"""## 📊 Document Statistics
+        
+**Total Documents:** {total_documents}
+**Total Text Chunks:** {total_chunks}
+**Storage Status:** Active
+        
+## 📚 Document List
+        """
+        
+        # Create document list with details
+        document_list = ""
+        file_id_list = []
+        
+        for i, (file_id, info) in enumerate(doc_map.items(), 1):
+            timestamp = info['upload_timestamp'][:19] if len(info['upload_timestamp']) > 19 else info['upload_timestamp']
+            
+            document_list += f"""
+**{i}. {info['source']}**
+- University: {info['university']}
+- Country: {info['country']}
+- Type: {info['document_type']}
+- Language: {info['language']}
+- Chunks: {len(info['chunks'])}
+- Uploaded: {timestamp}
+- File ID: `{file_id}`
+
+---
+            """
+            file_id_list.append(file_id)
+        
+        # Create dropdown options for individual deletion
+        file_options = [f"{info['source']} ({info['university']})" for info in doc_map.values()]
+        
+        return summary, document_list, file_options
+        
+    except Exception as e:
+        return f"❌ Error loading documents: {str(e)}", "", []
+
+def delete_document(selected_file, current_doc_list, global_vars):
+    """Delete a specific document"""
+    doc_ingestion = global_vars.get('doc_ingestion')
+    
+    if not doc_ingestion or not selected_file:
+        return "❌ Please select a document to delete.", current_doc_list
+    
+    try:
+        vectorstore = doc_ingestion.load_existing_vectorstore()
+        if not vectorstore:
+            return "❌ No vectorstore found.", current_doc_list
+        
+        # Get all documents and find the matching file_id
+        collection = vectorstore._collection
+        all_docs = collection.get(include=["metadatas"])
+        metadatas = all_docs["metadatas"]
+        ids = all_docs["ids"]
+        
+        # Find file_id for the selected document
+        target_file_id = None
+        for meta, doc_id in zip(metadatas, ids):
+            source = meta.get("source", "Unknown")
+            university = meta.get("university", "Unknown")
+            if f"{source} ({university})" == selected_file:
+                target_file_id = meta.get("file_id", doc_id)
+                break
+        
+        if not target_file_id:
+            return "❌ Document not found.", current_doc_list
+        
+        # Delete all chunks with this file_id
+        ids_to_delete = [doc_id for meta, doc_id in zip(metadatas, ids) if meta.get("file_id", doc_id) == target_file_id]
+        collection.delete(ids=ids_to_delete)
+        
+        # Refresh the document list
+        _, new_doc_list, _ = manage_documents(global_vars)
+        
+        return f"✅ Successfully deleted document: {selected_file}", new_doc_list
+        
+    except Exception as e:
+        return f"❌ Error deleting document: {str(e)}", current_doc_list
+
+def delete_all_documents(global_vars):
+    """Delete all documents from the vectorstore"""
+    doc_ingestion = global_vars.get('doc_ingestion')
+    
+    if not doc_ingestion:
+        return "❌ Please initialize systems first.", ""
+    
+    try:
+        vectorstore_instance = doc_ingestion.load_existing_vectorstore()
+        if not vectorstore_instance:
+            return "⚠️ No documents found to delete.", ""
+        
+        # Get all document IDs
+        collection = vectorstore_instance._collection
+        all_docs = collection.get()
+        all_ids = all_docs["ids"]
+        
+        # Delete all documents
+        if all_ids:
+            collection.delete(ids=all_ids)
+            # Clear global vectorstore
+            global_vars['vectorstore'] = None
+            return f"✅ Successfully deleted all {len(all_ids)} document chunks.", ""
+        else:
+            return "ℹ️ No documents found to delete.", ""
+            
+    except Exception as e:
+        return f"❌ Error deleting all documents: {str(e)}", ""
+
+def create_manage_tab(global_vars):
+    """Create the Manage Documents tab"""
+    with gr.Tab("🗂 Manage Documents", id="manage"):
+        gr.Markdown("""
+        ### Step 4: Manage Your Documents
+        View, inspect, and manage all uploaded documents in your knowledge base.
+        You can see document details and delete individual documents or all documents.
+        """)
+        
+        # Buttons for actions
+        with gr.Row():
+            refresh_btn = gr.Button("🔄 Refresh Document List", variant="secondary")
+            delete_all_btn = gr.Button("🗑️ Delete All Documents", variant="stop")
+        
+        # Document statistics and list
+        doc_summary = gr.Markdown(
+            value="📊 Click 'Refresh Document List' to view your documents.",
+            label="Document Summary"
+        )
+        
+        doc_list = gr.Markdown(
+            value="📚 Document details will appear here after refresh.",
+            label="Document List"
+        )
+        
+        # Individual document deletion
+        gr.Markdown("### 🗑️ Delete Individual Document")
+        
+        with gr.Row():
+            file_selector = gr.Dropdown(
+                choices=[],
+                label="Select Document to Delete",
+                interactive=True,
+                info="First click 'Refresh Document List' to see available documents"
+            )
+            delete_single_btn = gr.Button("🗑️ Delete Selected", variant="stop")
+        
+        delete_status = gr.Textbox(
+            label="Action Status",
+            interactive=False,
+            lines=2,
+            placeholder="Deletion status will appear here..."
+        )
+        
+        # Event handlers
+        def refresh_documents():
+            summary, documents, file_options = manage_documents(global_vars)
+            # Update dropdown choices
+            return summary, documents, gr.Dropdown(choices=file_options, value=None)
+        
+        def delete_selected_document(selected_file, current_list):
+            if not selected_file:
+                return "❌ Please select a document to delete first.", current_list, gr.Dropdown(choices=[])
+            
+            status, new_list = delete_document(selected_file, current_list, global_vars)
+            # Also refresh the file options after deletion
+            _, _, new_options = manage_documents(global_vars)
+            return status, new_list, gr.Dropdown(choices=new_options, value=None)
+        
+        def delete_all_docs():
+            status, empty_list = delete_all_documents(global_vars)
+            return status, "📚 No documents in the system.", gr.Dropdown(choices=[], value=None)
+        
+        # Connect event handlers
+        refresh_btn.click(
+            refresh_documents,
+            outputs=[doc_summary, doc_list, file_selector]
+        )
+        
+        delete_single_btn.click(
+            delete_selected_document,
+            inputs=[file_selector, doc_list],
+            outputs=[delete_status, doc_list, file_selector]
+        )
+        
+        delete_all_btn.click(
+            delete_all_docs,
+            outputs=[delete_status, doc_list, file_selector]
+        )

tabs/query.py

@@ -0,0 +1,139 @@
+"""
+Query documents tab functionality for the Gradio app
+"""
+import gradio as gr
+
+def query_documents(question, language, global_vars):
+    """Handle document queries"""
+    rag_system = global_vars.get('rag_system')
+    vectorstore = global_vars.get('vectorstore')
+    
+    if not rag_system:
+        return "❌ Please initialize systems first using the 'Initialize System' tab!"
+    
+    if not vectorstore:
+        return "❌ Please upload and process documents first using the 'Upload Documents' tab!"
+    
+    if not question.strip():
+        return "❌ Please enter a question."
+    
+    try:
+        print(f"🔍 Processing query: {question}")
+        result = rag_system.query(question, language)
+        
+        # Format response
+        answer = result["answer"]
+        sources = result.get("source_documents", [])
+        model_used = result.get("model_used", "SEA-LION")
+        
+        # Add model information
+        response = f"**Model Used:** {model_used}\n\n"
+        response += f"**Answer:**\n{answer}\n\n"
+        
+        if sources:
+            response += "**📚 Sources:**\n"
+            for i, doc in enumerate(sources[:3], 1):
+                metadata = doc.metadata
+                source_name = metadata.get('source', 'Unknown')
+                university = metadata.get('university', 'Unknown')
+                country = metadata.get('country', 'Unknown')
+                doc_type = metadata.get('document_type', 'Unknown')
+                
+                response += f"{i}. **{source_name}**\n"
+                response += f"   - University: {university}\n"
+                response += f"   - Country: {country}\n"
+                response += f"   - Type: {doc_type}\n"
+                response += f"   - Preview: {doc.page_content[:150]}...\n\n"
+        else:
+            response += "\n*No specific sources found. This might be a general response.*"
+        
+        return response
+        
+    except Exception as e:
+        return f"❌ Error querying documents: {str(e)}\n\nPlease check the console for more details."
+
+def get_example_questions():
+    """Return example questions for the interface"""
+    return [
+        "What are the admission requirements for Computer Science programs in Singapore?",
+        "Which universities offer scholarships for international students?",
+        "What are the tuition fees for MBA programs in Thailand?",
+        "Find universities with engineering programs under $5000 per year",
+        "What are the application deadlines for programs in Malaysia?",
+        "Compare admission requirements between different ASEAN countries"
+    ]
+
+def create_query_tab(global_vars):
+    """Create the Search & Query tab"""
+    with gr.Tab("🔍 Search & Query", id="query"):
+        gr.Markdown("""
+        ### Step 3: Ask Questions
+        Ask questions about the uploaded documents in your preferred language.
+        The AI will provide detailed answers with source citations.
+        """)
+        
+        with gr.Row():
+            with gr.Column(scale=3):
+                question_input = gr.Textbox(
+                    label="💭 Your Question",
+                    placeholder="Ask anything about the universities...",
+                    lines=3
+                )
+            
+            with gr.Column(scale=1):
+                language_dropdown = gr.Dropdown(
+                    choices=[
+                        "English", "Chinese", "Malay", "Thai", 
+                        "Indonesian", "Vietnamese", "Filipino"
+                    ],
+                    value="English",
+                    label="🌍 Response Language"
+                )
+        
+        query_btn = gr.Button(
+            "🔍 Search Documents", 
+            variant="primary", 
+            size="lg"
+        )
+        
+        answer_output = gr.Textbox(
+            label="🤖 AI Response",
+            interactive=False,
+            lines=20,
+            placeholder="Ask a question to get AI-powered answers..."
+        )
+        
+        # Example questions section
+        gr.Markdown("### 💡 Example Questions")
+        example_questions = get_example_questions()
+        
+        with gr.Row():
+            for i in range(0, len(example_questions), 2):
+                with gr.Column():
+                    if i < len(example_questions):
+                        example_btn = gr.Button(
+                            example_questions[i], 
+                            size="sm",
+                            variant="secondary"
+                        )
+                        example_btn.click(
+                            lambda x=example_questions[i]: x,
+                            outputs=question_input
+                        )
+                    
+                    if i + 1 < len(example_questions):
+                        example_btn2 = gr.Button(
+                            example_questions[i + 1], 
+                            size="sm",
+                            variant="secondary"
+                        )
+                        example_btn2.click(
+                            lambda x=example_questions[i + 1]: x,
+                            outputs=question_input
+                        )
+        
+        query_btn.click(
+            lambda question, language: query_documents(question, language, global_vars),
+            inputs=[question_input, language_dropdown],
+            outputs=answer_output
+        )

tabs/upload.py

@@ -0,0 +1,99 @@
+"""
+Upload documents tab functionality for the Gradio app
+"""
+import gradio as gr
+
+def upload_documents(files, global_vars):
+    """Handle document upload and processing"""
+    doc_ingestion = global_vars.get('doc_ingestion')
+    
+    if not doc_ingestion:
+        return "❌ Please initialize systems first using the 'Initialize System' tab!"
+    
+    if not files:
+        return "❌ Please upload at least one PDF file."
+    
+    try:
+        # Filter for PDF files only
+        pdf_files = []
+        for file_path in files:
+            if file_path.endswith('.pdf'):
+                pdf_files.append(file_path)
+        
+        if not pdf_files:
+            return "❌ Please upload PDF files only."
+        
+        print(f"📄 Processing {len(pdf_files)} PDF file(s)...")
+        
+        # Process documents
+        documents = doc_ingestion.process_documents(pdf_files)
+        
+        if documents:
+            print("🔗 Creating vector store...")
+            # Create vector store
+            vectorstore = doc_ingestion.create_vector_store(documents)
+            
+            if vectorstore:
+                # Store vectorstore in global vars
+                global_vars['vectorstore'] = vectorstore
+                
+                # Create summary
+                summary = f"✅ Successfully processed {len(documents)} document(s):\n\n"
+                
+                for i, doc in enumerate(documents, 1):
+                    metadata = doc.metadata
+                    university = metadata.get('university', 'Unknown')
+                    country = metadata.get('country', 'Unknown')
+                    doc_type = metadata.get('document_type', 'Unknown')
+                    language = metadata.get('language', 'Unknown')
+                    
+                    summary += f"{i}. **{metadata['source']}**\n"
+                    summary += f"   - University: {university}\n"
+                    summary += f"   - Country: {country}\n"
+                    summary += f"   - Type: {doc_type}\n"
+                    summary += f"   - Language: {language}\n\n"
+                
+                summary += "🎉 **Ready for queries!** Go to the 'Search & Query' tab to start asking questions."
+                return summary
+            else:
+                return "❌ Failed to create vector store from documents."
+        else:
+            return "❌ No documents were successfully processed. Please check if your PDFs are readable."
+            
+    except Exception as e:
+        return f"❌ Error processing documents: {str(e)}\n\nPlease check the console for more details."
+
+def create_upload_tab(global_vars):
+    """Create the Upload Documents tab"""
+    with gr.Tab("📄 Upload Documents", id="upload"):
+        gr.Markdown("""
+        ### Step 2: Upload PDF Documents
+        Upload university documents (brochures, admission guides, etc.) in PDF format.
+        The system will automatically extract metadata including university name, country, and document type.
+        """)
+        
+        file_upload = gr.File(
+            label="📁 Upload PDF Documents",
+            file_types=[".pdf"],
+            file_count="multiple",
+            height=120
+        )
+        
+        upload_btn = gr.Button(
+            "📄 Process Documents", 
+            variant="primary",
+            size="lg"
+        )
+        
+        upload_status = gr.Textbox(
+            label="Processing Status", 
+            interactive=False, 
+            lines=12,
+            placeholder="Upload PDF files and click 'Process Documents'..."
+        )
+        
+        upload_btn.click(
+            lambda files: upload_documents(files, global_vars),
+            inputs=file_upload,
+            outputs=upload_status
+        )

utils/display.py

@@ -0,0 +1,79 @@
+import streamlit as st
+from utils.rag_system import DocumentIngestion, RAGSystem, save_query_result, load_shared_query
+
+def display_query_result(result, show_share_link=False):
+    """Display query results in a formatted way."""
+    st.markdown('<div class="query-result">', unsafe_allow_html=True)
+    
+    # Show which model was used
+    if result.get("model_used"):
+        st.info(f"🤖 **Model Used:** {result['model_used']}")
+    
+    st.subheader("🎯 Answer")
+    st.write(result["answer"])
+    
+    # Share link
+    if show_share_link and result.get("query_id"):
+        st.markdown("---")
+        current_url = st.get_option("browser.serverAddress") or "localhost:8501"
+        share_url = f"http://{current_url}?share={result['query_id']}"
+        st.markdown(f"""
+        <div class="share-link">
+            <strong>🔗 Share this result:</strong><br>
+            <code>{share_url}</code>
+        </div>
+        """, unsafe_allow_html=True)
+        
+        if st.button("📋 Copy Share Link"):
+            st.code(share_url)
+    
+    # Source documents
+    if result.get("source_documents"):
+        st.markdown("---")
+        st.subheader("📚 Sources")
+        for i, doc in enumerate(result["source_documents"], 1):
+            with st.expander(f"Source {i}: {doc.metadata.get('source', 'Unknown')}"):
+                col1, col2 = st.columns([1, 2])
+                with col1:
+                    st.write(f"**University:** {doc.metadata.get('university', 'Unknown')}")
+                    st.write(f"**Country:** {doc.metadata.get('country', 'Unknown')}")
+                    st.write(f"**Type:** {doc.metadata.get('document_type', 'Unknown')}")
+                with col2:
+                    st.write("**Relevant Content:**")
+                    content_preview = doc.page_content[:300] + "..." if len(doc.page_content) > 300 else doc.page_content
+                    st.write(content_preview)
+    
+    st.markdown('</div>', unsafe_allow_html=True)
+
+def display_shared_query(query_id):
+    """Display a shared query result."""
+    st.header("🔗 Shared Query Result")
+    
+    result_data = load_shared_query(query_id)
+    
+    if result_data:
+        st.info(f"**Original Question:** {result_data['question']}")
+        st.write(f"**Language:** {result_data['language']}")
+        st.write(f"**Date:** {result_data['timestamp'][:10]}")
+        
+        # Create a mock result object for display
+        mock_result = {
+            "answer": result_data["answer"],
+            "source_documents": [
+                type('MockDoc', (), {
+                    'metadata': source,
+                    'page_content': source.get('content_preview', '')
+                })() for source in result_data.get('sources', [])
+            ]
+        }
+        
+        display_query_result(mock_result, show_share_link=False)
+        
+        if st.button("🔍 Ask Your Own Question"):
+            st.experimental_set_query_params()
+            st.experimental_rerun()
+    else:
+        st.error("❌ Shared query not found or has expired.")
+        if st.button("🏠 Go to Home"):
+            st.experimental_set_query_params()
+            st.experimental_rerun()

utils/rag_system.py

@@ -0,0 +1,615 @@
+import os
+import uuid
+import tempfile
+from typing import List, Optional, Dict, Any
+from pathlib import Path
+import PyPDF2
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_openai import OpenAIEmbeddings, ChatOpenAI
+from langchain_community.vectorstores import Chroma
+from langchain.chains import RetrievalQA
+from langchain_community.document_loaders import PyPDFLoader
+from langchain.schema import Document
+from dotenv import load_dotenv
+
+from datetime import datetime
+import json
+import base64
+from openai import OpenAI
+import re
+from semantic_chunking import SemanticChunker
+
+# Load environment variables
+load_dotenv()
+
+class AlternativeEmbeddings:
+    """Alternative embeddings using Sentence Transformers when OpenAI is not available"""
+    
+    def __init__(self):
+        self.model = None
+        self.embedding_size = 384
+        
+        try:
+            from sentence_transformers import SentenceTransformer
+            
+            # Try smaller models in order of preference for better cloud compatibility
+            model_options = [
+                ("all-MiniLM-L6-v2", 384),      # Very small and reliable
+                ("paraphrase-MiniLM-L3-v2", 384), # Even smaller
+                ("BAAI/bge-small-en-v1.5", 384)   # Original choice
+            ]
+            
+            for model_name, embed_size in model_options:
+                try:
+                    print(f"🔄 Trying to load model: {model_name}")
+                    self.model = SentenceTransformer(model_name)
+                    self.embedding_size = embed_size
+                    print(f"✅ Successfully loaded: {model_name}")
+                    break
+                except Exception as e:
+                    print(f"⚠️ Failed to load {model_name}: {str(e)}")
+                    continue
+            
+            if not self.model:
+                raise Exception("All embedding models failed to load")
+                
+        except ImportError:
+            print("❌ sentence-transformers not available. Please install it or provide OpenAI API key.")
+            raise ImportError("sentence-transformers not available")
+    
+    def embed_documents(self, texts):
+        if not self.model:
+            raise Exception("No embedding model available")
+        try:
+            return self.model.encode(texts, convert_to_numpy=True).tolist()
+        except Exception as e:
+            print(f"Error encoding documents: {e}")
+            raise
+    
+    def embed_query(self, text):
+        if not self.model:
+            raise Exception("No embedding model available")
+        try:
+            return self.model.encode([text], convert_to_numpy=True)[0].tolist()
+        except Exception as e:
+            print(f"Error encoding query: {e}")
+            raise
+
+class SEALionLLM:
+    """Custom LLM class for SEA-LION models"""
+    
+    def __init__(self):
+        self.client = OpenAI(
+            api_key=os.getenv("SEA_LION_API_KEY"),
+            base_url=os.getenv("SEA_LION_BASE_URL", "https://api.sea-lion.ai/v1")
+        )
+        
+        # Model configurations
+        self.instruct_model = "aisingapore/Gemma-SEA-LION-v3-9B-IT"
+        self.reasoning_model = "aisingapore/Llama-SEA-LION-v3.5-8B-R"
+        
+    def _is_complex_query(self, query: str) -> bool:
+        """Determine if query requires reasoning model or simple instruct model"""
+        # Keywords that indicate complex university search queries
+        complex_keywords = [
+            "university", "admission", "requirement", "tuition", "fee", "program", "course",
+            "degree", "master", "bachelor", "phd", "scholarship", "deadline", "application",
+            "budget", "under", "less than", "below", "compare", "recommend", "suggest",
+            "which", "what are the", "show me", "find me", "search for",
+            # Chinese keywords
+            "大学", "学费", "专业", "硕士", "学士", "博士", "申请", "要求", "奖学金",
+            # Malay keywords  
+            "universiti", "yuran", "program", "ijazah", "syarat", "permohonan",
+            # Thai keywords
+            "มหาวิทยาลัย", "ค่าเล่าเรียน", "หลักสูตร", "ปริญญา", "เงื่อนไข",
+            # Indonesian keywords
+            "universitas", "biaya", "kuliah", "program", "sarjana", "persyaratan"
+        ]
+        
+        # Check for multiple criteria (indicates complex search)
+        criteria_count = 0
+        query_lower = query.lower()
+        
+        for keyword in complex_keywords:
+            if keyword.lower() in query_lower:
+                criteria_count += 1
+        
+        # Also check for comparison words, numbers, conditions
+        comparison_patterns = [
+            r"under \$?\d+", r"less than \$?\d+", r"below \$?\d+", r"between \$?\d+ and \$?\d+",
+            r"不超过.*元", r"低于.*元", r"少于.*元",  # Chinese
+            r"kurang dari", r"di bawah",  # Malay/Indonesian  
+            r"น้อยกว่า", r"ต่ำกว่า"  # Thai
+        ]
+        
+        for pattern in comparison_patterns:
+            if re.search(pattern, query_lower):
+                criteria_count += 2
+        
+        # Complex query if multiple keywords or comparison patterns found
+        return criteria_count >= 2
+        
+    def _is_translation_query(self, query: str) -> bool:
+        """Check if query is primarily for translation"""
+        translation_keywords = [
+            "translate", "translation", "แปล", "翻译", "terjemah", "traduire"
+        ]
+        
+        query_lower = query.lower()
+        return any(keyword in query_lower for keyword in translation_keywords)
+
+    def generate_response(self, query: str, context: str = "", language: str = "English") -> str:
+        """Generate response using appropriate SEA-LION model"""
+        
+        # Choose model based on query complexity
+        if self._is_translation_query(query) or not self._is_complex_query(query):
+            model = self.instruct_model
+            use_reasoning = False
+        else:
+            model = self.reasoning_model  
+            use_reasoning = True
+            
+        # Prepare messages
+        system_prompt = f"""You are a helpful assistant specializing in ASEAN university admissions. 
+        Respond in {language} unless specifically asked otherwise.
+        
+        If provided with context from university documents, use that information to give accurate, specific answers.
+        Always cite your sources when using provided context.
+        
+        For complex university search queries, provide:
+        1. Direct answers to the question
+        2. Relevant admission requirements  
+        3. Tuition fees (if available)
+        4. Application deadlines (if available)
+        5. Source citations from the documents
+        
+        Context: {context}"""
+        
+        messages = [
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": query}
+        ]
+        
+        try:
+            if use_reasoning:
+                # Use reasoning model with thinking mode
+                response = self.client.chat.completions.create(
+                    model=model,
+                    messages=messages,
+                    max_tokens=2000,
+                    temperature=0.1,
+                    extra_body={"thinking_mode": True}
+                )
+            else:
+                # Use instruct model for simpler queries
+                response = self.client.chat.completions.create(
+                    model=model,
+                    messages=messages,
+                    max_tokens=1500,
+                    temperature=0.3
+                )
+            
+            # Strip out reasoning steps from the response
+            response_text = response.choices[0].message.content
+            if "</think>" in response_text:
+                response_text = response_text.split("</think>")[-1].strip()
+
+            return response_text
+
+        except Exception as e:
+            print(f"Error with SEA-LION model: {str(e)}")
+            return f"I apologize, but I encountered an error processing your query. Please try rephrasing your question. Error: {str(e)}"
+
+    def extract_metadata(self, document_text: str) -> Dict[str, str]:
+        """Extract metadata from document text using LLM"""
+        
+        system_prompt = """You are an expert at extracting metadata from university documents. 
+        Analyze the provided document text and extract the following information:
+        
+        1. University name (full official name)
+        2. Country (where the university is located)
+        3. Document type (choose from: admission_requirements, tuition_fees, program_information, scholarship_info, application_deadlines, general_info)
+        4. Language (choose from: English, Chinese, Malay, Thai, Indonesian, Vietnamese, Filipino)
+        
+        Return your response as a JSON object with these exact keys:
+        {
+            "university_name": "extracted university name or \'Unknown\' if not found",
+            "country": "extracted country or \'Unknown\' if not found", 
+            "document_type": "most appropriate document type from the list above",
+            "language": "detected language of the document"
+        }
+        
+        Guidelines:
+        - For university_name: Look for official university names, avoid abbreviations when possible
+        - For country: Look for country names, city names that indicate country, or domain extensions
+        - For document_type: Analyze the content to determine what type of information it contains
+        - For language: Determine the primary language of the document.
+        - If information is unclear, use "Unknown" for university_name and country
+        - Always choose one of the specified document_type options and language options
+        """
+        
+        messages = [
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": f"Extract metadata from this document text:\n\n{document_text}"}
+        ]
+        
+        try:
+            response = self.client.chat.completions.create(
+                model=self.instruct_model,
+                messages=messages,
+                max_tokens=500,
+                temperature=0.1
+            )
+            
+            response_text = response.choices[0].message.content.strip()
+            print("--- DEBUG: LLM Metadata Extraction Details ---")
+            print(f"**Input Text for LLM (first 2 pages):**\n```\n{document_text[:1000]}...\n```") # Show first 1000 chars of input
+            print(f"**Raw LLM Response:**\n```json\n{response_text}\n```")
+            
+            json_match = re.search(r'\{.*?\}', response_text, re.DOTALL)
+            if json_match:
+                json_str = json_match.group(0)
+                try:
+                    metadata = json.loads(json_str)
+                    print(f"**Parsed JSON Metadata:**\n```json\n{json.dumps(metadata, indent=2)}\n```")
+                    required_keys = ["university_name", "country", "document_type", "language"]
+                    if all(key in metadata for key in required_keys):
+                        print("DEBUG: Successfully extracted and parsed metadata from LLM.")
+                        return metadata
+                    else:
+                        print("DEBUG: LLM response missing required keys, attempting fallback or using defaults.")
+                        return self._get_default_metadata()
+                except json.JSONDecodeError as e:
+                    print(f"DEBUG: JSON Parsing Failed: {e}")
+                    print(f"DEBUG: Attempting fallback text extraction from raw response.")
+                    return self._extract_from_text_response(response_text)
+            else:
+                print("DEBUG: No JSON object found in LLM response.")
+                return self._extract_from_text_response(response_text)
+                
+        except Exception as e:
+            print(f"DEBUG: Error during LLM Metadata Extraction: {str(e)}")
+            return self._get_default_metadata()
+    
+    def _extract_from_text_response(self, response_text: str) -> Dict[str, str]:
+        """Fallback method to extract metadata from non-JSON LLM response"""
+        metadata = self._get_default_metadata()
+        lines = response_text.split("\n")
+        for line in lines:
+            line = line.strip()
+            if "university" in line.lower() and ":" in line:
+                value = line.split(":", 1)[1].strip().strip('",')
+                metadata["university_name"] = value
+            elif "country" in line.lower() and ":" in line:
+                value = line.split(":", 1)[1].strip().strip('",')
+                metadata["country"] = value
+            elif "document_type" in line.lower() and ":" in line:
+                value = line.split(":", 1)[1].strip().strip('",')
+                metadata["document_type"] = value
+            elif "language" in line.lower() and ":" in line:
+                value = line.split(":", 1)[1].strip().strip('",')
+                metadata["language"] = value
+        print(f"DEBUG: Fallback text extraction result: {metadata}")
+        return metadata
+    
+    def _get_default_metadata(self) -> Dict[str, str]:
+        """Return default metadata when extraction fails"""
+        return {
+            "university_name": "Unknown",
+            "country": "Unknown", 
+            "document_type": "general_info",
+            "language": "Unknown"
+        }
+
+def classify_query_type(query: str) -> str:
+    """Public function to classify query type for UI display"""
+    # Create a temporary SEALionLLM instance just for classification
+    temp_llm = SEALionLLM()
+    
+    if temp_llm._is_translation_query(query) or not temp_llm._is_complex_query(query):
+        return "simple"
+    else:
+        return "complex"
+
+class DocumentIngestion:
+    def __init__(self):
+        # Initialize SEA-LION LLM for metadata extraction
+        self.sea_lion_llm = SEALionLLM()
+
+        # Use BGE embeddings by default for better performance
+        try:
+            self.embeddings = AlternativeEmbeddings()
+            self.embedding_type = "BGE-small-en"
+            if not self.embeddings.model:
+                raise Exception("BGE model not available")
+        except Exception:
+            # Fallback to OpenAI if BGE not available
+            openai_key = os.getenv("OPENAI_API_KEY")
+            if openai_key and openai_key != "placeholder_for_embeddings" and openai_key != "your_openai_api_key_here":
+                try:
+                    self.embeddings = OpenAIEmbeddings()
+                    self.embedding_type = "OpenAI"
+                except Exception as e:
+                    print("Both BGE and OpenAI embeddings failed. Please check your setup.")
+                    raise e
+            else:
+                print("No embedding model available. Please install sentence-transformers or provide OpenAI API key.")
+                raise Exception("No embedding model available")
+            
+        self.text_splitter = SemanticChunker(
+            embeddings_model=self.embeddings,
+            chunk_size=4,                    # 4 sentences per base chunk
+            overlap=1,                       # 1 sentence overlap
+            similarity_threshold=0.75,       # Semantic similarity threshold
+            min_chunk_size=150,             # Minimum 150 characters
+            max_chunk_size=1500,            # Maximum 1500 characters
+            debug=True                      # Show statistics in Streamlit
+        )
+        
+        # st.info(f"🧠 Using semantic chunking with {self.embedding_type} embeddings") # Commented out as it\'s a Streamlit call
+        self.persist_directory = os.getenv("CHROMA_PERSIST_DIRECTORY", "./chroma_db")
+        os.makedirs(self.persist_directory, exist_ok=True)
+        
+    def extract_text_from_pdf(self, pdf_file_path) -> List[str]:
+        """Extract text from PDF file path with multiple fallback methods."""
+        try:
+            # Method 1: Try with PyPDF2 (handles most PDFs including encrypted ones with PyCryptodome)
+            with open(pdf_file_path, 'rb') as pdf_file:
+                pdf_reader = PyPDF2.PdfReader(pdf_file)
+                
+                # Check if PDF is encrypted
+                if pdf_reader.is_encrypted:
+                    # Try to decrypt with empty password (common for protected but not password-protected PDFs)
+                    try:
+                        pdf_reader.decrypt("")
+                    except Exception:
+                        print(f"PDF {os.path.basename(pdf_file_path)} is password-protected. Please provide an unprotected version.")
+                        return [] # Return empty list for password-protected PDFs
+                
+                text_per_page = []
+                for page_num, page in enumerate(pdf_reader.pages):
+                    try:
+                        page_text = page.extract_text()
+                        text_per_page.append(page_text)
+                    except Exception as e:
+                        print(f"Could not extract text from page {page_num + 1} of {os.path.basename(pdf_file_path)}: {str(e)}")
+                        text_per_page.append("") # Append empty string for failed pages
+                
+                if any(text.strip() for text in text_per_page):
+                    return text_per_page
+                else:
+                    print(f"No extractable text found in {os.path.basename(pdf_file_path)}. This might be a scanned PDF or image-based document.")
+                    return []
+                
+        except Exception as e:
+            error_msg = str(e)
+            if "PyCryptodome" in error_msg:
+                print(f"Encryption error with {os.path.basename(pdf_file_path)}: {error_msg}")
+                print("💡 The PDF uses encryption. PyCryptodome has been installed to handle this.")
+            elif "password" in error_msg.lower():
+                print(f"Password-protected PDF: {os.path.basename(pdf_file_path)}")
+                print("💡 Please provide an unprotected version of this PDF.")
+            else:
+                print(f"Error extracting text from {os.path.basename(pdf_file_path)}: {error_msg}")
+            return []
+    
+    def process_documents(self, pdf_file_paths) -> List[Document]:
+        """Process PDF file paths and convert to documents with automatic metadata extraction."""
+        documents = []
+        processed_count = 0
+        failed_count = 0
+        
+        print(f"📄 Processing {len(pdf_file_paths)} document(s) with automatic metadata detection...") # Changed to print
+        
+        for pdf_file_path in pdf_file_paths:
+            if pdf_file_path.endswith('.pdf'):
+                filename = os.path.basename(pdf_file_path)
+                print(f"🔍 Extracting text from: **{filename}**") # Changed to print
+                
+                # Extract text per page
+                text_per_page = self.extract_text_from_pdf(pdf_file_path)
+                print(f"DEBUG: Extracted {len(text_per_page)} pages from {filename}")
+                
+                if text_per_page:
+                    # Combine first two pages for metadata extraction
+                    text_for_metadata = "\n".join(text_per_page[:2])
+                    print(f"DEBUG: Text for metadata extraction (first 500 chars): {text_for_metadata[:500]}")
+                    # Extract metadata using LLM
+                    print(f"🤖 Detecting metadata for: **{filename}**") # Changed to print
+                    extracted_metadata = self.sea_lion_llm.extract_metadata(text_for_metadata)
+                    
+                    # Create metadata
+                    metadata = {
+                        "source": filename,
+                        "university": extracted_metadata.get("university_name", "Unknown"),
+                        "country": extracted_metadata.get("country", "Unknown"),
+                        "document_type": extracted_metadata.get("document_type", "general_info"),
+                        "language": extracted_metadata.get("language", "Unknown"), # Added language
+                        "upload_timestamp": datetime.now().isoformat(),
+                        "file_id": str(uuid.uuid4())
+                    }
+                    
+                    # Create document
+                    doc = Document(
+                        page_content="\n".join(text_per_page), # Use all pages for document content
+                        metadata=metadata
+                    )
+                    documents.append(doc)
+                    processed_count += 1
+                    print(f"✅ Successfully processed: **{filename}** ({len(doc.page_content)} characters)") # Changed to print
+                else:
+                    failed_count += 1
+                    print(f"⚠️ Could not extract text from **{filename}**") # Changed to print
+            else:
+                failed_count += 1
+                filename = os.path.basename(pdf_file_path)
+                print(f"❌ Unsupported file type for {filename} (expected .pdf)") # Changed to print
+        
+        # Summary
+        if processed_count > 0:
+            print(f"🎉 Successfully processed **{processed_count}** document(s)") # Changed to print
+        if failed_count > 0:
+            print(f"⚠️ Failed to process **{failed_count}** document(s)") # Changed to print
+        
+        return documents
+    
+    def create_vector_store(self, documents: List[Document]) -> Chroma:
+        """Create and persist vector store from documents."""
+        if not documents:
+            print("No documents to process") # Changed to print
+            return None
+        
+        # Split documents into chunks
+        texts = self.text_splitter.split_documents(documents)
+        
+        # Create vector store
+        vectorstore = Chroma.from_documents(
+            documents=texts,
+            embedding=self.embeddings,
+            persist_directory=self.persist_directory
+        )
+        
+        return vectorstore
+    
+    def load_existing_vectorstore(self) -> Optional[Chroma]:
+        """Load existing vector store if it exists."""
+        try:
+            vectorstore = Chroma(
+                persist_directory=self.persist_directory,
+                embedding_function=self.embeddings
+            )
+            return vectorstore
+        except Exception as e:
+            print(f"Could not load existing vector store: {str(e)}") # Changed to print
+            return None
+
+class RAGSystem:
+    def __init__(self):
+        # Initialize embeddings - try BGE first, fallback to OpenAI
+        try:
+            self.embeddings = AlternativeEmbeddings()
+            if not self.embeddings.model:
+                # Fallback to OpenAI if BGE not available
+                self.embeddings = OpenAIEmbeddings()
+        except Exception:
+            # If both fail, use OpenAI as last resort
+            self.embeddings = OpenAIEmbeddings()
+            
+        self.sea_lion_llm = SEALionLLM()
+        self.persist_directory = os.getenv("CHROMA_PERSIST_DIRECTORY", "./chroma_db")
+        
+    def get_vectorstore(self) -> Optional[Chroma]:
+        """Get the vector store."""
+        try:
+            vectorstore = Chroma(
+                persist_directory=self.persist_directory,
+                embedding_function=self.embeddings
+            )
+            return vectorstore
+        except Exception as e:
+            print(f"Error loading vector store: {str(e)}")
+            return None
+    
+    def query(self, question: str, language: str = "English") -> Dict[str, Any]:
+        """Query the RAG system using SEA-LION models."""
+        vectorstore = self.get_vectorstore()
+        # if not vectorstore:
+        #     return {
+        #         "answer": "No documents have been ingested yet. Please upload some PDF documents first.",
+        #         "source_documents": [],
+        #         "query_id": None
+        #     }
+        
+        try:
+            # Retrieve relevant documents
+            retriever = vectorstore.as_retriever(search_kwargs={"k": 5})
+            relevant_docs = retriever.get_relevant_documents(question)
+            
+            # Prepare context from retrieved documents
+            context_parts = []
+            for i, doc in enumerate(relevant_docs, 1):
+                source_info = doc.metadata.get('source', 'Unknown')
+                university = doc.metadata.get('university', 'Unknown')
+                country = doc.metadata.get('country', 'Unknown')
+                
+                context_parts.append(f"""
+Document {i} (Source: {source_info}, University: {university}, Country: {country}):
+{doc.page_content[:500]}...
+""")
+            
+            context = "\n".join(context_parts)
+            
+            # Generate response using SEA-LION model
+            answer = self.sea_lion_llm.generate_response(
+                query=question, 
+                context=context, 
+                language=language
+            )
+            
+            # Generate query ID for sharing
+            query_id = str(uuid.uuid4())
+            
+            return {
+                "answer": answer,
+                "source_documents": relevant_docs,
+                "query_id": query_id,
+                "original_question": question,
+                "language": language,
+                "model_used": "SEA-LION" + (" Reasoning" if self.sea_lion_llm._is_complex_query(question) else " Instruct")
+            }
+            
+        except Exception as e:
+            print(f"Error querying system: {str(e)}")
+            return {
+                "answer": f"Error processing your question: {str(e)}",
+                "source_documents": [],
+                "query_id": None
+            }
+
+def save_query_result(query_result: Dict[str, Any]):
+    """Save query result for sharing."""
+    if query_result.get("query_id"):
+        results_dir = "query_results"
+        os.makedirs(results_dir, exist_ok=True)
+        
+        result_file = f"{results_dir}/{query_result['query_id']}.json"
+        
+        # Prepare data for saving (remove non-serializable objects)
+        save_data = {
+            "query_id": query_result["query_id"],
+            "question": query_result.get("original_question", ""),
+            "answer": query_result["answer"],
+            "language": query_result.get("language", "English"),
+            "timestamp": datetime.now().isoformat(),
+            "sources": [
+                {
+                    "source": doc.metadata.get("source", "Unknown"),
+                    "university": doc.metadata.get("university", "Unknown"),
+                    "country": doc.metadata.get("country", "Unknown"),
+                    "content_preview": doc.page_content[:200] + "..." if len(doc.page_content) > 200 else doc.page_content
+                }
+                for doc in query_result.get("source_documents", [])
+            ]
+        }
+        
+        try:
+            with open(result_file, 'w', encoding='utf-8') as f:
+                json.dump(save_data, f, indent=2, ensure_ascii=False)
+            return True
+        except Exception as e:
+            print(f"Error saving query result: {str(e)}")
+            return False
+    return False
+
+def load_shared_query(query_id: str) -> Optional[Dict[str, Any]]:
+    """Load a shared query result."""
+    result_file = f"query_results/{query_id}.json"
+    
+    if os.path.exists(result_file):
+        try:
+            with open(result_file, 'r', encoding='utf-8') as f:
+                return json.load(f)
+        except Exception as e:
+            print(f"Error loading shared query: {str(e)}")
+    
+    return None

utils/translations.py

@@ -0,0 +1,753 @@
+translations = {
+    "English": {
+        # Navigation
+        "search_universities": "🔍 Search Universities",
+        "upload_documents": "📄 Upload Documents", 
+        "manage_documents": "🗂 Manage Documents",
+        "about": "ℹ️ About Top.Edu",
+        "navigation": "🎯 Navigation",
+        
+        # Main header
+        "app_title": "🎓 Top.Edu",
+        "app_subtitle": "Unlock ASEAN Education with AI-Powered Search",
+        
+        # Search page
+        "search_header": "🔍 Search University Information",
+        "search_description": "Ask about admissions, fees, scholarships, and programs:",
+        "language_label": "Response Language",
+        "your_question": "Your question:",
+        "placeholder_text": "e.g., Master's in Malaysia under 40,000 RMB/year",
+        "example_queries": "💡 See Example Queries",
+        "complex_queries": "🧠 Complex Queries (Uses Reasoning Model)",
+        "simple_queries": "⚡ Simple Queries (Uses Instruct Model)",
+        "advanced_filters": "🔧 Advanced Filters (Optional)",
+        "budget_range": "Budget Range (Local Currency/Year)",
+        "study_level": "Study Level",
+        "preferred_countries": "Preferred Countries",
+        "search_button": "🔍 Search",
+        "ready_to_search": "✅ Ready to search! Click the search button when you're ready.",
+        "enter_question": "💭 Enter your question in the text box above to start searching.",
+        "using_example": "📝 Using example:",
+        "responses_in": "🌐 Responses will be in",
+        
+        # Upload page
+        "upload_header": "📄 Upload University Documents",
+        "upload_description": "Upload official PDF documents containing university admission requirements, fees, and program information.",
+        "university_name": "University Name",
+        "country": "Country",
+        "document_type": "Document Type",
+        "choose_files": "Choose PDF files",
+        "drag_drop": "Drag and drop files here",
+        "file_limit": "Limit 200MB per file • PDF",
+        "browse_files": "Browse files",
+        "process_documents": "🚀 Process Documents",
+        "processing_docs": "📄 Processing document(s)...",
+        "successfully_processed": "🎉 Successfully processed",
+        "failed_to_process": "⚠️ Failed to process",
+        "documents": "document(s)",
+        "no_docs_processed": "No documents were successfully processed.",
+        
+        # Document types
+        "admission_requirements": "Admission Requirements",
+        "tuition_fees": "Tuition Fees & Costs",
+        "program_information": "Program Information",
+        "scholarship_info": "Scholarship Information",
+        "application_deadlines": "Application Deadlines",
+        "general_info": "General Information",
+        
+        # Manage documents page
+        "manage_header": "🗂 Manage Documents",
+        "manage_description": "View and manage uploaded university documents in your knowledge base.",
+        "total_documents": "Total Documents",
+        "total_chunks": "Total Text Chunks",
+        "storage_size": "Storage Size",
+        "last_updated": "Last Updated",
+        "document_list": "📚 Document List",
+        "no_documents": "No documents found. Upload some documents first!",
+        "delete_all": "🗑️ Delete All Documents",
+        "confirm_delete": "⚠️ Are you sure you want to delete ALL documents? This cannot be undone.",
+        "yes_delete": "Yes, Delete All",
+        "documents_deleted": "All documents have been deleted.",
+        
+        # About page  
+        "about_header": "About Top.Edu",
+        "what_we_do": "🎯 What We Do",
+        "what_we_do_description": "Top.Edu helps students worldwide easily find accurate and up-to-date information on universities in Southeast Asia. Our platform aggregates official university documents and uses AI to answer questions about programs, tuition, entry requirements, and application deadlines.",
+        "who_we_are": "💡 Who We Are",
+        "who_we_are_description": "We are a team of education and AI enthusiasts dedicated to making higher education accessible and transparent. Our mission is to simplify the search process and provide trustworthy guidance to students looking to study abroad.",
+        "contact": "📞 Contact & Support",
+        "supported_languages": "🌏 Supported Languages",
+        
+        # Countries
+        "singapore": "Singapore",
+        "malaysia": "Malaysia", 
+        "thailand": "Thailand",
+        "indonesia": "Indonesia",
+        "philippines": "Philippines",
+        "vietnam": "Vietnam",
+        "brunei": "Brunei",
+        
+        # Study levels
+        "diploma": "Diploma",
+        "bachelor": "Bachelor",
+        "master": "Master", 
+        "phd": "PhD",
+        
+        # Budget options
+        "any": "Any",
+        "under_10k": "<10k",
+        "10k_20k": "10k-20k",
+        "20k_30k": "20k-30k", 
+        "30k_40k": "30k-40k",
+        "over_40k": ">40k",
+        
+        # Example queries
+        "example_complex_1": "Show me universities in Malaysia for master's degrees with tuition under 40,000 RMB per year",
+        "example_complex_2": "Compare engineering programs in Thailand and Singapore under $15,000 per year",
+        "example_complex_3": "Find MBA programs in ASEAN with GMAT requirements and scholarships available",
+        "example_complex_4": "Universities in Indonesia with English-taught programs and no IELTS requirement",
+        "example_simple_1": "What does IELTS stand for?",
+        "example_simple_2": "What is the difference between bachelor and master degree?",
+        "example_simple_3": "How to apply for student visa?",
+        "example_simple_4": "What documents are needed for university application?",
+        
+        # System messages
+        "systems_initialized": "✅ Systems initialized successfully!",
+        "can_upload_documents": "You can now upload documents.",
+        "initialization_error": "Error initializing systems",
+        "installation_help": """**Possible solutions:**
+1. Install sentence-transformers: `pip install sentence-transformers`
+2. Or provide OpenAI API key in environment variables
+3. Check that PyTorch is properly installed
+
+**For deployment:**
+- Ensure requirements.txt includes: sentence-transformers, torch, transformers""",
+        "please_initialize_first": "Please initialize systems first using the 'Initialize System' tab!",
+        "please_upload_pdf": "Please upload at least one PDF file.",
+        "upload_pdf_only": "Please upload PDF files only.",
+        "successfully_processed_docs": "Successfully processed",
+        "failed_create_vectorstore": "Failed to create vector store from documents.",
+        "no_docs_successfully_processed": "No documents were successfully processed. Please check if your PDFs are readable.",
+        "error_processing_docs": "Error processing documents",
+        "check_console": "Please check the console for more details.",
+        "please_upload_process_first": "Please upload and process documents first using the 'Upload Documents' tab!",
+        "please_enter_question": "Please enter a question.",
+        "processing_query": "Processing query",
+        "model_used": "Model Used",
+        "answer": "Answer",
+        "sources": "Sources",
+        "no_sources_found": "No specific sources found. This might be a general response.",
+        "error_querying_docs": "Error querying documents",
+        "ready_for_queries": "Ready for queries! Go to the 'Search & Query' tab to start asking questions.",
+        
+        # Interface elements
+        "initialize_system": "Initialize System",
+        "initialize_systems": "Initialize Systems",
+        "initialization_status": "Initialization Status",
+    },
+    
+    "中文": {
+        # Navigation
+        "search_universities": "🔍 搜索大学",
+        "upload_documents": "📄 上传文档",
+        "manage_documents": "🗂 管理文档",
+        "about": "ℹ️ 关于Top.Edu",
+        "navigation": "🎯 导航",
+        
+        # Main header
+        "app_title": "🎓 Top.Edu",
+        "app_subtitle": "用AI驱动的搜索解锁东盟教育机会",
+        
+        # Search page
+        "search_header": "🔍 搜索大学信息",
+        "search_description": "询问关于入学要求、学费、奖学金和专业项目:",
+        "language_label": "回复语言",
+        "your_question": "您的问题:",
+        "placeholder_text": "例如：马来西亚硕士学位，学费低于4万人民币/年",
+        "example_queries": "💡 查看示例问题",
+        "complex_queries": "🧠 复杂查询（使用推理模型）",
+        "simple_queries": "⚡ 简单查询（使用指令模型）",
+        "advanced_filters": "🔧 高级筛选（可选）",
+        "budget_range": "预算范围（当地货币/年）",
+        "study_level": "学历层次",
+        "preferred_countries": "首选国家",
+        "search_button": "🔍 搜索",
+        "ready_to_search": "✅ 准备搜索！准备好后点击搜索按钮。",
+        "enter_question": "💭 在上面的文本框中输入您的问题开始搜索。",
+        "using_example": "📝 使用示例:",
+        "responses_in": "🌐 回复将使用",
+        
+        # Upload page
+        "upload_header": "📄 上传大学文档",
+        "upload_description": "上传包含大学入学要求、学费和专业信息的官方PDF文档。",
+        "university_name": "大学名称",
+        "country": "国家",
+        "document_type": "文档类型",
+        "choose_files": "选择PDF文件",
+        "drag_drop": "将文件拖放到此处",
+        "file_limit": "限制每个文件200MB • PDF",
+        "browse_files": "浏览文件",
+        "process_documents": "🚀 处理文档",
+        "processing_docs": "📄 正在处理文档...",
+        "successfully_processed": "🎉 成功处理",
+        "failed_to_process": "⚠️ 处理失败",
+        "documents": "个文档",
+        "no_docs_processed": "没有成���处理任何文档。",
+        
+        # Document types
+        "admission_requirements": "入学要求",
+        "tuition_fees": "学费和费用",
+        "program_information": "专业信息",
+        "scholarship_info": "奖学金信息",
+        "application_deadlines": "申请截止日期",
+        "general_info": "一般信息",
+        
+        # Manage documents page
+        "manage_header": "🗂 管理文档",
+        "manage_description": "查看和管理您知识库中上传的大学文档。",
+        "total_documents": "文档总数",
+        "total_chunks": "文本块总数",
+        "storage_size": "存储大小",
+        "last_updated": "最后更新",
+        "document_list": "📚 文档列表",
+        "no_documents": "未找到文档。请先上传一些文档！",
+        "delete_all": "🗑️ 删除所有文档",
+        "confirm_delete": "⚠️ 您确定要删除所有文档吗？此操作无法撤消。",
+        "yes_delete": "是的，删除全部",
+        "documents_deleted": "所有文档已被删除。",
+        
+        # About page
+        "about_header": "关于 Top.Edu",
+        "what_we_do": "🎯 我们的工作",
+        "what_we_do_description": "Top.Edu 帮助全球学生轻松获取东南亚高校的准确且最新的信息。我们的平台整合官方大学文件，并利用 AI 回答有关课程、学费、入学要求和申请截止日期的问题。",
+        "who_we_are": "💡 我们是谁",
+        "who_we_are_description": "我们是一支热衷教育与 AI 的团队，致力于让高等教育变得更透明可及。我们的使命是简化搜索流程，为希望出国留学的学生提供可靠指导。",
+        "contact": "📞 联系与支持",
+        "supported_languages": "🌏 支持语言",
+        
+        # Countries
+        "singapore": "新加坡",
+        "malaysia": "马来西亚",
+        "thailand": "泰国",
+        "indonesia": "印度尼西亚",
+        "philippines": "菲律宾",
+        "vietnam": "越南",
+        "brunei": "文莱",
+        
+        # Study levels
+        "diploma": "文凭",
+        "bachelor": "学士",
+        "master": "硕士",
+        "phd": "博士",
+        
+        # Budget options
+        "any": "任意",
+        "under_10k": "<1万",
+        "10k_20k": "1-2万",
+        "20k_30k": "2-3万",
+        "30k_40k": "3-4万", 
+        "over_40k": ">4万",
+        
+        # Example queries
+        "example_complex_1": "为我推荐马来西亚学费低于4万人民币/年的硕士学位项目",
+        "example_complex_2": "比较泰国和新加坡学费低于1.5万美元/年的工程专业",
+        "example_complex_3": "寻找东盟地区有GMAT要求和奖学金的MBA项目",
+        "example_complex_4": "印尼有英语授课且无需雅思的大学项目",
+        "example_simple_1": "IELTS是什么意思？",
+        "example_simple_2": "学士学位和硕士学位有什么区别？",
+        "example_simple_3": "如何申请学生签证？",
+        "example_simple_4": "大学申请需要哪些文件？",
+        
+        # System messages
+        "systems_initialized": "✅ 系统初始化成功！",
+        "can_upload_documents": "您现在可以上传文档。",
+        "initialization_error": "系统初始化错误",
+        "installation_help": """**可能的解决方案：**
+1. 安装 sentence-transformers: `pip install sentence-transformers`
+2. 或在环境变量中提供 OpenAI API 密钥
+3. 检查 PyTorch 是否正确安装
+
+**部署时：**
+- 确保 requirements.txt 包含：sentence-transformers, torch, transformers""",
+        "please_initialize_first": "请先使用'初始化系统'选项卡初始化系统！",
+        "please_upload_pdf": "请至少上传一个PDF文件。",
+        "upload_pdf_only": "请仅上传PDF文件。",
+        "successfully_processed_docs": "成功处理",
+        "failed_create_vectorstore": "创建向量存储失败。",
+        "no_docs_successfully_processed": "没有成功处理任何文档。请检查您的PDF是否可读。",
+        "error_processing_docs": "处理文档时出错",
+        "check_console": "请查看控制台获取更多详细信息。",
+        "please_upload_process_first": "请先使用'上传文档'选项卡上传和处理文档！",
+        "please_enter_question": "请输入问题。",
+        "processing_query": "正在处理查询",
+        "model_used": "使用的模型",
+        "answer": "答案",
+        "sources": "来源",
+        "no_sources_found": "未找到特定来源。这可能是一般性回答。",
+        "error_querying_docs": "查询文档时出错",
+        "ready_for_queries": "准备查询！前往'搜索与查询'选项卡开始提问。",
+        
+        # Interface elements
+        "initialize_system": "初始化系统",
+        "initialize_systems": "初始化系统",
+        "initialization_status": "初始化状态",
+    },
+    
+    "Malay": {
+        # Navigation
+        "search_universities": "🔍 Cari Universiti",
+        "upload_documents": "📄 Muat Naik Dokumen",
+        "manage_documents": "🗂 Urus Dokumen",
+        "about": "ℹ️ Mengenai Top.Edu",
+        "navigation": "🎯 Navigasi",
+        
+        # Main header
+        "app_title": "🎓 Top.Edu",
+        "app_subtitle": "Buka Pendidikan ASEAN dengan Carian Berkuasa AI",
+        
+        # Search page
+        "search_header": "🔍 Cari Maklumat Universiti",
+        "search_description": "Tanya tentang kemasukan, yuran, biasiswa, dan program:",
+        "language_label": "Bahasa Respons",
+        "your_question": "Soalan anda:",
+        "placeholder_text": "cth: Ijazah Sarjana di Malaysia di bawah 40,000 RMB/tahun",
+        "example_queries": "💡 Lihat Contoh Soalan",
+        "complex_queries": "🧠 Soalan Kompleks (Menggunakan Model Penaakulan)",
+        "simple_queries": "⚡ Soalan Mudah (Menggunakan Model Arahan)",
+        "advanced_filters": "🔧 Penapis Lanjutan (Pilihan)",
+        "budget_range": "Julat bajet (mata wang tempatan/tahun)",
+        "study_level": "Tahap Pengajian",
+        "preferred_countries": "Negara Pilihan",
+        "search_button": "🔍 Cari",
+        "ready_to_search": "✅ Sedia untuk cari! Klik butang cari bila anda sedia.",
+        "enter_question": "💭 Masukkan soalan anda di kotak teks di atas untuk mula mencari.",
+        "using_example": "📝 Menggunakan contoh:",
+        "responses_in": "🌐 Respons akan dalam bahasa",
+        
+        # Upload page
+        "upload_header": "📄 Muat Naik Dokumen Universiti",
+        "upload_description": "Muat naik dokumen PDF rasmi yang mengandungi keperluan kemasukan universiti, yuran, dan maklumat program.",
+        "university_name": "Nama Universiti",
+        "country": "Negara",
+        "document_type": "Jenis Dokumen",
+        "choose_files": "Pilih fail PDF",
+        "drag_drop": "Seret dan lepas fail di sini",
+        "file_limit": "Had 200MB setiap fail • PDF",
+        "browse_files": "Layari fail",
+        "process_documents": "🚀 Proses Dokumen",
+        "processing_docs": "📄 Memproses dokumen...",
+        "successfully_processed": "🎉 Berjaya diproses",
+        "failed_to_process": "⚠️ Gagal diproses",
+        "documents": "dokumen",
+        "no_docs_processed": "Tiada dokumen yang berjaya diproses.",
+        
+        # Document types
+        "admission_requirements": "Keperluan Kemasukan",
+        "tuition_fees": "Yuran Pengajian & Kos",
+        "program_information": "Maklumat Program",
+        "scholarship_info": "Maklumat Biasiswa",
+        "application_deadlines": "Tarikh Tutup Permohonan",
+        "general_info": "Maklumat Umum",
+        
+        # Manage documents page
+        "manage_header": "🗂 Urus Dokumen",
+        "manage_description": "Lihat dan urus dokumen universiti yang dimuat naik dalam pangkalan pengetahuan anda.",
+        "total_documents": "Jumlah Dokumen",
+        "total_chunks": "Jumlah Bahagian Teks",
+        "storage_size": "Saiz Storan",
+        "last_updated": "Kemaskini Terakhir",
+        "document_list": "📚 Senarai Dokumen",
+        "no_documents": "Tiada dokumen dijumpai. Muat naik beberapa dokumen dahulu!",
+        "delete_all": "🗑️ Padam Semua Dokumen",
+        "confirm_delete": "⚠️ Adakah anda pasti mahu memadam SEMUA dokumen? Tindakan ini tidak boleh dibatalkan.",
+        "yes_delete": "Ya, Padam Semua",
+        "documents_deleted": "Semua dokumen telah dipadam.",
+        
+        # About page  
+        "about_header": "Tentang Top.Edu",
+        "what_we_do": "🎯 Apa Yang Kami Lakukan",
+        "what_we_do_description": "Top.Edu membantu pelajar di seluruh dunia untuk mencari maklumat tepat dan terkini mengenai universiti di Asia Tenggara dengan mudah. Platform kami menggabungkan dokumen rasmi universiti dan menggunakan AI untuk menjawab soalan tentang program, yuran pengajian, syarat kemasukan, dan tarikh akhir permohonan.",
+        "who_we_are": "💡 Siapa Kami",
+        "who_we_are_description": "Kami adalah pasukan yang berminat dalam pendidikan dan AI, berdedikasi untuk menjadikan pendidikan tinggi lebih mudah diakses dan telus. Misi kami adalah mempermudah proses carian dan memberikan panduan yang boleh dipercayai kepada pelajar yang ingin belajar di luar negara.",
+        "contact": "📞 Hubungi & Sokongan",
+        "supported_languages": "🌏 Bahasa Disokong",
+        
+        # Countries
+        "singapore": "Singapura",
+        "malaysia": "Malaysia",
+        "thailand": "Thailand",
+        "indonesia": "Indonesia",
+        "philippines": "Filipina",
+        "vietnam": "Vietnam",
+        "brunei": "Brunei",
+        
+        # Study levels
+        "diploma": "Diploma",
+        "bachelor": "Sarjana Muda",
+        "master": "Sarjana",
+        "phd": "PhD",
+        
+        # Budget options
+        "any": "Mana-mana",
+        "under_10k": "<10k",
+        "10k_20k": "10k-20k",
+        "20k_30k": "20k-30k",
+        "30k_40k": "30k-40k", 
+        "over_40k": ">40k",
+        
+        # Example queries
+        "example_complex_1": "Tunjukkan saya universiti di Malaysia untuk ijazah sarjana dengan yuran di bawah 40,000 RMB setahun",
+        "example_complex_2": "Bandingkan program kejuruteraan di Thailand dan Singapura di bawah $15,000 setahun",
+        "example_complex_3": "Cari program MBA di ASEAN dengan keperluan GMAT dan biasiswa tersedia",
+        "example_complex_4": "Universiti di Indonesia dengan program bahasa Inggeris dan tanpa keperluan IELTS",
+        "example_simple_1": "Apakah maksud IELTS?",
+        "example_simple_2": "Apakah perbezaan antara ijazah sarjana muda dan sarjana?",
+        "example_simple_3": "Bagaimana untuk memohon visa pelajar?",
+        "example_simple_4": "Dokumen apakah yang diperlukan untuk permohonan universiti?",
+    },
+    
+    "ไทย": {
+        # Navigation  
+        "search_universities": "🔍 ค้นหามหาวิทยาลัย",
+        "upload_documents": "📄 อัพโหลดเอกสาร",
+        "manage_documents": "🗂 จัดการเอกสาร",
+        "about": "ℹ️ เกี่ยวกับ Top.Edu",
+        "navigation": "🎯 เมนูหลัก",
+        
+        # Main header
+        "app_title": "🎓 Top.Edu",
+        "app_subtitle": "ปลดล็อกการศึกษาอาเซียนด้วยการค้นหาที่ขับเคลื่อนด้วย AI",
+        
+        # Search page
+        "search_header": "🔍 ค้นหาข้อมูลมหาวิทยาลัย",
+        "search_description": "ถามเกี่ยวกับการเข้าเรียน ค่าใช้จ่าย ทุนการศึกษา และหลักสูตร:",
+        "language_label": "ภาษาการตอบ",
+        "your_question": "คำถามของคุณ:",
+        "placeholder_text": "เช่น ปริญญาโทในมาเลเซียต่ำกว่า 40,000 หยวนจีน/ปี",
+        "example_queries": "💡 ดูตัวอย่างคำถาม",
+        "complex_queries": "🧠 คำถามซับซ้อน (ใช้โมเดลการให้เหตุผล)",
+        "simple_queries": "⚡ คำถามง่าย (ใช้โมเดลคำสั่ง)",
+        "advanced_filters": "🔧 ตัวกรองขั้นสูง (ตัวเลือก)",
+        "budget_range": "ช่วงงบประมาณ (สกุลเงินท้องถิ่น/ปี)",
+        "study_level": "ระดับการศึกษา",
+        "preferred_countries": "ประเทศที่ต้องการ",
+        "search_button": "🔍 ค้นหา",
+        "ready_to_search": "✅ พร้อมค้นหา! คลิกปุ่มค้นหาเมื่อคุณพร้อม",
+        "enter_question": "💭 ใส่คำถามในกล่องข้อความด้านบนเพื่อเริ่มค้นหา",
+        "using_example": "📝 ใช้ตัวอย่าง:",
+        "responses_in": "🌐 จะตอบเป็นภาษา",
+        
+        # Upload page
+        "upload_header": "📄 อัพโหลดเอกสารมหาวิทยาลัย",
+        "upload_description": "อัพโหลดเอกสาร PDF ที่มีข้อกำหนดการรับเข้า ค่าธรรมเนียม และข้อมูลหลักสูตร",
+        "university_name": "ชื่อมหาวิทยาลัย",
+        "country": "ประเทศ",
+        "document_type": "ประเภทเอกสาร",
+        "choose_files": "เลือกไฟล์ PDF",
+        "file_limit": "จำกัด 200MB ต่อไฟล์ • PDF",
+        "process_documents": "🚀 ประมวลผลเอกสาร",
+        "processing_docs": "📄 กำลังประมวลผลเอกสาร...",
+        "successfully_processed": "🎉 ประมวลผลสำเร็จ",
+        "failed_to_process": "⚠️ ประมวลผลล้มเหลว",
+        "documents": "เอกสาร",
+        "no_docs_processed": "ไม่สามารถประมวลผลเอกสารใดได้สำเร็จ",
+        
+        # Document types
+        "admission_requirements": "ข้อกำหนดการรับเข้า",
+        "tuition_fees": "ค่าธรรมเนียมการศึกษา",
+        "program_information": "ข้อมูลหลักสูตร",
+        "scholarship_info": "ข้อมูลทุนการศึกษา",
+        "application_deadlines": "กำหนดส่งใบสมัคร",
+        "general_info": "ข้อมูลทั่วไป",
+        
+        # Manage documents page
+        "manage_header": "🗂 จัดกา��เอกสาร",
+        "manage_description": "ดูและจัดการเอกสารมหาวิทยาลัยในฐานข้อมูลของคุณ",
+        "total_documents": "เอกสารทั้งหมด",
+        "total_chunks": "ส่วนข้อความทั้งหมด",
+        "storage_size": "ขนาดที่เก็บข้อมูล",
+        "last_updated": "อัปเดตล่าสุด",
+        "document_list": "📚 รายการเอกสาร",
+        "no_documents": "ไม่พบเอกสาร อัปโหลดเอกสารก่อน!",
+        "delete_all": "🗑️ ลบเอกสารทั้งหมด",
+        "documents_deleted": "เอกสารทั้งหมดถูกลบแล้ว",
+        
+        # About page
+        "about_header": "เกี่ยวกับ Top.Edu",
+        "what_we_do": "🎯 สิ่งที่เราทำ",
+        "what_we_do_description": "Top.Edu ช่วยให้นักเรียนทั่วโลกสามารถค้นหาข้อมูลที่ถูกต้องและทันสมัยเกี่ยวกับมหาวิทยาลัยในเอเชียตะวันออกเฉียงใต้ได้อย่างง่ายดาย แพลตฟอร์มของเรารวบรวมเอกสารทางการของมหาวิทยาลัยและใช้ AI เพื่อตอบคำถามเกี่ยวกับหลักสูตร ค่าเล่าเรียน ข้อกำหนดการเข้าเรียน และกำหนดส่งใบสมัคร",
+        "who_we_are": "💡 เราคือใคร",
+        "who_we_are_description": "เราคือทีมผู้ที่ชื่นชอบการศึกษาและ AI มุ่งมั่นที่จะทำให้การศึกษาระดับอุดมศึกษาสามารถเข้าถึงได้และโปร่งใส ภารกิจของเราคือทำให้กระบวนการค้นหาง่ายขึ้นและให้คำแนะนำที่เชื่อถือได้แก่นักเรียนที่ต้องการศึกษาต่อต่างประเทศ",
+        "contact": "📞 ติดต่อ & สนับสนุน",
+        "supported_languages": "🌏 ภาษาที่รองรับ",
+        
+        # Countries
+        "singapore": "สิงคโปร์",
+        "malaysia": "มาเลเซีย", 
+        "thailand": "ไทย",
+        "indonesia": "อินโดนีเซีย",
+        "philippines": "ฟิลิปปินส์",
+        "vietnam": "เวียดนาม",
+        "brunei": "บรูไน",
+        
+        # Study levels
+        "diploma": "ประกาศนียบัตร",
+        "bachelor": "ปริญญาตรี",
+        "master": "ปริญญาโท",
+        "phd": "ปริญญาเอก",
+        
+        # Budget options
+        "any": "ใดก็ได้",
+        "under_10k": "<10k",
+        "10k_20k": "10k-20k",
+        "20k_30k": "20k-30k",
+        "30k_40k": "30k-40k",
+        "over_40k": ">40k",
+        
+        # Example queries
+        "example_complex_1": "แสดงมหาวิทยาลัยในมาเลเซียสำหรับปริญญาโทที่มีค่าเล่าเรียนต่ำกว่า 40,000 หยวนต่อปี",
+        "example_complex_2": "เปรียบเทียบหลักสูตรวิศวกรรมในไทยและสิงคโปร์ต่ำกว่า $15,000 ต่อปี",
+        "example_complex_3": "ค้นหาหลักสูตร MBA ในอาเซียนที่มีข้อกำหนด GMAT และทุนการศึกษา",
+        "example_complex_4": "มหาวิทยาลัยในอินโดนีเซียที่มีหลักสูตรสอนภาษาอังกฤษและไม่ต้องการ IELTS",
+        "example_simple_1": "IELTS ย่อมาจากอะไร?",
+        "example_simple_2": "ความแตกต่างระหว่างปริญญาตรีและปริญญาโทคืออะไร?",
+        "example_simple_3": "วิธีสมัครวีซ่านักเรียนอย่างไร?",
+        "example_simple_4": "เอกสารอะไรบ้างที่จำเป็นสำหรับการสมัครเข้ามหาวิทยาลัย?",
+    },
+    
+    "Indonesian": {
+        # Navigation
+        "search_universities": "�� Cari Universitas",
+        "upload_documents": "📄 Unggah Dokumen",
+        "manage_documents": "🗂 Kelola Dokumen",
+        "about": "ℹ️ Tentang Top.Edu",
+        "navigation": "🎯 Navigasi",
+        
+        # Main header
+        "app_title": "🎓 Top.Edu",
+        "app_subtitle": "Buka Pendidikan ASEAN dengan Pencarian Bertenaga AI",
+        
+        # Search page
+        "search_header": "🔍 Cari Informasi Universitas",
+        "search_description": "Tanya tentang penerimaan, biaya, beasiswa, dan program:",
+        "language_label": "Bahasa Respon",
+        "your_question": "Pertanyaan Anda:",
+        "placeholder_text": "mis: Magister di Malaysia di bawah 40.000 RMB/tahun",
+        "example_queries": "💡 Lihat Contoh Pertanyaan",
+        "complex_queries": "🧠 Pertanyaan Kompleks (Menggunakan Model Penalaran)",
+        "simple_queries": "⚡ Pertanyaan Sederhana (Menggunakan Model Instruksi)",
+        "advanced_filters": "🔧 Filter Lanjutan (Opsional)",
+        "budget_range": "Rentang anggaran (mata uang lokal/tahun)",
+        "study_level": "Tingkat Studi",
+        "preferred_countries": "Negara Pilihan",
+        "search_button": "🔍 Cari",
+        "ready_to_search": "✅ Siap mencari! Klik tombol cari saat Anda siap.",
+        "enter_question": "💭 Masukkan pertanyaan di kotak teks di atas untuk mulai mencari.",
+        "using_example": "📝 Menggunakan contoh:",
+        "responses_in": "🌐 Respon akan dalam bahasa",
+        
+        # Upload page
+        "upload_header": "📄 Unggah Dokumen Universitas",
+        "upload_description": "Unggah dokumen PDF berisi persyaratan masuk universitas, biaya, dan informasi program.",
+        "university_name": "Nama Universitas",
+        "country": "Negara",
+        "document_type": "Jenis Dokumen",
+        "choose_files": "Pilih file PDF",
+        "file_limit": "Batas 200MB per file • PDF",
+        "process_documents": "🚀 Proses Dokumen",
+        "processing_docs": "📄 Memproses dokumen...",
+        "successfully_processed": "🎉 Berhasil diproses",
+        "failed_to_process": "⚠️ Gagal diproses",
+        "documents": "dokumen",
+        "no_docs_processed": "Tidak ada dokumen yang berhasil diproses.",
+        
+        # Document types
+        "admission_requirements": "Persyaratan Masuk",
+        "tuition_fees": "Biaya Kuliah & Biaya",
+        "program_information": "Informasi Program",
+        "scholarship_info": "Informasi Beasiswa",
+        "application_deadlines": "Batas Waktu Aplikasi",
+        "general_info": "Informasi Umum",
+        
+        # Manage documents page
+        "manage_header": "🗂 Kelola Dokumen",
+        "manage_description": "Lihat dan kelola dokumen universitas dalam basis pengetahuan Anda.",
+        "total_documents": "Total Dokumen",
+        "total_chunks": "Total Bagian Teks",
+        "storage_size": "Ukuran Penyimpanan",
+        "last_updated": "Terakhir Diperbarui",
+        "document_list": "📚 Daftar Dokumen",
+        "no_documents": "Tidak ada dokumen ditemukan. Unggah beberapa dokumen terlebih dahulu!",
+        "delete_all": "🗑️ Hapus Semua Dokumen",
+        "documents_deleted": "Semua dokumen telah dihapus.",
+        
+        # About page
+        "about_header": "Tentang Top.Edu",
+        "what_we_do": "🎯 Apa Yang Kami Lakukan",
+        "what_we_do_description": "Top.Edu membantu mahasiswa di seluruh dunia dengan mudah menemukan informasi yang akurat dan terbaru tentang universitas di Asia Tenggara. Platform kami mengumpulkan dokumen resmi universitas dan menggunakan AI untuk menjawab pertanyaan tentang program, biaya kuliah, persyaratan masuk, dan tenggat waktu pendaftaran.",
+        "who_we_are": "💡 Siapa Kami",
+        "who_we_are_description": "Kami adalah tim yang bersemangat di bidang pendidikan dan AI, berdedikasi untuk membuat pendidikan tinggi lebih mudah diakses dan transparan. Misi kami adalah menyederhanakan proses pencarian dan memberikan panduan terpercaya bagi mahasiswa yang ingin belajar di luar negeri.",
+        "contact": "📞 Kontak & Dukungan",
+        "supported_languages": "🌏 Bahasa Didukung",
+        
+        # Countries
+        "singapore": "Singapura",
+        "malaysia": "Malaysia",
+        "thailand": "Thailand", 
+        "indonesia": "Indonesia",
+        "philippines": "Filipina",
+        "vietnam": "Vietnam",
+        "brunei": "Brunei",
+        
+        # Study levels
+        "diploma": "Diploma",
+        "bachelor": "Sarjana",
+        "master": "Magister",
+        "phd": "Doktor",
+        
+        # Budget options
+        "any": "Apa saja",
+        "under_10k": "<10k",
+        "10k_20k": "10k-20k",
+        "20k_30k": "20k-30k",
+        "30k_40k": "30k-40k",
+        "over_40k": ">40k",
+        
+        # Example queries
+        "example_complex_1": "Tunjukkan universitas di Malaysia untuk gelar magister dengan biaya kuliah di bawah 40.000 RMB per tahun",
+        "example_complex_2": "Bandingkan program teknik di Thailand dan Singapura di bawah $15.000 per tahun",
+        "example_complex_3": "Cari program MBA di ASEAN dengan persyaratan GMAT dan beasiswa tersedia",
+        "example_complex_4": "Universitas di Indonesia dengan program berbahasa Inggris tanpa persyaratan IELTS",
+        "example_simple_1": "Apa kepanjangan dari IELTS?",
+        "example_simple_2": "Apa perbedaan antara gelar sarjana dan magister?",
+        "example_simple_3": "Bagaimana cara mengajukan visa pelajar?",
+        "example_simple_4": "Dokumen apa saja yang diperlukan untuk aplikasi universitas?",
+    },
+    
+    "Tiếng Việt": {
+        # Navigation
+        "search_universities": "🔍 Tìm kiếm Trường đại học",
+        "upload_documents": "📄 Tải lên Tài liệu",
+        "manage_documents": "🗂 Quản lý Tài liệu", 
+        "about": "ℹ️ Về Top.Edu",
+        "navigation": "🎯 Điều hướng",
+        
+        # Main header
+        "app_title": "🎓 Top.Edu",
+        "app_subtitle": "Mở khóa Giáo dục ASEAN với Tìm kiếm được hỗ trợ bởi AI",
+        
+        # Search page
+        "search_header": "🔍 Tìm kiếm Thông tin Trường đại học",
+        "search_description": "Hỏi về tuyển sinh, học phí, học bổng và chương trình:",
+        "language_label": "Ngôn ngữ Phản hồi",
+        "your_question": "Câu hỏi của bạn:",
+        "placeholder_text": "vd: Thạc sĩ tại Malaysia dưới 40.000 tệ/năm",
+        "example_queries": "💡 Xem Câu hỏi Mẫu",
+        "complex_queries": "🧠 Câu hỏi Phức tạp (Sử dụng Mô hình Lý luận)",
+        "simple_queries": "⚡ Câu hỏi Đơn giản (Sử dụng Mô hình Hướng dẫn)",
+        "advanced_filters": "🔧 Bộ lọc Nâng cao (Tùy chọn)",
+        "budget_range": "Khoảng ngân sách (tiền tệ địa phương/năm)",
+        "study_level": "Bậc học",
+        "preferred_countries": "Quốc gia Ưa thích",
+        "search_button": "🔍 Tìm kiếm",
+        "ready_to_search": "✅ Sẵn sàng tìm kiếm! Nhấp vào nút tìm kiếm khi bạn sẵn sàng.",
+        "enter_question": "💭 Nhập câu hỏi vào hộp văn bản ở trên để bắt đầu tìm kiếm.",
+        "using_example": "📝 Sử dụng ví dụ:",
+        "responses_in": "🌐 Phản hồi sẽ bằng tiếng",
+        
+        # Upload page
+        "upload_header": "📄 Tải lên Tài liệu Đại học",
+        "upload_description": "Tải lên tài liệu PDF chứa yêu cầu tuyển sinh, học phí và thông tin chương trình của đại học.",
+        "university_name": "Tên Đại học",
+        "country": "Quốc gia",
+        "document_type": "Loại Tài liệu",
+        "choose_files": "Chọn file PDF",
+        "file_limit": "Giới hạn 200MB mỗi file • PDF",
+        "process_documents": "🚀 Xử lý Tài liệu",
+        "processing_docs": "📄 Đang xử lý tài liệu...",
+        "successfully_processed": "🎉 Xử lý thành công",
+        "failed_to_process": "⚠️ Xử lý thất bại",
+        "documents": "tài liệu",
+        "no_docs_processed": "Không có tài liệu nào được xử lý thành công.",
+        
+        # Document types
+        "admission_requirements": "Yêu cầu Tuyển sinh",
+        "tuition_fees": "Học phí & Chi phí",
+        "program_information": "Thông tin Chương trình",
+        "scholarship_info": "Thông tin Học bổng",
+        "application_deadlines": "Hạn nộp Đơn",
+        "general_info": "Thông tin Chung",
+        
+        # Manage documents page
+        "manage_header": "🗂 Quản lý Tài liệu",
+        "manage_description": "Xem và quản lý tài liệu đại học trong cơ sở tri thức của bạn.",
+        "total_documents": "Tổng Tài liệu",
+        "total_chunks": "Tổng Đoạn Văn bản",
+        "storage_size": "Kích thước Lưu trữ",
+        "last_updated": "Cập nhật Cuối",
+        "document_list": "📚 Danh sách Tài liệu",
+        "no_documents": "Không tìm thấy tài liệu. Hãy tải lên một số tài liệu trước!",
+        "delete_all": "🗑️ Xóa Tất cả Tài liệu",
+        "documents_deleted": "Tất cả tài liệu đã được xóa.",
+        
+        # About page
+        "about_header": "Về Top.Edu",
+        "what_we_do": "🎯 Chúng tôi làm gì",
+        "what_we_do_description": "Top.Edu giúp sinh viên toàn cầu dễ dàng tìm thông tin chính xác và cập nhật về các trường đại học ở Đông Nam Á. Nền tảng của chúng tôi tổng hợp các tài liệu chính thức của trường và sử dụng AI để trả lời các câu hỏi về chương trình học, học phí, yêu cầu đầu vào và hạn nộp hồ sơ.",
+        "who_we_are": "💡 Chúng tôi là ai",
+        "who_we_are_description": "Chúng tôi là nhóm những người đam mê giáo dục và AI, cam kết làm cho giáo dục đại học trở nên dễ tiếp cận và minh bạch. Sứ mệnh của chúng tôi là đơn giản hóa quá trình tìm kiếm và cung cấp hướng dẫn đáng tin cậy cho sinh viên muốn du học.",
+        "contact": "📞 Liên hệ & Hỗ trợ",
+        "supported_languages": "🌏 Ngôn ngữ được hỗ trợ",        
+        # Countries
+        "singapore": "Singapore",
+        "malaysia": "Malaysia",
+        "thailand": "Thái Lan",
+        "indonesia": "Indonesia", 
+        "philippines": "Philippines",
+        "vietnam": "Việt Nam",
+        "brunei": "Brunei",
+        
+        # Study levels
+        "diploma": "Chứng chỉ",
+        "bachelor": "Cử nhân",
+        "master": "Thạc sĩ",
+        "phd": "Tiến sĩ",
+        
+        # Budget options
+        "any": "Bất kỳ",
+        "under_10k": "<10k",
+        "10k_20k": "10k-20k",
+        "20k_30k": "20k-30k",
+        "30k_40k": "30k-40k",
+        "over_40k": ">40k",
+        
+        # Example queries
+        "example_complex_1": "Cho tôi xem các trường đại học ở Malaysia cho bằng thạc sĩ với học phí dưới 40.000 tệ/năm",
+        "example_complex_2": "So sánh các chương trình kỹ thuật ở Thái Lan và Singapore dưới $15.000/năm",
+        "example_complex_3": "Tìm các chương trình MBA ở ASEAN có yêu cầu GMAT và học bổng",
+        "example_complex_4": "Các trường đại học ở Indonesia với chương trình giảng dạy bằng tiếng Anh không yêu cầu IELTS",
+        "example_simple_1": "IELTS là viết tắt của gì?",
+        "example_simple_2": "Sự khác biệt giữa bằng cử nhân và thạc sĩ là gì?",
+        "example_simple_3": "Làm thế nào để xin visa du học?",
+        "example_simple_4": "Những tài liệu gì cần thiết cho đơn xin học đại học?",
+    }
+}
+
+def get_text(key: str, lang: str = "English") -> str:
+    """Get translated text for a given key and language"""
+    if lang in translations and key in translations[lang]:
+        return translations[lang][key]
+    # Fallback to English if translation not found
+    return translations["English"].get(key, key)
+
+def get_language_code(display_name: str) -> str:
+    """Convert display name to language code"""
+    language_map = {
+        "English": "English",
+        "中文 (Chinese)": "中文", 
+        "Bahasa Malaysia": "Malay",
+        "ไทย (Thai)": "ไทย",
+        "Bahasa Indonesia": "Indonesian",
+        "Tiếng Việt (Vietnamese)": "Tiếng Việt"
+    }
+    return language_map.get(display_name, "English")