Added Files

.gitignore

@@ -0,0 +1,194 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+.idea
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Abstra
+# Abstra is an AI-powered process automation framework.
+# Ignore directories containing user credentials, local state, and settings.
+# Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#  Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 
+#  that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#  and can be added to the global gitignore or merged into this file. However, if you prefer, 
+#  you could uncomment the following to ignore the enitre vscode folder
+# .vscode/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Cursor
+#  Cursor is an AI-powered code editor. `.cursorignore` specifies files/directories to
+#  exclude from AI features like autocomplete and code analysis. Recommended for sensitive data
+#  refer to https://docs.cursor.com/context/ignore-files
+.cursorignore
+.cursorindexingignore

LICENSE

@@ -0,0 +1,21 @@
+IT License
+
+Copyright (c) 2025 Sarvesh Chaudhari
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,12 +1 @@
----
-title: AppointmentApplication
-emoji: 💬
-colorFrom: yellow
-colorTo: purple
-sdk: gradio
-sdk_version: 5.0.1
-app_file: app.py
-pinned: false
----
-
-An example chatbot using [Gradio](https://gradio.app), [`huggingface_hub`](https://huggingface.co/docs/huggingface_hub/v0.22.2/en/index), and the [Hugging Face Inference API](https://huggingface.co/docs/api-inference/index).
+# appointmentSchedulingApp

app.py

@@ -1,64 +1,91 @@
+# main.py
+
 import gradio as gr
-from huggingface_hub import InferenceClient
+from dotenv import load_dotenv
 
-"""
-For more information on `huggingface_hub` Inference API support, please check the docs: https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
-"""
-client = InferenceClient("HuggingFaceH4/zephyr-7b-beta")
+from database.db_handler import init_db
+from langchain_logic.agent_setup import create_agent_executor
 
+# --- Load Environment and Initialize ---
+load_dotenv()
+init_db()
+agent_executor = create_agent_executor()
 
-def respond(
-    message,
-    history: list[tuple[str, str]],
-    system_message,
-    max_tokens,
-    temperature,
-    top_p,
-):
-    messages = [{"role": "system", "content": system_message}]
+# --- Initial Bot Message ---
+INITIAL_MESSAGE = """
+Hey! I'm your appointment scheduling assistant. I can help you schedule, find, update, or delete appointments.
 
-    for val in history:
-        if val[0]:
-            messages.append({"role": "user", "content": val[0]})
-        if val[1]:
-            messages.append({"role": "assistant", "content": val[1]})
+To schedule an appointment, I'll need the following details:
+- **customer_name**: Customer's full name.
+- **customer_phone**: Customer's contact phone number.
+- **appointment_datetime**: The desired date and time in `YYYY-MM-DD HH:MM:SS` format.
+- **service_type**: The reason for the visit (e.g., "Dental Checkup", "Haircut").
 
-    messages.append({"role": "user", "content": message})
+How can I help you today?
+"""
 
-    response = ""
 
-    for message in client.chat_completion(
-        messages,
-        max_tokens=max_tokens,
-        stream=True,
-        temperature=temperature,
-        top_p=top_p,
-    ):
-        token = message.choices[0].delta.content
+# --- Gradio Chat Interface Logic ---
+def chat_interface_fn(message, history):
+    """
+    The function that the Gradio ChatInterface will call.
+    It processes the user's message, invokes the agent, and returns the response.
+    """
+    # The 'history' from Gradio is a list of [user, bot] pairs.
+    # We convert it to the list-of-tuples format LangChain's agent expects.
+    chat_history_tuples = []
+    for user_msg, ai_msg in history:
+        # We only want to feed the actual conversational turns to the agent,
+        # not the initial greeting.
+        if ai_msg != INITIAL_MESSAGE:
+            chat_history_tuples.append(("human", user_msg))
+            chat_history_tuples.append(("ai", ai_msg))
 
-        response += token
-        yield response
+    response = agent_executor.invoke({
+        "input": message,
+        "chat_history": chat_history_tuples
+    })
 
+    # The ChatInterface expects a single string response from the function.
+    # It will automatically append the user's message and this response to the chatbot's history.
+    return response["output"]
 
-"""
-For information on how to customize the ChatInterface, peruse the gradio docs: https://www.gradio.app/docs/chatinterface
-"""
-demo = gr.ChatInterface(
-    respond,
-    additional_inputs=[
-        gr.Textbox(value="You are a friendly Chatbot.", label="System message"),
-        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
-        gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
-        gr.Slider(
-            minimum=0.1,
-            maximum=1.0,
-            value=0.95,
-            step=0.05,
-            label="Top-p (nucleus sampling)",
-        ),
-    ],
-)
 
+def greet():
+    """
+    Function to provide the initial greeting.
+    It must return the data in the format the chatbot expects: a list of [user, bot] pairs.
+    """
+    # FIX: Return the history in the correct format.
+    return [[None, INITIAL_MESSAGE]]
 
+
+# --- Launch the Gradio App ---
 if __name__ == "__main__":
-    demo.launch()
+    print("Launching Gradio Appointment Bot...")
+
+    with gr.Blocks(theme=gr.themes.Soft(), title="Appointment Bot") as demo:
+        # Create a Chatbot component that will be populated on load.
+        chatbot = gr.Chatbot(label="Appointment Bot", elem_id="chatbot", height=600)
+
+        # Create the full ChatInterface.
+        chat_interface = gr.ChatInterface(
+            fn=chat_interface_fn,
+            chatbot=chatbot,
+            examples=[
+                ["Find all appointments for 'John Doe'"],
+                ["I'd like to book a 'Financial Consultation' for 2024-12-25 at 14:00:00. My name is Jane Doe and my number is 555-876-5432."],
+                ["Please delete all 'Maintenance Check' appointments."],
+                ["Update the phone number for Jane Doe to 555-999-0000"]
+            ],
+            title="Conversational Appointment Scheduler"
+        )
+
+        # Use a 'load' event to populate the initial greeting using the greet function.
+        demo.load(
+            fn=greet,
+            inputs=None,
+            outputs=chatbot
+        )
+
+    demo.launch()

database/db_handler.py

@@ -0,0 +1,123 @@
+import sqlite3
+from typing import List, Dict, Any
+
+DB_FILE = "appointments.db"
+
+# ... (get_db_connection, init_db, add_appointment functions are unchanged) ...
+
+def get_db_connection():
+    """Establishes a connection to the database."""
+    conn = sqlite3.connect(DB_FILE)
+    conn.row_factory = sqlite3.Row  # This allows accessing columns by name
+    return conn
+
+
+def init_db():
+    """Initializes the database and creates the appointments table."""
+    conn = get_db_connection()
+    cursor = conn.cursor()
+    cursor.execute("""
+        CREATE TABLE IF NOT EXISTS appointments (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        customer_name TEXT NOT NULL,
+        customer_phone TEXT NOT NULL,
+        appointment_datetime TEXT NOT NULL UNIQUE,
+        service_type TEXT NOT NULL,
+        duration_minutes INTEGER NOT NULL DEFAULT 60,
+        status TEXT NOT NULL CHECK (status IN ('CONFIRMED', 'CANCELLED')) DEFAULT 'CONFIRMED',
+        created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP
+    )""")
+    conn.commit()
+    conn.close()
+
+
+def add_appointment(name: str, phone: str, dt: str, service: str) -> Dict[str, Any]:
+    """Adds a new appointment to the database."""
+    conn = get_db_connection()
+    cursor = conn.cursor()
+    try:
+        cursor.execute(
+            "INSERT INTO appointments (customer_name, customer_phone, appointment_datetime, service_type) VALUES (?, ?, ?, ?)",
+            (name, phone, dt, service)
+        )
+        conn.commit()
+        appointment_id = cursor.lastrowid
+        return {"status": "success", "id": appointment_id}
+    except sqlite3.IntegrityError:
+        return {"status": "error", "message": "This time slot is already booked."}
+    finally:
+        conn.close()
+
+
+def search_appointments(criteria: str, value: str) -> List[Dict[str, Any]]:
+    """Searches for appointments by customer_name, service_type, or date."""
+    conn = get_db_connection()
+    cursor = conn.cursor()
+
+    allowed_criteria = {
+        "customer_name": "customer_name",
+        "service_type": "service_type",
+        "date": "date(appointment_datetime)"
+    }
+
+    if criteria not in allowed_criteria:
+        return []
+
+    query = f"SELECT * FROM appointments WHERE {allowed_criteria[criteria]} = ? AND status = 'CONFIRMED'"
+    cursor.execute(query, (value,))
+
+    appointments = [dict(row) for row in cursor.fetchall()]
+    conn.close()
+    return appointments
+
+# --- NEW FUNCTION ---
+def get_all_appointments() -> List[Dict[str, Any]]:
+    """Retrieves all confirmed appointments from the database."""
+    conn = get_db_connection()
+    cursor = conn.cursor()
+    # Order by date to make the list more useful
+    query = "SELECT * FROM appointments WHERE status = 'CONFIRMED' ORDER BY appointment_datetime"
+    cursor.execute(query)
+    appointments = [dict(row) for row in cursor.fetchall()]
+    conn.close()
+    return appointments
+# --------------------
+
+
+def delete_appointments(criteria: str, value: str) -> int:
+    # ... (function is unchanged) ...
+    conn = get_db_connection()
+    cursor = conn.cursor()
+
+    allowed_criteria = {
+        "customer_name": "customer_name",
+        "service_type": "service_type",
+        "date": "date(appointment_datetime)",
+        "id": "id"
+    }
+    if criteria not in allowed_criteria:
+        return 0
+
+    query = f"DELETE FROM appointments WHERE {allowed_criteria[criteria]} = ?"
+    cursor.execute(query, (value,))
+    deleted_count = cursor.rowcount
+    conn.commit()
+    conn.close()
+    return deleted_count
+
+def update_appointment(identifier_value: str, field_to_update: str, new_value: str) -> int:
+    # ... (function is unchanged) ...
+    conn = get_db_connection()
+    cursor = conn.cursor()
+
+    allowed_fields = ["customer_phone", "appointment_datetime", "service_type"]
+    if field_to_update not in allowed_fields:
+        return 0
+
+    query = f"UPDATE appointments SET {field_to_update} = ? WHERE customer_name = ?"
+
+    cursor.execute(query, (new_value, identifier_value))
+    updated_count = cursor.rowcount
+    conn.commit()
+    conn.close()
+    return updated_count

langchain_logic/agent_setup.py

@@ -0,0 +1,49 @@
+from langchain.agents import AgentExecutor, create_tool_calling_agent
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_google_genai import ChatGoogleGenerativeAI
+# Import the new tool
+from langchain_logic.tools import schedule_appointment, search_for_appointments, delete_appointment_records, update_appointment_record, list_all_appointments
+from datetime import datetime
+
+def create_agent_executor():
+    """Creates the LangChain agent and executor."""
+    # Add the new tool to the list
+    tools = [
+        schedule_appointment,
+        search_for_appointments,
+        list_all_appointments, # <-- ADDED HERE
+        delete_appointment_records,
+        update_appointment_record
+    ]
+
+    llm = ChatGoogleGenerativeAI(model="gemini-2.5-flash-lite-preview-06-17", temperature=0)
+
+    # You can optionally update the prompt to mention the new capability
+    prompt = ChatPromptTemplate.from_messages([
+        ("system", """You are an advanced, helpful appointment scheduling assistant.
+
+        Your tasks are to schedule, search, update, and delete appointments using the available tools.
+
+        **Core Instructions:**
+        1.  **Be Conversational:** Always be polite and helpful.
+        2.  **Gather Information:** If you don't have enough information for a tool, ask the user for it.
+        3.  **Search:** You can search for appointments by `customer_name`, `service_type` (which the user might call 'title'), or a specific `date`. If the user asks for *all* appointments, use the `list_all_appointments` tool.
+        4.  **Update:** To update an appointment, you must know the customer's name and what specific information to change (e.g., 'update the phone for John Doe to 555-1111').
+        5.  **CRITICAL-SAFETY-RULE for Deletion:** Deleting by name, service, or date can remove MULTIPLE appointments. Before using the `delete_appointment_records` tool, you MUST first search for the appointments to see how many will be affected. Then, you MUST ask the user for explicit confirmation. For example: "I found 3 appointments for 'Dental Checkup'. Are you sure you want to delete all of them? Please reply with 'yes' to confirm or 'no' to cancel." Only proceed with deletion if they confirm with 'yes'.
+        6.  **Current Date:** Today's date is {today}.
+
+        Begin the conversation by introducing yourself and what you can do.
+        """.format(today=datetime.now().strftime('%Y-%m-%d'))),
+        ("placeholder", "{chat_history}"),
+        ("human", "{input}"),
+        ("placeholder", "{agent_scratchpad}"),
+    ])
+
+    agent = create_tool_calling_agent(llm, tools, prompt)
+    agent_executor = AgentExecutor(
+        agent=agent,
+        tools=tools,
+        verbose=True, # For debugging
+        handle_parsing_errors=True
+    )
+    return agent_executor

langchain_logic/tools.py

@@ -0,0 +1,100 @@
+from langchain_core.tools import tool
+from pydantic.v1 import BaseModel, Field
+from datetime import datetime
+from database.db_handler import (
+    add_appointment,
+    search_appointments,
+    delete_appointments,
+    update_appointment,
+    get_all_appointments
+)
+
+# --- Pydantic Models for Tool Inputs ---
+# (These are unchanged)
+class ScheduleAppointmentInput(BaseModel):
+    customer_name: str = Field(description="The full name of the customer.")
+    customer_phone: str = Field(description="The contact phone number of the customer.")
+    appointment_datetime: str = Field(description="The date and time in 'YYYY-MM-DD HH:MM:SS' format.")
+    service_type: str = Field(description="The type of service, e.g., 'Dental Checkup', 'Haircut'.")
+
+
+class SearchAppointmentInput(BaseModel):
+    criteria: str = Field(description="The field to search by: 'customer_name', 'service_type', or 'date'.")
+    value: str = Field(description="The value to search for. For date, use 'YYYY-MM-DD' format.")
+
+
+class DeleteAppointmentInput(BaseModel):
+    criteria: str = Field(
+        description="The field to identify appointments to delete: 'customer_name', 'service_type', or 'date'.")
+    value: str = Field(description="The value to identify the appointments by.")
+
+
+class UpdateAppointmentInput(BaseModel):
+    identifier_value: str = Field(description="The name of the customer whose appointment needs updating.")
+    field_to_update: str = Field(
+        description="The specific field to change, e.g., 'customer_phone', 'appointment_datetime'.")
+    new_value: str = Field(description="The new value for the specified field.")
+
+
+# --- Tool Definitions ---
+
+@tool(args_schema=ScheduleAppointmentInput)
+def schedule_appointment(customer_name: str, customer_phone: str, appointment_datetime: str, service_type: str) -> str:
+    """Schedules a new appointment.""" # <-- ADDED THIS DOCSTRING BACK
+    try:
+        datetime.strptime(appointment_datetime, '%Y-%m-%d %H:%M:%S')
+    except ValueError:
+        return "Error: Invalid datetime format. Please use 'YYYY-MM-DD HH:MM:SS'."
+
+    result = add_appointment(customer_name, customer_phone, appointment_datetime, service_type)
+    if result["status"] == "success":
+        return f"Success! Appointment for {customer_name} is scheduled. The appointment ID is {result['id']}."
+    else:
+        return f"Error: {result['message']}"
+
+
+@tool(args_schema=SearchAppointmentInput)
+def search_for_appointments(criteria: str, value: str) -> str:
+    """Searches for existing appointments based on name, service type, or date.""" # <-- ADDED THIS DOCSTRING BACK
+    results = search_appointments(criteria, value)
+    if not results:
+        return f"No confirmed appointments found for {criteria} = {value}."
+
+    details = "\n".join([
+                            f"- ID: {r['id']}, Name: {r['customer_name']}, DateTime: {r['appointment_datetime']}, Service: {r['service_type']}"
+                            for r in results])
+    return f"Found the following appointments:\n{details}"
+
+
+@tool
+def list_all_appointments() -> str:
+    """Lists all confirmed appointments currently in the system. Use this when the user asks to see all appointments without specifying any criteria."""
+    results = get_all_appointments()
+    if not results:
+        return "There are currently no confirmed appointments in the system."
+
+    details = "\n".join([
+        f"- ID: {r['id']}, Name: {r['customer_name']}, DateTime: {r['appointment_datetime']}, Service: {r['service_type']}"
+        for r in results
+    ])
+    return f"Here are all the confirmed appointments:\n{details}"
+
+
+@tool(args_schema=DeleteAppointmentInput)
+def delete_appointment_records(criteria: str, value: str) -> str:
+    """Deletes appointment records by name, service type, or date.""" # <-- ADDED THIS DOCSTRING BACK
+    count = delete_appointments(criteria, value)
+    if count == 0:
+        return f"No appointments found to delete for {criteria} = {value}."
+    else:
+        return f"Successfully deleted {count} appointment(s)."
+
+
+@tool(args_schema=UpdateAppointmentInput)
+def update_appointment_record(identifier_value: str, field_to_update: str, new_value: str) -> str:
+    """Updates an appointment's information, like phone number or time.""" # <-- ADDED THIS DOCSTRING BACK
+    count = update_appointment(identifier_value, field_to_update, new_value)
+    if count == 0:
+        return f"Error: Could not find or update an appointment for customer '{identifier_value}'."
+    else:
+        return f"Successfully updated {count} appointment(s) for {identifier_value}."

requirements.txt

@@ -1 +1,6 @@
-huggingface_hub==0.25.2
+# requirements.txt
+langchain
+langchain-google-genai
+google-generativeai
+gradio
+python-dotenv