Some updates

main.py

@@ -73,17 +73,17 @@ class HealthcareChatbot:
         self.user_id = 'e2fe5655-d6ac-447d-8237-850413288561'
         self.max_retries = 3
         self.retry_delay = 2
-        
+
         # Store conversation history
         self.conversation_history = []
         self.max_history_length = 10  # Keep last 10 exchanges
-        
+
         # Initialize components
         self._initialize_language_tools()
         self._initialize_llm()
         self._initialize_parsers_and_chains()
         self._initialize_date_parser()
-        
+
         print("Healthcare Chatbot initialized successfully!")
         self._print_welcome_message()
 
@@ -111,7 +111,7 @@ class HealthcareChatbot:
         try:
             self.embeddings = HuggingFaceEmbeddings(model_name="intfloat/multilingual-e5-large")
             self.language_classifier = pipeline(
-                "text-classification", 
+                "text-classification",
                 model="papluca/xlm-roberta-base-language-detection",
                 top_k=1
             )
@@ -156,172 +156,172 @@ class HealthcareChatbot:
 
         # Intent classification prompt
         self.intent_classifier_template = PromptTemplate(
-            template="""
-            You are an intent classifier. Your job is simple: understand what the user wants and check if any API endpoint can do that.
+          template="""
+          You are an intent classifier. Your job is simple: understand what the user wants and check if any API endpoint can do that.
 
-            User Message: {user_query}
-            Language: {detected_language}
-            API Endpoints: {endpoints_documentation}
-
-            Think step by step:
-
-            1. What does the user want from this message?
-            Read the user's message carefully. What is the user trying to say or accomplish? What would a human understand from this message?
-
-            2. Can any API endpoint fulfill what the user wants?
-            Look at each API endpoint. Does any endpoint do what the user is asking for? Be very precise - only say yes if there's a clear match.
-
-            Important rules:
-            - Focus ONLY on the current message, ignore conversation history for classification
-            - If the user is just talking, being social, or saying something casual, that's CONVERSATION
-            - Only choose API_ACTION if the user is clearly asking for something an API endpoint can do
-            - When you're not sure, choose CONVERSATION
-
-            Answer in this format:
-            {{
-                "intent": "API_ACTION" or "CONVERSATION",
-                "confidence": [0.0 to 1.0],
-                "reasoning": "What does the user want? Can any API do this?",
-                "requires_backend": true or false
-            }}
-            """,
-            input_variables=["user_query", "detected_language", "conversation_history", "endpoints_documentation"]
-        )
+          User Message: {user_query}
+          Language: {detected_language}
+          API Endpoints: {endpoints_documentation}
 
+          Think step by step:
 
+          1. What does the user want from this message?
+          Read the user's message carefully. What is the user trying to say or accomplish? What would a human understand from this message?
 
+          2. Can any API endpoint fulfill what the user wants?
+          Look at each API endpoint. Does any endpoint do what the user is asking for? Be very precise - only say yes if there's a clear match.
 
-        # API routing prompt (reuse existing router_prompt_template)
-        self.router_prompt_template = PromptTemplate(
-            template="""
-            You are an expert API routing assistant with deep analytical capabilities. Your role is to thoroughly understand user intentions and precisely match them with the most appropriate API endpoint after comprehensive analysis.
+          Important rules:
+          - Focus ONLY on the current message, ignore conversation history for classification
+          - If the user is just talking, being social, or saying something casual, that's CONVERSATION
+          - Only choose API_ACTION if the user is clearly asking for something an API endpoint can do
+          - When you're not sure, choose CONVERSATION
 
-            === CURRENT CONTEXT ===
-            Current Date/Time: {current_datetime}
-            Current Timezone: {timezone}
-            User Location/Locale: {user_locale}
+          Answer in this format:
+          {{
+              "intent": "API_ACTION" or "CONVERSATION",
+              "confidence": [0.0 to 1.0],
+              "reasoning": "What does the user want? Can any API do this?",
+              "requires_backend": true or false
+          }}
+          """,
+          input_variables=["user_query", "detected_language", "conversation_history", "endpoints_documentation"]
+      )
 
-            === AVAILABLE ENDPOINTS ===
-            {endpoints_documentation}
 
-            === USER REQUEST DETAILS ===
-            User Query: {user_query}
-            Detected Language: {detected_language}
-            Extracted Keywords: {extracted_keywords}
-            Sentiment Analysis: {sentiment_analysis}
-            Conversation History: {conversation_history}
 
-            === COMPREHENSIVE ANALYSIS PROCESS ===
-
-            PHASE 1: DEEP QUERY UNDERSTANDING
-            Thoroughly analyze the user's request by examining:
-            - PRIMARY INTENT: What is the core action the user wants to perform?
-            - SECONDARY INTENTS: Are there multiple actions or follow-up implications?
-            - ENTITY IDENTIFICATION: What specific resources/objects are mentioned?
-            - OPERATION TYPE: Create, Read, Update, Delete, Search, List, Filter, Aggregate?
-            - IMPLICIT CONTEXT: What assumptions or unstated requirements exist?
-            - URGENCY/PRIORITY: Is this time-sensitive or routine?
-            - SCOPE: Single item, multiple items, or system-wide operation?
-
-            PHASE 2: ENDPOINTS DOCUMENTATION COMPREHENSION
-            For EACH endpoint in the documentation, analyze:
-            - PURPOSE AND FUNCTIONALITY: What business problem does this endpoint solve?
-            - REQUIRED VS OPTIONAL PARAMETERS: What data is absolutely necessary?
-            - INPUT DATA TYPES AND FORMATS: How should data be structured?
-            - EXPECTED OUTPUT: What will this endpoint return?
-            - USE CASES: When would this endpoint be the best choice?
-            - CONSTRAINTS AND LIMITATIONS: What are the boundaries of this endpoint?
-            - RELATIONSHIP TO OTHER ENDPOINTS: How does it fit in the overall API ecosystem?
-
-            PHASE 3: SEMANTIC MATCHING AND SCORING
-            For each potential endpoint match:
-            - INTENT ALIGNMENT SCORE (0-100): How well does the endpoint's purpose match user intent?
-            - PARAMETER AVAILABILITY SCORE (0-100): How much required data can be extracted/inferred?
-            - CONTEXT RELEVANCE SCORE (0-100): How well does this fit the conversation context?
-            - OPERATIONAL COMPLEXITY SCORE (0-100): How straightforward is this operation?
-            - TOTAL MATCH SCORE: Weighted average of above scores
-
-            PHASE 4: TEMPORAL AND CONTEXTUAL PROCESSING
-            Handle time-related expressions with precision:
-            - RELATIVE TIME CONVERSION:
-                * Arabic: اليوم/today, غدا/tomorrow, أمس/yesterday, بعد/after, قبل/before
-                * English: today, tomorrow, yesterday, next week, in 2 hours, etc.
-                * Context-aware: "next appointment", "usual time", "same day"
-            - ABSOLUTE TIME PARSING:
-                * Date formats: DD/MM/YYYY, MM-DD-YYYY, YYYY-MM-DD
-                * Time formats: 12-hour (AM/PM), 24-hour, relative (morning/afternoon)
-            - TIMEZONE CONSIDERATIONS:
-                * Convert all times to user's timezone
-                * Account for daylight saving time if applicable
-                * Provide ISO 8601 formatted output
-
-            PHASE 5: PARAMETER EXTRACTION AND VALIDATION
-            Extract and validate ALL parameters:
-            - DIRECT EXTRACTION: Explicitly mentioned values in user query
-            - CONTEXTUAL INFERENCE: Values derivable from conversation history
-            - TYPE CONVERSION: Ensure proper data types (string, int, float, datetime, boolean)
-            - FORMAT VALIDATION: Check against endpoint requirements
-            - DEFAULT VALUES: Apply sensible defaults for optional parameters
-            - MISSING PARAMETER IDENTIFICATION: Clearly identify what's missing and why it's needed
-
-            PHASE 6: DECISION VALIDATION AND CONFIDENCE ASSESSMENT
-            Before finalizing the decision:
-            - SANITY CHECK: Does this endpoint actually solve the user's problem?
-            - ALTERNATIVE CONSIDERATION: Are there better endpoint options?
-            - COMPLETENESS VERIFICATION: Are all required parameters available or obtainable?
-            - EDGE CASE EVALUATION: What could go wrong with this choice?
-            - CONFIDENCE CALCULATION: How certain are you about this routing decision?
-
-            === RESPONSE FORMAT ===
-            Provide your comprehensive analysis and decision in this exact JSON structure:
-
-            {{
-                "reasoning": {{
-                    "user_intent": "Detailed description of what the user wants to accomplish, including primary and secondary goals",
-                    "temporal_analysis": "How dates/times were interpreted and converted with step-by-step calculations",
-                    "context_used": "Any context from conversation history that was applied, including entity persistence and implicit references",
-                    "endpoint_analysis": "Thorough evaluation of why each potential endpoint was considered or rejected, with scoring rationale",
-                    "selected_endpoint": "Detailed explanation of why this specific endpoint was chosen over all others",
-                    "parameter_mapping": "Comprehensive explanation of how user query maps to endpoint parameters, including extraction methods and confidence levels"
-                }},
-                "endpoint": "/exact_endpoint_path_from_documentation",
-                "method": "HTTP_METHOD",
-                "params": {{
-                    "required_param_1": "extracted_or_converted_value",
-                    "required_param_2": "extracted_or_converted_value",
-                    "optional_param": "value_if_applicable"
-                }},
-                "missing_required": ["list", "of", "missing", "required", "parameters"],
-                "confidence": 0.95
-            }}
-
-            === CRITICAL EXCELLENCE STANDARDS ===
-            1. **ACCURACY FIRST**: Only route to endpoints that exist in the documentation
-            2. **NO FABRICATION**: Never assume parameters or capabilities not explicitly documented
-            3. **COMPLETE UNDERSTANDING**: Demonstrate deep comprehension of both query and endpoints
-            4. **TEMPORAL PRECISION**: Handle all time expressions with mathematical accuracy
-            5. **CONTEXT MASTERY**: Leverage conversation history intelligently and completely
-            6. **MULTILINGUAL COMPETENCY**: Handle Arabic, English, and mixed-language queries flawlessly
-            7. **PARAMETER COMPLETENESS**: Account for every required parameter or clearly identify gaps
-            8. **CONFIDENCE HONESTY**: Provide realistic confidence scores with clear reasoning
-            9. **EDGE CASE AWARENESS**: Consider what could go wrong and prepare for it
-            10. **DECISION TRANSPARENCY**: Make your reasoning process completely clear and auditable
-
-            === ADVANCED CONTEXT HANDLING ===
-            - **Pronoun Resolution**: "Cancel it" → identify what "it" refers to from history
-            - **Implicit References**: "Same time tomorrow" → extract time from previous context
-            - **Entity Persistence**: Remember patient IDs, appointment IDs across conversation turns
-            - **Intent Continuation**: Understand when user is continuing a previous request
-            - **Correction Handling**: Detect when user is correcting previous information
-
-            Think methodically through each phase. Demonstrate deep understanding before making decisions. Be thorough in your analysis and transparent in your reasoning.
-            """,
-            input_variables=[
-                "endpoints_documentation", "user_query", "detected_language",
-                "extracted_keywords", "sentiment_analysis", "conversation_history", 
-                "current_datetime", "timezone", "user_locale"
-            ]
-        )
+
+        # API routing prompt (reuse existing router_prompt_template)
+        self.router_prompt_template = PromptTemplate(
+          template="""
+          You are an expert API routing assistant with deep analytical capabilities. Your role is to thoroughly understand user intentions and precisely match them with the most appropriate API endpoint after comprehensive analysis.
+
+          === CURRENT CONTEXT ===
+          Current Date/Time: {current_datetime}
+          Current Timezone: {timezone}
+          User Location/Locale: {user_locale}
+
+          === AVAILABLE ENDPOINTS ===
+          {endpoints_documentation}
+
+          === USER REQUEST DETAILS ===
+          User Query: {user_query}
+          Detected Language: {detected_language}
+          Extracted Keywords: {extracted_keywords}
+          Sentiment Analysis: {sentiment_analysis}
+          Conversation History: {conversation_history}
+
+          === COMPREHENSIVE ANALYSIS PROCESS ===
+
+          PHASE 1: DEEP QUERY UNDERSTANDING
+          Thoroughly analyze the user's request by examining:
+          - PRIMARY INTENT: What is the core action the user wants to perform?
+          - SECONDARY INTENTS: Are there multiple actions or follow-up implications?
+          - ENTITY IDENTIFICATION: What specific resources/objects are mentioned?
+          - OPERATION TYPE: Create, Read, Update, Delete, Search, List, Filter, Aggregate?
+          - IMPLICIT CONTEXT: What assumptions or unstated requirements exist?
+          - URGENCY/PRIORITY: Is this time-sensitive or routine?
+          - SCOPE: Single item, multiple items, or system-wide operation?
+
+          PHASE 2: ENDPOINTS DOCUMENTATION COMPREHENSION
+          For EACH endpoint in the documentation, analyze:
+          - PURPOSE AND FUNCTIONALITY: What business problem does this endpoint solve?
+          - REQUIRED VS OPTIONAL PARAMETERS: What data is absolutely necessary?
+          - INPUT DATA TYPES AND FORMATS: How should data be structured?
+          - EXPECTED OUTPUT: What will this endpoint return?
+          - USE CASES: When would this endpoint be the best choice?
+          - CONSTRAINTS AND LIMITATIONS: What are the boundaries of this endpoint?
+          - RELATIONSHIP TO OTHER ENDPOINTS: How does it fit in the overall API ecosystem?
+
+          PHASE 3: SEMANTIC MATCHING AND SCORING
+          For each potential endpoint match:
+          - INTENT ALIGNMENT SCORE (0-100): How well does the endpoint's purpose match user intent?
+          - PARAMETER AVAILABILITY SCORE (0-100): How much required data can be extracted/inferred?
+          - CONTEXT RELEVANCE SCORE (0-100): How well does this fit the conversation context?
+          - OPERATIONAL COMPLEXITY SCORE (0-100): How straightforward is this operation?
+          - TOTAL MATCH SCORE: Weighted average of above scores
+
+          PHASE 4: TEMPORAL AND CONTEXTUAL PROCESSING
+          Handle time-related expressions with precision:
+          - RELATIVE TIME CONVERSION:
+            * Arabic: اليوم/today, غدا/tomorrow, أمس/yesterday, بعد/after, قبل/before
+            * English: today, tomorrow, yesterday, next week, in 2 hours, etc.
+            * Context-aware: "next appointment", "usual time", "same day"
+          - ABSOLUTE TIME PARSING:
+            * Date formats: DD/MM/YYYY, MM-DD-YYYY, YYYY-MM-DD
+            * Time formats: 12-hour (AM/PM), 24-hour, relative (morning/afternoon)
+          - TIMEZONE CONSIDERATIONS:
+            * Convert all times to user's timezone
+            * Account for daylight saving time if applicable
+            * Provide ISO 8601 formatted output
+
+          PHASE 5: PARAMETER EXTRACTION AND VALIDATION
+          Extract and validate ALL parameters:
+          - DIRECT EXTRACTION: Explicitly mentioned values in user query
+          - CONTEXTUAL INFERENCE: Values derivable from conversation history
+          - TYPE CONVERSION: Ensure proper data types (string, int, float, datetime, boolean)
+          - FORMAT VALIDATION: Check against endpoint requirements
+          - DEFAULT VALUES: Apply sensible defaults for optional parameters
+          - MISSING PARAMETER IDENTIFICATION: Clearly identify what's missing and why it's needed
+
+          PHASE 6: DECISION VALIDATION AND CONFIDENCE ASSESSMENT
+          Before finalizing the decision:
+          - SANITY CHECK: Does this endpoint actually solve the user's problem?
+          - ALTERNATIVE CONSIDERATION: Are there better endpoint options?
+          - COMPLETENESS VERIFICATION: Are all required parameters available or obtainable?
+          - EDGE CASE EVALUATION: What could go wrong with this choice?
+          - CONFIDENCE CALCULATION: How certain are you about this routing decision?
+
+          === RESPONSE FORMAT ===
+          Provide your comprehensive analysis and decision in this exact JSON structure:
+
+          {{
+              "reasoning": {{
+                  "user_intent": "Detailed description of what the user wants to accomplish, including primary and secondary goals",
+                  "temporal_analysis": "How dates/times were interpreted and converted with step-by-step calculations",
+                  "context_used": "Any context from conversation history that was applied, including entity persistence and implicit references",
+                  "endpoint_analysis": "Thorough evaluation of why each potential endpoint was considered or rejected, with scoring rationale",
+                  "selected_endpoint": "Detailed explanation of why this specific endpoint was chosen over all others",
+                  "parameter_mapping": "Comprehensive explanation of how user query maps to endpoint parameters, including extraction methods and confidence levels"
+              }},
+              "endpoint": "/exact_endpoint_path_from_documentation",
+              "method": "HTTP_METHOD",
+              "params": {{
+                  "required_param_1": "extracted_or_converted_value",
+                  "required_param_2": "extracted_or_converted_value",
+                  "optional_param": "value_if_applicable"
+              }},
+              "missing_required": ["list", "of", "missing", "required", "parameters"],
+              "confidence": 0.95
+          }}
+
+          === CRITICAL EXCELLENCE STANDARDS ===
+          1. **ACCURACY FIRST**: Only route to endpoints that exist in the documentation
+          2. **NO FABRICATION**: Never assume parameters or capabilities not explicitly documented
+          3. **COMPLETE UNDERSTANDING**: Demonstrate deep comprehension of both query and endpoints
+          4. **TEMPORAL PRECISION**: Handle all time expressions with mathematical accuracy
+          5. **CONTEXT MASTERY**: Leverage conversation history intelligently and completely
+          6. **MULTILINGUAL COMPETENCY**: Handle Arabic, English, and mixed-language queries flawlessly
+          7. **PARAMETER COMPLETENESS**: Account for every required parameter or clearly identify gaps
+          8. **CONFIDENCE HONESTY**: Provide realistic confidence scores with clear reasoning
+          9. **EDGE CASE AWARENESS**: Consider what could go wrong and prepare for it
+          10. **DECISION TRANSPARENCY**: Make your reasoning process completely clear and auditable
+
+          === ADVANCED CONTEXT HANDLING ===
+          - **Pronoun Resolution**: "Cancel it" → identify what "it" refers to from history
+          - **Implicit References**: "Same time tomorrow" → extract time from previous context
+          - **Entity Persistence**: Remember patient IDs, appointment IDs across conversation turns
+          - **Intent Continuation**: Understand when user is continuing a previous request
+          - **Correction Handling**: Detect when user is correcting previous information
+
+          Think methodically through each phase. Demonstrate deep understanding before making decisions. Be thorough in your analysis and transparent in your reasoning.
+          """,
+          input_variables=[
+              "endpoints_documentation", "user_query", "detected_language",
+              "extracted_keywords", "sentiment_analysis", "conversation_history",
+              "current_datetime", "timezone", "user_locale"
+          ]
+      )
         # self.router_prompt_template = PromptTemplate(
         #     template="""
         #     You are a precise API routing assistant. Your job is to analyze user queries and select the correct API endpoint with proper parameters.
