Update app.py

app.py

@@ -10,15 +10,14 @@ from collections import defaultdict
 import re
 import uuid
 import hashlib
+import google.generativeai as genai
 
 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
@@ -423,20 +422,19 @@ class PersonalizedLearningTracker:
         return words
 
 class PersonalizedKazakhAssistant:
-    def __init__(self):
+    def __init__(self, target_language: str = "English"):
         self.known_terms = set()
         self.setup_environment()
         self.setup_vectorstore()
-        self.setup_llm()
+        self.setup_llm(target_language)
         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")
         load_dotenv()
-        os.environ['GOOGLE_API_KEY'] = os.getenv("GOOGLE_API_KEY")
+        genai.configure(api_key=os.getenv("GOOGLE_API_KEY"))
         self.MODEL = "gemini-1.5-flash"
         self.db_name = "vector_db"
         
@@ -486,34 +484,37 @@ class PersonalizedKazakhAssistant:
         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.
+    def setup_llm(self, target_language: str = "English"):
+        """Setup Gemini model with system prompt formatted with target language"""
+        self.system_prompt = f"""
+        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. Respond in {target_language}.
 
-    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
+        Key capabilities:
+        1. **Answer Queries**: Provide accurate definitions and examples for Kazakh words and idioms
+        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
+        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
-    - Avoid storing definitions as terms; only track the word/idiom itself
-    - Normalize terms to lowercase to avoid duplicates due to case differences
-
-    Format responses naturally in conversational style, not JSON unless specifically requested.
-    """
-        
-        self.llm = ChatGoogleGenerativeAI(
-            model="models/gemini-1.5-flash",
-            temperature=0.7,
-            model_kwargs={"system_instruction": system_prompt}
+        Response Guidelines:
+        - For word/idiom queries: Provide definition, usage examples, and related information in {target_language}
+        - When explaining a Kazakh word or idiom retrieved from the knowledge base, **bold** the term (e.g., **күләпара**) in the response to highlight it
+        - Only bold the main term or idiom being explained, not other Kazakh words
+        - Always identify the main Kazakh word/idiom for progress tracking
+        - Be encouraging and supportive
+        - Use simple, clear explanations
+        - When discussing progress, be specific and motivating
+        - Avoid storing definitions as terms
+        - Normalize terms to lowercase
+        - Respond in conversational style
+        """
+        self.llm = genai.GenerativeModel(
+            model_name=self.MODEL,
+            system_instruction=self.system_prompt,
+            generation_config={
+                "temperature": 0.7,
+                "max_output_tokens": 500
+            }
         )
         
     def normalize_term(self, term: str) -> str:
@@ -521,253 +522,52 @@ class PersonalizedKazakhAssistant:
         return ' '.join(term.lower().strip().split())
     
     def extract_kazakh_terms(self, message: str, response: str) -> List[Tuple[str, str, str]]:
-        """Extract meaningful Kazakh terms, prioritizing response terms and full idioms."""
+        """Extract bolded Kazakh terms from response and verify against known terms."""
         terms = []
         seen_terms = set()
         
         try:
             retrieved_docs = self.vectorstore.similarity_search(message, k=5)
             
-            response_normalized = self.normalize_term(response)
-            message_normalized = self.normalize_term(message)
+            # Pattern to match bolded terms (e.g., **күләпара**)
+            bold_pattern = r'\*\*([А-Яа-яӘәҒғҚқҢңӨөҰұҮүҺһІі]+(?:[\s-][А-Яа-яӘәҒғҚқҢңӨөҰұҮүҺһІі]+)*)\*\*'
+            bold_matches = re.findall(bold_pattern, response)
             
-            is_multi_term_query = any(keyword in message_normalized for keyword in ['мысал', 'тіркестер', 'пример'])
-            is_definition_query = any(keyword in message_normalized for keyword in ['деген не', 'мағынасы', 'қалай аталады'])
-
-            # Step 1: For definition queries, prioritize response's primary term
-            if is_definition_query and not is_multi_term_query:
-                # Check if response is a single word
-                response_words = response_normalized.split()
-                if len(response_words) == 1:
-                    term = response.strip()
-                    normalized_term = self.normalize_term(term)
-                    if normalized_term in self.known_terms and normalized_term not in seen_terms and len(normalized_term) > 2 and len(normalized_term) <= 100:
-                        category = "word"
-                        definition = ""
-                        for doc in retrieved_docs:
-                            if normalized_term in self.normalize_term(doc.page_content):
-                                doc_type = doc.metadata.get('doc_type', '').lower()
-                                if 'idiom' in doc_type or 'тіркес' in doc_type:
-                                    category = "idiom"
-                                elif 'grammar' in doc_type:
-                                    category = "grammar"
-                                else:
-                                    category = "word"
-                                definition = self.extract_clean_definition(normalized_term, doc.page_content, response)
-                                break
-                        if not definition:
-                            definition = self.extract_clean_definition(normalized_term, "", response)
-                        if definition:
-                            terms.append((term, category, definition))
-                            seen_terms.add(normalized_term)
-                            print(f"Added single response term: {term}, category: {category}, definition: {definition}")
-                            return terms
-
-                # Look for quoted term in response (e.g., "басыр" in "Берілген мәтін бойынша, 'басыр' - көз ауруы")
-                quoted_pattern = r'[\'\"]([А-Яа-яӘәҒғҚқҢңӨөҰұҮүҺһІі]+(?:[\s-][А-Яа-яӘәҒғҚқҢңӨөҰұҮүҺһІі]+)*)[\'\"]'
-                quoted_matches = re.findall(quoted_pattern, response)
-                if quoted_matches:
-                    term = quoted_matches[0]
-                    normalized_term = self.normalize_term(term)
-                    if normalized_term in self.known_terms and normalized_term not in seen_terms and len(normalized_term) > 2 and len(normalized_term) <= 100:
-                        category = "word"
-                        definition = ""
-                        for doc in retrieved_docs:
-                            if normalized_term in self.normalize_term(doc.page_content):
-                                doc_type = doc.metadata.get('doc_type', '').lower()
-                                if 'idiom' in doc_type or 'тіркес' in doc_type:
-                                    category = "idiom"
-                                elif 'grammar' in doc_type:
-                                    category = "grammar"
-                                else:
-                                    category = "word"
-                                definition = self.extract_clean_definition(normalized_term, doc.page_content, response)
-                                break
-                        if not definition:
-                            definition = self.extract_clean_definition(normalized_term, "", response)
-                        if definition:
-                            terms.append((term, category, definition))
-                            seen_terms.add(normalized_term)
-                            print(f"Added quoted term: {term}, category: {category}, definition: {definition}")
-                            return terms
-
-                # Look for term before hyphen (e.g., "басыр — көз ауруы")
-                hyphen_pattern = r'^([А-Яа-яӘәҒғҚқҢңӨөҰұҮүҺһІі]+(?:[\s-][А-Яа-яӘәҒғҚқҢңӨөҰұҮүҺһІі]+)*)\s*[-–—]\s*(.+)$'
-                hyphen_matches = re.match(hyphen_pattern, response.strip(), re.MULTILINE)
-                if hyphen_matches:
-                    term = hyphen_matches.group(1).strip()
-                    definition_part = hyphen_matches.group(2).strip()
-                    normalized_term = self.normalize_term(term)
-                    if normalized_term in self.known_terms and normalized_term not in seen_terms and len(normalized_term) > 2 and len(normalized_term) <= 100:
-                        category = "word"
-                        definition = definition_part
-                        for doc in retrieved_docs:
-                            if normalized_term in self.normalize_term(doc.page_content):
-                                doc_type = doc.metadata.get('doc_type', '').lower()
-                                if 'idiom' in doc_type or 'тіркес' in doc_type:
-                                    category = "idiom"
-                                elif 'grammar' in doc_type:
-                                    category = "grammar"
-                                else:
-                                    category = "word"
-                                definition = self.extract_clean_definition(normalized_term, doc.page_content, response)
-                                break
-                        if not definition:
-                            definition = definition_part
-                        if definition:
-                            terms.append((term, category, definition))
-                            seen_terms.add(normalized_term)
-                            print(f"Added hyphen term: {term}, category: {category}, definition: {definition}")
-                            return terms
-
-                # Check query term, but only if it’s the primary term in the response
-                query_words = message_normalized.split()
-                for word in query_words:
-                    normalized_word = self.normalize_term(word)
-                    if normalized_word in self.known_terms and normalized_word not in seen_terms:
-                        # Ensure the query term is the primary term in the response
-                        sentences = response.split('.')
-                        for sentence in sentences:
-                            sentence = sentence.strip()
-                            if not sentence:
-                                continue
-                            if normalized_word in self.normalize_term(sentence):
+            for term in bold_matches:
+                normalized_term = self.normalize_term(term)
+                if normalized_term in seen_terms or len(normalized_term) <= 2 or len(normalized_term) > 100:
+                    print(f"Skipped term {normalized_term}: Invalid length or already seen")
+                    continue
+                    
+                # Check if term is in known_terms
+                if normalized_term in self.known_terms:
+                    category = "word"
+                    definition = ""
+                    # Determine category and definition from retrieved docs
+                    for doc in retrieved_docs:
+                        if normalized_term in self.normalize_term(doc.page_content):
+                            doc_type = doc.metadata.get('doc_type', '').lower()
+                            if 'idiom' in doc_type or 'тіркес' in doc_type:
+                                category = "idiom"
+                            elif 'grammar' in doc_type:
+                                category = "grammar"
+                            else:
                                 category = "word"
-                                definition = ""
-                                for doc in retrieved_docs:
-                                    if normalized_word in self.normalize_term(doc.page_content):
-                                        doc_type = doc.metadata.get('doc_type', '').lower()
-                                        if 'idiom' in doc_type or 'тіркес' in doc_type:
-                                            category = "idiom"
-                                        elif 'grammar' in doc_type:
-                                            category = "grammar"
-                                        else:
-                                            category = "word"
-                                        definition = self.extract_clean_definition(normalized_word, doc.page_content, response)
-                                        break
-                                if not definition:
-                                    definition = self.extract_clean_definition(normalized_word, "", response)
-                                if definition:
-                                    terms.append((word, category, definition))
-                                    seen_terms.add(normalized_word)
-                                    print(f"Added query term: {word}, category: {category}, definition: {definition}")
-                                    return terms
-
-                # Fallback to primary term in response (e.g., "абыз" in "Ел атасы данагөйді абыз деп атайды")
-                sentences = response.split('.')
-                for sentence in sentences:
-                    sentence = sentence.strip()
-                    if not sentence:
-                        continue
-                    kazakh_phrases = re.findall(
-                        r'[А-Яа-яӘәҒғҚқҢңӨөҰұҮүҺһІі]+(?:[\s-][А-Яа-яӘәҒғҚқҢңӨөҰұҮүҺһІі]+){0,2}',
-                        sentence
-                    )
-                    for phrase in kazakh_phrases:
-                        normalized_phrase = self.normalize_term(phrase)
-                        if normalized_phrase in seen_terms or len(normalized_phrase) <= 2 or len(normalized_phrase) > 100:
-                            print(f"Skipped phrase {normalized_phrase}: Invalid length or already seen")
-                            continue
-                        if normalized_phrase in self.known_terms and any(
-                            normalized_phrase in self.normalize_term(doc.page_content) for doc in retrieved_docs
-                        ):
-                            category = "word"
-                            definition = ""
-                            for doc in retrieved_docs:
-                                if normalized_phrase in self.normalize_term(doc.page_content):
-                                    doc_type = doc.metadata.get('doc_type', '').lower()
-                                    if 'idiom' in doc_type or 'тіркес' in doc_type:
-                                        category = "idiom"
-                                    elif 'grammar' in doc_type:
-                                        category = "grammar"
-                                    else:
-                                        category = "word"
-                                    definition = self.extract_clean_definition(normalized_phrase, doc.page_content, response)
-                                    break
-                            if not definition:
-                                definition = self.extract_clean_definition(normalized_phrase, "", response)
-                            if definition:
-                                terms.append((phrase, category, definition))
-                                seen_terms.add(normalized_phrase)
-                                print(f"Added phrase: {phrase}, category: {category}, definition: {definition}")
-                                return terms
-
-            # Step 2: For multi-term queries, prioritize full idioms from response
-            if is_multi_term_query:
-                kazakh_phrases = re.findall(
-                    r'[А-Яа-яӘәҒғҚқҢңӨөҰұҮүҺһІі]+(?:[\s,-]+[А-Яа-яӘәҒғҚқҢңӨөҰұҮүҺһІі]+)*',
-                    response
-                )
-                for phrase in kazakh_phrases:
-                    normalized_phrase = self.normalize_term(phrase)
-                    if normalized_phrase in seen_terms or len(normalized_phrase) <= 2 or len(normalized_phrase) > 100:
-                        print(f"Skipped phrase {normalized_phrase}: Invalid length or already seen")
-                        continue
-                    if normalized_phrase in self.known_terms or any(
-                        normalized_phrase in self.normalize_term(doc.page_content) for doc in retrieved_docs
-                    ):
-                        category = "word"
-                        definition = ""
-                        for doc in retrieved_docs:
-                            if normalized_phrase in self.normalize_term(doc.page_content):
-                                doc_type = doc.metadata.get('doc_type', '').lower()
-                                if 'idiom' in doc_type or 'тіркес' in doc_type:
-                                    category = "idiom"
-                                elif 'grammar' in doc_type:
-                                    category = "grammar"
-                                else:
-                                    category = "word"
-                                definition = self.extract_clean_definition(normalized_phrase, doc.page_content, response)
-                                break
-                        if not definition:
-                            definition = self.extract_clean_definition(normalized_phrase, "", response)
-                        if definition and len(normalized_phrase.split()) <= 6:
-                            terms.append((phrase, category, definition))
-                            seen_terms.add(normalized_phrase)
-                            print(f"Added phrase: {phrase}, category: {category}, definition: {definition}")
-                return terms
-
-            for known_term in self.known_terms:
-                normalized_known_term = self.normalize_term(known_term)
-                if normalized_known_term in response_normalized and normalized_known_term not in seen_terms:
-  
-                    is_part_of_idiom = any(
-                        normalized_known_term in self.normalize_term(idiom) and len(idiom.split()) > 1
-                        for idiom in self.known_terms
-                        if idiom != normalized_known_term
-                    )
-                    if is_part_of_idiom:
-                        print(f"Skipped term {known_term}: Part of a larger idiom")
-                        continue
-                    if normalized_known_term in self.known_terms and any(
-                        normalized_known_term in self.normalize_term(doc.page_content) for doc in retrieved_docs
-                    ):
-                        category = "word"
-                        definition = ""
-                        for doc in retrieved_docs:
-                            if normalized_known_term in self.normalize_term(doc.page_content):
-                                doc_type = doc.metadata.get('doc_type', '').lower()
-                                if 'idiom' in doc_type or 'тіркес' in doc_type:
-                                    category = "idiom"
-                                elif 'grammar' in doc_type:
-                                    category = "grammar"
-                                else:
-                                    category = "word"
-                                definition = self.extract_clean_definition(normalized_known_term, doc.page_content, response)
-                                break
-                        if not definition:
-                            definition = self.extract_clean_definition(normalized_known_term, "", response)
-                        if definition and len(normalized_known_term.split()) <= 10:
-                            terms.append((known_term, category, definition))
-                            seen_terms.add(normalized_known_term)
-                            print(f"Added known term: {known_term}, category: {category}, definition: {definition}")
-                            if not is_multi_term_query:
-                                return terms
-
+                            definition = self.extract_clean_definition(normalized_term, doc.page_content, response)
+                            break
+                    if not definition:
+                        definition = self.extract_clean_definition(normalized_term, "", response)
+                    
+                    if definition:
+                        terms.append((term, category, definition))
+                        seen_terms.add(normalized_term)
+                        print(f"Added bolded term: {term}, category: {category}, definition: {definition}")
+            
+            return terms
+        
         except Exception as e:
             print(f"Error extracting terms: {e}")
-        
-        return terms
+            return terms
     
     def extract_clean_definition(self, term: str, doc_content: str, response: str) -> str:
         """Extract a clean definition for a term from the knowledge base."""
@@ -810,14 +610,18 @@ class PersonalizedKazakhAssistant:
         """Process user message with proper user session management and toggle for direct Gemini"""
         
         if session_token and not self.tracker.validate_session(user_id, session_token):
-            return "Session expired. Please login again."
-        
+            return f"Session expired. Please login again in {target_language}."
+
         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)
+
+        # Set up LLM with the specified target language
+        self.setup_llm(target_language)
         
+        # Handle special commands
         if message.lower().startswith('/progress'):
             return self.get_progress_report(user_id)
         elif message.lower().startswith('/recommendations'):
@@ -831,35 +635,90 @@ class PersonalizedKazakhAssistant:
         elif message.lower().startswith('/newword'):
             new_word = self.get_new_word(user_id)
             if not new_word:
-                return "Қазір жаңа сөздер жоқ. Басқа сөздерді қайталаңыз! 🌟\n\nNo new words available right now. Review other words! 🌟"
+                return f"Қазір жаңа сөздер жоқ. Басқа сөздерді қайталаңыз! 🌟\n\nNo new words available right now. Review other words! 🌟"
             self.tracker.track_word_encounter(user_id, new_word['word'], new_word['definition'], new_word['category'])
             return f"📝 **Жаңа сөз / New Word**: {new_word['word']}\n\nМағынасы / Meaning: {new_word['definition']}"
         elif message.lower().startswith('/newidiom'):
             new_idiom = self.get_new_idiom(user_id)
             if not new_idiom:
-                return "Қазір жаңа тіркестер жоқ. Басқа тіркестерді қайталаңыз! 🌟\n\nNo new idioms available right now. Review other idioms! 🌟"
+                return f"Қазір жаңа тіркестер жоқ. Басқа тіркестерді қайталаңыз! 🌟\n\nNo new idioms available right now. Review other idioms! 🌟"
             self.tracker.track_word_encounter(user_id, new_idiom['word'], new_idiom['definition'], new_idiom['category'])
             return f"🎭 **Жаңа тіркес / New Idiom**: {new_idiom['word']}\n\nМағынасы / Meaning: {new_idiom['definition']}"
         elif message.lower().startswith('/help'):
             return self.get_help_message()
-        
+
         if use_direct_gemini:
             return self.process_direct_gemini(message, user_id, target_language)
         
-        conversation_chain = self.get_user_chain(user_id)
-        result = conversation_chain.invoke({"question": message})
-        response = result["answer"]
+        # Retrieve relevant documents from vectorstore
+        retrieved_docs = self.vectorstore.similarity_search(message, k=5)
+        context = "\n".join([doc.page_content for doc in retrieved_docs])
         
-        extracted_terms = self.extract_kazakh_terms(message, response)
+        # Get conversation history
+        memory = self.get_user_memory(user_id)
+        chat_history = ""
+        for msg in memory.chat_memory.messages[-10:]:
+            if isinstance(msg, HumanMessage):
+                chat_history += f"User: {msg.content}\n"
+            elif isinstance(msg, AIMessage):
+                chat_history += f"Assistant: {msg.content}\n"
+        
+        # Retrieve user progress from SQLite database
+        progress = self.tracker.get_user_progress(user_id)
+        words_to_review = self.tracker.get_words_to_review(user_id, 5)
+        mastered_words = self.tracker.get_mastered_words(user_id, page=1, page_size=5)
+        
+        progress_summary = """
+            User Learning Progress (in {target_language}):
+            - Total Terms Learned: {total_words}
+            - Category Statistics:
+            {category_stats}
+            - Recent Activity: {recent_activity} terms reviewed in the last 7 days
+            - Words to Review:
+            {words_to_review}
+            - Mastered Words:
+            {mastered_words}
+            """.format(
+                target_language=target_language,
+                total_words=progress['total_words'],
+                category_stats=''.join([f"  - {category}: {stats['count']} terms, Average Mastery: {stats['average_mastery']}/5\n"
+                                    for category, stats in progress['category_stats'].items()]),
+                recent_activity=progress['recent_activity'],
+                words_to_review=''.join([f"  - {word['word']} (Category: {word['category']}, Mastery: {word['mastery_level']}/5, Encounters: {word['encounter_count']})\n"
+                                        for word in words_to_review]),
+                mastered_words=''.join([f"  - {word['word']} (Category: {word['category']}, Mastery: {word['mastery_level']}/5, Encounters: {word['encounter_count']})\n"
+                                    for word in mastered_words])
+            )
+        
+        # Construct prompt with context, history, and progress
+        full_prompt = f"""
+        {self.system_prompt}
+        
+        Previous conversation:
+        {chat_history}
         
+        Context from knowledge base:
+        {context}
+        
+        {progress_summary}
+        
+        User question: {message}
+        
+        Respond in {target_language}. If explaining a Kazakh word or idiom retrieved from the context, **bold** the term (e.g., **күләпара**) in your response to highlight it. Only bold the main term being explained.
+        """
+        
+        # Call Gemini API
+        response = self.llm.generate_content(full_prompt).text
+        
+        # Add to conversation memory
+        memory.chat_memory.add_user_message(message)
+        memory.chat_memory.add_ai_message(response)
+        
+        # Extract and track terms
+        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
-                )
+            if definition and term:
+                self.tracker.track_word_encounter(user_id, term, definition, category)
         
         return response
     
@@ -1058,38 +917,41 @@ Start learning by asking about any Kazakh term! 🌟
         """Process message using direct Gemini with conversation memory for context."""
         try:
             memory = self.get_user_memory(user_id)
-
-            direct_prompt = """
-    You are a friendly and supportive Kazakh language learning assistant. Your role is to help users learn Kazakh vocabulary, grammar, and idioms in a clear, concise, and engaging way. Respond in the user's primary language, inferred from their input, unless a specific language (English, Kazakh, or Russian) is requested. Provide practical examples and explanations tailored to language learners. Keep responses concise (under 200 words) and encouraging. Use your internal knowledge to ensure accuracy and relevance, focusing exclusively on Kazakh language learning.
-    
-    Previous conversation context:
-    {chat_history}
-    """
             chat_history = ""
-            for msg in memory.chat_memory.messages[-10:]: 
+            for msg in memory.chat_memory.messages[-10:]:
                 if isinstance(msg, HumanMessage):
                     chat_history += f"User: {msg.content}\n"
                 elif isinstance(msg, AIMessage):
                     chat_history += f"Assistant: {msg.content}\n"
-    
-            direct_llm = ChatGoogleGenerativeAI(
-                model="models/gemini-1.5-flash",
-                temperature=0.7,
-                model_kwargs={"system_instruction": direct_prompt.format(chat_history=chat_history)}
-            )
-    
+            
+            direct_prompt = """
+            You are a friendly and supportive Kazakh language learning assistant. Your role is to help users learn Kazakh vocabulary, grammar, and idioms in a clear, concise, and engaging way. Respond in the user's primary language, inferred from their input, unless a specific language (English, Kazakh, or Russian) is requested. Provide practical examples and explanations tailored to language learners. Keep responses concise (under 200 words) and encouraging. Use your internal knowledge to ensure accuracy and relevance, focusing exclusively on Kazakh language learning.
+            
+            Previous conversation context:
+            {chat_history}
+            """
+            
             if target_language != "English" and not any(
                 keyword in message.lower() for keyword in ['kazakh', 'қазақша', 'қазақ тілінде', 'russian', 'русский', 'орысша']
             ):
                 modified_message = f"Explain in {target_language}: {message}"
             else:
                 modified_message = message
-    
-            response = direct_llm.invoke(modified_message).content
-    
+            
+            direct_model = genai.GenerativeModel(
+                model_name=self.MODEL,
+                system_instruction=direct_prompt.format(chat_history=chat_history),
+                generation_config={
+                    "temperature": 0.7,
+                    "max_output_tokens": 200
+                }
+            )
+            
+            response = direct_model.generate_content(modified_message).text
+            
             memory.chat_memory.add_user_message(message)
             memory.chat_memory.add_ai_message(response)
-    
+            
             return response
         except Exception as e:
             return f"Error processing direct Gemini request: {str(e)}"