Update the model to work as agent and charbot

main.py

@@ -4,7 +4,7 @@ import requests
 import traceback
 import time
 import os
-from typing import Dict, Any, List, Optional
+from typing import Dict, Any, List, Optional, Tuple
 from datetime import datetime, timedelta
 
 # Updated imports for pydantic
@@ -27,10 +27,34 @@ import numpy as np
 from endpoints_documentation import endpoints_documentation
 
 # Set environment variables for HuggingFace
-# os.environ["HF_HOME"] = "/tmp/huggingface"
+# if os.name == 'posix' and os.uname().sysname == 'Darwin':  # Check if running on macOS
+#     os.environ["HF_HOME"] = os.path.expanduser("~/Library/Caches/huggingface")
+#     os.environ["TRANSFORMERS_CACHE"] = os.path.expanduser("~/Library/Caches/huggingface/transformers")
+# else:
 os.environ["HF_HOME"] = "/tmp/huggingface"
 os.environ["HF_HUB_DISABLE_SYMLINKS_WARNING"] = "1"
 
+
+class ChatMessage(BaseModel):
+    """Data model for chat messages"""
+    message_id: str = Field(..., description="Unique identifier for the message")
+    user_id: str = Field(..., description="User identifier")
+    message: str = Field(..., description="The user's message")
+    timestamp: datetime = Field(default_factory=datetime.now, description="When the message was sent")
+    language: str = Field(default="english", description="Detected language of the message")
+
+
+class ChatResponse(BaseModel):
+    """Data model for chatbot responses"""
+    response_id: str = Field(..., description="Unique identifier for the response")
+    response_type: str = Field(..., description="Type of response: 'conversation' or 'api_action'")
+    message: str = Field(..., description="The chatbot's response message")
+    api_call_made: bool = Field(default=False, description="Whether an API call was made")
+    api_data: Optional[Dict[str, Any]] = Field(default=None, description="API response data if applicable")
+    language: str = Field(default="english", description="Language of the response")
+    timestamp: datetime = Field(default_factory=datetime.now, description="When the response was generated")
+
+
 class EndpointRequest(BaseModel):
     """Data model for API endpoint requests"""
     endpoint: str = Field(..., description="The API endpoint path to call")
@@ -39,188 +63,147 @@ class EndpointRequest(BaseModel):
     missing_required: List[str] = Field(default_factory=list, description="Any required parameters that are missing")
 
 
-class AIAgent:
+class HealthcareChatbot:
     def __init__(self):
         self.endpoints_documentation = endpoints_documentation
-        self.ollama_base_url = "http://localhost:11434"  # Default Ollama URL
-        # self.model_name = "mistral"  # Using mistral model for better multilingual support
-        self.model_name = 'gemma3'
-        self.BASE_URL = 'https://a961-105-196-69-205.ngrok-free.app'
-        self.headers = {
-            'Content-type': 'application/json'
-        }
-        self.user_id = '76ceed74-143a-45c1-843e-ba583c122dea'
+        self.ollama_base_url = "http://localhost:11434"
+        self.model_name = "gemma3"
+        self.BASE_URL = 'https://d623-105-196-69-205.ngrok-free.app'
+        self.headers = {'Content-type': 'application/json'}
+        self.user_id = '5c745974-f1e6-4a9d-b93f-0e0aa75c5b09'
         self.max_retries = 3
-        self.retry_delay = 2  # seconds
+        self.retry_delay = 2
         
-        # Enhanced language detection using HuggingFace models
-        self._initialize_language_tools()
+        # Store conversation history
+        self.conversation_history = []
+        self.max_history_length = 10  # Keep last 10 exchanges
         
-        # Initialize LangChain components
+        # Initialize components
+        self._initialize_language_tools()
         self._initialize_llm()
         self._initialize_parsers_and_chains()
-        
-        # Add date parsing capabilities
         self._initialize_date_parser()