@@ -448,162 +448,140 @@ class HealthcareChatbot:
         # API response formatting prompt (reuse existing user_response_template)
         # self.user_response_template = PromptTemplate(
         #     template="""
-        #     You are a professional healthcare assistant. Generate clear, accurate responses using EXACT data from the system.
-
-        #     === STRICT REQUIREMENTS ===
-        #     - Respond ONLY in {detected_language}
-        #     - Use EXACT information from api_response - NO modifications
-        #     - Keep responses SHORT, SIMPLE, and DIRECT
-        #     - Use professional healthcare tone
-        #     - NEVER mix languages or make up information
+        #     You are a professional healthcare assistant. Answer the user's question using the provided API data.
 
-        #     === ORIGINAL REQUEST ===
         #     User Query: {user_query}
         #     User Sentiment: {sentiment_analysis}
+        #     Response Language: {detected_language}
 
-        #     === SYSTEM DATA ===
+        #     API Response Data:
         #     {api_response}
 
-        #     === LANGUAGE-SPECIFIC FORMATTING ===
-
-        #     FOR ARABIC RESPONSES:
-        #     - Use Modern Standard Arabic (الفصحى)
-        #     - Use Arabic numerals: ١، ٢، ٣، ٤، ٥، ٦، ٧، ٨، ٩، ١٠
-        #     - Time format: "من الساعة ٨:٠٠ صباحاً إلى ٥:٠٠ مساءً"
-        #     - Date format: "١٥ مايو ٢٠٢٥"
-        #     - Use proper Arabic medical terminology
-        #     - Keep sentences short and grammatically correct
-        #     - Example format for hospitals:
-        #     "مستشفى [الاسم] - العنوان: [العنوان الكامل] - أوقات العمل: من [الوقت] إلى [الوقت]"
-
-        #     FOR ENGLISH RESPONSES:
-        #     - Use clear, professional language
-        #     - Time format: "8:00 AM to 5:00 PM"
-        #     - Date format: "May 15, 2025"
-        #     - Keep sentences concise and direct
-        #     - Example format for hospitals:
-        #     "[Hospital Name] - Address: [Full Address] - Hours: [Opening Time] to [Closing Time]"
-
-        #     === RESPONSE STRUCTURE ===
-        #     1. Direct answer to the user's question
-        #     2. Essential details only (names, addresses, hours, contact info)
-        #     3. Brief helpful note if needed
-        #     4. No unnecessary introductions or conclusions
+        #     === INSTRUCTIONS ===
+
+        #     1. Read and understand the API response data above
+        #     2. Use ONLY the actual data from the API response - never make up information
+        #     3. Respond in {detected_language} language only
+        #     4. Write like you're talking to a friend or family member - warm, friendly, and caring
+        #     5. Make it sound natural and conversational, not like a system message
+        #     6. Convert technical data to simple, everyday language
+
+        #     === DATE AND TIME FORMATTING ===
+
+        #     When you see date_time fields like '2025-05-30T10:28:10':
+        #     - For English: Convert to "May 30, 2025 at 10:28 AM"
+        #     - For Arabic: Convert to "٣٠ مايو ٢٠٢٥ في الساعة ١٠:٢٨ صباحاً"
+
+        #     === RESPONSE EXAMPLES ===
+
+        #     For appointment confirmations:
+        #     - English: "Great! I've got your appointment set up for May 30, 2025 at 10:28 AM. Everything looks good!"
+        #     - Arabic: "ممتاز! موعدك محجوز يوم ٣٠ مايو ٢٠٢٥ الساعة ١٠:٢٨ صباحاً. كل شيء جاهز!"
+
+        #     For appointment info:
+        #     - English: "Your next appointment is on May 30, 2025 at 10:28 AM. See you then!"
+        #     - Arabic: "موعدك القادم يوم ٣٠ مايو ٢٠٢٥ الساعة ١٠:٢٨ صباحاً. نراك قريباً!"
+
+        #     === TONE GUIDELINES ===
+        #     - Use friendly words like: "Great!", "Perfect!", "All set!", "ممتاز!", "رائع!", "تمام!"
+        #     - Add reassuring phrases: "Everything looks good", "You're all set", "كل شيء جاهز", "تم بنجاح"
+        #     - Sound helpful and caring, not robotic or formal
+
+        #     === LANGUAGE FORMATTING ===
+
+        #     For Arabic responses:
+        #     - Use Arabic numerals: ٠١٢٣٤٥٦٧٨٩
+        #     - Use Arabic month names: يناير، فبراير، مارس، أبريل، مايو، يونيو، يوليو، أغسطس، سبتمبر، أكتوبر، نوفمبر، ديسمبر
+        #     - Friendly, warm Arabic tone
+
+        #     For English responses:
+        #     - Use standard English numerals
+        #     - 12-hour time format with AM/PM
+        #     - Friendly, conversational English tone
 
         #     === CRITICAL RULES ===
