Upload 10 files

Readme.md

@@ -0,0 +1,32 @@
+# Appointment Booking Bot for Virtual Doctor Appointments
+
+## Project Overview
+
+The Appointment Booking Bot is a comprehensive solution for managing virtual doctor appointments. It integrates with Google Calendar to automate appointment scheduling tasks, provides symptom analysis, and offers doctor recommendations based on user input. The system operates efficiently to improve patient experience and streamline healthcare provider operations.
+
+## Key Features
+
+- **Symptom Analysis:** Analyze user symptoms and suggest relevant doctors.
+- **Appointment Management:** Book, reschedule, delete, and check availability of appointments.
+- **Real-Time Updates:** Check doctor availability and book appointments instantly.
+- **Data Insights:** Provides actionable insights into appointment trends and patient preferences.
+
+## Tech Stack
+
+- **LangChain Framework:** Utilized for building the agent with multiple tools.
+- **Google Calendar API:** For managing appointment-related actions.
+- **Model:** Llama-3.1-70B-Versatile using Groq hardware for symptom analysis and health advice.
+- **Python:** Backend programming.
+- **Streamlit:** For user interface integration.
+- **MongoDB:** For secure data storage.
+
+## Files and Their Functions
+
+- **`functions.py`**: Contains information on all the tools and functions used in the project.
+- **`schema.py`**: Defines the input schema for all tools.
+- **`bot.py`**: Command-line interface (CLI) application for managing appointments and interacting with the bot.
+- **`app.py`**: Streamlit integration file that connects the model with the user interface for a seamless experience.
+- **`model.py`**: Contains the agent used for the system.
+- **`requirements.txt`**: Contains all the necessary libraries for development of this project.
+
+

app.py

@@ -0,0 +1,107 @@
+import streamlit as st
+import pandas as pd
+from model import create_agent
+
+# Set page config at the very beginning
+st.set_page_config(page_title="Appointment Booking Bot", page_icon="🏥")
+# Load doctor data
+@st.cache_data
+def load_doctor_data():
+    return pd.read_csv('doctor_specialization_dummy_data.csv')
+
+doctor_df = load_doctor_data()
+API_KEY = "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"
+
+# General prompt template
+general_prompt_template = """
+You are a healthcare assistant AI. Your primary responsibilities are:
+
+- Keep the conversation friendly and provide required details too.
+- Suggesting a doctor based on the user's symptoms.
+- Managing doctor-related appointments (book, reschedule, delete), adhering to specific rules.
+- Provide general assistance, such as greetings, if the user starts with a hello or introduction.
+
+Appointment Rules:
+- Appointments can only be scheduled/reschedule from Monday to Friday, between 10 AM and 7 PM.
+- Appointments must be booked/reschedule within the next 7 days.
+- Book/Reschedule the appointment for 60 minutes/1 hr.
+- You are not allowed to handle appointments outside these constraints.
+
+If the user says something like "hello," "hi," "hey," or a similar greeting, respond appropriately. 
+If the user provides symptoms, suggest a doctor based on those symptoms.
+If user asks details of doctor or book appointment slots without specifying symptoms, ask the user what symptoms they have.
+"""
+
+# Initialize the agent
+@st.cache_resource
+def get_agent():
+    return create_agent(general_prompt_template)
+
+agent = get_agent()
+
+# Streamlit app
+st.title("Appointment Booking Bot")
+
+# Initialize chat history
+if "messages" not in st.session_state:
+    st.session_state.messages = []
+
+# Display chat messages from history on app rerun
+for message in st.session_state.messages:
+    with st.chat_message(message["role"]):
+        st.markdown(message["content"])
+
+# React to user input
+if prompt := st.chat_input("What is your query?"):
+    # Display user message in chat message container
+    st.chat_message("user").markdown(prompt)
+    # Add user message to chat history
+    st.session_state.messages.append({"role": "user", "content": prompt})
+
+    response = agent({"input": prompt})['output']
+    
+    # Display assistant response in chat message container
+    with st.chat_message("assistant"):
+        st.markdown(response)
+    # Add assistant response to chat history
+    st.session_state.messages.append({"role": "assistant", "content": response})
+
+# Main function to run the app
+def main():
+    st.sidebar.title("About")
+    st.sidebar.info("""
+        🏥 **Appointment Booking Bot**
+
+        🩺 Virtual Doctors Appointment Managing
+       
+        🔑 **Key Features:**
+        - Symptom analysis and health advice
+        - Medical information lookup
+        - Appointment management:
+        📅 Book appointments
+        🔄 Reschedule appointments
+        🗑️ Delete appointments
+
+        ⏰ **Appointment Availability:**
+        - Monday to Friday
+        - 10 AM to 7 PM
+        - Book up to 7 days in advance
+
+        ⚠️ **Important Note:**
+        This app is for informational purposes only and does not replace professional medical advice. Always consult with a qualified healthcare provider for medical concerns.
+
+        💡 Start by describing your symptoms or managing your appointments!
+        """)
+    # Display a horizontal line, emoji, and the name "SIMRAN"
+    col1, col2 = st.sidebar.columns([2, 1])
+
+# Display emoji and name in the first column
+    with col1:
+        st.markdown("👤 **SIMRAN**")  # Profile emoji next to the name
+
+    # Display red logout button in the second column
+    with col2:
+        logout_button = st.button("Logout", key="logout", help="Click to logout", use_container_width=True)
+
+if __name__ == "__main__":
+    main()