+        
+        print("Healthcare Chatbot initialized successfully!")
+        self._print_welcome_message()
+
+    def _print_welcome_message(self):
+        """Print welcome message in both languages"""
+        print("\n" + "="*60)
+        print("🏥 HEALTHCARE CHATBOT READY")
+        print("="*60)
+        print("English: Hello! I'm your healthcare assistant. I can help you with:")
+        print("• Booking and managing appointments")
+        print("• Finding hospital information")
+        print("• Viewing your medical records")
+        print("• General healthcare questions")
+        print()
+        print("Arabic: مرحباً! أنا مساعدك الطبي. يمكنني مساعدتك في:")
+        print("• حجز وإدارة المواعيد")
+        print("• العثور على معلومات المستشفى")
+        print("• عرض سجلاتك الطبية")
+        print("• الأسئلة الطبية العامة")
+        print("="*60)
+        print("Type 'quit' or 'خروج' to exit\n")
 
     def _initialize_language_tools(self):
-        """Initialize more sophisticated language processing tools"""
-        # Use multilingual embeddings for semantic understanding
-        self.embeddings = HuggingFaceEmbeddings(model_name="intfloat/multilingual-e5-large")
-        
-        # Initialize language identification model
+        """Initialize language processing tools"""
         try:
+            self.embeddings = HuggingFaceEmbeddings(model_name="intfloat/multilingual-e5-large")
             self.language_classifier = pipeline(
                 "text-classification", 
                 model="papluca/xlm-roberta-base-language-detection",
                 top_k=1
             )
-            print("Language classification model loaded successfully")
-        except Exception as e:
-            print(f"Failed to load language classification model: {e}")
-            # Fallback to basic regex detection if model fails to load
-            self.language_classifier = None
-            
-        # Add sentiment analysis for enhanced response generation
-        try:
             self.sentiment_analyzer = pipeline(
                 "sentiment-analysis",
                 model="cardiffnlp/twitter-xlm-roberta-base-sentiment"
             )
-            print("Sentiment analysis model loaded successfully")
+            print("✓ Language processing models loaded successfully")
         except Exception as e:
-            print(f"Failed to load sentiment analysis model: {e}")
+            print(f"⚠ Warning: Some language models failed to load: {e}")
+            self.language_classifier = None
             self.sentiment_analyzer = None
 
     def _initialize_date_parser(self):
-        """Initialize date parsing model for handling relative date expressions"""
+        """Initialize date parsing model"""
         try:
             self.date_parser = pipeline(
                 "token-classification",
                 model="Jean-Baptiste/roberta-large-ner-english",
                 aggregation_strategy="simple"
             )
-            print("Date parsing model loaded successfully")
         except Exception as e:
-            print(f"Failed to load date parsing model: {e}")
+            print(f"⚠ Warning: Date parsing model failed to load: {e}")
             self.date_parser = None
 
