Update app.py

app.py

@@ -1,803 +1,971 @@
-import os
-os.environ["PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION"] = "python"
-import glob
-import json
-import sqlite3
-from datetime import datetime, timedelta
-from typing import Dict, List, Optional, Tuple
-from dataclasses import dataclass, asdict
-from collections import defaultdict
-import re
-
-from dotenv import load_dotenv
-import gradio as gr
-
-from langchain_community.document_loaders import DirectoryLoader, TextLoader
-from langchain.text_splitter import CharacterTextSplitter
-from langchain.schema import Document
-from langchain_chroma import Chroma
-from langchain_google_genai import GoogleGenerativeAIEmbeddings, ChatGoogleGenerativeAI
-from langchain_huggingface import HuggingFaceEmbeddings
-from langchain.memory import ConversationBufferMemory
-from langchain.chains import ConversationalRetrievalChain
-import numpy as np
-
-@dataclass
-class LearningSession:
-    session_id: str
-    user_id: str
-    start_time: datetime
-    end_time: Optional[datetime] = None
-    words_learned: int = 0
-    idioms_learned: int = 0
-    questions_asked: int = 0
-
-@dataclass
-class WordProgress:
-    word: str
-    definition: str
-    category: str  
-    first_encountered: datetime
-    last_reviewed: datetime
-    encounter_count: int
-    mastery_level: int 
-    correct_answers: int
-    total_questions: int
-
-class PersonalizedLearningTracker:
-    def __init__(self, db_path: str = "learning_progress.db"):
-        self.db_path = db_path
-        self.init_database()
-        
-    def init_database(self):
-        """Initialize SQLite database for tracking learning progress"""
-        conn = sqlite3.connect(self.db_path)
-        cursor = conn.cursor()
-        
-        cursor.execute('''
-            CREATE TABLE IF NOT EXISTS learning_sessions (
-                session_id TEXT PRIMARY KEY,
-                user_id TEXT NOT NULL,
-                start_time TEXT NOT NULL,
-                end_time TEXT,
-                words_learned INTEGER DEFAULT 0,
-                idioms_learned INTEGER DEFAULT 0,
-                questions_asked INTEGER DEFAULT 0
-            )
-        ''')
-        
-        cursor.execute('''
-            CREATE TABLE IF NOT EXISTS word_progress (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                user_id TEXT NOT NULL,
-                word TEXT NOT NULL,
-                definition TEXT NOT NULL,
-                category TEXT NOT NULL,
-                first_encountered TEXT NOT NULL,
-                last_reviewed TEXT NOT NULL,
-                encounter_count INTEGER DEFAULT 1,
-                mastery_level INTEGER DEFAULT 0,
-                correct_answers INTEGER DEFAULT 0,
-                total_questions INTEGER DEFAULT 0,
-                UNIQUE(user_id, word, category)
-            )
-        ''')
-        
-        cursor.execute('''
-            CREATE TABLE IF NOT EXISTS learning_analytics (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                user_id TEXT NOT NULL,
-                date TEXT NOT NULL,
-                metric_name TEXT NOT NULL,
-                metric_value REAL NOT NULL
-            )
-        ''')
-        
-        conn.commit()
-        conn.close()
-    
-    def start_session(self, user_id: str) -> str:
-        """Start a new learning session"""
-        session_id = f"{user_id}_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
-        session = LearningSession(
-            session_id=session_id,
-            user_id=user_id,
-            start_time=datetime.now()
-        )
-        
-        conn = sqlite3.connect(self.db_path)
-        cursor = conn.cursor()
-        cursor.execute('''
-            INSERT INTO learning_sessions (session_id, user_id, start_time)
-            VALUES (?, ?, ?)
-        ''', (session.session_id, session.user_id, session.start_time.isoformat()))
-        conn.commit()
-        conn.close()
-        
-        return session_id
-    
-    def end_session(self, session_id: str):
-        """End a learning session"""
-        conn = sqlite3.connect(self.db_path)
-        cursor = conn.cursor()
-        cursor.execute('''
-            UPDATE learning_sessions 
-            SET end_time = ? 
-            WHERE session_id = ?
-        ''', (datetime.now().isoformat(), session_id))
-        conn.commit()
-        conn.close()
-    
-    def track_word_encounter(self, user_id: str, word: str, definition: str, category: str):
-        """Track when a user encounters a word or idiom"""
-        conn = sqlite3.connect(self.db_path)
-        cursor = conn.cursor()
-        
-        cursor.execute('''
-            SELECT * FROM word_progress 
-            WHERE user_id = ? AND word = ? AND category = ?
-        ''', (user_id, word, category))
-        
-        existing = cursor.fetchone()
-        now = datetime.now().isoformat()
-        
-        if existing:
-            
-            cursor.execute('''
-                UPDATE word_progress 
-                SET last_reviewed = ?, encounter_count = encounter_count + 1
-                WHERE user_id = ? AND word = ? AND category = ?
-            ''', (now, user_id, word, category))
-        else:
-            
-            cursor.execute('''
-                INSERT INTO word_progress 
-                (user_id, word, definition, category, first_encountered, last_reviewed)
-                VALUES (?, ?, ?, ?, ?, ?)
-            ''', (user_id, word, definition, category, now, now))
-        
-        conn.commit()
-        conn.close()
-    
-    def update_mastery_level(self, user_id: str, word: str, category: str, correct: bool):
-        """Update mastery level based on user performance"""
-        conn = sqlite3.connect(self.db_path)
-        cursor = conn.cursor()
-        
-        cursor.execute('''
-            SELECT mastery_level, correct_answers, total_questions
-            FROM word_progress 
-            WHERE user_id = ? AND word = ? AND category = ?
-        ''', (user_id, word, category))
-        
-        result = cursor.fetchone()
-        if result:
-            current_mastery, correct_answers, total_questions = result
-            new_correct = correct_answers + (1 if correct else 0)
-            new_total = total_questions + 1
-            
-            accuracy = new_correct / new_total if new_total > 0 else 0
-            new_mastery = min(5, int(accuracy * 5) + (1 if new_total >= 3 else 0))
-            
-            cursor.execute('''
-                UPDATE word_progress 
-                SET mastery_level = ?, correct_answers = ?, total_questions = ?
-                WHERE user_id = ? AND word = ? AND category = ?
-            ''', (new_mastery, new_correct, new_total, user_id, word, category))
-        
-        conn.commit()
-        conn.close()
-    
-    def get_user_progress(self, user_id: str) -> Dict:
-        """Get comprehensive user progress statistics"""
-        conn = sqlite3.connect(self.db_path)
-        cursor = conn.cursor()
-        
-        cursor.execute('''
-            SELECT category, COUNT(*), AVG(mastery_level)
-            FROM word_progress 
-            WHERE user_id = ?
-            GROUP BY category
-        ''', (user_id,))
-        
-        category_stats = {}
-        for category, count, avg_mastery in cursor.fetchall():
-            category_stats[category] = {
-                'count': count,
-                'average_mastery': round(avg_mastery or 0, 2)
-            }
-        
-        week_ago = (datetime.now() - timedelta(days=7)).isoformat()
-        cursor.execute('''
-            SELECT COUNT(*) FROM word_progress 
-            WHERE user_id = ? AND last_reviewed >= ?
-        ''', (user_id, week_ago))
-        recent_activity = cursor.fetchone()[0]
-        
-        cursor.execute('''
-            SELECT DATE(last_reviewed) as date, COUNT(*) as daily_count
-            FROM word_progress 
-            WHERE user_id = ?
-            GROUP BY DATE(last_reviewed)
-            ORDER BY date DESC
-            LIMIT 30
-        ''', (user_id,))
-        
-        daily_activity = cursor.fetchall()
-        
-        conn.close()
-        
-        return {
-            'category_stats': category_stats,
-            'recent_activity': recent_activity,
-            'daily_activity': daily_activity,
-            'total_words': sum(stats['count'] for stats in category_stats.values())
-        }
-    
-    def get_words_to_review(self, user_id: str, limit: int = 10) -> List[Dict]:
-        """Get words that need review based on spaced repetition"""
-        conn = sqlite3.connect(self.db_path)
-        cursor = conn.cursor()
-        
-        cursor.execute('''
-            SELECT word, definition, category, mastery_level, last_reviewed
-            FROM word_progress 
-            WHERE user_id = ? AND (
-                mastery_level < 3 OR 
-                last_reviewed < datetime('now', '-2 days')
-            )
-            ORDER BY mastery_level ASC, last_reviewed ASC
-            LIMIT ?
-        ''', (user_id, limit))
-        
-        words = []
-        for word, definition, category, mastery, last_reviewed in cursor.fetchall():
-            words.append({
-                'word': word,
-                'definition': definition,
-                'category': category,
-                'mastery_level': mastery,
-                'last_reviewed': last_reviewed
-            })
-        
-        conn.close()
-        return words
-    
-    def get_learning_recommendations(self, user_id: str) -> List[str]:
-        """Get personalized learning recommendations"""
-        progress = self.get_user_progress(user_id)
-        recommendations = []
-        
-        if progress['total_words'] < 10:
-            recommendations.append("Start with basic vocabulary - try asking about common Kazakh words!")
-        
-        if 'idiom' not in progress['category_stats'] or progress['category_stats'].get('idiom', {}).get('count', 0) < 5:
-            recommendations.append("Explore Kazakh idioms to improve your cultural understanding!")
-        
-        words_to_review = self.get_words_to_review(user_id, 5)
-        if words_to_review:
-            recommendations.append(f"Review these words: {', '.join([w['word'] for w in words_to_review[:3]])}")
-        
-        if progress['recent_activity'] == 0:
-            recommendations.append("You haven't practiced recently - consistency is key to language learning!")
-        
-        return recommendations
-
-class PersonalizedKazakhAssistant:
-    def __init__(self):
-        
-        self.setup_environment()
-        self.setup_vectorstore()
-        self.setup_llm()
-        self.tracker = PersonalizedLearningTracker()
-        self.current_user = "default_user" 
-        self.current_session = None
-        
-    def setup_environment(self):
-        """Setup environment and configuration"""
-        # load_dotenv()
-        # os.environ['GOOGLE_API_KEY'] = os.getenv("GOOGLE_API_KEY")
-        self.google_api_key = os.getenv("GOOGLE_API_KEY")
-        self.MODEL = "gemini-1.5-flash"
-        self.db_name = "vector_db"
-        
-    def setup_vectorstore(self):
-        """Setup document loading and vector store"""
-        folders = glob.glob("knowledge-base/*")
-        text_loader_kwargs = {'encoding': 'utf-8'}
-        documents = []
-        
-        for folder in folders:
-            doc_type = os.path.basename(folder)
-            loader = DirectoryLoader(
-                folder,
-                glob="**/*.txt",
-                loader_cls=TextLoader,
-                loader_kwargs=text_loader_kwargs
-            )
-            folder_docs = loader.load()
-            for doc in folder_docs:
-                doc.metadata["doc_type"] = doc_type
-                documents.append(doc)
-        
-        text_splitter = CharacterTextSplitter(separator=r'\n', chunk_size=2000, chunk_overlap=0)
-        chunks = text_splitter.split_documents(documents)
-        
-        print(f"Total chunks: {len(chunks)}")
-        
-        embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/distiluse-base-multilingual-cased-v1")
-        
-        if os.path.exists(self.db_name):
-            Chroma(persist_directory=self.db_name, embedding_function=embeddings).delete_collection()
-        
-        self.vectorstore = Chroma.from_documents(documents=chunks, embedding=embeddings, persist_directory=self.db_name)
-        print(f"Vectorstore created with {self.vectorstore._collection.count()} documents")
-        
-    def setup_llm(self):
-        """Setup LLM with enhanced system prompt"""
-        system_prompt = """
-You are a personalized Kazakh language learning assistant with access to a comprehensive knowledge base and user learning history. Your role is to help users learn Kazakh words and idioms while tracking their progress and providing personalized recommendations.
-
-Key capabilities:
-1. **Answer Queries**: Provide accurate definitions and examples for Kazakh words and idioms from your knowledge base
-2. **Track Learning Progress**: Identify and track when users learn new words or idioms
-3. **Personalized Responses**: Adapt responses based on user's learning history and progress
-4. **Progress Reporting**: Provide detailed progress reports when asked
-5. **Learning Recommendations**: Suggest words/idioms to review or learn next
-
-Response Guidelines:
-- For word/idiom queries: Provide definition, usage examples, and related information
-- Always identify the main Kazakh word/idiom being discussed for progress tracking
-- Be encouraging and supportive of the user's learning journey
-- Use simple, clear explanations appropriate for language learners
-- When discussing progress, be specific and motivating
-
-Format responses naturally in conversational style, not JSON unless specifically requested.
-"""
-        
-        self.llm = ChatGoogleGenerativeAI(
-            model="models/gemini-1.5-flash",
-            temperature=0.7,
-            system_instruction=system_prompt
-        )
-        
-        self.memory = ConversationBufferMemory(
-            memory_key='chat_history',
-            return_messages=True,
-            max_token_limit=10000 
-        )
-        
-        retriever = self.vectorstore.as_retriever()
-        self.conversation_chain = ConversationalRetrievalChain.from_llm(
-            llm=self.llm, 
-            retriever=retriever, 
-            memory=self.memory
-        )
-    
-    def extract_kazakh_terms(self, message: str, response: str) -> List[Tuple[str, str, str]]:
-        """Extract meaningful Kazakh terms using document metadata to determine category"""
-        terms = []
-        
-        try:
-            retrieved_docs = self.vectorstore.similarity_search(message, k=5)
-            
-            kazakh_words = re.findall(r'[А-Яа-яӘәҒғҚқҢңӨөҰұҮүҺһІі]+(?:\s+[А-Яа-яӘәҒғҚқ��ңӨөҰұҮүҺһІі]+)*', response)
-            
-            for word in kazakh_words:
-                word = word.strip()
-                
-                if len(word) <= 2 or len(word) > 50:
-                    continue
-                
-                skip_words = ['деген', 'деп', 'берілген', 'мәтінде', 'мағынасы', 'дегеннің', 
-                             'түсіндірілген', 'келтірілген', 'болып', 'табылады', 'ауруы',
-                             'мынадай', 'тақырыбына', 'тіркестер', 'арналған', 'байланысты']
-                
-                if any(skip in word.lower() for skip in skip_words):
-                    continue
-                
-                category = "word"  
-                definition = ""
-                
-                for doc in retrieved_docs:
-                    if word.lower() in doc.page_content.lower():
-                        doc_type = doc.metadata.get('doc_type', '').lower()
-                        if 'idiom' in doc_type or 'тіркес' in doc_type:
-                            category = "idiom"
-                        else:
-                            category = "word"
-                        
-                        definition = self.extract_clean_definition(word, doc.page_content, response)
-                        break
-                
-                if definition and len(word.split()) <= 4:
-                   
-                    if not any(phrase in word.lower() for phrase in ['қалай', 'қандай', 'қайда', 'неше', 'қашан']):
-                        terms.append((word, category, definition))
-            
-        except Exception as e:
-            print(f"Error extracting terms: {e}")
-        
-        return terms
-    
-    def extract_clean_definition(self, term: str, doc_content: str, response: str) -> str:
-        """Extract clean definition for a term"""
-        sentences = response.split('.')
-        for sentence in sentences:
-            if term.lower() in sentence.lower():
-                clean_sentence = sentence.strip()
-                if len(clean_sentence) > 10 and len(clean_sentence) < 150:
-                   
-                    if not any(word in clean_sentence.lower() for word in ['деген не', 'қалай аталады', 'нені білдіреді']):
-                        return clean_sentence
-        
-        doc_sentences = doc_content.split('.')
-        for sentence in doc_sentences:
-            if term.lower() in sentence.lower():
-                clean_sentence = sentence.strip()
-                if len(clean_sentence) > 10 and len(clean_sentence) < 150:
-                    return clean_sentence
-        
-        return f"Definition for {term}"
-    
-    def process_message(self, message: str) -> str:
-        """Process user message with personalization tracking"""
-        
-        if not self.current_session:
-            self.current_session = self.tracker.start_session(self.current_user)
-        
-        if message.lower().startswith('/progress'):
-            return self.get_progress_report()
-        elif message.lower().startswith('/recommendations'):
-            return self.get_recommendations()
-        elif message.lower().startswith('/review'):
-            return self.get_review_words()
-        elif message.lower().startswith('/help'):
-            return self.get_help_message()
-        
-        result = self.conversation_chain.invoke({"question": message})
-        response = result["answer"]
-        
-        extracted_terms = self.extract_kazakh_terms(message, response)
-        
-        for term, category, definition in extracted_terms:
-            if definition and term: 
-                self.tracker.track_word_encounter(
-                    self.current_user, 
-                    term, 
-                    definition, 
-                    category
-                )
-        
-        return response
-    
-    def extract_definition_from_response(self, response: str, term: str) -> str:
-        """Extract definition of a term from the response"""
-       
-        sentences = response.split('.')
-        for sentence in sentences:
-            if term in sentence:
-                return sentence.strip()
-        return "Definition extracted from conversation"
-    
-    def get_progress_report(self) -> str:
-        """Generate a comprehensive progress report"""
-        progress = self.tracker.get_user_progress(self.current_user)
-        
-        if progress['total_words'] == 0:
-            return "Сіз әлі үйренуді бастамадыңыз! Маған кез келген қазақ сөзі немесе тіркес туралы сұраңыз. 🌟\n\nYou haven't started learning yet! Ask me about any Kazakh word or idiom to begin your journey. 🌟"
-        
-        report = "📊 **Сізді�� үйрену прогресіңіз / Your Learning Progress Report**\n\n"
-        
-        report += f"🎯 **Үйренген терминдер саны / Total Terms Learned**: {progress['total_words']}\n"
-        
-        for category, stats in progress['category_stats'].items():
-            emoji = "📝" if category == "word" else "🎭"
-            category_name = "Сөздер / Words" if category == "word" else "Тіркестер / Idioms"
-            report += f"{emoji} **{category_name}**: {stats['count']} (Орташа меңгеру / Average mastery: {stats['average_mastery']}/5)\n"
-        
-        report += f"\n⚡ **Соңғы белсенділік / Recent Activity**: {progress['recent_activity']} терминдер соңғы 7 күнде қаралды / terms reviewed in the last 7 days\n"
-        
-        if progress['daily_activity']:
-            recent_days = len(progress['daily_activity'])
-            report += f"🔥 **Үйрену ырғағы / Learning Streak**: {recent_days} күн белсенді болдыңыз / Active on {recent_days} days recently\n"
-        
-        recommendations = self.tracker.get_learning_recommendations(self.current_user)
-        if recommendations:
-            report += f"\n💡 **Ұсыныстар / Recommendations**:\n"
-            for i, rec in enumerate(recommendations, 1):
-                report += f"{i}. {rec}\n"
-        
-        return report
-    
-    def get_recommendations(self) -> str:
-        """Get personalized learning recommendations"""
-        recommendations = self.tracker.get_learning_recommendations(self.current_user)
-        
-        if not recommendations:
-            return "Керемет! Сіз өте жақсы прогресс жасап жатырсыз. Үнемі жаттығуды жалғастырыңыз! 🎉\n\nGreat job! You're making excellent progress. Keep practicing regularly! 🎉"
-        
-        response = "💡 **Жеке ұсыныстар / Personalized Learning Recommendations**:\n\n"
-        for i, rec in enumerate(recommendations, 1):
-            response += f"{i}. {rec}\n"
-        
-        return response
-    
-    def get_review_words(self) -> str:
-        """Get words that need review"""
-        words_to_review = self.tracker.get_words_to_review(self.current_user, 10)
-        
-        if not words_to_review:
-            return "Тамаша! Сізде қазір қайталау қажет сөздер жоқ. Жаңа терминдерді үйренуге тырысыңыз! ✨\n\nExcellent! You don't have any words that need review right now. Try learning some new terms! ✨"
-        
-        response = "📚 **Қайталауға арналған сөздер / Words to Review**:\n\n"
-        for word_info in words_to_review:
-            emoji = "📝" if word_info['category'] == "word" else "🎭"
-            mastery_stars = "⭐" * word_info['mastery_level'] + "☆" * (5 - word_info['mastery_level'])
-            response += f"{emoji} **{word_info['word']}** - {mastery_stars}\n"
-            
-            definition_preview = word_info['definition'][:80] + "..." if len(word_info['definition']) > 80 else word_info['definition']
-            response += f"   {definition_preview}\n\n"
-        
-        return response
-    
-    def get_help_message(self) -> str:
-        """Get help message with available commands"""
-        return """
-🎓 **Kazakh Learning Assistant Help**
-
-**Available Commands**:
-- `/progress` - View your detailed learning progress
-- `/recommendations` - Get personalized learning suggestions  
-- `/review` - See words that need review
-- `/help` - Show this help message
-
-**How to Use**:
-- Ask about any Kazakh word or idiom for definitions and examples
-- Your progress is automatically tracked as you learn
-- Regular practice improves your mastery levels
-- Use commands to monitor your learning journey
-
-**Examples**:
-- "What does 'сәлем' mean?"
-- "Tell me about Kazakh idioms"
-- "How do you say 'thank you' in Kazakh?"
-
-Start learning by asking about any Kazakh term! 🌟
-"""
-
-assistant = PersonalizedKazakhAssistant()
-
-def chat_interface(message, history):
-    """Chat interface for Gradio"""
-    try:
-        response = assistant.process_message(message)
-        return response
-    except Exception as e:
-        return f"Sorry, I encountered an error: {str(e)}. Please try again."
-
-demo = gr.ChatInterface(
-    chat_interface,
-    type="messages",
-    title="🇰🇿 Personalized Kazakh Learning Assistant",
-    description="Learn Kazakh words and idioms with personalized progress tracking. Use commands like /progress, /recommendations, and /review to monitor your learning journey!",
-    examples=[
-        "What does 'сәлем' mean?",
-        "Tell me about Kazakh idioms",
-        "/progress",
-        "/recommendations",
-        "How do you say 'hello' in Kazakh?"
-    ]
-)
-
-if __name__ == "__main__":
-    demo.launch(inbrowser=True)
-
-def api_chat(message: str, user_id: str = "default_user") -> dict:
-    """API endpoint for chat functionality"""
-    try:
-        
-        assistant.current_user = user_id
-        if not assistant.current_session:
-            assistant.current_session = assistant.tracker.start_session(user_id)
-        
-        response = assistant.process_message(message)
-        return {
-            "success": True,
-            "response": response,
-            "user_id": user_id
-        }
-    except Exception as e:
-        return {
-            "success": False,
-            "error": str(e),
-            "response": "Кешіріңіз, қате орын алды. Қайталап көріңіз."
-        }
-
-def api_progress(user_id: str = "default_user") -> dict:
-    """API endpoint for user progress"""
-    try:
-        assistant.current_user = user_id
-        progress_text = assistant.get_progress_report()
-        progress_data = assistant.tracker.get_user_progress(user_id)
-        
-        return {
-            "success": True,
-            "progress_text": progress_text,
-            "progress_data": progress_data,
-            "user_id": user_id
-        }
-    except Exception as e:
-        return {
-            "success": False,
-            "error": str(e)
-        }
-
-def api_recommendations(user_id: str = "default_user") -> dict:
-    """API endpoint for learning recommendations"""
-    try:
-        assistant.current_user = user_id
-        recommendations_text = assistant.get_recommendations()
-        recommendations_list = assistant.tracker.get_learning_recommendations(user_id)
-        
-        return {
-            "success": True,
-            "recommendations_text": recommendations_text,
-            "recommendations_list": recommendations_list,
-            "user_id": user_id
-        }
-    except Exception as e:
-        return {
-            "success": False,
-            "error": str(e)
-        }
-
-def api_review_words(user_id: str = "default_user") -> dict:
-    """API endpoint for words to review"""
-    try:
-        assistant.current_user = user_id
-        review_text = assistant.get_review_words()
-        review_data = assistant.tracker.get_words_to_review(user_id, 10)
-        
-        return {
-            "success": True,
-            "review_text": review_text,
-            "review_data": review_data,
-            "user_id": user_id
-        }
-    except Exception as e:
-        return {
-            "success": False,
-            "error": str(e)
-        }
-
-with gr.Blocks(title="🇰🇿 Kazakh Learning API") as demo:
-    gr.Markdown("# 🇰🇿 Personalized Kazakh Learning Assistant")
-    gr.Markdown("### Chat Interface + API Endpoints for Mobile Integration")
-    
-    with gr.Tab("💬 Chat Interface"):
-        chat_interface = gr.ChatInterface(
-            chat_interface,
-            type="messages",
-            examples=[
-                "сәлем деген не?",
-                "күләпара не үшін керек?",
-                "/progress",
-                "/recommendations",
-                "/review"
-            ]
-        )
-    
-    with gr.Tab("🔌 API Testing"):
-        gr.Markdown("## Test API Endpoints")
-        
-        with gr.Row():
-            with gr.Column():
-                user_id_input = gr.Textbox(label="User ID", value="test_user", placeholder="Enter user ID")
-                message_input = gr.Textbox(label="Message", placeholder="Enter your message in Kazakh or English")
-                
-        with gr.Row():
-            chat_btn = gr.Button("💬 Test Chat API")
-            progress_btn = gr.Button("📊 Test Progress API")
-            recommendations_btn = gr.Button("💡 Test Recommendations API")
-            review_btn = gr.Button("📚 Test Review API")
-        
-        api_output = gr.JSON(label="API Response")
-        
-        chat_btn.click(
-            fn=lambda msg, uid: api_chat(msg, uid),
-            inputs=[message_input, user_id_input],
-            outputs=api_output
-        )
-        
-        progress_btn.click(
-            fn=lambda uid: api_progress(uid),
-            inputs=user_id_input,
-            outputs=api_output
-        )
-        
-        recommendations_btn.click(
-            fn=lambda uid: api_recommendations(uid),
-            inputs=user_id_input,
-            outputs=api_output
-        )
-        
-        review_btn.click(
-            fn=lambda uid: api_review_words(uid),
-            inputs=user_id_input,
-            outputs=api_output
-        )
-    
-    with gr.Tab("📖 API Documentation"):
-        gr.Markdown("""
-        ## API Endpoints for Flutter Integration
-        
-        Your Gradio Space will automatically provide these API endpoints:
-        
-        ### Base URL: `https://your-username-kazakh-learning.hf.space`
-        
-        ### Available Endpoints:
-        
-        #### 1. Chat API
-        ```
-        POST /api/predict
-        Content-Type: application/json
-        
-        {
-          "data": ["message", "user_id"],
-          "fn_index": 0
-        }
-        ```
-        
-        #### 2. Progress API  
-        ```
-        POST /api/predict
-        Content-Type: application/json
-        
-        {
-          "data": ["user_id"],
-          "fn_index": 1
-        }
-        ```
-        
-        #### 3. Recommendations API
-        ```
-        POST /api/predict
-        Content-Type: application/json
-        
-        {
-          "data": ["user_id"],
-          "fn_index": 2
-        }
-        ```
-        
-        #### 4. Review Words API
-        ```
-        POST /api/predict
-        Content-Type: application/json
-        
-        {
-          "data": ["user_id"],
-          "fn_index": 3
-        }
-        ```
-        
-        ### Flutter HTTP Example:
-        ```dart
-        // Chat API call
-        final response = await http.post(
-          Uri.parse('https://your-username-kazakh-learning.hf.space/api/predict'),
-          headers: {'Content-Type': 'application/json'},
-          body: jsonEncode({
-            'data': ['сәлем деген не?', 'user123'],
-            'fn_index': 0
-          }),
-        );
-        
-        final result = jsonDecode(response.body);
-        final chatResponse = result['data'][0]['response'];
-        ```
-        """)
-
-if __name__ == "__main__":
+import os
+os.environ["PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION"] = "python"
+import glob
+import json
+import sqlite3
+from datetime import datetime, timedelta
+from typing import Dict, List, Optional, Tuple
+from dataclasses import dataclass, asdict
+from collections import defaultdict
+import re
+import uuid
+import hashlib
+
+from dotenv import load_dotenv
+import gradio as gr
+
+from langchain_community.document_loaders import DirectoryLoader, TextLoader
+from langchain.text_splitter import CharacterTextSplitter
+from langchain.schema import Document
+from langchain_chroma import Chroma
+from langchain_google_genai import GoogleGenerativeAIEmbeddings, ChatGoogleGenerativeAI
+from langchain_huggingface import HuggingFaceEmbeddings
+from langchain.memory import ConversationBufferMemory
+from langchain.chains import ConversationalRetrievalChain
+import numpy as np
+
+@dataclass
+class LearningSession:
+    session_id: str
+    user_id: str
+    start_time: datetime
+    end_time: Optional[datetime] = None
+    words_learned: int = 0
+    idioms_learned: int = 0
+    questions_asked: int = 0
+
+@dataclass
+class WordProgress:
+    word: str
+    definition: str
+    category: str  
+    first_encountered: datetime
+    last_reviewed: datetime
+    encounter_count: int
+    mastery_level: int 
+    correct_answers: int
+    total_questions: int
+
+class PersonalizedLearningTracker:
+    def __init__(self, db_path: str = "learning_progress.db"):
+        self.db_path = db_path
+        self.init_database()
+        
+    def init_database(self):
+        """Initialize SQLite database for tracking learning progress"""
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+        
+        cursor.execute('''
+            CREATE TABLE IF NOT EXISTS learning_sessions (
+                session_id TEXT PRIMARY KEY,
+                user_id TEXT NOT NULL,
+                start_time TEXT NOT NULL,
+                end_time TEXT,
+                words_learned INTEGER DEFAULT 0,
+                idioms_learned INTEGER DEFAULT 0,
+                questions_asked INTEGER DEFAULT 0
+            )
+        ''')
+        
+        cursor.execute('''
+            CREATE TABLE IF NOT EXISTS word_progress (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                user_id TEXT NOT NULL,
+                word TEXT NOT NULL,
+                definition TEXT NOT NULL,
+                category TEXT NOT NULL,
+                first_encountered TEXT NOT NULL,
+                last_reviewed TEXT NOT NULL,
+                encounter_count INTEGER DEFAULT 1,
+                mastery_level INTEGER DEFAULT 0,
+                correct_answers INTEGER DEFAULT 0,
+                total_questions INTEGER DEFAULT 0,
+                UNIQUE(user_id, word, category)
+            )
+        ''')
+        
+        cursor.execute('''
+            CREATE TABLE IF NOT EXISTS learning_analytics (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                user_id TEXT NOT NULL,
+                date TEXT NOT NULL,
+                metric_name TEXT NOT NULL,
+                metric_value REAL NOT NULL
+            )
+        ''')
+        
+        cursor.execute('''
+            CREATE TABLE IF NOT EXISTS user_sessions (
+                user_id TEXT NOT NULL,
+                session_token TEXT NOT NULL,
+                created_at TEXT NOT NULL,
+                last_activity TEXT NOT NULL,
+                is_active BOOLEAN DEFAULT 1,
+                PRIMARY KEY (user_id, session_token)
+            )
+        ''')
+        
+        conn.commit()
+        conn.close()
+    
+    def create_user_session(self, user_id: str) -> str:
+        """Create a new session token for a user"""
+        session_token = str(uuid.uuid4())
+        now = datetime.now().isoformat()
+        
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+        
+        cursor.execute('''
+            UPDATE user_sessions 
+            SET is_active = 0 
+            WHERE user_id = ?
+        ''', (user_id,))
+        
+        cursor.execute('''
+            INSERT INTO user_sessions (user_id, session_token, created_at, last_activity)
+            VALUES (?, ?, ?, ?)
+        ''', (user_id, session_token, now, now))
+        
+        conn.commit()
+        conn.close()
+        
+        return session_token
+    
+    def validate_session(self, user_id: str, session_token: str) -> bool:
+        """Validate if a session is active and belongs to the user"""
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+        
+        cursor.execute('''
+            SELECT is_active FROM user_sessions 
+            WHERE user_id = ? AND session_token = ?
+        ''', (user_id, session_token))
+        
+        result = cursor.fetchone()
+        conn.close()
+        
+        return result is not None and result[0] == 1
+    
+    def update_session_activity(self, user_id: str, session_token: str):
+        """Update last activity time for a session"""
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+        
+        cursor.execute('''
+            UPDATE user_sessions 
+            SET last_activity = ? 
+            WHERE user_id = ? AND session_token = ?
+        ''', (datetime.now().isoformat(), user_id, session_token))
+        
+        conn.commit()
+        conn.close()
+    
+    def start_session(self, user_id: str) -> str:
+        """Start a new learning session"""
+        session_id = f"{user_id}_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
+        session = LearningSession(
+            session_id=session_id,
+            user_id=user_id,
+            start_time=datetime.now()
+        )
+        
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+        cursor.execute('''
+            INSERT INTO learning_sessions (session_id, user_id, start_time)
+            VALUES (?, ?, ?)
+        ''', (session.session_id, session.user_id, session.start_time.isoformat()))
+        conn.commit()
+        conn.close()
+        
+        return session_id
+    
+    def end_session(self, session_id: str):
+        """End a learning session"""
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+        cursor.execute('''
+            UPDATE learning_sessions 
+            SET end_time = ? 
+            WHERE session_id = ?
+        ''', (datetime.now().isoformat(), session_id))
+        conn.commit()
+        conn.close()
+    
+    def track_word_encounter(self, user_id: str, word: str, definition: str, category: str):
+        """Track when a user encounters a word or idiom"""
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+        
+        cursor.execute('''
+            SELECT * FROM word_progress 
+            WHERE user_id = ? AND word = ? AND category = ?
+        ''', (user_id, word, category))
+        
+        existing = cursor.fetchone()
+        now = datetime.now().isoformat()
+        
+        if existing:
+            cursor.execute('''
+                UPDATE word_progress 
+                SET last_reviewed = ?, encounter_count = encounter_count + 1
+                WHERE user_id = ? AND word = ? AND category = ?
+            ''', (now, user_id, word, category))
+        else:
+            cursor.execute('''
+                INSERT INTO word_progress 
+                (user_id, word, definition, category, first_encountered, last_reviewed)
+                VALUES (?, ?, ?, ?, ?, ?)
+            ''', (user_id, word, definition, category, now, now))
+        
+        conn.commit()
+        conn.close()
+    
+    def update_mastery_level(self, user_id: str, word: str, category: str, correct: bool):
+        """Update mastery level based on user performance"""
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+        
+        cursor.execute('''
+            SELECT mastery_level, correct_answers, total_questions
+            FROM word_progress 
+            WHERE user_id = ? AND word = ? AND category = ?
+        ''', (user_id, word, category))
+        
+        result = cursor.fetchone()
+        if result:
+            current_mastery, correct_answers, total_questions = result
+            new_correct = correct_answers + (1 if correct else 0)
+            new_total = total_questions + 1
+            
+            accuracy = new_correct / new_total if new_total > 0 else 0
+            new_mastery = min(5, int(accuracy * 5) + (1 if new_total >= 3 else 0))
+            
+            cursor.execute('''
+                UPDATE word_progress 
+                SET mastery_level = ?, correct_answers = ?, total_questions = ?
+                WHERE user_id = ? AND word = ? AND category = ?
+            ''', (new_mastery, new_correct, new_total, user_id, word, category))
+        
+        conn.commit()
+        conn.close()
+    
+    def get_user_progress(self, user_id: str) -> Dict:
+        """Get comprehensive user progress statistics"""
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+        
+        cursor.execute('''
+            SELECT category, COUNT(*), AVG(mastery_level)
+            FROM word_progress 
+            WHERE user_id = ?
+            GROUP BY category
+        ''', (user_id,))
+        
+        category_stats = {}
+        for category, count, avg_mastery in cursor.fetchall():
+            category_stats[category] = {
+                'count': count,
+                'average_mastery': round(avg_mastery or 0, 2)
+            }
+        
+        week_ago = (datetime.now() - timedelta(days=7)).isoformat()
+        cursor.execute('''
+            SELECT COUNT(*) FROM word_progress 
+            WHERE user_id = ? AND last_reviewed >= ?
+        ''', (user_id, week_ago))
+        recent_activity = cursor.fetchone()[0]
+        
+        cursor.execute('''
+            SELECT DATE(last_reviewed) as date, COUNT(*) as daily_count
+            FROM word_progress 
+            WHERE user_id = ?
+            GROUP BY DATE(last_reviewed)
+            ORDER BY date DESC
+            LIMIT 30
+        ''', (user_id,))
+        
+        daily_activity = cursor.fetchall()
+        
+        conn.close()
+        
+        return {
+            'category_stats': category_stats,
+            'recent_activity': recent_activity,
+            'daily_activity': daily_activity,
+            'total_words': sum(stats['count'] for stats in category_stats.values())
+        }
+    
+    def get_words_to_review(self, user_id: str, limit: int = 10) -> List[Dict]:
+        """Get words that need review based on spaced repetition"""
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+        
+        cursor.execute('''
+            SELECT word, definition, category, mastery_level, last_reviewed
+            FROM word_progress 
+            WHERE user_id = ? AND (
+                mastery_level < 3 OR 
+                last_reviewed < datetime('now', '-2 days')
+            )
+            ORDER BY mastery_level ASC, last_reviewed ASC
+            LIMIT ?
+        ''', (user_id, limit))
+        
+        words = []
+        for word, definition, category, mastery, last_reviewed in cursor.fetchall():
+            words.append({
+                'word': word,
+                'definition': definition,
+                'category': category,
+                'mastery_level': mastery,
+                'last_reviewed': last_reviewed
+            })
+        
+        conn.close()
+        return words
+    
+    def get_learning_recommendations(self, user_id: str) -> List[str]:
+        """Get personalized learning recommendations"""
+        progress = self.get_user_progress(user_id)
+        recommendations = []
+        
+        if progress['total_words'] < 10:
+            recommendations.append("Start with basic vocabulary - try asking about common Kazakh words!")
+        
+        if 'idiom' not in progress['category_stats'] or progress['category_stats'].get('idiom', {}).get('count', 0) < 5:
+            recommendations.append("Explore Kazakh idioms to improve your cultural understanding!")
+        
+        words_to_review = self.get_words_to_review(user_id, 5)
+        if words_to_review:
+            recommendations.append(f"Review these words: {', '.join([w['word'] for w in words_to_review[:3]])}")
+        
+        if progress['recent_activity'] == 0:
+            recommendations.append("You haven't practiced recently - consistency is key to language learning!")
+        
+        return recommendations
+
+class PersonalizedKazakhAssistant:
+    def __init__(self):
+        self.setup_environment()
+        self.setup_vectorstore()
+        self.setup_llm()
+        self.tracker = PersonalizedLearningTracker()
+        self.user_sessions = {}  
+        self.user_memories = {} 
+        
+    def setup_environment(self):
+        """Setup environment and configuration"""
+        
+        self.google_api_key = os.getenv("GOOGLE_API_KEY")
+        self.MODEL = "gemini-1.5-flash"
+        self.db_name = "vector_db"
+        
+    def setup_vectorstore(self):
+        """Setup document loading and vector store"""
+        folders = glob.glob("knowledge-base/*")
+        text_loader_kwargs = {'encoding': 'utf-8'}
+        documents = []
+        
+        for folder in folders:
+            doc_type = os.path.basename(folder)
+            loader = DirectoryLoader(
+                folder,
+                glob="**/*.txt",
+                loader_cls=TextLoader,
+                loader_kwargs=text_loader_kwargs
+            )
+            folder_docs = loader.load()
+            for doc in folder_docs:
+                doc.metadata["doc_type"] = doc_type
+                documents.append(doc)
+        
+        text_splitter = CharacterTextSplitter(separator=r'\n', chunk_size=2000, chunk_overlap=0)
+        chunks = text_splitter.split_documents(documents)
+        
+        print(f"Total chunks: {len(chunks)}")
+        
+        embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/distiluse-base-multilingual-cased-v1")
+        
+        if os.path.exists(self.db_name):
+            Chroma(persist_directory=self.db_name, embedding_function=embeddings).delete_collection()
+        
+        self.vectorstore = Chroma.from_documents(documents=chunks, embedding=embeddings, persist_directory=self.db_name)
+        print(f"Vectorstore created with {self.vectorstore._collection.count()} documents")
+        
+    def setup_llm(self):
+        """Setup LLM with enhanced system prompt"""
+        system_prompt = """
+You are a personalized Kazakh language learning assistant with access to a comprehensive knowledge base and user learning history. Your role is to help users learn Kazakh words and idioms while tracking their progress and providing personalized recommendations.
+
+Key capabilities:
+1. **Answer Queries**: Provide accurate definitions and examples for Kazakh words and idioms from your knowledge base
+2. **Track Learning Progress**: Identify and track when users learn new words or idioms
+3. **Personalized Responses**: Adapt responses based on user's learning history and progress
+4. **Progress Reporting**: Provide detailed progress reports when asked
+5. **Learning Recommendations**: Suggest words/idioms to review or learn next
+
+Response Guidelines:
+- For word/idiom queries: Provide definition, usage examples, and related information
+- Always identify the main Kazakh word/idiom being discussed for progress tracking
+- Be encouraging and supportive of the user's learning journey
+- Use simple, clear explanations appropriate for language learners
+- When discussing progress, be specific and motivating
+
+Format responses naturally in conversational style, not JSON unless specifically requested.
+"""
+        
+        self.llm = ChatGoogleGenerativeAI(
+            model="models/gemini-1.5-flash",
+            temperature=0.7,
+            system_instruction=system_prompt
+        )
+        
+        
+    def get_user_memory(self, user_id: str):
+        """Get or create conversation memory for a specific user"""
+        if user_id not in self.user_memories:
+            self.user_memories[user_id] = ConversationBufferMemory(
+                memory_key='chat_history',
+                return_messages=True,
+                max_token_limit=10000 
+            )
+        return self.user_memories[user_id]
+    
+    def get_user_chain(self, user_id: str):
+        """Get or create conversation chain for a specific user"""
+        memory = self.get_user_memory(user_id)
+        retriever = self.vectorstore.as_retriever()
+        return ConversationalRetrievalChain.from_llm(
+            llm=self.llm, 
+            retriever=retriever, 
+            memory=memory
+        )
+    
+    def extract_kazakh_terms(self, message: str, response: str) -> List[Tuple[str, str, str]]:
+        """Extract meaningful Kazakh terms using document metadata to determine category"""
+        terms = []
+        
+        try:
+            retrieved_docs = self.vectorstore.similarity_search(message, k=5)
+            
+            kazakh_words = re.findall(r'[А-Яа-яӘәҒғҚқҢңӨөҰұҮүҺһІі]+(?:\s+[А-Яа-яӘәҒғҚқҢңӨөҰұҮүҺһІі]+)*', response)
+            
+            for word in kazakh_words:
+                word = word.strip()
+                
+                if len(word) <= 2 or len(word) > 50:
+                    continue
+                
+                skip_words = ['деген', 'деп', 'берілген', 'мәтінде', 'мағынасы', 'дегеннің', 
+                             'түсіндірілген', 'келтірілген', 'болып', 'табылады', 'ауруы',
+                             'мынадай', 'тақырыбына', 'тіркестер', 'арналған', 'байланысты']
+                
+                if any(skip in word.lower() for skip in skip_words):
+                    continue
+                
+                category = "word"  
+                definition = ""
+                
+                for doc in retrieved_docs:
+                    if word.lower() in doc.page_content.lower():
+                        doc_type = doc.metadata.get('doc_type', '').lower()
+                        if 'idiom' in doc_type or 'тіркес' in doc_type:
+                            category = "idiom"
+                        else:
+                            category = "word"
+                        
+                        definition = self.extract_clean_definition(word, doc.page_content, response)
+                        break
+                
+                if definition and len(word.split()) <= 4:
+                    if not any(phrase in word.lower() for phrase in ['қалай', 'қандай', 'қайда', 'неше', 'қашан']):
+                        terms.append((word, category, definition))
+            
+        except Exception as e:
+            print(f"Error extracting terms: {e}")
+        
+        return terms
+    
+    def extract_clean_definition(self, term: str, doc_content: str, response: str) -> str:
+        """Extract clean definition for a term"""
+        sentences = response.split('.')
+        for sentence in sentences:
+            if term.lower() in sentence.lower():
+                clean_sentence = sentence.strip()
+                if len(clean_sentence) > 10 and len(clean_sentence) < 150:
+                    if not any(word in clean_sentence.lower() for word in ['деген не', 'қалай аталады', 'нені білдіреді']):
+                        return clean_sentence
+        
+        doc_sentences = doc_content.split('.')
+        for sentence in doc_sentences:
+            if term.lower() in sentence.lower():
+                clean_sentence = sentence.strip()
+                if len(clean_sentence) > 10 and len(clean_sentence) < 150:
+                    return clean_sentence
+        
+        return f"Definition for {term}"
+    
+    def process_message(self, message: str, user_id: str = "default_user", session_token: str = None) -> str:
+        """Process user message with proper user session management"""
+        
+        if session_token and not self.tracker.validate_session(user_id, session_token):
+            return "Session expired. Please login again."
+        
+        if session_token:
+            self.tracker.update_session_activity(user_id, session_token)
+        
+        if user_id not in self.user_sessions:
+            self.user_sessions[user_id] = self.tracker.start_session(user_id)
+        
+        if message.lower().startswith('/progress'):
+            return self.get_progress_report(user_id)
+        elif message.lower().startswith('/recommendations'):
+            return self.get_recommendations(user_id)
+        elif message.lower().startswith('/review'):
+            return self.get_review_words(user_id)
+        elif message.lower().startswith('/help'):
+            return self.get_help_message()
+        
+        conversation_chain = self.get_user_chain(user_id)
+        result = conversation_chain.invoke({"question": message})
+        response = result["answer"]
+        
+        extracted_terms = self.extract_kazakh_terms(message, response)
+        
+        for term, category, definition in extracted_terms:
+            if definition and term: 
+                self.tracker.track_word_encounter(
+                    user_id, 
+                    term, 
+                    definition, 
+                    category
+                )
+        
+        return response
+    
+    def get_progress_report(self, user_id: str) -> str:
+        """Generate a comprehensive progress report for specific user"""
+        progress = self.tracker.get_user_progress(user_id)
+        
+        if progress['total_words'] == 0:
+            return "Сіз әлі үйренуді бастамадыңыз! Маған кез келген қазақ сөзі немесе тіркес туралы сұраңыз. 🌟\n\nYou haven't started learning yet! Ask me about any Kazakh word or idiom to begin your journey. 🌟"
+        
+        report = "📊 **Сіздің үйрену прогресіңіз / Your Learning Progress Report**\n\n"
+        
+        report += f"🎯 **Үйренген терминдер саны / Total Terms Learned**: {progress['total_words']}\n"
+        
+        for category, stats in progress['category_stats'].items():
+            emoji = "📝" if category == "word" else "🎭"
+            category_name = "Сөздер / Words" if category == "word" else "Тіркестер / Idioms"
+            report += f"{emoji} **{category_name}**: {stats['count']} (Орташа меңгеру / Average mastery: {stats['average_mastery']}/5)\n"
+        
+        report += f"\n⚡ **Соңғы белсенділік / Recent Activity**: {progress['recent_activity']} терминдер соңғы 7 күнде қаралды / terms reviewed in the last 7 days\n"
+        
+        if progress['daily_activity']:
+            recent_days = len(progress['daily_activity'])
+            report += f"🔥 **Үйрену ырғағы / Learning Streak**: {recent_days} күн белсенді болдыңыз / Active on {recent_days} days recently\n"
+        
+        recommendations = self.tracker.get_learning_recommendations(user_id)
+        if recommendations:
+            report += f"\n💡 **Ұсыныстар / Recommendations**:\n"
+            for i, rec in enumerate(recommendations, 1):
+                report += f"{i}. {rec}\n"
+        
+        return report
+    
+    def get_recommendations(self, user_id: str) -> str:
+        """Get personalized learning recommendations for specific user"""
+        recommendations = self.tracker.get_learning_recommendations(user_id)
+        
+        if not recommendations:
+            return "Керемет! Сіз өте жақсы прогресс жасап жатырсыз. Үнемі жаттығуды жалғастырыңыз! 🎉\n\nGreat job! You're making excellent progress. Keep practicing regularly! 🎉"
+        
+        response = "💡 **Жеке ұсыныстар / Personalized Learning Recommendations**:\n\n"
+        for i, rec in enumerate(recommendations, 1):
+            response += f"{i}. {rec}\n"
+        
+        return response
+    
+    def get_review_words(self, user_id: str) -> str:
+        """Get words that need review for specific user"""
+        words_to_review = self.tracker.get_words_to_review(user_id, 10)
+        
+        if not words_to_review:
+            return "Тамаша! Сізде қазір қайталау қажет сөздер жоқ. Жаңа терминдерді үйренуге тырысыңыз! ✨\n\nExcellent! You don't have any words that need review right now. Try learning some new terms! ✨"
+        
+        response = "📚 **Қайталауға арналған сөздер / Words to Review**:\n\n"
+        for word_info in words_to_review:
+            emoji = "📝" if word_info['category'] == "word" else "🎭"
+            mastery_stars = "⭐" * word_info['mastery_level'] + "☆" * (5 - word_info['mastery_level'])
+            response += f"{emoji} **{word_info['word']}** - {mastery_stars}\n"
+            
+            definition_preview = word_info['definition'][:80] + "..." if len(word_info['definition']) > 80 else word_info['definition']
+            response += f"   {definition_preview}\n\n"
+        
+        return response
+    
+    def get_help_message(self) -> str:
+        """Get help message with available commands"""
+        return """
+🎓 **Kazakh Learning Assistant Help**
+
+**Available Commands**:
+- `/progress` - View your detailed learning progress
+- `/recommendations` - Get personalized learning suggestions  
+- `/review` - See words that need review
+- `/help` - Show this help message
+
+**How to Use**:
+- Ask about any Kazakh word or idiom for definitions and examples
+- Your progress is automatically tracked as you learn
+- Regular practice improves your mastery levels
+- Use commands to monitor your learning journey
+
+**Examples**:
+- "What does 'сәлем' mean?"
+- "Tell me about Kazakh idioms"
+- "How do you say 'thank you' in Kazakh?"
+
+Start learning by asking about any Kazakh term! 🌟
+"""
+
+    def login_user(self, user_id: str) -> str:
+        """Create a session token for user authentication"""
+        session_token = self.tracker.create_user_session(user_id)
+        return session_token
+
+assistant = PersonalizedKazakhAssistant()
+
+def chat_interface(message, history):
+    """Chat interface for Gradio - uses default user for web interface"""
+    try:
+        web_user_id = "web_user_" + str(hash(str(history)) % 10000)
+        response = assistant.process_message(message, web_user_id)
+        return response
+    except Exception as e:
+        return f"Sorry, I encountered an error: {str(e)}. Please try again."
+
+def api_login(user_id: str) -> dict:
+    """API endpoint for user login/session creation"""
+    try:
+        session_token = assistant.login_user(user_id)
+        return {
+            "success": True,
+            "session_token": session_token,
+            "user_id": user_id,
+            "message": "Login successful"
+        }
+    except Exception as e:
+        return {
+            "success": False,
+            "error": str(e)
+        }
+    
+def api_chat(message: str, user_id: str, session_token: str = None) -> dict:
+    """API endpoint for chat functionality with proper user session"""
+    try:
+        response = assistant.process_message(message, user_id, session_token)
+        return {
+            "success": True,
+            "response": response,
+            "user_id": user_id
+        }
+    except Exception as e:
+        return {
+            "success": False,
+            "error": str(e),
+            "response": "Кешіріңіз, қате орын алды. Қайталап көріңіз."
+        }
+
+def api_progress(user_id: str, session_token: str = None) -> dict:
+    """API endpoint for user progress with session validation"""
+    try:
+        if session_token and not assistant.tracker.validate_session(user_id, session_token):
+            return {"success": False, "error": "Invalid session"}
+            
+        progress_text = assistant.get_progress_report(user_id)
+        progress_data = assistant.tracker.get_user_progress(user_id)
+        
+        return {
+            "success": True,
+            "progress_text": progress_text,
+            "progress_data": progress_data,
+            "user_id": user_id
+        }
+    except Exception as e:
+        return {
+            "success": False,
+            "error": str(e)
+        }
+
+def api_recommendations(user_id: str, session_token: str = None) -> dict:
+    """API endpoint for learning recommendations with session validation"""
+    try:
+        if session_token and not assistant.tracker.validate_session(user_id, session_token):
+            return {"success": False, "error": "Invalid session"}
+            
+        recommendations_text = assistant.get_recommendations(user_id)
+        recommendations_list = assistant.tracker.get_learning_recommendations(user_id)
+        
+        return {
+            "success": True,
+            "recommendations_text": recommendations_text,
+            "recommendations_list": recommendations_list,
+            "user_id": user_id
+        }
+    except Exception as e:
+        return {
+            "success": False,
+            "error": str(e)
+        }
+
+def api_review_words(user_id: str, session_token: str = None) -> dict:
+    """API endpoint for words to review with session validation"""
+    try:
+        if session_token and not assistant.tracker.validate_session(user_id, session_token):
+            return {"success": False, "error": "Invalid session"}
+            
+        review_text = assistant.get_review_words(user_id)
+        review_data = assistant.tracker.get_words_to_review(user_id, 10)
+        
+        return {
+            "success": True,
+            "review_text": review_text,
+            "review_data": review_data,
+            "user_id": user_id
+        }
+    except Exception as e:
+        return {
+            "success": False,
+            "error": str(e)
+        }
+
+# Gradio Interface with API Testing
+with gr.Blocks(title="🇰🇿 Kazakh Learning API") as demo:
+    gr.Markdown("# 🇰🇿 Personalized Kazakh Learning Assistant")
+    gr.Markdown("### Multi-User Chat Interface + API Endpoints for Mobile Integration")
+    
+    with gr.Tab("💬 Chat Interface"):
+        chat_interface = gr.ChatInterface(
+            chat_interface,
+            type="messages",
+            examples=[
+                "сәлем деген не?",
+                "күләпара не үшін керек?",
+                "/progress",
+                "/recommendations",
+                "/review"
+            ]
+        )
+    
+    with gr.Tab("🔌 API Testing"):
+        gr.Markdown("## Test API Endpoints")
+        
+        with gr.Row():
+            with gr.Column():
+                user_id_input = gr.Textbox(label="User ID", value="test_user", placeholder="Enter unique user ID")
+                session_token_input = gr.Textbox(label="Session Token", placeholder="Session token (get from login)")
+                message_input = gr.Textbox(label="Message", placeholder="Enter your message in Kazakh or English")
+                
+        with gr.Row():
+            login_btn = gr.Button("🔑 Test Login API")
+            chat_btn = gr.Button("💬 Test Chat API")
+            progress_btn = gr.Button("📊 Test Progress API")
+            recommendations_btn = gr.Button("💡 Test Recommendations API")
+            review_btn = gr.Button("📚 Test Review API")
+        
+        api_output = gr.JSON(label="API Response")
+        
+        login_btn.click(
+            fn=lambda uid: api_login(uid),
+            inputs=user_id_input,
+            outputs=api_output
+        )
+        
+        chat_btn.click(
+            fn=lambda msg, uid, token: api_chat(msg, uid, token),
+            inputs=[message_input, user_id_input, session_token_input],
+            outputs=api_output
+        )
+        
+        progress_btn.click(
+            fn=lambda uid, token: api_progress(uid, token),
+            inputs=[user_id_input, session_token_input],
+            outputs=api_output
+        )
+        
+        recommendations_btn.click(
+            fn=lambda uid, token: api_recommendations(uid, token),
+            inputs=[user_id_input, session_token_input],
+            outputs=api_output
+        )
+        
+        review_btn.click(
+            fn=lambda uid, token: api_review_words(uid, token),
+            inputs=[user_id_input, session_token_input],
+            outputs=api_output
+        )
+    
+    with gr.Tab("📖 API Documentation"):
+        gr.Markdown("""
+        ## API Endpoints for Flutter Integration
+        
+        ### Base URL: `https://huggingface.co/spaces/GuestUser33/kazakh-learning-api`
+        
+        ### Authentication Flow:
+        1. **Login** to get session token
+        2. **Use session token** for subsequent API calls
+        3. **Session tokens expire** after inactivity
+        
+        ### Available Endpoints:
+        
+        #### 1. Login API
+        ```
+        POST /api/predict
+        Content-Type: application/json
+        
+        {
+          "data": ["user_id"],
+          "fn_index": 0
+        }
+        ```
+        **Response**: `{"success": true, "session_token": "uuid", "user_id": "user_id"}`
+        
+        #### 2. Chat API
+        ```
+        POST /api/predict
+        Content-Type: application/json
+        
+        {
+          "data": ["message", "user_id", "session_token"],
+          "fn_index": 1
+        }
+        ```
+        
+        #### 3. Progress API  
+        ```
+        POST /api/predict
+        Content-Type: application/json
+        
+        {
+          "data": ["user_id", "session_token"],
+          "fn_index": 2
+        }
+        ```
+        
+        #### 4. Recommendations API
+        ```
+        POST /api/predict
+        Content-Type: application/json
+        
+        {
+          "data": ["user_id", "session_token"],
+          "fn_index": 3
+        }
+        ```
+        
+        #### 5. Review Words API
+        ```
+        POST /api/predict
+        Content-Type: application/json
+        
+        {
+          "data": ["user_id", "session_token"],
+          "fn_index": 4
+        }
+        ```
+        
+        ### Flutter Integration Example:
+        ```dart
+        class KazakhLearningAPI {
+          static const String baseUrl = 'https://huggingface.co/spaces/GuestUser33/kazakh-learning-api';
+          String? sessionToken;
+          String? userId;
+          
+          // Login and get session token
+          Future<bool> login(String userId) async {
+            final response = await http.post(
+              Uri.parse('$baseUrl/api/predict'),
+              headers: {'Content-Type': 'application/json'},
+              body: jsonEncode({
+                'data': [userId],
+                'fn_index': 0
+              }),
+            );
+            
+            if (response.statusCode == 200) {
+              final result = jsonDecode(response.body);
+              if (result['data'][0]['success']) {
+                this.userId = userId;
+                this.sessionToken = result['data'][0]['session_token'];
+                return true;
+              }
+            }
+            return false;
+          }
+          
+          // Send chat message
+          Future<String?> sendMessage(String message) async {
+            if (sessionToken == null) return null;
+            
+            final response = await http.post(
+              Uri.parse('$baseUrl/api/predict'),
+              headers: {'Content-Type': 'application/json'},
+              body: jsonEncode({
+                'data': [message, userId, sessionToken],
+                'fn_index': 1
+              }),
+            );
+            
+            if (response.statusCode == 200) {
+              final result = jsonDecode(response.body);
+              if (result['data'][0]['success']) {
+                return result['data'][0]['response'];
+              }
+            }
+            return null;
+          }
+          
+          // Get user progress
+          Future<Map<String, dynamic>?> getProgress() async {
+            if (sessionToken == null) return null;
+            
+            final response = await http.post(
+              Uri.parse('$baseUrl/api/predict'),
+              headers: {'Content-Type': 'application/json'},
+              body: jsonEncode({
+                'data': [userId, sessionToken],
+                'fn_index': 2
+              }),
+            );
+            
+            if (response.statusCode == 200) {
+              final result = jsonDecode(response.body);
+              if (result['data'][0]['success']) {
+                return result['data'][0]['progress_data'];
+              }
+            }
+            return null;
+          }
+        }
+        ```
+        
+        ### Key Features:
+        - ✅ **Multi-User Support**: Each user has separate learning progress
+        - ✅ **Session Management**: Secure session tokens for authentication
+        - ✅ **Personalized Tracking**: Individual progress tracking per user
+        - ✅ **API Ready**: All endpoints ready for mobile app integration
+        - ✅ **Session Validation**: Automatic session validation and expiry
+        
+        ### Usage Notes:
+        - Always call **login** first to get a session token
+        - Include **session_token** in all subsequent API calls
+        - Handle **session expiry** by re-logging in
+        - Use **unique user_id** for each user (could be email, username, etc.)
+        """)
+
+if __name__ == "__main__":
     demo.launch()