Update calendar_rag.py

calendar_rag.py

@@ -3,7 +3,7 @@ from haystack.components.generators.openai import OpenAIGenerator
 from haystack.components.builders import PromptBuilder
 from haystack.components.embedders import SentenceTransformersDocumentEmbedder
 from haystack.components.retrievers.in_memory import *
-from haystack.document_stores.in_memory import *
+from haystack.document_stores.in_memory import InMemoryDocumentStore
 from haystack.utils import Secret
 from pathlib import Path
 import hashlib
@@ -14,6 +14,7 @@ import json
 import logging
 import re
 import pickle
+import statistics
 
 # Setup logging
 logging.basicConfig(level=logging.INFO)
@@ -647,7 +648,6 @@ class CalendarDataProcessor:
                     transportation=transportation
                 ))
             except Exception as e:
-                print(f"Error processing contact data: {e}")
                 continue
         
         return contact_details
@@ -710,25 +710,25 @@ class CalendarDataProcessor:
         # Create course categories
         structure = {
             'หมวดวิชาปรับพื้นฐาน': CourseCategory(  # Previously foundation_courses
-                description=foundation_data.get('metadata', {}).get('description'),
+                description="วิชาพื้นฐานที่จำเป็นต้องเรียน foundation courses รายวิชาปรับพื้นฐาน",
                 credits=foundation_data.get('metadata', {}).get('credits', 'non-credit'),
                 minimum_credits=None,
                 courses=foundation_courses
             ),
             'หมวดวิชาบังคับ': CourseCategory(  # Previously core_courses
-                description=None,
+                description="วิชาบังคับ วิชาหลัก core courses รายวิชาที่ต้องเรียน", 
                 credits=0,
                 minimum_credits=core_data.get('minimum_requirement_credits'),
                 courses=core_courses
             ),
             'หมวดวิชาเลือก': CourseCategory(  # Previously elective_courses
-                description=None,
+                description="วิชาเลือก elective courses รายวิชาเลือก วิชาที่สามารถเลือกเรียนได้",
                 credits=0,
                 minimum_credits=elective_data.get('minimum_requirement_credits'),
                 courses=elective_courses
             ),
             'หมวดวิชาการค้นคว้าอิสระ': CourseCategory(  # Previously research_courses
-                description=None,
+                description="วิชาค้นคว้าอิสระ research courses วิทยานิพนธ์",
                 credits=0,
                 minimum_credits=research_data.get('minimum_requirement_credits'),
                 courses=research_courses
@@ -877,33 +877,52 @@ class HybridDocumentStore:
         self.cache_manager.set_embedding_cache(text, embedding)
         return embedding
 
-    def add_document(self, text: str, event_type: str):
-        """Add a single document to the store"""
-        try:
-            # Compute embedding
-            embedding = self._compute_embedding(text)
-            
-            # Create document with unique ID
-            doc = Document(
-                id=self._generate_unique_id(),
-                content=text,
-                embedding=embedding,
-                meta={'event_type': event_type}
-            )
-            
-            # Write document
-            self.store.write_documents([doc])
-            
-            # Cache document
-            self.cache_manager.set_document_cache(doc.id, doc)
-            
-        except Exception as e:
-            logger.error(f"Error adding document: {str(e)}")
-            raise
+    def _format_required_docs(self, docs: Dict) -> str:
+        """Format required documents information with detailed English proficiency requirements"""
+        result = []
+        
+        if 'mandatory' in docs:
+            result.append("เอกสารที่ต้องใช้:")
+            for doc in docs['mandatory'].values():
+                result.append(f"- {doc.name}: {doc.description}")
+        
+        if 'optional' in docs:
+            result.append("\nเอกสารเพิ่มเติม:")
+            for doc_key, doc in docs['optional'].items():
+                if doc_key == 'english_proficiency':
+                    result.append(f"- {doc.name}")
+                    # Parse and format the accepted tests
+                    try:
+                        accepted_tests = eval(doc.description)
+                        result.append("  เกณฑ์คะแนนที่ยอมรับ:")
+                        for test, requirement in accepted_tests.items():
+                            result.append(f"    * {test}: {requirement}")
+                    except:
+                        result.append(f"  {doc.description}")
+                    
+                    if doc.conditions:
+                        conditions = doc.conditions.split(', ')
+                        for condition in conditions:
+                            result.append(f"  {condition}")
+                else:
+                    desc = f"- {doc.name}"
+                    if doc.conditions:
+                        desc += f" ({doc.conditions})"
+                    result.append(desc)
+        
+        return "\n".join(result)
+    
+    def _format_selection_steps(self, steps: List[SelectionStep]) -> str:
+        """Format selection process steps"""
+        return "\n".join(f"{step.step_number}. {step.description}" for step in steps)
 
-    def add_events(self, events: List[CalendarEvent], contact_details: Optional[List[ContactDetail]] = None,
-                  course_structure: Optional[List[CourseStructure]] = None,
-                  study_plans: Optional[List[StudyPlan]] = None):
+    def add_events(self, 
+                    events: List[CalendarEvent], 
+                    contact_details: Optional[List[ContactDetail]] = None,
+                    course_structure: Optional[List[CourseStructure]] = None,
+                    study_plans: Optional[List[StudyPlan]] = None,
+                    program_details: Optional[List[ProgramDetailInfo]] = None,
+                    tuition_fees: Optional[List[TuitionFee]] = None):
         """Add events and additional data with caching"""
         documents = []
         added_events = set()  # Track added events to prevent duplicates
@@ -976,7 +995,6 @@ class HybridDocumentStore:
         # Process course structure
         if course_structure:
             for course in course_structure:
-                self.course_data.append(course)
                 text = f"""
                 โครงสร้างหลักสูตร:
                 ชื่อหลักสูตร: {course.program_name}
@@ -985,23 +1003,33 @@ class HybridDocumentStore:
                 ระดับการศึกษา: {course.degree_level}
                 
                 รายละเอียดโครงสร้าง:
+                
+                หมวดวิชาปรับพื้นฐาน/วิชาพื้นฐาน:
+                คำอธิบาย: {course.structure['หมวดวิชาปรับพื้นฐาน'].description or 'ไม่ระบุ'}
+                หน่วยกิต: {course.structure['หมวดวิชาปรับพื้นฐาน'].credits}
+                รายวิชา:
+                {' '.join([f'- {c.code}: {c.title_th} ({c.title_en}) - {c.credits} หน่วยกิต\n' for c in course.structure['หมวดวิชาปรับพื้นฐาน'].courses])}
+                
+                หมวดวิชาบังคับ/วิชาหลัก:
+                หน่วยกิตขั้นต่ำ: {course.structure['หมวดวิชาบังคับ'].minimum_credits}
+                รายวิชา:
+                {' '.join([f'- {c.code}: {c.title_th} ({c.title_en}) - {c.credits} หน่วยกิต\n' for c in course.structure['หมวดวิชาบังคับ'].courses])}
+                
+                หมวดวิชาเลือก:
+                หน่วยกิตขั้นต่ำ: {course.structure['หมวดวิชาเลือก'].minimum_credits}
+                รายวิชา:
+                {' '.join([f'- {c.code}: {c.title_th} ({c.title_en}) - {c.credits} หน่วยกิต\n' for c in course.structure['หมวดวิชาเลือก'].courses])}
+                
+                หมวดวิชาการค้นคว้าอิสระ:
+                หน่วยกิตขั้นต่ำ: {course.structure['หมวดวิชาการค้นคว้าอิสระ'].minimum_credits}
+                รายวิชา:
+                {' '.join([f'- {c.code}: {c.title_th} ({c.title_en}) - {c.credits} หน่วยกิต\n' for c in course.structure['หมวดวิชาการค้นคว้าอิสระ'].courses])}
                 """
-                for category_name, category in course.structure.items():
-                    text += f"\n{category_name}:\n"
-                    if category.description:
-                        text += f"คำอธิบาย: {category.description}\n"
-                    text += f"หน่วยกิต: {category.credits}\n"
-                    if category.minimum_credits:
-                        text += f"หน่วยกิตขั้นต่ำ: {category.minimum_credits}\n"
-                    text += "รายวิชา:\n"
-                    for course_item in category.courses:
-                        text += f"- {course_item.code}: {course_item.title_th} ({course_item.title_en}) - {course_item.credits} หน่วยกิต\n"
                 
-                embedding = self._compute_embedding(text)
                 doc = Document(
                     id=self._generate_unique_id(),
-                    content=text,
-                    embedding=embedding,
+                    content=text.strip(),
+                    embedding=self._compute_embedding(text),
                     meta={'event_type': 'curriculum'}
                 )
                 documents.append(doc)
@@ -1010,23 +1038,107 @@ class HybridDocumentStore:
         if study_plans:
             for plan in study_plans:
                 self.study_plan_data.append(plan)
-                text = "แผนการศึกษา:\n"
                 for year, semesters in plan.years.items():
-                    text += f"\nปีที่ {year}:\n"
                     for semester, data in semesters.items():
-                        text += f"\n{semester}:\n"
-                        if 'metadata' in data and data['metadata']:
-                            text += f"ข้อมูลเพิ่มเติม: {json.dumps(data['metadata'], ensure_ascii=False)}\n"
+                        # Convert year and semester format
+                        year_num = year.replace('year', '')
+                        semester_num = semester.replace('semester', '')
+                        
+                        # Determine course type and translate to Thai
+                        course_type = data.get('metadata', {}).get('course_type', 'core')
+                        course_type_th = 'วิชาหลัก' if course_type == 'core' else 'วิชาเลือก'
+                        
+                        # Calculate total credits
+                        total_credits = sum(course.get('credits', 0) for course in data.get('courses', []))
+                        
+                        text = f"""แผนการศึกษา:
+    ปี: {year_num}
+    ภาคการศึกษา: {semester_num}
+    ประเภทรายวิชา: {course_type_th} ({course_type})
+    จำนวนหน่วยกิตรวม: {total_credits}
+
+    รายวิชาที่ต้องเรียน:"""
+                        
+                        # Add courses
                         if 'courses' in data:
                             for course in data['courses']:
-                                text += f"- {course['code']}: {course['title'].get('th', '')} ({course['title'].get('en', '')}) - {course['credits']} หน่วยกิต\n"
+                                text += f"\n- {course['code']}: {course['title'].get('th', '')} ({course['title'].get('en', '')}) - {course['credits']} หน่วยกิต"
+                        
+                        embedding = self._compute_embedding(text)
+                        doc = Document(
+                            id=self._generate_unique_id(),
+                            content=text,
+                            embedding=embedding,
+                            meta={
+                                'event_type': 'study_plan',
+                                'year': year_num,
+                                'semester': semester_num,
+                                'course_type': course_type
+                            }
+                        )
+                        documents.append(doc)
+        
+        if program_details:
+            for detail in program_details:
+                # Main application document
+                app_text = f"""
+                ข้อมูลการสมัคร:
+                เว็บไซต์รับสมัคร: {detail.application_info.application_portal}
+                อีเมล: {detail.application_info.program_email}
+                
+                เอกสารที่ต้องใช้:
+                {self._format_required_docs(detail.required_documents)}
+                
+                ขั้นตอนการส่งเอกสาร:
+                {detail.submission_process}
+                
+                ขั้นตอนการคัดเลือก:
+                {self._format_selection_steps(detail.selection_process)}
+                """
                 
-                embedding = self._compute_embedding(text)
                 doc = Document(
                     id=self._generate_unique_id(),
-                    content=text,
-                    embedding=embedding,
-                    meta={'event_type': 'study_plan'}
+                    content=app_text.strip(),
+                    embedding=self._compute_embedding(app_text),
+                    meta={'event_type': 'program_details'}
+                )
+                documents.append(doc)
+                
+                # Create separate document for English proficiency requirements
+                if 'optional' in detail.required_documents:
+                    eng_prof = next((doc for doc_key, doc in detail.required_documents['optional'].items() 
+                                if doc_key == 'english_proficiency'), None)
+                    if eng_prof:
+                        eng_text = f"""
+                        ข้อกำหนดภาษาอังกฤษ:
+                        {eng_prof.name}
+                        รายละเอียด: {eng_prof.description}
+                        เงื่อนไข: {eng_prof.conditions}
+                        """
+                        
+                        eng_doc = Document(
+                            id=self._generate_unique_id(),
+                            content=eng_text.strip(),
+                            embedding=self._compute_embedding(eng_text),
+                            meta={
+                                'event_type': 'program_details'                            }
+                        )
+                        documents.append(eng_doc)
+
+        # Process tuition fees
+        if tuition_fees:
+            for fee in tuition_fees:
+                fee_text = f"""
+                ค่าธรรมเนียมการศึกษา:
+                - ค่าเล่าเรียน: {fee.regular_fee.amount:,.2f} {fee.regular_fee.currency} {fee.regular_fee.period}
+                - ค่าปรับชำระล่าช้า: {fee.late_payment_fee.amount:,.2f} {fee.late_payment_fee.currency}
+                """
+                
+                doc = Document(
+                    id=self._generate_unique_id(),
+                    content=fee_text.strip(),
+                    embedding=self._compute_embedding(fee_text),
+                    meta={'event_type': 'fees'}
                 )
                 documents.append(doc)
         
@@ -1045,10 +1157,12 @@ class HybridDocumentStore:
     
     def hybrid_search(self, 
                      query: str, 
-                     event_type: Optional[str] = None,
-                     semester: Optional[str] = None,
-                     top_k: int = 10,
+                     event_type: Optional[str] = None, 
+                     detail_type: Optional[str] = None,
+                     semester: Optional[str] = None, 
+                     top_k: int = 10, 
                      weight_semantic: float = 0.5) -> List[Document]:
+        
         """Hybrid search combining semantic and lexical search results"""
         
         cache_key = json.dumps({
@@ -1065,15 +1179,16 @@ class HybridDocumentStore:
         
         # Get semantic search results
         query_embedding = self._compute_embedding(query)
-        semantic_results = self.embedding_retriever.run(
-            query_embedding=query_embedding
-        )["documents"]
+        semantic_results = self.embedding_retriever.run(query_embedding=query_embedding)["documents"]
         
         # Get BM25 results
         bm25_results = self.bm25_retriever.run(
             query=query
         )["documents"]
         
+        if event_type == "program_details":
+            weight_semantic = 0.3  # Give more weight to keyword matching
+        
         # Combine results using score fusion
         combined_results = self._merge_results(
             semantic_results=semantic_results,
@@ -1085,10 +1200,8 @@ class HybridDocumentStore:
         # Filter results based on metadata
         filtered_results = []
         for doc in combined_results:
-            if event_type and doc.meta.get('event_type') != event_type:
-                continue
-            if semester and doc.meta.get('semester') != semester:
-                continue
+            if event_type and event_type != "program_details" and doc.meta.get('event_type') != event_type:
+                continue  # Keep only relevant event type unless it's program_details
             filtered_results.append(doc)
         
         final_results = filtered_results[:top_k]
@@ -1139,80 +1252,6 @@ class HybridDocumentStore:
         )
         
         return sorted_docs[:top_k]
-
-class AdvancedQueryProcessor:
-    """Process queries with better understanding"""
-    
-    def __init__(self, config: PipelineConfig):
-        self.generator = OpenAIGenerator(
-            api_key=Secret.from_token(config.model.openai_api_key),
-            model=config.model.openai_model
-        )
-        self.prompt_builder = PromptBuilder(
-            template="""
-            วิเคราะห์คำถามที่เกี่ยวข้องกับปฏิทินการศึกษา (ภาษาไทย):
-            คำถาม: {{query}}
-            
-            ระบุ:
-            1. ประเภทของข้อมูลที่ต้องการค้นหา
-            2. ภาคการศึกษาที่ระบุไว้ (ถ้ามี)
-            3. คำสำคัญที่เกี่ยวข้อง
-            
-            ให้ผลลัพธ์ในรูปแบบ JSON:
-            {
-                "event_type": "ลงทะเบียน|กำหน���เวลา|การสอบ|วิชาการ|วันหยุด",
-                "semester": "ภาคการศึกษาที่ระบุ หรือ null",
-                "key_terms": ["คำสำคัญ 3 คำที่สำคัญที่สุด"],
-                "response_format": "รายการ|คำตอบเดียว|คำตอบละเอียด"
-            }
-            """
-        )
-    
-    def _get_default_analysis(self, query: str) -> Dict[str, Any]:
-        """Return default analysis when processing fails"""
-        logger.info("Returning default analysis")
-        return {
-            "original_query": query,
-            "event_type": None,
-            "semester": None,
-            "key_terms": [],
-            "response_format": "detailed"
-        }
-         
-    def process_query(self, query: str) -> Dict[str, Any]:
-        """Enhanced query processing with better error handling."""
-        
-        try:
-            result = self.prompt_builder.run(query=query)
-            response = self.generator.run(prompt=result["prompt"])
-
-            if not response or not response.get("replies") or not response["replies"][0]:
-                logger.warning("Received empty response from OpenAI")
-                return self._get_default_analysis(query)
-
-            try:
-                analysis = json.loads(response["replies"][0])
-            except json.JSONDecodeError as je:
-                return self._get_default_analysis(query)
-
-            # **Ensure course-related queries retrieve study plans & curricula**
-            course_keywords = ['หน่วยกิต', 'วิชา', 'หลักสูตร', 'แผนการเรียน', 'วิชาเลือก', 'วิชาบังคับ', 'วิชาการค้นคว้า', 'วิชาหลัก']
-            if any(keyword in query for keyword in course_keywords):
-                analysis['event_type'] = 'curriculum'
-
-            # **Ensure fee-related queries retrieve tuition fee documents**
-            fee_keywords = ['ค่าเทอม', 'ค่าธรรมเนียม', 'ค่าเรียน', 'ค่าปรับ']
-            if any(keyword in query for keyword in fee_keywords):
-                analysis['event_type'] = 'fees'
-
-            return {
-                "original_query": query,
-                **analysis
-            }
-
-        except Exception as e:
-            logger.error(f"Query processing failed: {str(e)}")
-            return self._get_default_analysis(query)
              
 class ResponseGenerator:
     """Generate responses with better context utilization"""
@@ -1224,21 +1263,27 @@ class ResponseGenerator:
         )
         self.prompt_builder = PromptBuilder(
             template="""
-            คุณเป็นที่ปรึกษาทางวิชาการ กรุณาตอบคำถามต่อไปนี้โดยใช้ข้อมูลจากปฏิทินการศึกษาที่ให้มา
+            คุณเป็นที่ปรึกษาทางวิชาการ กรุณาตอบคำถามต่อไปนี้โดยใช้ข้อมูลจากเอกสารที่ให้มาเท่านั้น
 
             คำถาม: {{query}}
 
-            ข้อมูลที่เกี่ยวข้องจากปฏิทินการศึกษา:
+            ข้อมูลที่เกี่ยวข้อง:
             {% for doc in context %}
-            --- 
+            ---
+            ประเภท: {{doc.meta.event_type}}{% if doc.meta.detail_type %}, รายละเอียด: {{doc.meta.detail_type}}{% endif %}
+            เนื้อหา:
             {{doc.content}}
             {% endfor %}
             
-            **ห้ามเดาข้อมูลเอง ถ้าไม่มีข้อมูลให้ตอบว่า "ไม่มีข้อมูลที่ตรงกับคำถาม"**
+            คำแนะนำในการตอบ:
+            1. ตอบเฉพาะข้อมูลที่มีในเอกสารเท่านั้น
+            2. หากไม่มีข้อมูลให้ตอบว่า "ขออภัย ไม่พบข้อมูลที่เกี่ยวข้องกับคำถามนี้"
+            3. หากข้อมูลไม่ชัดเจนให้ระบุว่าข้อมูลอาจไม่ครบถ้วน
+            4. จัดรูปแบบคำตอบให้อ่านง่าย ใช้หัวข้อและย่อหน้าตามความเหมาะสม
+            5. สำหรับคำถามเกี่ยวกับข้อกำหนดภาษาอังกฤษหรือขั้นตอนการสมัคร ให้อธิบายข้อมูลอย่างละเอียด
+            6. ใส่ข้อความ "หากมีข้อสงสัยเพิ่มเติม สามารถสอบถามได้" ท้ายคำตอบเสมอ
 
             กรุณาตอบเป็นภาษาไทย:
-
-            ต้องบอกเสมอว่า **หากมีข้อสงสัยเพิ่มเติมสามารถสอบถามได้**
             """
         )
    
@@ -1248,12 +1293,12 @@ class ResponseGenerator:
                          query_info: Dict[str, Any]) -> str:
         """Generate response using retrieved documents"""
         try:
+            print(query_info)
             result = self.prompt_builder.run(
                 query=query,
                 context=documents,
                 format=query_info["response_format"]
             )
-            
             response = self.generator.run(prompt=result["prompt"])
             return response["replies"][0]
             
@@ -1261,6 +1306,184 @@ class ResponseGenerator:
             logger.error(f"Response generation failed: {str(e)}")
             return "ขออภัย ไม่สามารถประมวลผลคำตอบได้ในขณะนี้"
 
+class AdvancedQueryProcessor:
+    """Process queries with better understanding"""
+
+    def __init__(self, config: PipelineConfig):
+        self.generator = OpenAIGenerator(
+            api_key=Secret.from_token(config.model.openai_api_key),
+            model=config.model.openai_model
+        )
+        self.prompt_builder = PromptBuilder(
+            template="""
+        คุณเป็นผู้ช่วย AI ที่เชี่ยวชาญด้านการศึกษาในประเทศไทย หน้าที่ของคุณคือการวิเคราะห์และจำแนกคำถามของผู้ใช้ให้ตรงกับหมวดหมู่ข้อมูลที่เหมาะสม ได้แก่:  
+
+        1. **รายละเอียดโปรแกรมการศึกษา (program_details)**: ข้อมูลเกี่ยวกับหลักสูตร โปรแกรมการเรียนการสอน และโครงสร้างหลักสูตร  
+        2. **ข้อมูลการติดต่อ (contact)**: ข้อมูลการติดต่อของหน่วยงานหรือบุคคลที่เกี่ยวข้องในสถาบันการศึกษา  
+        3. **โครงสร้างหลักสูตร (curriculum)**: รายละเอียดเกี่ยวกับวิชาเรียน หน่วยกิต และแผนการศึกษา  
+        4. **ค่าเล่าเรียน (fees)**: ข้อมูลเกี่ยวกับค่าใช้จ่ายในการศึกษา ค่าธรรมเนียม และทุนการศึกษา  
+        5. **แผนการศึกษารายปี (study_plan)**: ข้อมูลแผนการเรียนแบ่งตามชั้นปีและภาคการศึกษา รายละเอียดรายวิชาที่ต้องลงทะเบียนในแต่ละเทอม และจำนวนหน่วยกิตรวม  
+
+        **คำถาม**: {{query}}  
+
+        **คำแนะนำในการวิเคราะห์**:  
+        - ตรวจสอบคำสำคัญในคำถามเพื่อระบุหมวดหมู่ที่สอดคล้อง  
+        - หากคำถามเกี่ยวข้องกับหลายหมวดหมู่ ให้จัดลำดับความสำคัญตามความต้องการของผู้ใช้  
+        - หากไม่สามารถระบุหมวดหมู่ได้อย่างชัดเจน ให้จัดหมวดหมู่เป็น "อื่นๆ" และระบุความไม่แน่นอน  
+
+        **รูปแบบการตอบกลับ**:  
+
+        หมายเหตุ:  
+        - รูปแบบปีการศึกษาที่ยอมรับ: "ปีที่ 1", "ปี 1", "ชั้นปีที่ 1"  
+        - รูปแบบภาคการศึกษาที่ยอมรับ: "เทอมที่ 1", "เทอม 1", "ภาคการศึกษาที่ 1"  
+        - หากข้อมูลไม่ครบ ให้ระบุค่าสำหรับฟิลด์ที่ขาดหายเป็น null พร้อมข้อความแจ้งความไม���แน่นอน  
+
+        ให้ผลลัพธ์ในรูปแบบ JSON ตามโครงสร้าง:  
+        {  
+            "event_type": "program_details" | "contact" | "curriculum" | "fees" | "study_plan",  
+            "year": "ปีที่ X",            // แปลงเป็นรูปแบบมาตรฐาน หรือ null หากไม่ระบุ  
+            "semester": "เทอมที่ X",     // แปลงเป็นรูปแบบมาตรฐาน หรือ null หากไม่ระบุ  
+            "key_terms": ["คำสำคัญที่เกี่ยวข้อง"],  
+            "response_format": "detailed",  
+            "uncertainty": "low"         // ระบุระดับความไม่แน่นอน (เช่น 'low', 'high')  
+        }  
+
+        ตัวอย่าง:  
+        Input: "โปรแกรมการศึกษามีรายละเอียดอะไรบ้าง"  
+        Output: {  
+            "event_type": "program_details",  
+            "year": null,  
+            "semester": null,  
+            "key_terms": ["โปรแกรมการศึกษา", "รายละเอียด"],  
+            "response_format": "detailed",  
+            "uncertainty": "low"  
+        }  
+
+        Input: "ฉันจะติดต่อภาควิชาได้อย่างไร"  
+        Output: {  
+            "event_type": "contact",  
+            "year": null,  
+            "semester": null,  
+            "key_terms": ["ติดต่อ", "ภาควิชา"],  
+            "response_format": "detailed",  
+            "uncertainty": "low"  
+        }  
+
+        Input: "โครงสร้างหลักสูตรของปี 2 เป็นอย่างไร"  
+        Output: {  
+            "event_type": "curriculum",  
+            "year": "ปีที่ 2",  
+            "semester": null,  
+            "key_terms": ["โครงสร้างหลักสูตร"],  
+            "response_format": "detailed",  
+            "uncertainty": "low"  
+        }  
+
+        Input: "ค่าเล่าเรียนสำหรับเทอม 1 เท่าไหร่"  
+        Output: {  
+            "event_type": "fees",  
+            "year": null,  
+            "semester": "เทอมที่ 1",  
+            "key_terms": ["ค่าเล่าเรียน", "เทอม 1"],  
+            "response_format": "detailed",  
+            "uncertainty": "low"  
+        }  
+          
+        Input: "ปี 1 เทอม 1 ต้องเรียนอะไรบ้าง"  
+        Output: {  
+            "event_type": "study_plan",  
+            "year": null,  
+            "semester": null,  
+            "key_terms": ["เรียนอะไร", "เทอม"],  
+            "response_format": "detailed",  
+            "uncertainty": "low"  
+        }  
+
+        กรุณาตอบเป็นภาษาไทยและตรวจสอบให้แน่ใจว่า JSON มีโครงสร้างที่ถูกต้อง  
+            """
+        )
+
+    def normalize_year_semester(self, query: str) -> str:
+        """Normalize year and semester formats in queries"""
+        # Year patterns
+        year_patterns = {
+            r'ปี\s*(\d+)': r'ปีที่ \1',
+            r'ชั้นปีที่\s*(\d+)': r'ปีที่ \1',
+            r'ปีการศึกษาที่\s*(\d+)': r'ปีที่ \1'
+        }
+        # Semester patterns
+        semester_patterns = {
+            r'เทอม\s*(\d+)': r'เทอมที่ \1',
+            r'ภาคเรียนที่\s*(\d+)': r'เทอมที่ \1',
+            r'ภาคการศึกษาที่\s*(\d+)': r'เทอมที่ \1'
+        }
+        normalized_query = query
+        for pattern, replacement in year_patterns.items():
+            normalized_query = re.sub(pattern, replacement, normalized_query)
+        for pattern, replacement in semester_patterns.items():
+            normalized_query = re.sub(pattern, replacement, normalized_query)
+        return normalized_query
+
+    def normalize_query(self, query: str) -> str:
+        """เพิ่มการเปลี่ยนแปลงคำ (synonym mapping) เพื่อลดปัญหา Vocabulary Mismatch"""
+        normalized_query = self.normalize_year_semester(query)
+        # เพิ่ม mapping สำหรับคำที่มีความหมายเดียวกัน
+        synonyms = {
+            "วิชาเลือก": "หมวดวิชาเลือก"
+            # สามารถเพิ่มคำอื่น ๆ ได้ตามต้องการ
+        }
+        for original, replacement in synonyms.items():
+            normalized_query = normalized_query.replace(original, replacement)
+        return normalized_query
+
+    def _get_default_analysis(self, query: str) -> Dict[str, Any]:
+        logger.info("Returning default analysis")
+        return {
+            "original_query": query,
+            "event_type": None,
+            "semester": None,
+            "key_terms": [],
+            "response_format": "detailed"
+        }
+
+    def process_query(self, query: str) -> Dict[str, Any]:
+        """Enhanced query processing with support for detail types and better categorization."""
+        try:
+            # ใช้ normalize_query ที่แก้ไขแล้วเพื่อให้คำค้นมีรูปแบบที่ตรงกับดัชนีข้อมูล
+            normalized_query = self.normalize_query(query)
+            result = self.prompt_builder.run(query=normalized_query)
+            response = self.generator.run(prompt=result["prompt"])
+
+            if not response or not response.get("replies") or not response["replies"][0]:
+                logger.warning("Received empty response from OpenAI")
+                return self._get_default_analysis(query)
+
+            # ทำความสะอาด JSON string
+            json_str = response["replies"][0]
+            json_str = json_str.replace("```json", "").replace("```", "").strip()
+            analysis = json.loads(json_str)
+
+            analysis['detail_type'] = None
+
+            # Enhanced categorization with detail types
+            if any(keyword in query.lower() for keyword in ['ภาษาอังกฤษ', 'toefl', 'ielts', 'swu-set', 'โทอิค', 'คะแนนภาษา']):
+                analysis['event_type'] = 'program_details'
+            elif any(keyword in query.lower() for keyword in ['สมัคร', 'ขั้นตอน', 'วิธีการ', 'เอกสาร', 'หลักฐาน', 'admission']):
+                analysis['event_type'] = 'program_details'
+                analysis['detail_type'] = None
+            elif any(keyword in query.lower() for keyword in ['ค่าเทอม', 'ค่าธรรมเนียม', 'ค่าเรียน', 'ค่าปรับ', 'ค่าใช้จ่าย']):
+                analysis['event_type'] = 'fees'
+            elif any(keyword in query.lower() for keyword in ['หน่วยกิต', 'วิชา', 'หลักสูตร', 'แผนการเรียน', 'วิชาเลือก', 'วิชาบังคับ', 'วิชาหลัก', 'หมวดวิชา']):
+                analysis['event_type'] = 'curriculum'
+            return {
+                "original_query": query,
+                **analysis
+            }
+        except Exception as e:
+            logger.error(f"Query processing failed: {str(e)}")
+            return self._get_default_analysis(query)
+
+        
 class AcademicCalendarRAG:
     """Enhanced RAG system for academic calendar and program information"""
     
@@ -1295,152 +1518,75 @@ class AcademicCalendarRAG:
             self.study_plans = self.data_processor.extract_program_study_plan(json_data)
             self.tuition_fees = self.data_processor.extract_fees(json_data)
             
-            self._add_calendar_events()
-            self._add_program_info()
-            
-        except Exception as e:
-            logger.error(f"Error loading data: {str(e)}")
-            raise
-    
-    def _add_calendar_events(self):
-        """Add calendar events and other data to document store"""
-        if self.calendar_events:
             self.document_store.add_events(
                 events=self.calendar_events,
+                program_details=self.program_details,
                 contact_details=self.contact_details,
                 course_structure=self.course_structure,
-                study_plans=self.study_plans
+                study_plans=self.study_plans,
+                tuition_fees=self.tuition_fees
             )
-    
-    def _add_program_info(self):
-        """Enhanced method to add program-related information to document store"""
-        if self.program_details:
-            for detail in self.program_details:
-                text = f"""
-                ข้อมูลการสมัคร:
-                เว็บไซต์รับสมัคร: {detail.application_info.application_portal}
-                อีเมล: {detail.application_info.program_email}
-                
-                เอกสารที่ต้องใช้:
-                {self._format_required_docs(detail.required_documents)}
-                
-                ขั้นตอนการส่งเอกสาร:
-                {detail.submission_process}
-                
-                ขั้นตอนการคัดเลือก:
-                {self._format_selection_steps(detail.selection_process)}
-                """
-                self.document_store.add_document(text, "program_details")
-        
-        if self.tuition_fees:
-            for fee in self.tuition_fees:
-                text = f"""
-                ค่าธรรมเนียมการศึกษา:
-                ค่าเล่าเรียนปกติ: {fee.regular_fee.amount:,.2f} {fee.regular_fee.currency} {fee.regular_fee.period}
-                ค่าปรับชำระล่าช้า: {fee.late_payment_fee.amount:,.2f} {fee.late_payment_fee.currency}
-                """
-                self.document_store.add_document(text, "fees")
-    
-    def _format_required_docs(self, docs: Dict) -> str:
-        """Format required documents information with detailed English proficiency requirements"""
-        result = []
-        
-        if 'mandatory' in docs:
-            result.append("เอกสารที่ต้องใช้:")
-            for doc in docs['mandatory'].values():
-                result.append(f"- {doc.name}: {doc.description}")
-        
-        if 'optional' in docs:
-            result.append("\nเอกสารเพิ่มเติม:")
-            for doc_key, doc in docs['optional'].items():
-                if doc_key == 'english_proficiency':
-                    result.append(f"- {doc.name}")
-                    # Parse and format the accepted tests
-                    try:
-                        accepted_tests = eval(doc.description)
-                        result.append("  เกณฑ์คะแนนที่ยอมรับ:")
-                        for test, requirement in accepted_tests.items():
-                            result.append(f"    * {test}: {requirement}")
-                    except:
-                        result.append(f"  {doc.description}")
-                    
-                    if doc.conditions:
-                        conditions = doc.conditions.split(', ')
-                        for condition in conditions:
-                            result.append(f"  {condition}")
-                else:
-                    desc = f"- {doc.name}"
-                    if doc.conditions:
-                        desc += f" ({doc.conditions})"
-                    result.append(desc)
-        
-        return "\n".join(result)
-    
-    def _format_selection_steps(self, steps: List[SelectionStep]) -> str:
-        """Format selection process steps"""
-        return "\n".join(f"{step.step_number}. {step.description}" for step in steps)
-    
-    def _get_fee_documents(self) -> List[Document]:
-        """Get fee-related documents"""
-        if not self.tuition_fees:
-            return []
             
-        documents = []
-        for fee in self.tuition_fees:
-            text = f"""
-            ค่าธรรมเนียมการศึกษา:
-            - ค่าเล่าเรียน: {fee.regular_fee.amount:,.2f} {fee.regular_fee.currency} {fee.regular_fee.period}
-            - ค่าปรับชำระล่าช้า: {fee.late_payment_fee.amount:,.2f} {fee.late_payment_fee.currency}
-            """
-            doc = Document(
-                content=text,
-                meta={"event_type": "fees"}
-            )
-            documents.append(doc)
-        
-        return documents
+        except Exception as e:
+            logger.error(f"Error loading data: {str(e)}")
+            raise
     
-    def process_query(self, query: str, weight_semantic: float = 0.5) -> Dict[str, Any]:
-        """Process user query using hybrid retrieval"""
-        try:
-            # Analyze query
-            query_info = self.query_processor.process_query(query)
-            
-            # Get relevant documents using hybrid search
-            documents = self.document_store.hybrid_search(
-                query=query,
-                event_type=query_info.get("event_type"),
-                semester=query_info.get("semester"),
-                top_k=self.config.retriever.top_k,
-                weight_semantic= 0.3
-            )
-            
-            # Add fee information for fee-related queries
-            if query_info.get("event_type") == "fees" and self.tuition_fees:
-                fee_docs = self._get_fee_documents()
-                documents.extend(fee_docs)
-            
-            # Generate response
-            response = self.response_generator.generate_response(
-                query=query,
-                documents=documents,
-                query_info=query_info
-            )
-            
-            return {
-                "query": query,
-                "answer": response,
-                "relevant_docs": documents,
-                "query_info": query_info
-            }
+    def process_query(self, query: str) -> Dict[str, Any]:
+        """Process user query using hybrid retrieval with dynamic retries."""
+        max_attempts = 4  # Allow up to 4 attempts
+        attempt = 0
+        weight_values = [0.3, 0.7, 0.3, 0.7]  # Switching semantic retrieval weight
+
+        while attempt < max_attempts:
+            attempt += 1
+            try:
+                # Analyze query
+                if attempt <= 2:
+                    query_info = self.query_processor.process_query(query)  # Use normal query analysis for first 2 attempts
+                else:
+                    query_info = self.query_processor._get_default_analysis(query)  # Use default analysis for last 2 attempts
+                    logger.info(f"Retrying query processing (attempt {attempt}) with default analysis")
+
+                weight_semantic = weight_values[attempt - 1]  # Adjust weight for semantic search dynamically
+
+                # Get relevant documents using hybrid search
+                logger.info(f"Attempt {attempt}: Searching with weight_semantic={weight_semantic}")
+                documents = self.document_store.hybrid_search(
+                    query=query,
+                    event_type=query_info.get("event_type"),
+                    detail_type=query_info.get("detail_type"),
+                    semester=query_info.get("semester"),
+                    top_k=self.config.retriever.top_k,
+                    weight_semantic=weight_semantic
+                )
+
+                # Generate response
+                response = self.response_generator.generate_response(
+                    query=query,
+                    documents=documents,
+                    query_info=query_info
+                ).strip()
+
+                # If response indicates no relevant information, retry with adjusted approach
+                if "ขออภัย ไม่พบข้อมูลที่เกี่ยวข้อง" in response and attempt < max_attempts:
+                    continue  # Try again with new weight or default analysis
+
+                return {
+                    "query": query,
+                    "answer": response,
+                    "relevant_docs": documents,
+                    "query_info": query_info
+                }
+
+            except Exception as e:
+                logger.error(f"Error processing query: {str(e)}")
+
+        return {
+            "query": query,
+            "answer": "ขออภัย ไม่สามารถประมวลผลคำตอบได้ในขณะนี้",
+            "error": "Maximum retry attempts reached"
+        }
             
-        except Exception as e:
-            logger.error(f"Error processing query: {str(e)}")
-            return {
-                "query": query,
-                "answer": "ขออภัย ไม่สามารถประมวลผลคำตอบได้ในขณะนี้",
-                "error": str(e)
-            }
 # def main():
 #     """Main function demonstrating hybrid retrieval"""
 #     try:
@@ -1459,8 +1605,8 @@ class AcademicCalendarRAG:
 #         pipeline.load_data(raw_data)
         
 #         # Test queries with different semantic weights
-#         queries = ["มีวิชาหลักหรือวิชาเลือกอะไรบ้าง"]
-        
+#         queries = ["ค่าเทอมเท่าไหร่","เปิดเรียนวันไหน","ขั้นตอนการสมัครที่สาขานี้มีอะไรบ้าง","ต้องใช้ระดับภาษาอังกฤษเท่าไหร่ในการสมัครเรียนที่นี้","ถ้าจะไปติดต่อมาหลายต้องลง mrt อะไร","มีวิชาหลักเเละวิชาเลือกออะไรบ้าง", "ปีที่ 1 เทอม 1 ต้องเรียนอะไรบ้าง", "ปีที่ 2 เทอม 1 ต้องเรียนอะไรบ้าง"]
+#         # queries = ["ขั้นตอนการสมัคเรียนที่สาขานี้มีอะไรบ้าง" ,"ต้องใช้ระดับภาษาอังกฤษเท่าไหร่ในการสมัครเรียนที่นี้"]
 #         print("=" * 80)
         
 #         for query in queries:
@@ -1472,6 +1618,6 @@ class AcademicCalendarRAG:
 #     except Exception as e:
 #         logger.error(f"Pipeline execution failed: {str(e)}")
 #         raise
-
+ 
 # if __name__ == "__main__":
 #     main()