bot.py

@@ -0,0 +1,44 @@
+from model import create_agent
+import pandas as pd 
+
+doctor_df = pd.read_csv('doctor_specialization_dummy_data.csv')
+API_KEY = "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"
+
+# General prompt template with fallback included
+general_prompt_template = """
+You are a healthcare assistant AI. Your primary responsibilities are:
+
+- Keep the conversation friendly and provide require details too.
+- Suggesting a doctor based on the user's symptoms.
+- Managing doctor-related appointments (book, reschedule, delete), adhering to specific rules.
+- Provide general assistance, such as greetings, if the user starts with a hello or introduction.
+
+Appointment Rules:
+- Appointments can only be scheduled from Monday to Friday, between 10 AM and 7 PM.
+- Appointments must be booked within the next 7 days.
+- Book the appointment for 60 minutes/1 hr.
+- You are not allowed to handle appointments outside these constraints.
+
+If the user says something like "hello," "hi," "hey," or a similar greeting, respond appropriately. 
+If the user provides symptoms, suggest a doctor based on those symptoms.
+If user ask details of doctor or book appointment slots without specify symptoms ask to user that which symptoms they have
+ 
+"""
+ 
+# Initialize the agent with tools and the general prompt
+agent = create_agent(general_prompt_template)
+ 
+# Updated interactive function to handle user queries with proper tool invocation
+def interactive_ai_doctor_advisor():
+    print("Welcome to the AI Doctor Advisor!")
+    print("I am here to suggest you a doctor based on your symptoms and help with managing your appointments.")
+    
+    while True:
+        query = input("\nYour Query: ")
+        if query.lower() == 'exit':
+            break
+        response = agent({"input": query})['output']
+        print(response)
+ 
+# Example Usage: Run the interactive advisor
+interactive_ai_doctor_advisor()

credentials.json

@@ -0,0 +1,4 @@
+{"installed":{"client_id":"123736158724-1hf7onqa73dtlirlljc8nq17ecjlmash.apps.googleusercontent.com",
+"project_id":"ethereal-app-434922-g3","auth_uri":"https://accounts.google.com/o/oauth2/auth",
+"token_uri":"https://oauth2.googleapis.com/token","auth_provider_x509_cert_url":"https://www.googleapis.com/oauth2/v1/certs",
+"client_secret":"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","redirect_uris":["http://localhost"]}}

doctor_specialization_dummy_data.csv

@@ -0,0 +1,13 @@
+Doctor Name,Specialization,Contact Number,Address
+Dr. John Doe,Dentist,123-456-7890,"123 Main St, Cityville"
+Dr. Sarah White,Cardiologist,123-555-7890,"456 Oak St, Townsville"
+Dr. Michael Smith,Neurologist,123-678-9012,"789 Pine St, Metropolis"
+Dr. Emily Davis,Orthopedist,321-456-1234,"101 Maple St, Springfield"
+Dr. David Brown,Pediatrician,987-654-3210,"202 Birch St, Villagetown"
+Dr. Jennifer Taylor,Dermatologist,555-123-4567,"303 Cedar St, Cityplace"
+Dr. Christopher Wilson,Ophthalmologist,222-333-4444,"404 Elm St, Riverdale"
+Dr. Amanda Moore,Psychiatrist,888-555-1234,"505 Walnut St, Capitalcity"
+Dr. Robert Johnson,Gynecologist,999-888-7777,"606 Chestnut St, Boroughburg"
+Dr. Linda Green,Oncologist,111-222-3333,"707 Poplar St, Urbantown"
+Dr. Green Smith,Gastro,123-432-1221,"21,Apk apartments,San Franciso"
+Dr. New Rasal,Primary Care,987-234-987,"32,Awert, LA"

functions.py