-        #     - Extract information EXACTLY as provided in api_response
-        #     - Do NOT include technical URLs, IDs, or system codes in the response
-        #     - Do NOT show raw links or booking URLs to users
-        #     - Present information in natural, conversational language
-        #     - Do NOT use bullet points or technical formatting
-        #     - Write as if you're speaking to the patient directly
-        #     - If data is missing, state "المعلومات غير متوفرة" (Arabic) or "Information not available" (English)
-        #     - Convert technical data into human-readable format
-        #     - NEVER add translations or explanations in other languages
-        #     - NEVER include "Translated response" or similar phrases
-        #     - END your response immediately after providing the requested information
-        #     - Do NOT add any English translation when responding in Arabic
-        #     - Do NOT add any Arabic translation when responding in English
-
-        #     === HUMAN-LIKE FORMATTING RULES ===
-        #     FOR ARABIC:
-        #     - Instead of "رابط الحجز: [URL]" → say "تم حجز موعدك بنجاح"
-        #     - Instead of "الأزمة: غير متوفرة" → omit or say "بدون أعراض محددة"
-        #     - Use natural sentences like "موعدك مع الدكتور [Name] يوم [Date] في تمام الساعة [Time]"
-        #     - Avoid technical terms and system language
-
-        #     FOR ENGLISH:
-        #     - Instead of "Booking URL: [link]" → say "Your appointment has been scheduled"
-        #     - Use natural sentences like "You have an appointment with Dr. [Name] on [Date] at [Time]"
-        #     - Avoid showing raw URLs, IDs, or technical data
-
-        #     === QUALITY CHECKS ===
-        #     Before responding, verify:
-        #     ✓ Response sounds natural and conversational
-        #     ✓ No technical URLs, IDs, or system codes are shown
-        #     ✓ Information is presented in human-friendly language
-        #     ✓ Grammar is correct in the target language
-        #     ✓ Response directly answers the user's question
-        #     ✓ No bullet points or technical formatting
-        #     ✓ Sounds like a helpful human assistant, not a system
-
-        #     Generate a response that is accurate, helpful, and professionally formatted.
-
-        #     === FINAL INSTRUCTION ===
-        #     Respond ONLY in the requested language. Do NOT provide translations, explanations, or additional text in any other language. Stop immediately after answering the user's question.
+        #     - Extract dates and times exactly as they appear in the API response
+        #     - Never use example dates or placeholder information
+        #     - Respond only in the specified language
+        #     - Make your response sound like a helpful friend, not a computer
+        #     - Focus on answering the user's specific question with warmth and care
+
+        #     Generate a friendly, helpful response using the API data provided above.
         #     """,
         #     input_variables=["user_query", "api_response", "detected_language", "sentiment_analysis"]
         # )
         self.user_response_template = PromptTemplate(
-            template="""
-            You are a professional healthcare assistant. Answer the user's question using the provided API data.
-
-            User Query: {user_query}
-            User Sentiment: {sentiment_analysis}
-            Response Language: {detected_language}
-
-            API Response Data:
-            {api_response}
-
-            === INSTRUCTIONS ===
-            
-            1. Read and understand the API response data above
-            2. Use ONLY the actual data from the API response - never make up information
-            3. Respond in {detected_language} language only
-            4. Write like you're talking to a friend or family member - warm, friendly, and caring
-            5. Make it sound natural and conversational, not like a system message
-            6. Convert technical data to simple, everyday language
-
-            === DATE AND TIME FORMATTING ===
-            
-            When you see date_time fields like '2025-05-30T10:28:10':
-            - For English: Convert to "May 30, 2025 at 10:28 AM" 
-            - For Arabic: Convert to "٣٠ مايو ٢٠٢٥ في الساعة ١٠:٢٨ صباحاً"
-
-            === RESPONSE EXAMPLES ===
-            
-            For appointment confirmations:
-            - English: "Great! I've got your appointment set up for May 30, 2025 at 10:28 AM. Everything looks good!"
-            - Arabic: "ممتاز! موعدك محجوز يوم ٣٠ مايو ٢٠٢٥ الساعة ١٠:٢٨ صباحاً. كل شيء جاهز!"
-
-            For appointment info:
-            - English: "Your next appointment is on May 30, 2025 at 10:28 AM. See you then!"
-            - Arabic: "موعدك القادم يوم ٣٠ مايو ٢٠٢٥ الساعة ١٠:٢٨ صباحاً. نراك قريباً!"
-
-            === TONE GUIDELINES ===
-            - Use friendly words like: "Great!", "Perfect!", "All set!", "ممتاز!", "رائع!", "تمام!"
-            - Add reassuring phrases: "Everything looks good", "You're all set", "كل شيء جاهز", "تم بنجاح"
-            - Sound helpful and caring, not robotic or formal
-
-            === LANGUAGE FORMATTING ===
-            
-            For Arabic responses:
-            - Use Arabic numerals: ٠١٢٣٤٥٦٧٨٩
-            - Use Arabic month names: يناير، فبراير، مارس، أبريل، مايو، يونيو، يوليو، أغسطس، سبتمبر، أكتوبر، نوفمبر، ديسمبر
-            - Friendly, warm Arabic tone
-
-            For English responses:  
-            - Use standard English numerals
-            - 12-hour time format with AM/PM
-            - Friendly, conversational English tone
-
-            === CRITICAL RULES ===
-            - Extract dates and times exactly as they appear in the API response
-            - Never use example dates or placeholder information
-            - Respond only in the specified language
-            - Make your response sound like a helpful friend, not a computer
-            - Focus on answering the user's specific question with warmth and care
-
-            Generate a friendly, helpful response using the API data provided above.
-            """,
-            input_variables=["user_query", "api_response", "detected_language", "sentiment_analysis"]
-        )
+          template="""
+          You are a professional healthcare assistant. Your task is to carefully analyze the API data and respond to the user's question accurately.
+
+          User Query: {user_query}
+          User Sentiment: {sentiment_analysis}
+          Response Language: {detected_language}
+
+          API Response Data:
+          {api_response}
+
+          === CRITICAL INSTRUCTIONS ===
+
+          1. FIRST: Carefully read and analyze the API response data above
+          2. SECOND: Identify all date_time fields in the format 'YYYY-MM-DDTHH:MM:SS'
+          3. THIRD: Extract the EXACT dates and times from the API response - DO NOT use any example dates
+          4. FOURTH: Convert these extracted dates to the user-friendly format specified below
+          5. FIFTH: Respond ONLY in {detected_language} language
+          6. Use a warm, friendly, conversational tone like talking to a friend
+
+          === DATE EXTRACTION AND CONVERSION ===
+
+          Step 1: Find date_time fields in the API response (format: 'YYYY-MM-DDTHH:MM:SS')
+          Step 2: Convert ONLY the actual extracted dates using these rules:
+
+          For English:
+          - Convert 'YYYY-MM-DDTHH:MM:SS' to readable format
+          - Example: '2025-06-01T08:00:00' becomes "June 1, 2025 at 8:00 AM"
+          - Use 12-hour format with AM/PM
+
+          For Arabic:
+          - Convert to Arabic numerals and month names
+          - Example: '2025-06-01T08:00:00' becomes "١ يونيو ٢٠٢٥ في الساعة ٨:٠٠ صباحاً"
+          - Arabic months: يناير، فبراير، مارس، أبريل، مايو، يونيو، يوليو، أغسطس، سبتمبر، أكتوبر، نوفمبر، ديسمبر
+          - Arabic numerals: ٠١٢٣٤٥٦٧٨٩
+
+          === RESPONSE APPROACH ===
+
+          1. Analyze what the user is asking for
+          2. Find the relevant information in the API response
+          3. Extract actual dates/times from the API data
+          4. Convert technical information to simple language
+          5. Respond warmly and helpfully
+
+          === TONE AND LANGUAGE ===
+
+          English responses:
+          - Use phrases like: "Great!", "Perfect!", "All set!", "Here's what I found:"
+          - Be conversational and reassuring
+
+          Arabic responses:
+          - Use phrases like: "ممتاز!", "رائع!", "تمام!", "إليك ما وجدته:"
+          - Be warm and helpful in Arabic style
+
+          === IMPORTANT REMINDERS ===
+          - NEVER use example dates from this prompt
+          - ALWAYS extract dates from the actual API response data
+          - If no dates exist in API response, don't mention any dates
+          - Stay focused on answering the user's specific question
+          - Use only information that exists in the API response
+
+          Now, carefully analyze the API response above and generate a helpful response to the user's query using ONLY the actual data provided.
+          """,
+          input_variables=["user_query", "api_response", "detected_language", "sentiment_analysis"]
+      )
 
         # Create chains
         self.intent_chain = LLMChain(llm=self.llm, prompt=self.intent_classifier_template)
         self.router_chain = LLMChain(llm=self.llm, prompt=self.router_prompt_template)
         self.conversation_chain = LLMChain(llm=self.llm, prompt=self.conversation_template)
         self.api_response_chain = LLMChain(llm=self.llm, prompt=self.user_response_template)
