Update the api generate promot

main.py

@@ -68,9 +68,9 @@ class HealthcareChatbot:
         self.endpoints_documentation = endpoints_documentation
         self.ollama_base_url = "http://localhost:11434"
         self.model_name = "gemma3"
-        self.BASE_URL = 'https://a21e-197-54-54-66.ngrok-free.app'
+        self.BASE_URL = 'https://9f87-197-54-54-66.ngrok-free.app'
         self.headers = {'Content-type': 'application/json'}
-        self.user_id = '8eb58851-f276-4854-8548-5abd40ed383d'
+        self.user_id = 'e2fe5655-d6ac-447d-8237-850413288561'
         self.max_retries = 3
         self.retry_delay = 2
         
@@ -194,82 +194,212 @@ class HealthcareChatbot:
         # API routing prompt (reuse existing router_prompt_template)
         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.
-
-                === ENDPOINT DOCUMENTATION ===
-                {endpoints_documentation}
-
-                === USER REQUEST ANALYSIS ===
-                User Query: {user_query}
-                Language: {detected_language}
-                Keywords: {extracted_keywords}
-                Sentiment: {sentiment_analysis}
-
-                === ROUTING PROCESS ===
-                Follow these steps in order:
-
-                STEP 1: INTENT ANALYSIS
-                - What is the user trying to accomplish?
-                - What type of operation are they requesting? (create, read, update, delete, search, etc.)
-                - What entity/resource are they working with?
-
-                STEP 2: ENDPOINT MATCHING
-                - Review each endpoint in the documentation
-                - Match the user's intent to the endpoint's PURPOSE/DESCRIPTION
-                - Consider the HTTP method (GET for retrieval, POST for creation, etc.)
-                - Verify the endpoint can handle the user's specific request
-
-                STEP 3: PARAMETER EXTRACTION
-                - Identify ALL required parameters from the endpoint documentation
-                - Extract parameter values from the user query
-                - Convert data types as needed (dates to ISO 8601, numbers to integers, etc.)
-                - Set appropriate defaults for optional parameters if beneficial
-
-                STEP 4: VALIDATION
-                - Ensure ALL required parameters are provided or identified as missing
-                - Verify parameter formats match documentation requirements
-                - Check that the selected endpoint actually solves the user's problem
-
-                === RESPONSE FORMAT ===
-                Provide your analysis and decision in this exact JSON structure:
-
-                {{
-                    "reasoning": {{
-                        "user_intent": "Brief description of what the user wants to accomplish",
-                        "selected_endpoint": "Why this endpoint was chosen over others",
-                        "parameter_mapping": "How user query maps to endpoint parameters"
-                    }},
-                    "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 RULES ===
-                1. ONLY select endpoints that exist in the provided documentation
-                2. NEVER fabricate or assume endpoint parameters not in documentation
-                3. ALL required parameters MUST be included or listed as missing
-                4. Convert dates/times to ISO 8601 format (YYYY-MM-DDTHH:MM:SS)
-                5. If patient_id is required and not provided, add it to missing_required
-                6. Match endpoints by PURPOSE, not just keywords in the path
-                7. If multiple endpoints could work, choose the most specific one
-                8. If no endpoint matches, set endpoint to null and explain in reasoning
-
-                === EXAMPLES OF GOOD MATCHING ===
-                - User wants "patient records" → Use patient retrieval endpoint, not general search
-                - User wants to "schedule appointment" → Use appointment creation endpoint
-                - User asks "what appointments today" → Use appointment listing with date filter
-                - User wants to "update medication" → Use medication update endpoint with patient_id
-
-                Think step by step and be precise with your endpoint selection and parameter extraction.:""",
-            input_variables=["endpoints_documentation", "user_query", "detected_language",
-                            "extracted_keywords", "sentiment_analysis", "conversation_history"]
+            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.
+
+        #         === ENDPOINT DOCUMENTATION ===
+        #         {endpoints_documentation}
+
+        #         === USER REQUEST ANALYSIS ===
+        #         User Query: {user_query}
+        #         Language: {detected_language}
+        #         Keywords: {extracted_keywords}
+        #         Sentiment: {sentiment_analysis}
+
+        #         === ROUTING PROCESS ===
+        #         Follow these steps in order:
+
+        #         STEP 1: INTENT ANALYSIS
+        #         - What is the user trying to accomplish?
+        #         - What type of operation are they requesting? (create, read, update, delete, search, etc.)
+        #         - What entity/resource are they working with?
+
+        #         STEP 2: ENDPOINT MATCHING
+        #         - Review each endpoint in the documentation
+        #         - Match the user's intent to the endpoint's PURPOSE/DESCRIPTION
+        #         - Consider the HTTP method (GET for retrieval, POST for creation, etc.)
+        #         - Verify the endpoint can handle the user's specific request
+
+        #         STEP 3: PARAMETER EXTRACTION
+        #         - Identify ALL required parameters from the endpoint documentation
+        #         - Extract parameter values from the user query
+        #         - Convert data types as needed (dates to ISO 8601, numbers to integers, etc.)
+        #         - Set appropriate defaults for optional parameters if beneficial
+
+        #         STEP 4: VALIDATION
+        #         - Ensure ALL required parameters are provided or identified as missing
+        #         - Verify parameter formats match documentation requirements
+        #         - Check that the selected endpoint actually solves the user's problem
+
+        #         === RESPONSE FORMAT ===
+        #         Provide your analysis and decision in this exact JSON structure:
+
+        #         {{
+        #             "reasoning": {{
+        #                 "user_intent": "Brief description of what the user wants to accomplish",
+        #                 "selected_endpoint": "Why this endpoint was chosen over others",
+        #                 "parameter_mapping": "How user query maps to endpoint parameters"
+        #             }},
+        #             "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 RULES ===
+        #         1. ONLY select endpoints that exist in the provided documentation
+        #         2. NEVER fabricate or assume endpoint parameters not in documentation
+        #         3. ALL required parameters MUST be included or listed as missing
+        #         4. Convert dates/times to ISO 8601 format (YYYY-MM-DDTHH:MM:SS)
+        #         5. If patient_id is required and not provided, add it to missing_required
+        #         6. Match endpoints by PURPOSE, not just keywords in the path
+        #         7. If multiple endpoints could work, choose the most specific one
+        #         8. If no endpoint matches, set endpoint to null and explain in reasoning
+
+        #         === EXAMPLES OF GOOD MATCHING ===
+        #         - User wants "patient records" → Use patient retrieval endpoint, not general search
+        #         - User wants to "schedule appointment" → Use appointment creation endpoint
+        #         - User asks "what appointments today" → Use appointment listing with date filter
+        #         - User wants to "update medication" → Use medication update endpoint with patient_id
+
+        #         Think step by step and be precise with your endpoint selection and parameter extraction.:""",
+        #     input_variables=["endpoints_documentation", "user_query", "detected_language",
+        #                     "extracted_keywords", "sentiment_analysis", "conversation_history"]
+        # )
 
         # Conversational response prompt
         self.conversation_template = PromptTemplate(