@@ -0,0 +1,489 @@
+from datetime import timedelta
+from datetime import datetime
+import os.path
+from google.auth.transport.requests import Request
+from google.oauth2.credentials import Credentials
+from google_auth_oauthlib.flow import InstalledAppFlow
+from googleapiclient.discovery import build
+from googleapiclient.errors import HttpError
+import smtplib
+from email.mime.multipart import MIMEMultipart
+from email.mime.text import MIMEText
+import pandas as pd
+from langchain.prompts import PromptTemplate
+from langchain.chains import LLMChain
+from langchain_groq import ChatGroq
+from langchain.agents import tool
+from schemas import symptoms,bookSlot,deleteSlot,reschedule_event,listevent,checkevent
+
+API_KEY="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"
+
+llm = ChatGroq(
+    model="llama3-8b-8192",
+    temperature=0,
+    max_tokens=None,
+    timeout=None,
+    max_retries=2,
+    api_key=API_KEY
+)
+SCOPES = ["https://www.googleapis.com/auth/calendar"]
+doctor_df = pd.read_csv('doctor_specialization_dummy_data.csv')
+
+EMAIL_SENDER = "kothariyash360@gmail.com"  
+EMAIL_PASSWORD = "wlxf poqr wgsh qvqs" 
+
+def get_service():
+    """Create and return the Google Calendar API service."""
+    print('this function is called.')
+    creds = None
+    if os.path.exists("token.json"):
+        creds = Credentials.from_authorized_user_file("token.json", SCOPES)
+    if not creds or not creds.valid:
+        if creds and creds.expired and creds.refresh_token:
+            creds.refresh(Request())
+        else:
+            flow = InstalledAppFlow.from_client_secrets_file("credentials.json", SCOPES)
+            creds = flow.run_local_server(port=0)
+        with open("token.json", "w") as token:
+            token.write(creds.to_json())
+
+    return build("calendar", "v3", credentials=creds)
+
+def send_email(to_email, subject, body):
+    """Send an email notification to the participants."""
+    try:
+        msg = MIMEMultipart()
+        msg['From'] = EMAIL_SENDER
+        msg['To'] = to_email
+        msg['Subject'] = subject
+        msg.attach(MIMEText(body, 'plain'))
+
+        server = smtplib.SMTP('smtp.gmail.com', 587)
+        server.starttls()
+        server.login(EMAIL_SENDER, EMAIL_PASSWORD) 
+        text = msg.as_string()
+        server.sendmail(EMAIL_SENDER, to_email, text)
+        server.quit()
+
+        print(f"Email sent to {to_email}")
+    except Exception as e:
+        print(f"Failed to send email: {e}")
+
+
+def is_valid_booking_time(start_time):
+    # Convert string to datetime object
+    start_time_dt = datetime.strptime(start_time, "%Y-%m-%dT%H:%M:%S%z")
+    
+    # Ensure the booking is within the next 7 days
+    today = datetime.now(start_time_dt.tzinfo)
+    if start_time_dt < today or start_time_dt > (today + timedelta(days=7)):
+        return False, "You can only book appointments within the next 7 days."
+    
+    # Ensure the booking is on a weekday and within 10 AM to 7 PM
+    if start_time_dt.weekday() >= 5:  # 0 = Monday, 6 = Sunday
+        return False, "Appointments can only be booked Monday to Friday."
+    
+    if not (10 <= start_time_dt.hour < 19):  # Ensure the time is between 10 AM to 7 PM
+        return False, "Appointments can only be scheduled between 10 AM and 7 PM."
+
+    return True, None
+import pytz
+@tool("check-event", args_schema=checkevent, return_direct=True)
+def check_slots(date):
+    """
+    This function is to check available slot for a given date, excluding times when events are booked.
+    It only returns valid slots that fall on weekdays (Mon-Fri) between 10 AM to 7 PM.
+
+    Args:
+        date (str): The date for which to check availability (e.g., '2024-09-17').
+
+    Returns:
+        str: Formatted string of available 1-hour slots or a message if no slots are available.
+    """
+    # Define the start and end time for the day
+    start_time = f"{date}T10:00:00+05:30"  # Start at 10 AM
+    end_time = f"{date}T19:00:00+05:30"    # End at 7 PM
+    service = get_service()
+    
+    # Check if the date is valid (weekday, and within 10 AM to 7 PM)
+    valid, message = is_valid_booking_time(start_time)
+    if not valid:
+        return message
+
+    # Query for events between start and end time
+    events_result = service.events().list(
+        calendarId='primary',
+        timeMin=start_time,
+        timeMax=end_time,
+        singleEvents=True,
+        orderBy='startTime'
+    ).execute()
+
+    events = events_result.get('items', [])
+
+    # Define the working hours (10 AM to 7 PM)
+    work_start = datetime.fromisoformat(f"{date}T10:00:00+05:30")
+    work_end = datetime.fromisoformat(f"{date}T19:00:00+05:30")
+    available_slots = []
+
+    # Add all the slots starting from work_start until work_end
+    current_time = work_start
+
+    for event in events:
+        event_start = datetime.fromisoformat(event['start']['dateTime'])
+        event_end = datetime.fromisoformat(event['end']['dateTime'])
+
+        # Find all available 1-hour slots between current_time and the event start
+        while current_time + timedelta(hours=1) <= event_start:
+            slot_start = current_time
+            slot_end = current_time + timedelta(hours=1)
+            
+            # Ensure the slot is a valid booking time
+            valid, message = is_valid_booking_time(slot_start.isoformat())
+            if valid:
+                available_slots.append((slot_start, slot_end))
+            current_time += timedelta(hours=1)
+
+        # Move current_time to the end of the event
+        current_time = max(current_time, event_end)
+
+    # Add slots from the last event to the end of the working day
+    while current_time + timedelta(hours=1) <= work_end:
+        slot_start = current_time
+        slot_end = current_time + timedelta(hours=1)
+        
+        # Ensure the slot is a valid booking time
+        valid, message = is_valid_booking_time(slot_start.isoformat())
+        if valid:
+            available_slots.append((slot_start, slot_end))
+        current_time += timedelta(hours=1)
+
+    # Return available slots in a properly formatted string
+    if available_slots:
+        formatted_output = f"📅 **Available Slots for {date}:\n**\n\n"
+        for slot in available_slots:
+            start_time = slot[0].strftime('%I:%M %p')
+            end_time = slot[1].strftime('%I:%M %p')
+            formatted_output += f"\n🕒 {start_time} - {end_time}\n"
+        
+        formatted_output += "\n✨ Each slot is for a 1-hour appointment."
+        formatted_output += "\n\n💡 To book an appointment, please specify your preferred time slot."
+        
+        return formatted_output
+    else:
+        return "😔 I'm sorry, but there are no available slots for the requested date. Would you like to check another date?"
+    
+
+def check_slot_availability(start_time, end_time):
+    # Define the Asia/Kolkata timezone
+    kolkata_tz = pytz.timezone('Asia/Kolkata')
+    
+    # Parse and localize the start_time and end_time into Asia/Kolkata timezone
+    start_time_dt = datetime.strptime(start_time, "%Y-%m-%dT%H:%M:%S%z")
+    end_time_dt = datetime.strptime(end_time, "%Y-%m-%dT%H:%M:%S%z")
+    
+    # Ensure the times are correctly converted to ISO format without adding "Z"
+    time_min = start_time_dt.isoformat()  # Already includes the timezone info
+    time_max = end_time_dt.isoformat()  # Already includes the timezone info
+    service=get_service()
+    # Fetch events within the given time range in Asia/Kolkata timezone
+    events_result = service.events().list(
+        calendarId="primary",
+        timeMin=time_min,
+        timeMax=time_max,
+        singleEvents=True,
+        orderBy="startTime"
+    ).execute()
+    
+    events = events_result.get("items", [])
+    return len(events) == 0  # Returns True if the slot is free
+
+def find_event_by_time(start_time):
+    """
+    Finds an event by its start time in the user's Google Calendar.
+    
+    Args:
+        start_time (str): The start time of the event in ISO format (e.g., '2024-09-17T14:30:00+05:30').
+
+    Returns:
+        dict or None: The event details if found, otherwise None.
+    """
+    try:
+        print(f"Searching for event starting at {start_time}")
+        service=get_service()
+        # Calculate the end time (assuming 1-hour event window)
+        start_time_dt = datetime.fromisoformat(start_time)
+        end_time_dt = start_time_dt + timedelta(hours=1)
+        end_time = end_time_dt.isoformat()
+        
+        # Query Google Calendar API for events in this time window
+        events_result = service.events().list(
+            calendarId="primary",
+            timeMin=start_time,
+            timeMax=end_time,
+            singleEvents=True,
+            orderBy="startTime",
+        ).execute()
+
+        events = events_result.get("items", [])
+        print(f"Events found: {events}")
+
+        # Return the first event that matches the time exactly
+        for event in events:
+            event_start = event['start'].get('dateTime')
+            if event_start == start_time:
+                print(f"Matching event found: {event['summary']} at {event_start}")
+                return event
+        
+        print(f"No event found starting at {start_time}")
+        return None
+
+    except HttpError as error:
+        print(f"An error occurred: {error}")
+        return None
+    except Exception as e:
+        print(f"Unexpected error: {e}")
+        return None
+
+    
+
+
+@tool("list_event", args_schema=listevent, return_direct=True)
+def list_upcoming_events(target_date):
+    """
+    Lists the upcoming events on the user's calendar for a specific date.
+
+    Args:
+    target_date (str): The date to filter events on, in 'YYYY-MM-DD' format.
+
+    Returns:
+    string: Summary of the events
+    """
+    service=get_service()
+    # Parse the target date to create timeMin and timeMax bounds
+     # Convert the target date string to a datetime object
+    target_date_obj = datetime.strptime(target_date, "%Y-%m-%d")
+
+    # Set timeMin to the beginning of the day and timeMax to the end of the day
+    time_min = target_date_obj.isoformat() + "Z"  # Beginning of the day in UTC
+    time_max = (target_date_obj + timedelta(days=1)).isoformat() + "Z"  # End of the day in UTC
+
+    print(f"Getting events for {target_date}")
+
+    try:
+        events_result = (
+            service.events()
+            .list(
+                calendarId="primary",
+                timeMin=time_min,
+                timeMax=time_max,
+                singleEvents=True,
+                orderBy="startTime",
+            )
+            .execute()
+        )
+        events = events_result.get("items", [])
+        
+        if not events:
+            print(f"No events found for {target_date}.")
+        else:
+            for event in events:
+                start = event["start"].get("dateTime", event["start"].get("date"))
+                result=start, event["summary"]
+                return result
+    except HttpError as error:
+        print(f"An error occurred: {error}")
+
+@tool("book-slot-tool", args_schema=bookSlot, return_direct=True)
+def book_slot(start_time, end_time, summary):
+    """
+    This functions is to boos a appointment/slot for user by creating an event on the calendar.
+    
+    Args:
+        start_time (str): The start time of the slot (e.g., '2024-09-16T14:00:00+05:30').
+        end_time (str): The end time of the slot (e.g., '2024-09-16T15:00:00+05:30').
+        summary (str): Summary or title of the event.
+    
+    Returns:
+        str: Confirmation message if the event is created or an error message if booking fails.
+    """
+    service = get_service()
+    is_valid, error_message = is_valid_booking_time(start_time)
+    
+    if not is_valid:
+        # Return the error message with proper formatting
+        formatted_output = "❌ **Invalid Booking Time**\n\n"
+        formatted_output += f"{error_message}\n"
+        formatted_output += "\nAppointments can only be scheduled:\n"
+        formatted_output += "📅 Monday to Friday\n"
+        formatted_output += "🕒 Between 10 AM and 7 PM\n"
+        formatted_output += "📆 Within the next 7 days\n"
+        return formatted_output
+    if not check_slot_availability(start_time, end_time):
+        formatted_output = "❌ **Slot Unavailable**\n\n"
+        formatted_output += "\nThe requested slot is not available.\n"
+        formatted_output += "\nPlease choose another time."
+        return formatted_output
+
+    # Create the event object
+    event = {
+        'summary': summary,
+        'start': {
+            'dateTime': start_time,  # ISO 8601 format
+            'timeZone': 'Asia/Kolkata',  # Use appropriate timezone
+        },
+        'end': {
+            'dateTime': end_time,
+            'timeZone': 'Asia/Kolkata',
+        },
+    }
+
+    try:
+        # Insert the event into the primary calendar
+        event_result = service.events().insert(calendarId='primary', body=event).execute()
+        formatted_output = "✅ **Event Created Successfully!**\n\n"
+        formatted_output += f"\n📌 **Summary:** {summary}\n"
+        formatted_output += f"\n🕒 **Start Time:** {start_time}\n"
+        formatted_output += f"\n🕒 **End Time:** {end_time}\n\n"
+        formatted_output += "\n📅 The event has been added to your primary calendar."
+        return formatted_output
+    except HttpError as error:
+        return f"❌ **An error occurred:** {error}\n\nPlease try again or contact support if the issue persists."
+
+@tool("delete-slot-tool", args_schema=deleteSlot, return_direct=True)
+def delete_event(start_time):
+    """
+    Deletes an event by start time on the user's calendar.
+    
+    Args:
+        start_time (str): The start time of the event (e.g., '2024-09-20T15:30:00+05:30').
+    
+    Returns:
+        str: Confirmation message if the event is deleted.
+    """
+    service = get_service()
+    event = find_event_by_time(start_time)
+    
+    if event:
+        try:
+            service.events().delete(calendarId='primary', eventId=event['id']).execute()
+            formatted_output = "\n🗑️ **Event Deleted Successfully!**\n\n"
+            formatted_output += f"\n📌 **Summary:** {event['summary']}\n"
+            formatted_output += f"\n🕒 **Start Time:** {event['start']['dateTime']}\n\n"
+            formatted_output += "\nThe event has been removed from your primary calendar."
+            return formatted_output
+        except HttpError as error:
+            return f"❌ **An error occurred:** {error}\n\nPlease try again or contact support if the issue persists."
+    else:
+        formatted_output = "❓ **No Event Found**\n\n"
+        formatted_output += f"🕒 **\nRequested Start Time:** {start_time}\n\n"
+        formatted_output += "\nNo event was found for the specified time. Please check the time and try again."
+        return formatted_output
+
+
+@tool("reschedule-event-tool", args_schema=reschedule_event, return_direct=True)
+def reschedule_event(start_time, new_start_time, new_end_time):
+    """
+    Reschedules an existing event by providing new start and end times.
+    
+    Args:
+        start_time (str): The start time of the existing event (e.g., '2024-09-18T14:00:00+05:30').
+        new_start_time (str): The new start time of the event (e.g., '2024-09-18T12:00:00+05:30').
+        new_end_time (str): The new end time of the event (e.g., '2024-09-18T14:00:00+05:30').
+    
+    Returns:
+        str: Confirmation message if the event is rescheduled or an error message if rescheduling fails.
+    """
+    service = get_service()
+    if not is_valid_booking_time(start_time):
+        formatted_output = "❌ **Invalid Booking Time**\n\n"
+        formatted_output += "\nAppointments can only be scheduled:\n"
+        formatted_output += "\n📅 Monday to Friday\n"
+        formatted_output += "\n🕒 Between 10 AM and 7 PM\n"
+        formatted_output += "\n📆 Within the next 7 days\n"
+        return formatted_output
+
+    if not check_slot_availability(new_start_time, new_end_time):
+        formatted_output = "❌ **Slot Unavailable**\n\n"
+        formatted_output += "\nThe requested slot is not available.\n"
+        formatted_output += "\nPlease choose another time."
+        return formatted_output
+
+    try:
+        event = find_event_by_time(start_time)
+        
+        if not event:
+            formatted_output = "❓ **No Event Found**\n\n"
+            formatted_output += f"\n🕒 **Requested Start Time:** {start_time}\n\n"
+            formatted_output += "\nNo event was found for the specified time. Please check the time and try again."
+            return formatted_output
+        
+        event['start']['dateTime'] = new_start_time
+        event['end']['dateTime'] = new_end_time
+        
+        updated_event = service.events().update(calendarId='primary', eventId=event['id'], body=event).execute()
+        
+        formatted_output = "✅ **Event Rescheduled Successfully!**\n\n"
+        formatted_output += f"\n🔄 **Original Start Time:** {start_time}\n"
+        formatted_output += f"\n🆕 **New Start Time:** {new_start_time}\n"
+        formatted_output += f"\n🆕 **New End Time:** {new_end_time}\n\n"
+        formatted_output += "\nYour appointment has been updated in the calendar."
+        return formatted_output
+
+    except HttpError as error:
+        return f"❌ **An error occurred:** {error}\n\nPlease try again or contact support if the issue persists."
+
+
+@tool("suggest-doctors-tool", return_direct=True)
+def suggest_specialization(symptoms):
+    """This function understands user's symptoms and suggests specialization and doctor details.
+    Args:
+        symptoms (string): symptoms of patients/user
+    Returns:
+        string: Formatted string with specialization and doctor details
+    """
+    prompt_template = """
+    You are a highly knowledgeable Healthcare AI specialized in directing patients to the appropriate medical professionals. 
+    Greet the user politely. Based on the symptoms provided below, suggest the most suitable doctor's specialization for the patient to visit.
+    Respond with only the name of the specialization in one word, without any additional explanations.
+
+    Here are a few examples for reference:
+    - Symptoms: skin rash, itching, dryness → Answer: "Dermatologist"
+    - Symptoms: chest pain, shortness of breath → Answer: "Cardiologist"
+    - Symptoms: joint pain, stiffness, swelling → Answer: "Rheumatologist"
+    - Symptoms: persistent cough, fever, sore throat → Answer: "Pulmonologist"
+    - Symptoms: frequent headaches, dizziness, vision problems → Answer: "Neurologist"
+
+    Now, based on the symptoms below, provide the specialization in one word.
+    Symptoms: {symptoms}
+    """
+    prompt = PromptTemplate(input_variables=["symptoms"], template=prompt_template)
+    chain = LLMChain(llm=llm, prompt=prompt)
+
+    try:
+        result = chain.run(symptoms=symptoms)
+        specialization = result.split('\n')[-1].strip().lower()
+        
+        # Check if we have a match for the specialization in our doctor data
+        relevant_doctors = doctor_df[doctor_df['Specialization'].str.contains(specialization, case=False, na=False)]
+        
+        if relevant_doctors.empty:
+            # If no match, fallback to suggesting a General Practitioner
+            return ("Based on your symptoms, I recommend consulting a General Practitioner. "
+                    "Unfortunately, no specific doctors matching your symptoms were found in our database.")
+
+        # If doctors are found, format the details
+        formatted_output = f"Based on your symptoms, I recommend consulting an {specialization.capitalize()}.\n\n"
+        formatted_output += "Here are the details of a suitable doctor:\n\n"
+        
+        doctor = relevant_doctors.iloc[0]  # Get the first matching doctor
+        formatted_output += f"👨‍⚕️ **Doctor**: {doctor['Doctor Name']}\n"
+        formatted_output += f"\n🏥 **Specialization**: {doctor['Specialization']}\n"
+        formatted_output += f"\n📞 **Contact**: {doctor['Contact Number']}\n"
+        formatted_output += f"\n🏢 **Address**: {doctor['Address']}\n"
+
+        return formatted_output
+    
+    except Exception as e:
+        # Fallback if an error occurs
+        return "I apologize, but I encountered an issue while processing your request. Please try describing your symptoms again, or consider consulting a General Practitioner for a comprehensive evaluation."