+
     def detect_language(self, text):
         """Detect language of the input text"""
         if self.language_classifier and len(text.strip()) > 3:
@@ -611,7 +589,7 @@ class HealthcareChatbot:
                 result = self.language_classifier(text)
                 detected_lang = result[0][0]['label']
                 confidence = result[0][0]['score']
-                
+
                 if detected_lang in ['ar', 'arabic']:
                     return "arabic"
                 elif detected_lang in ['en', 'english']:
@@ -620,12 +598,12 @@ class HealthcareChatbot:
                     return "english"  # Default to English for unsupported languages
             except:
                 pass
-        
+
         # Fallback: Basic Arabic detection
         arabic_pattern = re.compile(r'[\u0600-\u06FF\u0750-\u077F\u08A0-\u08FF]+')
         if arabic_pattern.search(text):
             return "arabic"
-        
+
         return "english"
 
     def analyze_sentiment(self, text):
@@ -639,7 +617,7 @@ class HealthcareChatbot:
                 }
             except:
                 pass
-        
+
         return {"sentiment": "NEUTRAL", "score": 0.5}
 
     def extract_keywords(self, text):
@@ -655,12 +633,12 @@ class HealthcareChatbot:
         """Get recent conversation history as context"""
         if not self.conversation_history:
             return "No previous conversation"