-    def detect_language(self, text):
-        """
-        Enhanced language detection using HuggingFace models
-        """
-        # First try using the HuggingFace language classification model if available
-        if self.language_classifier and len(text.strip()) > 3:
-            try:
-                result = self.language_classifier(text)
-                detected_lang = result[0][0]['label']
-                confidence = result[0][0]['score']
-                
-                print(f"Language detected: {detected_lang} with confidence {confidence:.4f}")
-                
-                # Map the detected language to our simplified language set
-                if detected_lang in ['ar', 'arabic']:
-                    return "arabic"
-                elif detected_lang in ['en', 'english']:
-                    return "english"
-                elif confidence > 0.8:  # If confident but not English/Arabic
-                    # We currently only support English/Arabic, but log other languages
-                    print(f"Detected unsupported language: {detected_lang}")
-                    # Default to English for other languages for now
-                    return "english"
-            except Exception as e:
-                print(f"Error in language detection model: {e}")
-                # Continue to fallback methods
-        
-        # Fallback: Basic detection of Arabic text using regex
-        arabic_pattern = re.compile(r'[\u0600-\u06FF\u0750-\u077F\u08A0-\u08FF]+')
-        if arabic_pattern.search(text):
-            return "arabic"
-        
-        # Default to English
-        return "english"
-    
-    def analyze_sentiment(self, text):
-        """Analyze the sentiment of the input text"""
-        if self.sentiment_analyzer and len(text.strip()) > 3:
-            try:
-                result = self.sentiment_analyzer(text)
-                sentiment = result[0]['label']
-                score = result[0]['score']
-                return {
-                    "sentiment": sentiment,
-                    "score": score
-                }
-            except Exception as e:
-                print(f"Error in sentiment analysis: {e}")
-        
-        # Default neutral sentiment if analysis fails
-        return {"sentiment": "NEUTRAL", "score": 0.5}
-
-    def extract_semantic_keywords(self, text, top_n=5):
-        """Extract semantic keywords from text using embeddings"""
-        try:
-            # Simple keyword extraction using embeddings comparison
-            # This is a basic implementation - could be enhanced further
-            words = re.findall(r'\b\w+\b', text.lower())
-            unique_words = list(set([w for w in words if len(w) > 3]))
-            
-            if not unique_words:
-                return []
-                
-            # Get embeddings for all words
-            embeddings_list = []
-            for word in unique_words:
-                try:
-                    emb = self.embeddings.embed_query(word)
-                    embeddings_list.append((word, emb))
-                except Exception as e:
-                    print(f"Error embedding word {word}: {e}")
-            
-            # Get embedding for full text
-            text_embedding = self.embeddings.embed_query(text)
-            
-            # Calculate similarity to full text
-            similarities = []
-            for word, emb in embeddings_list:
-                similarity = np.dot(emb, text_embedding) / (np.linalg.norm(emb) * np.linalg.norm(text_embedding))
-                similarities.append((word, similarity))
-            
-            # Sort by similarity
-            similarities.sort(key=lambda x: x[1], reverse=True)
-            
-            # Return top N keywords
-            return [word for word, _ in similarities[:top_n]]
-            
-        except Exception as e:
-            print(f"Error extracting keywords: {e}")
-            return []
-
     def _initialize_llm(self):
-        """Initialize the LLM with appropriate configuration"""
-        # Set up the callback manager for streaming (optional)
+        """Initialize the LLM"""
         callbacks = [StreamingStdOutCallbackHandler()]
-        
-        # Initialize the Ollama LLM with updated parameters
         self.llm = OllamaLLM(
             model=self.model_name,
             base_url=self.ollama_base_url,
             callbacks=callbacks,
             temperature=0.7,
-            num_ctx=8192,  # Increased context window
+            num_ctx=8192,
             top_p=0.9,
-            request_timeout=60,  # Timeout in seconds
+            request_timeout=60,
         )
 
     def _initialize_parsers_and_chains(self):
-        """Initialize output parsers and LLM chains"""
-        # Setup JSON parser for structured output
+        """Initialize all prompt templates and chains"""
         self.json_parser = JsonOutputParser(pydantic_object=EndpointRequest)
         
-        # Create multilingual router prompt template with enhanced context
+        # Intent classification prompt
+        self.intent_classifier_template = PromptTemplate(
+            template="""
+            You are an intent classifier for a healthcare chatbot. Analyze the user's message and determine if it requires an API call or is conversational.
+
+            === ANALYSIS CONTEXT ===
+            User Message: {user_query}
+            Language: {detected_language}
+            Conversation History: {conversation_history}
+
+            === AVAILABLE API ENDPOINTS ===
+            {endpoints_documentation}
+
+            === CLASSIFICATION TASK ===
+            Determine if the user's message requires:
+            1. API_ACTION: Specific healthcare action (book appointment, view records, etc.)
+            2. CONVERSATION: General chat, greeting, questions not requiring backend data
+
+            === RESPONSE FORMAT ===
+            Respond with EXACTLY this JSON structure:
+            {{
+                "intent": "API_ACTION" or "CONVERSATION",
+                "confidence": 0.95,
+                "reasoning": "Brief explanation of classification decision",
+                "requires_backend": true or false
+            }}
+
+            === CLASSIFICATION RULES ===
+            Choose API_ACTION for:
+            - Booking, canceling, or viewing appointments
+            - Requesting medical records or test results
+            - Hospital information queries (locations, hours, etc.)
+            - Medication management requests
+            - Specific patient data requests
+
+            Choose CONVERSATION for:
+            - Greetings and pleasantries
+            - General health advice (not patient-specific)
+            - Explanations of medical terms
+            - Small talk or casual questions
+            - Questions about the chatbot itself
+
+            Classify the intent:""",
+            input_variables=["user_query", "detected_language", "conversation_history", "endpoints_documentation"]
+        )
+
+        # 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.
+            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}
@@ -292,66 +275,56 @@ class AIAgent:
                 - 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"],