model.py

@@ -0,0 +1,41 @@
+from langchain_core.utils.function_calling import convert_to_openai_function
+from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder
+from langchain.memory import ConversationBufferWindowMemory
+from langchain.schema.runnable import RunnablePassthrough
+from langchain.agents.format_scratchpad import format_to_openai_functions
+from langchain.agents.output_parsers import OpenAIFunctionsAgentOutputParser
+from langchain.agents import AgentExecutor
+from langchain_groq import ChatGroq
+from functions import book_slot , check_slots , suggest_specialization , reschedule_event,delete_event
+
+def create_agent(general_prompt_template):
+    # print("get user Id**********************",user_id)
+    
+    API_KEY = "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"
+    tools = [book_slot , delete_event , check_slots , suggest_specialization , reschedule_event]
+    functions = [convert_to_openai_function(f) for f in tools]
+
+    llm = ChatGroq(
+    model="llama-3.1-70b-versatile",
+    temperature=0,
+    max_tokens=None,
+    timeout=None,
+    max_retries=2,
+    api_key=API_KEY
+        ).bind_functions(functions=functions)
+ 
+    prompt = ChatPromptTemplate.from_messages([("system", general_prompt_template),
+                                               MessagesPlaceholder(variable_name="chat_history"), ("user", "{input}"),
+                                               MessagesPlaceholder(variable_name="agent_scratchpad")])
+
+
+
+    memory = ConversationBufferWindowMemory(memory_key="chat_history" , return_messages=True, k=5)
+
+    chain = RunnablePassthrough.assign(agent_scratchpad=lambda x: format_to_openai_functions(x["intermediate_steps"])) | prompt | llm | OpenAIFunctionsAgentOutputParser()
+
+    agent_executor = AgentExecutor(
+        agent=chain, tools=tools, memory=memory, verbose=True)
+
+    return agent_executor
+# give me available slots at 17 september 2024 , book schedule at 10:30 AM 17 september 2024 , 