-        
+
         context = []
         for item in self.conversation_history[-3:]:  # Last 3 exchanges
             context.append(f"User: {item['user_message']}")
             context.append(f"Bot: {item['bot_response'][:100]}...")  # Truncate long responses
-        
+
         return " | ".join(context)
 
     def add_to_history(self, user_message, bot_response, response_type):
@@ -671,7 +649,7 @@ class HealthcareChatbot:
             'bot_response': bot_response,
             'response_type': response_type
         })
-        
+
         # Keep only recent history
         if len(self.conversation_history) > self.max_history_length:
             self.conversation_history = self.conversation_history[-self.max_history_length:]
@@ -685,14 +663,14 @@ class HealthcareChatbot:
                 "conversation_history": self.get_conversation_context(),
                 "endpoints_documentation": json.dumps(self.endpoints_documentation, indent=2)
             })
-            
+
             # Parse the JSON response
             intent_text = result["text"]
             # Clean and parse JSON
             cleaned_response = re.sub(r'//.*?$', '', intent_text, flags=re.MULTILINE)
             cleaned_response = re.sub(r'/\*.*?\*/', '', cleaned_response, flags=re.DOTALL)
             cleaned_response = re.sub(r',(\s*[}\]])', r'\1', cleaned_response)
-            
+
             try:
                 intent_data = json.loads(cleaned_response)
                 return intent_data