-                partial_variables={"format_instructions": self.json_parser.get_format_instructions()}
-            )
-        
-        # # Create user-friendly response template with enhanced context awareness
-        # self.user_response_template = PromptTemplate(
-        #     template="""
-        #     You are a professional and friendly virtual assistant for a healthcare system.
-        #     Your task is to generate clear, concise, and professional responses to user queries.
-
-        #     IMPORTANT RULES:
-        #     - Respond ONLY in {detected_language}
-        #     - For Arabic, use Modern Standard Arabic (فصحى)
-        #     - Keep responses SHORT and DIRECT
-        #     - Include ONLY essential information
-        #     - NEVER mix languages
-        #     - ALWAYS use the EXACT data from the system response
-        #     - NEVER make up or modify hospital information
-        #     - Use professional and polite tone
-
-        #     Original query: {user_query}
-        #     System result: {api_response}
-        #     User sentiment: {sentiment_analysis}
-
-        #     ARABIC RESPONSE RULES:
-        #     - Use Arabic numbers (١، ٢، ٣)
-        #     - Use proper date format (١٥ مايو ٢٠٢٥)
-        #     - Use proper time format (الساعة ٨ صباحاً)
-        #     - Use formal medical terms
-        #     - Keep sentences short and clear
-        #     - Use exact hospital names and addresses from the data
-        #     - Use exact working hours from the data
-        #     - Use professional healthcare terminology
-
-        #     ENGLISH RESPONSE RULES:
-        #     - Use clear, direct language
-        #     - Include only essential details
-        #     - Use proper medical terms
-        #     - Keep responses concise
-        #     - Use exact hospital names and addresses from the data
-        #     - Use exact working hours from the data
-        #     - Use professional healthcare terminology
-
-        #     Remember: 
-        #     - Keep responses SHORT and FOCUSED
-        #     - Use ONLY data from the system response
-        #     - NEVER modify or make up hospital information
-        #     - Include only what's necessary to answer the query
-        #     - Maintain professional and polite tone
-        #     - Use proper healthcare terminology
-        #     """,
-        #     input_variables=["user_query", "api_response", "detected_language", 
-        #                    "sentiment_analysis", "extracted_keywords"]
-        # )
-        # Create user-friendly response template with enhanced context awareness
-        # Create user-friendly response template with enhanced context awareness
-        # Create user-friendly response template with enhanced context awareness
+                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(
+            template="""
+            You are a friendly and professional healthcare chatbot assistant.
+
+            === RESPONSE GUIDELINES ===
+            - Respond ONLY in {detected_language}
+            - Be helpful, empathetic, and professional
+            - Keep responses concise but informative
+            - Use appropriate medical terminology when needed
+            - Maintain a caring and supportive tone
+
+            === CONTEXT ===
+            User Message: {user_query}
+            Language: {detected_language}
+            Sentiment: {sentiment_analysis}
+            Conversation History: {conversation_history}
+
+            === LANGUAGE-SPECIFIC INSTRUCTIONS ===
+            
+            FOR ARABIC RESPONSES:
+            - Use Modern Standard Arabic (الفصحى)
+            - Be respectful and formal as appropriate in Arabic culture
+            - Use proper Arabic medical terminology
+            - Keep sentences clear and grammatically correct
+
+            FOR ENGLISH RESPONSES:
+            - Use clear, professional English
+            - Be warm and approachable
+            - Use appropriate medical terminology
+
+            === RESPONSE RULES ===
+            1. Address the user's question or comment directly
+            2. Provide helpful information when possible
+            3. If you cannot help with something specific, explain what you CAN help with
+            4. Never provide specific medical advice - always recommend consulting healthcare professionals
+            5. Be encouraging and supportive
+            6. Do NOT mix languages in your response
+            7. End responses naturally without asking multiple questions
+
+            Generate a helpful conversational response:""",
+            input_variables=["user_query", "detected_language", "sentiment_analysis", "conversation_history"]
+        )
+
+        # 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.
@@ -438,208 +411,159 @@ class AIAgent:
             === 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.
             """,
-            input_variables=["user_query", "api_response", "detected_language", 
-                            "sentiment_analysis", "extracted_keywords"]
-        )
-        
-        # Create LLM chains
-        self.router_chain = LLMChain(
-            llm=self.llm,
-            prompt=self.router_prompt_template,
-            output_key="route_result"
-        )
-        
-        self.user_response_chain = LLMChain(
-            llm=self.llm,
-            prompt=self.user_response_template,
-            output_key="user_friendly_response"
+            input_variables=["user_query", "api_response", "detected_language", "conversation_history"]
         )
 
-    def parse_relative_date(self, text, detected_language):
-        """
-        Parse relative dates from text using a combination of methods
-        """
-        today = datetime.now()
+        # 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:
+            try:
+                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']:
+                    return "english"
+                elif confidence > 0.8:
+                    return "english"  # Default to English for unsupported languages
+            except:
+                pass
         
-        # 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']
-        }
+        # Fallback: Basic Arabic detection
+        arabic_pattern = re.compile(r'[\u0600-\u06FF\u0750-\u077F\u08A0-\u08FF]+')
+        if arabic_pattern.search(text):
+            return "arabic"
         
-        next_week_patterns = {
-            'english': [r'\bnext week\b'],
-            'arabic': [r'\bالأسبوع القادم\b', r'\bالأسبوع المقبل\b', r'\bالاسبوع الجاي\b']
-        }
+        return "english"
+
+    def analyze_sentiment(self, text):
+        """Analyze sentiment of the text"""
+        if self.sentiment_analyzer and len(text.strip()) > 3:
+            try:
+                result = self.sentiment_analyzer(text)
+                return {
+                    "sentiment": result[0]['label'],
+                    "score": result[0]['score']
+                }
+            except:
+                pass
         
-        # 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')
+        return {"sentiment": "NEUTRAL", "score": 0.5}
+
+    def extract_keywords(self, text):
+        """Extract keywords from text"""
+        # Simple keyword extraction
+        words = re.findall(r'\b\w+\b', text.lower())
+        # Filter out common words and keep meaningful ones
+        stopwords = {'the', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for', 'of', 'with', 'by', 'is', 'are', 'was', 'were'}
+        keywords = [w for w in words if len(w) > 3 and w not in stopwords]
+        return list(set(keywords))[:5]  # Return top 5 unique keywords
+
+    def get_conversation_context(self):
+        """Get recent conversation history as context"""
+        if not self.conversation_history:
+            return "No previous conversation"
         
-        # 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')
+        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
         
-        # If NER model is available, use it to extract date entities
-        if self.date_parser and detected_language == 'english':
-            try:
-                date_entities = self.date_parser(text)
-                for entity in date_entities:
-                    if entity['entity_group'] == 'DATE':
-                        # Here you would need more complex date parsing logic
-                        # This is just a placeholder
-                        print(f"Found date entity: {entity['word']}")
-                        # For now, just default to tomorrow if we detect any date
-                        return (today + timedelta(days=1)).strftime('%Y-%m-%dT%H:%M:%S')
-            except Exception as e:
-                print(f"Error in date parsing: {e}")
+        return " | ".join(context)
+
+    def add_to_history(self, user_message, bot_response, response_type):
+        """Add exchange to conversation history"""
+        self.conversation_history.append({
+            'timestamp': datetime.now(),
+            'user_message': user_message,
+            'bot_response': bot_response,
+            'response_type': response_type
+        })
         
-        # Default return None if no date pattern is recognized
-        return None
+        # Keep only recent history
+        if len(self.conversation_history) > self.max_history_length:
+            self.conversation_history = self.conversation_history[-self.max_history_length:]
 
-    def process_user_query(self, user_query: str) -> Dict[str, Any]:
-        """
-        Process the user query through the LangChain pipeline and return a response
-        """
+    def classify_intent(self, user_query, detected_language):
+        """Classify if the user query requires API action or is conversational"""
         try:
-            start_time = time.time()
-            
-            # Detect language of the query
-            detected_language = self.detect_language(user_query)
-            print(f"Detected language: {detected_language}")
-            
-            # Enhanced context using Hugging Face models
-            sentiment_result = self.analyze_sentiment(user_query)
-            print(f"Sentiment analysis: {sentiment_result}")
-            
-            extracted_keywords = self.extract_semantic_keywords(user_query)
-            print(f"Extracted keywords: {extracted_keywords}")
-            
-            # Try to extract dates from query
-            parsed_date = self.parse_relative_date(user_query, detected_language)
-            if parsed_date:
-                print(f"Parsed relative date: {parsed_date}")
-            
-            # 1. Route the query to determine which API endpoint to call
-            new_start_time = time.time()
-            router_result = self.router_chain.invoke({
-                "endpoints_documentation": json.dumps(self.endpoints_documentation, indent=2),
+            result = self.intent_chain.invoke({
                 "user_query": user_query,
                 "detected_language": detected_language,
-                "extracted_keywords": ", ".join(extracted_keywords),
-                "sentiment_analysis": json.dumps(sentiment_result)
+                "conversation_history": self.get_conversation_context(),
+                "endpoints_documentation": json.dumps(self.endpoints_documentation, indent=2)
             })
-
-            # TODO: remove the print statement in production
-            print('End time of generating response: ', time.time() - new_start_time)
             
-            # 2. Parse the router response
-            route_result = router_result["route_result"]
-            parsed_route = None
-            
-            # Clean the response first
-            cleaned_response = route_result
-            
-            # Remove any comments (both single-line and multi-line)
-            cleaned_response = re.sub(r'//.*?$', '', cleaned_response, flags=re.MULTILINE)
+            # 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)
-            
-            # 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
-                parsed_route = json.loads(cleaned_response)
+                intent_data = json.loads(cleaned_response)
+                return intent_data
             except json.JSONDecodeError:
-                try:
-                    # Second attempt: extract JSON from markdown code block
-                    json_match = re.search(r'```(?:json)?\s*(\{.*?\})\s*```', cleaned_response, re.DOTALL)
-                    if json_match:
-                        parsed_route = json.loads(json_match.group(1))
-                except (json.JSONDecodeError, AttributeError):
-                    try:
-                        # Third attempt: find JSON-like content using regex
-                        json_pattern = r'\{\s*"endpoint"\s*:.*?\}'
-                        json_match = re.search(json_pattern, cleaned_response, re.DOTALL)
-                        if json_match:
-                            json_str = json_match.group(0)
-                            # Additional cleaning for the extracted JSON
-                            json_str = re.sub(r'//.*?$', '', json_str, flags=re.MULTILINE)
-                            json_str = re.sub(r',(\s*[}\]])', r'\1', json_str)
-                            parsed_route = json.loads(json_str)
-                    except (json.JSONDecodeError, AttributeError):
-                        print(f"Failed to parse JSON. Raw response: {route_result}")
-                        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
-            
-            print('Parsed route: ', parsed_route)
-            print(f"Routing completed in {time.time() - start_time:.2f} seconds")
-            
-            # 3. Make the backend API call
-            backend_response = self.backend_call(parsed_route)
-            
-            # 4. Generate user-friendly response
-            user_friendly_result = self.user_response_chain.invoke({
+                # Try to extract JSON from the response
+                json_match = re.search(r'\{.*?\}', cleaned_response, re.DOTALL)
+                if json_match:
+                    intent_data = json.loads(json_match.group(0))
+                    return intent_data
+                else:
+                    # Default classification if parsing fails
+                    return {
+                        "intent": "CONVERSATION",
+                        "confidence": 0.5,
+                        "reasoning": "Failed to parse LLM response",
+                        "requires_backend": False
+                    }
+        except Exception as e:
+            print(f"Error in intent classification: {e}")
+            return {
+                "intent": "CONVERSATION",
+                "confidence": 0.5,
+                "reasoning": f"Error in classification: {str(e)}",
+                "requires_backend": False
+            }
+
+    def handle_conversation(self, user_query, detected_language, sentiment_result):
+        """Handle conversational responses"""
+        try:
+            result = self.conversation_chain.invoke({
                 "user_query": user_query,
-                "api_response": json.dumps(backend_response, indent=2),
                 "detected_language": detected_language,
                 "sentiment_analysis": json.dumps(sentiment_result),
-                "extracted_keywords": ", ".join(extracted_keywords)
+                "conversation_history": self.get_conversation_context()
             })
-            print('user response: ', user_friendly_result["user_friendly_response"])
-            
-            print(f"Total processing time: {time.time() - start_time:.2f} seconds")
             
-            return {
-                "routing_info": parsed_route,
-                "api_response": backend_response,
-                "user_friendly_response": user_friendly_result["user_friendly_response"],
-                "detected_language": detected_language,
-                "sentiment": sentiment_result,
-                "keywords": extracted_keywords
-            }
+            return result["text"].strip()
             
         except Exception as e:
-            error_detail = {
-                "error": f"Error processing query: {str(e)}",
-                "type": type(e).__name__,
-                "traceback": traceback.format_exc()
-            }
-            print(f"Error: {error_detail['error']}")
-            print(f"Traceback: {error_detail['traceback']}")
-            return error_detail
+            # Fallback response
+            if detected_language == "arabic":
+                return "أعتذر، واجهت مشكلة في المعالجة. كيف يمكنني مساعدتك؟"
+            else:
+                return "I apologize, I encountered a processing issue. How can I help you?"
 
     def backend_call(self, data: Dict[str, Any]) -> Dict[str, Any]:
-        """
-        Make the actual API call to the backend with retry logic
-        """
+        """Make API call to backend with retry logic"""
         endpoint_url = data.get('endpoint')
         endpoint_method = data.get('method')
-        endpoint_params = data.get('params', {}).copy()  # Create a copy to avoid modifying the original
+        endpoint_params = data.get('params', {}).copy()
         
-        print('Endpoint url: ' + endpoint_url)
-        print('Method: ', endpoint_method)
-        print('Params: ', endpoint_params)
+        # Inject patient_id if needed
+        if 'patient_id' in endpoint_params:
+            endpoint_params['patient_id'] = self.user_id
         
-        # Add retry logic for more robust API calls
         retries = 0
         while retries < self.max_retries:
             try:
@@ -648,24 +572,17 @@ class AIAgent:
                         self.BASE_URL + endpoint_url,
                         params=endpoint_params,
                         headers=self.headers,
-                        timeout=10  # Add timeout for backend calls
-                    )
-                elif endpoint_method.upper() == 'POST':  # POST or other methods
-                    response = requests.post(
-                        self.BASE_URL + endpoint_url,
-                        json=endpoint_params,
-                        headers=self.headers,
                         timeout=10
                     )
-                elif endpoint_method.upper() == 'PUT':
-                    response = requests.put(
+                elif endpoint_method.upper() in ['POST', 'PUT', 'DELETE']:
+                    response = requests.request(
+                        endpoint_method.upper(),
                         self.BASE_URL + endpoint_url,
                         json=endpoint_params,
                         headers=self.headers,
                         timeout=10
                     )
                 
-                # Check if response status is success
                 response.raise_for_status()
                 return response.json()
                 
@@ -678,33 +595,207 @@ class AIAgent:
                         "status_code": getattr(e.response, 'status_code', None) if hasattr(e, 'response') else None
                     }
                 
-                print(f"API call attempt {retries} failed, retrying in {self.retry_delay} seconds...")
                 time.sleep(self.retry_delay)
 
+    def handle_api_action(self, user_query, detected_language, sentiment_result, keywords):
+        """Handle API-based actions"""
+        try:
+            # Route the query to determine API endpoint
+            router_result = self.router_chain.invoke({
+                "endpoints_documentation": json.dumps(self.endpoints_documentation, indent=2),
+                "user_query": user_query,
+                "detected_language": detected_language,
+                "extracted_keywords": ", ".join(keywords),
+                "sentiment_analysis": json.dumps(sentiment_result),
+                "conversation_history": self.get_conversation_context()
+            })
+            
+            # 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:
+                json_match = re.search(r'\{.*?\}', cleaned_response, re.DOTALL)
+                if json_match:
+                    parsed_route = json.loads(json_match.group(0))
+                else:
+                    raise ValueError("Could not parse routing response")
+            
+            # Make backend API call
+            api_response = self.backend_call(parsed_route)
+            
+            # Generate user-friendly response
+            user_response_result = self.api_response_chain.invoke({
+                "user_query": user_query,
+                "api_response": json.dumps(api_response, indent=2),
+                "detected_language": detected_language,
+                "conversation_history": self.get_conversation_context()
+            })
+            
+            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)},
+                "routing_info": None
+            }
+
+    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:
+            return ChatResponse(
+                response_id=f"resp_{int(time.time())}",
+                response_type="conversation",
+                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
+                print("🔗 Processing API action...")
+                action_result = self.handle_api_action(user_message, detected_language, sentiment_result, keywords)
+                
+                response = ChatResponse(
+                    response_id=f"resp_{int(time.time())}",
+                    response_type="api_action",
+                    message=action_result["response"],
+                    api_call_made=True,
+                    api_data=action_result["api_data"],
+                    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",
+                    message=conv_response,
+                    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",
+                message=error_msg,
+                api_call_made=False,
+                language="bilingual"
+            )
+
+    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...")
 
-# Initialize the AI agent singleton
-# ai_agent = AIAgent()
 
+# Create a simple function to start the chatbot
+# def start_healthcare_chatbot():
+#     """Initialize and start the healthcare chatbot"""
+#     try:
+#         chatbot = HealthcareChatbot()
+#         chatbot.start_interactive_chat()
+#     except Exception as e:
+#         print(f"Failed to start chatbot: {e}")
+#         print("Please check your Ollama installation and endpoint documentation.")
 
-# Test the agent directly
+
+# Test the chatbot
 # if __name__ == "__main__":
-#     agent = AIAgent()
+    # You can test individual messages like this:
+    # chatbot = HealthcareChatbot()
     
-#     # Test with English query
-#     # print("\n---Testing English Query---")
-#     # english_response = agent.process_user_query("I need to book an appointment with Dr. Smith tomorrow at 8 PM")
-#     # print("\nEnglish response:")
-#     # print(english_response["user_friendly_response"])
+    # Test conversational message
+    # print("\n=== TESTING CONVERSATIONAL MESSAGE ===")
+    # conv_response = chatbot.chat("Hello, how are you today?")
+    # print(f"Response: {conv_response.message}")
+    # print(f"Type: {conv_response.response_type}")
     
-#     # Test with Arabic query
-#     print("\n---Testing Arabic Query---")
-#     # arabic_response = agent.process_user_query(" اريد الغاء الحجز مع الدكتور Smith")
-#     arabic_response = agent.process_user_query("اريد حجز ميعاد غدا في الساعه الثامنه مساء مع الدكتور Smith")
-#     # arabic_response = agent.process_user_query("متى يفتح المستشفى؟")
-#     # arabic_response = agent.process_user_query("اريد معرفه كل الحجوزات الخاصه بي")
-#     print("\nArabic response:")
-#     print(arabic_response["user_friendly_response"])
-
+    # Test API action message
+    # print("\n=== TESTING API ACTION MESSAGE ===")
+    # api_response = chatbot.chat("I want to book an appointment tomorrow at 2 PM")
+    # print(f"Response: {api_response.message}")
+    # print(f"Type: {api_response.response_type}")
+    # print(f"API Called: {api_response.api_call_made}")
+    
+    # Start interactive session (uncomment to run)
+    # start_healthcare_chatbot()
 
 # Fast api section 
 from fastapi import FastAPI, HTTPException
@@ -719,11 +810,10 @@ app = FastAPI(
 )
 
 # Initialize the AI agent
-agent = AIAgent()
+agent = HealthcareChatbot()
 
 class QueryRequest(BaseModel):
     query: str
-    language: Optional[str] = None
 
 class QueryResponse(BaseModel):
     routing_info: Dict[str, Any]
@@ -738,7 +828,7 @@ async def process_query(request: QueryRequest):
     Process a user query and return a response
     """
     try:
-        response = agent.process_user_query(request.query)
+        response = agent.chat(request.query)
         return response
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))