requirements.txt

@@ -0,0 +1,91 @@
+aiohappyeyeballs==2.4.0
+aiohttp==3.10.5
+aiosignal==1.3.1
+altair==5.4.1
+annotated-types==0.7.0
+anyio==4.4.0
+async-timeout==4.0.3
+attrs==24.2.0
+blinker==1.8.2
+cachetools==5.5.0
+certifi==2024.8.30
+charset-normalizer==3.3.2
+click==8.1.7
+dataclasses-json==0.6.7
+distro==1.9.0
+exceptiongroup==1.2.2
+frozenlist==1.4.1
+gitdb==4.0.11
+GitPython==3.1.43
+google-api-core==2.19.2
+google-api-python-client==2.144.0
+google-auth==2.34.0
+google-auth-httplib2==0.2.0
+google-auth-oauthlib==1.2.1
+googleapis-common-protos==1.65.0
+greenlet==3.0.3
+groq==0.11.0
+h11==0.14.0
+httpcore==1.0.5
+httplib2==0.22.0
+httpx==0.27.2
+idna==3.8
+Jinja2==3.1.4
+jsonpatch==1.33
+jsonpointer==3.0.0
+jsonschema==4.23.0
+jsonschema-specifications==2023.12.1
+langchain==0.2.16
+langchain-community==0.2.16
+langchain-core==0.2.38
+langchain-experimental==0.0.65
+langchain-groq==0.1.9
+langchain-text-splitters==0.2.4
+langsmith==0.1.116
+markdown-it-py==3.0.0
+MarkupSafe==2.1.5
+marshmallow==3.22.0
+mdurl==0.1.2
+multidict==6.0.5
+mypy-extensions==1.0.0
+narwhals==1.7.0
+numpy==1.26.4
+oauthlib==3.2.2
+orjson==3.10.7
+packaging==24.1
+pandas==2.2.2
+pillow==10.4.0
+proto-plus==1.24.0
+protobuf==5.28.0
+pyarrow==17.0.0
+pyasn1==0.6.0
+pyasn1_modules==0.4.0
+pydantic==2.9.0
+pydantic_core==2.23.2
+pydeck==0.9.1
+Pygments==2.18.0
+pyparsing==3.1.4
+python-dateutil==2.9.0.post0
+pytz==2024.1
+PyYAML==6.0.2
+referencing==0.35.1
+requests==2.32.3
+requests-oauthlib==2.0.0
+rich==13.8.1
+rpds-py==0.20.0
+rsa==4.9
+six==1.16.0
+smmap==5.0.1
+sniffio==1.3.1
+SQLAlchemy==2.0.34
+streamlit==1.38.0
+tenacity==8.5.0
+toml==0.10.2
+tornado==6.4.1
+typing-inspect==0.9.0
+typing_extensions==4.12.2
+tzdata==2024.1
+uritemplate==4.1.1
+urllib3==2.2.2
+watchdog==4.0.2
+yarl==1.11.0