@@ -728,9 +706,9 @@ class HealthcareChatbot:
                 "sentiment_analysis": json.dumps(sentiment_result),
                 "conversation_history": self.get_conversation_context()
             })
-            
+
             return result["text"].strip()
-            
+
         except Exception as e:
             # Fallback response
             if detected_language == "arabic":
@@ -746,12 +724,13 @@ class HealthcareChatbot:
 
         print('Sending the api request')
         print(f"🔗 Making API call to {endpoint_method} {self.BASE_URL + endpoint_url} with params: {endpoint_params}")
-        
+
         # Inject patient_id if needed
         if 'patient_id' in endpoint_params:
             endpoint_params['patient_id'] = self.user_id
-        
+
         retries = 0
+        response = None
         while retries < self.max_retries:
             try:
                 if endpoint_method.upper() == 'GET':
@@ -769,10 +748,11 @@ class HealthcareChatbot:
                         headers=self.headers,
                         timeout=10
                     )
-                
+
                 response.raise_for_status()
+                print('Backend Response : ', response.json())
                 return response.json()
-                
+
             except requests.exceptions.RequestException as e:
                 retries += 1
                 if retries >= self.max_retries:
@@ -781,35 +761,35 @@ class HealthcareChatbot:
                         "details": str(e),
                         "status_code": getattr(e.response, 'status_code', None) if hasattr(e, 'response') else None
                     }