schemas.py

@@ -0,0 +1,24 @@
+from langchain.pydantic_v1 import BaseModel, Field
+
+class symptoms(BaseModel):
+    symptoms: str = Field(description="query of user")
+
+class bookSlot(BaseModel):
+    start_time: str = Field(description="starting time of the slot with date use this format '2024-09-20T15:30:00+05:30'.")
+    end_time: str = Field(description="ending time of the slot with date use this format '2024-09-20T15:30:00+05:30'.")
+    summary: str = Field(description="summary of the event with title.")
+
+class deleteSlot(BaseModel):
+    start_time: str = Field(description="starting time of the slot with date use this format '2024-09-20T15:30:00+05:30'.")
+
+class reschedule_event(BaseModel):
+    start_time: str = Field(description="starting time of the slot with date that need to be reschedule use this format '2024-09-20T15:30:00+05:30'.")
+    new_start_time: str = Field(description="new starting time of the slot with date that need to be reschedule use this format '2024-09-20T15:30:00+05:30'.")
+    new_end_time: str = Field(description="ending time of the slot with date that need to be reschedule use this format '2024-09-20T15:30:00+05:30'.")
+
+class listevent(BaseModel):
+    target_date: str = Field(description="Target date for which we want to list the events.")
+
+class checkevent(BaseModel):
+    date: str = Field(description="Target date for which we want to check the events.")
+

token.json

@@ -0,0 +1 @@
+{"token": "ya29.a0AcM612yIlulctbhGx8D-WJTGtWm9bjLUCZuQ54Uyhxr7PdrOmNBhUo8CYawxiNOq5ytT_5Y1m80vp_6hduLX4HDGlR-y6r3wrbWyoXTP5nMuyLAbNEGiW7IQogHLxdWTAspkBHZC_zZ1Cb3cvtftVfs6eaHbr8wiBLYZKhQyEAaCgYKAcUSARMSFQHGX2Mi5HFU3Yxjp6ukrkYA8I8ofA0177", "refresh_token": "1//0g1aFUrhQNn-WCgYIARAAGBASNwF-L9Ir_svA7VEve3hAfhp4Z9s1x1UIUpTvipEIXD_t9vcX9HSpN3_GW8IoKGlFVS9KKbZmz4I", "token_uri": "https://oauth2.googleapis.com/token", "client_id": "123736158724-1hf7onqa73dtlirlljc8nq17ecjlmash.apps.googleusercontent.com", "client_secret": "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", "scopes": ["https://www.googleapis.com/auth/calendar"], "universe_domain": "googleapis.com", "account": "", "expiry": "2024-09-17T07:31:09.908854Z"}