-                
+
                 time.sleep(self.retry_delay)
     def parse_relative_date(self, text, detected_language):
         """
         Parse relative dates from text using a combination of methods
         """
         today = datetime.now()
-        
+
         # Handle common relative date patterns in English and Arabic
         tomorrow_patterns = {
             'english': [r'\btomorrow\b', r'\bnext day\b'],
             'arabic': [r'\bغدا\b', r'\bبكرة\b', r'\bغدًا\b', r'\bالغد\b']
         }
-        
+
         next_week_patterns = {
             'english': [r'\bnext week\b'],
             'arabic': [r'\bالأسبوع القادم\b', r'\bالأسبوع المقبل\b', r'\bالاسبوع الجاي\b']
         }
-        
+
         # Check for "tomorrow" patterns
         for pattern in tomorrow_patterns.get(detected_language, []) + tomorrow_patterns.get('english', []):
             if re.search(pattern, text, re.IGNORECASE):
                 return (today + timedelta(days=1)).strftime('%Y-%m-%dT%H:%M:%S')
-        
+
         # Check for "next week" patterns
         for pattern in next_week_patterns.get(detected_language, []) + next_week_patterns.get('english', []):
             if re.search(pattern, text, re.IGNORECASE):
                 return (today + timedelta(days=7)).strftime('%Y-%m-%dT%H:%M:%S')
-        
+
         # If NER model is available, use it to extract date entities
         if self.date_parser and detected_language == 'english':
             try:
@@ -823,7 +803,7 @@ class HealthcareChatbot:
                         return (today + timedelta(days=1)).strftime('%Y-%m-%dT%H:%M:%S')
             except Exception as e:
                 print(f"Error in date parsing: {e}")
-        
+
         # Default return None if no date pattern is recognized
         return None
 
@@ -831,11 +811,11 @@ class HealthcareChatbot:
     def handle_api_action(self, user_query, detected_language, sentiment_result, keywords):
         """Handle API-based actions"""
         try:
-            
-            parsed_date = self.parse_relative_date(user_query, detected_language)
-            if parsed_date:
-                print(f"Parsed relative date: {parsed_date}")
-            
+
+            # parsed_date = self.parse_relative_date(user_query, detected_language)
+            # if parsed_date:
+            #     print(f"Parsed relative date: {parsed_date}")
+
             # Route the query to determine API endpoint
             router_result = self.router_chain.invoke({
                 "endpoints_documentation": json.dumps(self.endpoints_documentation, indent=2),
@@ -843,15 +823,18 @@ class HealthcareChatbot:
                 "detected_language": detected_language,
                 "extracted_keywords": ", ".join(keywords),
                 "sentiment_analysis": json.dumps(sentiment_result),
-                "conversation_history": self.get_conversation_context()
+                "conversation_history": self.get_conversation_context(),
+                "current_datetime": datetime.now().strftime('%Y-%m-%dT%H:%M:%S'),
+                "timezone": "UTC",
+                "user_locale": "en-US"
             })
-            
+
             # Parse router response
             route_text = router_result["text"]
             # cleaned_response = re.sub(r'//.*?$', '', route_text, flags=re.MULTILINE)
             # cleaned_response = re.sub(r'/\*.*?\*/', '', cleaned_response, flags=re.DOTALL)
             # cleaned_response = re.sub(r',(\s*[}\]])', r'\1', cleaned_response)
-            
+
             # try:
             #     parsed_route = json.loads(cleaned_response)
             # except json.JSONDecodeError:
@@ -860,17 +843,17 @@ class HealthcareChatbot:
             #         parsed_route = json.loads(json_match.group(0))
             #     else:
             #         raise ValueError("Could not parse routing response")
-            
+
             # print(f"🔍 Parsed route: {parsed_route}")
             cleaned_response = route_text
-            
+
             # Remove any comments (both single-line and multi-line)
             cleaned_response = re.sub(r'//.*?$', '', cleaned_response, flags=re.MULTILINE)
             cleaned_response = re.sub(r'/\*.*?\*/', '', cleaned_response, flags=re.DOTALL)
-            
+
             # Remove any trailing commas
             cleaned_response = re.sub(r',(\s*[}\]])', r'\1', cleaned_response)
-            
+
             # Try different methods to parse the JSON response
             try:
                 # First attempt: direct JSON parsing of cleaned response
@@ -896,27 +879,27 @@ class HealthcareChatbot:
                         print(f"Failed to parse JSON. Raw response: {route_text}")
                         print(f"Cleaned response: {cleaned_response}")
                         raise ValueError("Could not extract valid JSON from LLM response")
-            
+
             if not parsed_route:
                 raise ValueError("Failed to parse LLM response into valid JSON")
-            
+
             # Replace any placeholder values and inject parsed dates if available
             if 'params' in parsed_route:
                 if 'patient_id' in parsed_route['params']:
                     parsed_route['params']['patient_id'] = self.user_id
-                
+
                 # Inject parsed date if available and a date parameter exists
-                date_params = ['appointment_date', 'date', 'schedule_date', 'date_time', 'new_date_time']
-                if parsed_date:
-                    for param in date_params:
-                        if param in parsed_route['params']:
-                            parsed_route['params'][param] = parsed_date
-            
+                # date_params = ['appointment_date', 'date', 'schedule_date', 'date_time', 'new_date_time']
+                # if parsed_date:
+                #     for param in date_params:
+                #         if param in parsed_route['params']:
+                #             parsed_route['params'][param] = parsed_date
+
             print('Parsed route: ', parsed_route)
 
             # Make backend API call
             api_response = self.backend_call(parsed_route)
-            
+
             print("🔗 API response received:", api_response)
             # Generate user-friendly response
             user_response_result = self.api_response_chain.invoke({
@@ -927,20 +910,20 @@ class HealthcareChatbot:
             })
 
             print("🔗 API response:", user_response_result["text"].strip())
-            
+
             return {
                 "response": user_response_result["text"].strip(),
                 "api_data": api_response,
                 "routing_info": parsed_route
             }
-            
+
         except Exception as e:
             # Fallback error response
             if detected_language == "arabic":
                 error_msg = "أعتذر، لم أتمكن من معالجة طلبك. يرجى المحاولة مرة أخرى أو صياغة السؤال بطريقة مختلفة."
             else:
                 error_msg = "I apologize, I couldn't process your request. Please try again or rephrase your question."
-            
+
             return {
                 "response": error_msg,
                 "api_data": {"error": str(e)},
@@ -950,7 +933,7 @@ class HealthcareChatbot:
     def chat(self, user_message: str) -> ChatResponse:
         """Main chat method that handles user messages"""
         start_time = time.time()
-        
+
         # Check for exit commands
         exit_commands = ['quit', 'exit', 'bye', 'خروج', 'وداعا', 'مع السلامة']
         if user_message.lower().strip() in exit_commands:
@@ -960,19 +943,19 @@ class HealthcareChatbot:
                 message="Goodbye! Take care of your health! / وداعاً! اعتن بصحتك!",
                 language="bilingual"
             )
-        
+
         try:
             # Language detection and analysis
             detected_language = self.detect_language(user_message)
             sentiment_result = self.analyze_sentiment(user_message)
             keywords = self.extract_keywords(user_message)
-            
+
             print(f"🔍 Language: {detected_language} | Sentiment: {sentiment_result['sentiment']} | Keywords: {keywords}")
-            
+
             # Classify intent
             intent_data = self.classify_intent(user_message, detected_language)
             print(f"🎯 Intent: {intent_data['intent']} (confidence: {intent_data.get('confidence', 'N/A')})")
-            
+
             # Handle based on intent
             if intent_data["intent"] == "API_ACTION" and intent_data.get("requires_backend", False):
                 # Handle API-based actions
@@ -980,7 +963,7 @@ class HealthcareChatbot:
                 action_result = self.handle_api_action(user_message, detected_language, sentiment_result, keywords)
 
                 # print(action_result)
-                
+
                 response = ChatResponse(
                     response_id=f"resp_{int(time.time())}",
                     response_type="api_action",
@@ -989,12 +972,12 @@ class HealthcareChatbot:
                     api_data=json.dumps(action_result["api_data"]) if 'action_result' in action_result else None,
                     language=detected_language
                 )
-                
+
             else:
                 # Handle conversational responses
                 print("💬 Processing conversational response...")
                 conv_response = self.handle_conversation(user_message, detected_language, sentiment_result)
-                
+
                 response = ChatResponse(
                     response_id=f"resp_{int(time.time())}",
                     response_type="conversation",
@@ -1002,17 +985,17 @@ class HealthcareChatbot:
                     api_call_made=False,
                     language=detected_language
                 )
-            
+
             # Add to conversation history
             self.add_to_history(user_message, response.message, response.response_type)
-            
+
             print(f"⏱️ Processing time: {time.time() - start_time:.2f}s")
             return response
-            
+
         except Exception as e:
             print(f"❌ Error in chat processing: {e}")
             error_msg = "I apologize for the technical issue. Please try again. / أعتذر عن المشكلة التقنية. يرجى المحاولة مرة أخرى."
-            
+
             return ChatResponse(
                 response_id=f"resp_{int(time.time())}",
                 response_type="conversation",
@@ -1024,41 +1007,39 @@ class HealthcareChatbot:
     def start_interactive_chat(self):
         """Start an interactive chat session"""
         print("🚀 Starting interactive chat session...")
-        
+
         while True:
             try:
                 # Get user input
                 user_input = input("\n👤 You: ").strip()
-                
+
                 if not user_input:
                     continue
-                
+
                 # Process the message
                 print("🤖 Processing...")
                 response = self.chat(user_input)
-                
+
                 # Display response
                 print(f"\n🏥 Healthcare Bot: {response.message}")
-                
+
                 # Show additional info if API call was made
                 if response.api_call_made and response.api_data:
                     if "error" not in response.api_data:
                         print("✅ Successfully retrieved information from healthcare system")
                     else:
                         print("⚠️ There was an issue accessing the healthcare system")
-                
+
                 # Check for exit
                 if "Goodbye" in response.message or "وداعاً" in response.message:
                     break
-                    
+
             except KeyboardInterrupt:
                 print("\n\n👋 Chat session ended. Goodbye!")
                 break
             except Exception as e:
                 print(f"\n❌ Unexpected error: {e}")
                 print("The chat session will continue...")
-
-
 # Create a simple function to start the chatbot
 # def start_healthcare_chatbot():
 #     """Initialize and start the healthcare chatbot"""