Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+me/Sadashiv_Data_Scientist_Resume.pdf filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,12 +1,6 @@
 ---
-title: Resume Chatbot
-emoji: ⚡
-colorFrom: green
-colorTo: red
+title: Resume_Chatbot
+app_file: app.py
 sdk: gradio
 sdk_version: 5.33.0
-app_file: app.py
-pinned: false
 ---
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

Resume_chatbot.ipynb

@@ -0,0 +1,719 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "ca5e90ad-e3bf-446a-8dd1-56026a46d2dc",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "D:\\Projects\\Agents\\.venv-agents\\Lib\\site-packages\\tqdm\\auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+      "  from .autonotebook import tqdm as notebook_tqdm\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Importing the libraries\n",
+    "from dotenv import load_dotenv\n",
+    "from openai import OpenAI\n",
+    "import json\n",
+    "import os\n",
+    "import requests\n",
+    "import gradio as gr\n",
+    "import fitz  # PyMuPDF"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "6d5aac95-a0d2-42e7-b55a-883e6617d87e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# load the environment variables\n",
+    "load_dotenv(override=True)\n",
+    "\n",
+    "# Setting up pushover for notification\n",
+    "pushover_user = os.getenv(\"PUSHOVER_USER\")\n",
+    "pushover_token = os.getenv(\"PUSHOVER_TOKEN\")\n",
+    "pushover_url = \"https://api.pushover.net/1/messages.json\"\n",
+    "\n",
+    "# setting up openai \n",
+    "open_ai = OpenAI()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "1164e747-a349-4b29-85f4-3f559a1a5750",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Push: Hey!\n"
+     ]
+    }
+   ],
+   "source": [
+    "# function to send notifications\n",
+    "def push(message):\n",
+    "    print(f\"Push: {message}\")\n",
+    "    payload = {\"user\": pushover_user, \"token\": pushover_token, \"message\": message}\n",
+    "    requests.post(pushover_url, data=payload)\n",
+    "\n",
+    "# testing the function\n",
+    "push('Hey!')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "4cd1cb67-de1c-4e45-8929-98d41fc303c4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Function to record the user details\n",
+    "def record_user_details(email, name='Name not provided', notes='Notes not provided'):\n",
+    "    push(f\"Recording interest from {name} with email {email} and notes {notes}\")\n",
+    "    return {\"recorded\": \"ok\"}\n",
+    "\n",
+    "# Function to record unknown questions\n",
+    "def record_unknown_question(question):\n",
+    "    push(f\"Recording {question} asked that I couldn't answer\")\n",
+    "    return {\"recorded\": \"ok\"}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "30b64638-9868-4856-880e-356adf25e8e2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Creating a function-like tool definition to give LLM structured access to specific actions\n",
+    "# This JSON structure defines a tool (function schema) that LLMs like GPT can call via function calling API\n",
+    "\n",
+    "# Tool to record user details such as name, email, and notes during a conversation\n",
+    "record_user_details_json = {\n",
+    "    \"name\": \"record_user_details\",  # Unique identifier for the tool/function\n",
+    "    \"description\": \"Use this tool to record that a user is interested in being touch and provided an email address\",  # Describes the tool's purpose for the LLM\n",
+    "\n",
+    "    \"parameters\": {\n",
+    "        \"type\": \"object\",  # The expected input type is a JSON object\n",
+    "\n",
+    "        \"properties\": {  # Defines the input fields (like function arguments)\n",
+    "            \"email\": {\n",
+    "                \"type\": \"string\",  # Must be a string\n",
+    "                \"description\": \"The email address of this user\"  # Purpose of this field\n",
+    "            },\n",
+    "            \"name\": {\n",
+    "                \"type\": \"string\",  # Optional string input for user's name\n",
+    "                \"description\": \"The user's name, if they provided it\"\n",
+    "            },\n",
+    "            \"notes\": {\n",
+    "                \"type\": \"string\",  # Optional string input for storing conversation context\n",
+    "                \"description\": \"Any additional information about the conversation that's worth recording to give context\"\n",
+    "            }\n",
+    "        },\n",
+    "\n",
+    "        \"required\": [\"email\"],  # Only 'email' is mandatory; others are optional\n",
+    "        \"additionalProperties\": False  # Disallows extra/unexpected fields in input\n",
+    "    }\n",
+    "}\n",
+    "\n",
+    "\n",
+    "# Tool definition to help the LLM log questions it couldn't answer\n",
+    "# This helps track unanswered queries for future improvement or manual review\n",
+    "\n",
+    "record_unknown_question_json = {\n",
+    "    \"name\": \"record_unknown_question\",  # Unique identifier for this tool\n",
+    "    \"description\": \"Always use this tool to record any question that couldn't be answered as you didn't know the answer\",  # Explains to the LLM when to use this tool\n",
+    "\n",
+    "    \"parameters\": {\n",
+    "        \"type\": \"object\",  # The tool expects an input object (i.e., JSON format)\n",
+    "\n",
+    "        \"properties\": {  # Defines the structure of the expected input\n",
+    "            \"question\": {\n",
+    "                \"type\": \"string\",  # Input must be a string\n",
+    "                \"description\": \"The question that you couldn't answered\"  # Describes what should be captured\n",
+    "            }\n",
+    "        },\n",
+    "\n",
+    "        \"required\": [\"question\"],  # 'question' is mandatory\n",
+    "        \"additionalProperties\": False  # Disallows any other fields beyond what's defined\n",
+    "    }\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "243894ed-66d8-41c4-b055-da052709f69c",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[{'type': 'function',\n",
+       "  'function': {'name': 'record_user_details',\n",
+       "   'description': 'Use this tool to record that a user is interested in being touch and provided an email address',\n",
+       "   'parameters': {'type': 'object',\n",
+       "    'properties': {'email': {'type': 'string',\n",
+       "      'description': 'The email address of this user'},\n",
+       "     'name': {'type': 'string',\n",
+       "      'description': \"The user's name, if they provided it\"},\n",
+       "     'notes': {'type': 'string',\n",
+       "      'description': \"Any additional information about the conversation that's worth recording to give context\"}},\n",
+       "    'required': ['email'],\n",
+       "    'additionalProperties': False}}},\n",
+       " {'type': 'function',\n",
+       "  'function': {'name': 'record_unknown_question',\n",
+       "   'description': \"Always use this tool to record any question that couldn't be answered as you didn't know the answer\",\n",
+       "   'parameters': {'type': 'object',\n",
+       "    'properties': {'question': {'type': 'string',\n",
+       "      'description': \"The question that you couldn't answered\"}},\n",
+       "    'required': ['question'],\n",
+       "    'additionalProperties': False}}}]"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Creating a list of tools to feed to the LLM\n",
+    "tools = [\n",
+    "    {\"type\": \"function\", \"function\": record_user_details_json},\n",
+    "    {\"type\": \"function\", \"function\": record_unknown_question_json}\n",
+    "]\n",
+    "\n",
+    "tools"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "dc8861f9-e3dd-4766-941c-aa7c95611f69",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# This function takes a list of tool calls (as provided by an LLM) and executes them\n",
+    "def handle_tool_call(tool_calls):\n",
+    "    results = []  # To store the results of each tool execution\n",
+    "\n",
+    "    for tool_call in tool_calls:\n",
+    "        tool_name = tool_call.function.name  # Extract the name of the tool/function to be called\n",
+    "        arguments = json.loads(tool_call.function.arguments)  # Parse the function arguments from JSON string to Python dict\n",
+    "\n",
+    "        # Print tool invocation info for debugging\n",
+    "        print(f\"Tool called: {tool_name} with arguments: {arguments}\", flush=True)\n",
+    "\n",
+    "        # Match the tool name and call the appropriate function with unpacked arguments\n",
+    "        if tool_name == 'record_user_details':\n",
+    "            result = record_user_details(**arguments)  # Call function to record user details\n",
+    "        elif tool_name == 'record_unknown_question':\n",
+    "            result = record_unknown_question(**arguments)  # Call function to log unknown questions\n",
+    "\n",
+    "        # Append the result in a format expected by OpenAI's function calling\n",
+    "        results.append({\n",
+    "            \"role\": \"tool\",  # Indicates this is a tool-generated response\n",
+    "            \"content\": json.dump(result),  # Convert the result to a JSON string (consider fixing to json.dumps)\n",
+    "            \"tool_call_id\": tool_call.id  # Associate result with the original tool call ID\n",
+    "        })\n",
+    "\n",
+    "    return results  # Return list of tool responses"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "08ed672f-77c0-4481-95f6-2151d463fb5f",
+   "metadata": {},
+   "source": [
+    "This line is dynamically calling a function named `\"record_unknown_question\"` by accessing it through Python's global symbol table.\n",
+    "```python\n",
+    "globals()[\"record_unknown_question\"](\"this is a really hard question\")\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "0755d22c-06aa-4482-8d81-3fb97b7518cd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# This is a more elegant version of tool execution that avoids using if-else chains\n",
+    "def handle_tool_calls(tool_calls):\n",
+    "    results = []  # List to store outputs from all tool calls\n",
+    "\n",
+    "    for tool_call in tool_calls:\n",
+    "        # Extract the name of the tool (function) to be called\n",
+    "        tool_name = tool_call.function.name\n",
+    "\n",
+    "        # Parse the arguments from string to Python dict\n",
+    "        arguments = json.loads(tool_call.function.arguments)\n",
+    "\n",
+    "        # Print debug info to trace tool calls\n",
+    "        print(f\"Tool called: {tool_name} with arguments: {arguments}\", flush=True)\n",
+    "\n",
+    "        # Look up the function in the global namespace (returns None if not found)\n",
+    "        tool = globals().get(tool_name)\n",
+    "\n",
+    "        # If tool exists, call it with arguments; otherwise, return an empty result\n",
+    "        result = tool(**arguments) if tool else {}\n",
+    "\n",
+    "        # Append the result in the expected message format for the LLM\n",
+    "        results.append({\n",
+    "            \"role\": \"tool\",                      # Indicates the message is from a tool\n",
+    "            \"content\": json.dumps(result),       # Convert result back to JSON string\n",
+    "            \"tool_call_id\": tool_call.id         # Associate result with its tool_call\n",
+    "        })\n",
+    "\n",
+    "    # Return the full list of tool responses\n",
+    "    return results"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "ee35bd27-048c-49a8-9a72-830ab564ced8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# read the pdf file\n",
+    "def extract_text_from_pdf(pdf_path):\n",
+    "    doc = fitz.open(pdf_path)\n",
+    "    full_text = \"\"\n",
+    "    for page in doc:\n",
+    "        full_text += page.get_text()\n",
+    "    return full_text\n",
+    "\n",
+    "resume_text = extract_text_from_pdf(\"me/Sadashiv_Data_Scientist_Resume.pdf\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "4ee0cee0-d7f0-4fbc-9052-210cfa208cfe",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "system_prompt = f\"\"\"\n",
+    "You are acting as an expert assistant representing the individual whose resume is provided below.\n",
+    "Your task is to answer questions strictly based on the information contained in the resume.\n",
+    "Do not fabricate or assume any details that are not explicitly mentioned in the resume.\n",
+    "\n",
+    "If asked about improvements or suggestions, respond with clear, concise, and focused points only.\n",
+    "Keep your answers compact and to the point, and expand only if the user explicitly asks for more details.\n",
+    "\n",
+    "If a user asks a question you cannot answer from the resume, use the record_unknown_question tool to log the unanswered query.\n",
+    "\n",
+    "If the user expresses interest in following up or staying in touch, politely ask for their name and email,\n",
+    "then record it using the record_user_details tool.\n",
+    "\n",
+    "Resume Content:\n",
+    "{resume_text}\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "d9b8ad52-7778-44c5-8337-c4ef0e6f68b8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def chat(message, history):\n",
+    "    # Construct the full message history: system prompt, chat history, and new user message\n",
+    "    messages = [{\"role\": \"system\", \"content\": system_prompt}] + history + [{\"role\": \"user\", \"content\": message}]\n",
+    "    \n",
+    "    done = False  # Flag to track when the chat loop should stop\n",
+    "\n",
+    "    while not done:\n",
+    "        # Call the OpenAI chat model with messages and available tools\n",
+    "        response = open_ai.chat.completions.create(\n",
+    "            model=\"gpt-4o-mini\",       # Model to use\n",
+    "            messages=messages,         # Full conversation history\n",
+    "            tools=tools                # Pass in tools so the LLM can invoke them\n",
+    "        )\n",
+    "\n",
+    "        # Check how the model decided to end its generation\n",
+    "        finish_reason = response.choices[0].finish_reason\n",
+    "\n",
+    "        # If the model wants to call a tool, handle the tool calls\n",
+    "        if finish_reason == \"tool_calls\":\n",
+    "            message = response.choices[0].message           # Extract the message containing the tool call\n",
+    "            tool_calls = message.tool_calls                 # Get the list of tool calls\n",
+    "            results = handle_tool_calls(tool_calls)         # Run the tools and get their results\n",
+    "            messages.append(message)                        # Add the original tool call message to history\n",
+    "            messages.extend(results)                        # Add tool results to message history for LLM to continue\n",
+    "        else:\n",
+    "            # If no tool call is needed, we're done and can return the final response\n",
+    "            done = True\n",
+    "\n",
+    "    # Return the final message content from the model as the assistant's reply\n",
+    "    return response.choices[0].message.content\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "184405d4-349b-44c9-b8aa-faf4b5f0756a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "* Running on local URL:  http://127.0.0.1:7863\n",
+      "* To create a public link, set `share=True` in `launch()`.\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div><iframe src=\"http://127.0.0.1:7863/\" width=\"100%\" height=\"500\" allow=\"autoplay; camera; microphone; clipboard-read; clipboard-write;\" frameborder=\"0\" allowfullscreen></iframe></div>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": 21,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Tool called: record_unknown_question with arguments: {'question': 'Where did Sadashiv Nandanikar complete his 10th?'}\n",
+      "Push: Recording Where did Sadashiv Nandanikar complete his 10th? asked that I couldn't answer\n",
+      "Tool called: record_user_details with arguments: {'email': 'sada@gmail.com', 'name': 'Sada'}\n",
+      "Push: Recording interest from Sada with email sada@gmail.com and notes Notes not provided\n"
+     ]
+    }
+   ],
+   "source": [
+    "gr.ChatInterface(chat, type=\"messages\").launch()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "id": "23c6bd49-5f8c-4fe4-8ca7-f19ee734d172",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\Sadashiv\\AppData\\Local\\Temp\\ipykernel_14264\\15198562.py:215: UserWarning: You have not specified a value for the `type` parameter. Defaulting to the 'tuples' format for chatbot messages, but this is deprecated and will be removed in a future version of Gradio. Please set type='messages' instead, which uses openai-style dictionaries with 'role' and 'content' keys.\n",
+      "  chatbot = gr.Chatbot(label=\"Conversation\", height=500)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "* Running on local URL:  http://127.0.0.1:7867\n",
+      "* To create a public link, set `share=True` in `launch()`.\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div><iframe src=\"http://127.0.0.1:7867/\" width=\"100%\" height=\"500\" allow=\"autoplay; camera; microphone; clipboard-read; clipboard-write;\" frameborder=\"0\" allowfullscreen></iframe></div>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from dotenv import load_dotenv\n",
+    "from openai import OpenAI\n",
+    "import json\n",
+    "import os\n",
+    "import requests\n",
+    "import gradio as gr\n",
+    "import fitz  # PyMuPDF\n",
+    "\n",
+    "# load the environment variables\n",
+    "load_dotenv(override=True)\n",
+    "\n",
+    "# Setting up pushover for notification\n",
+    "pushover_user = os.getenv(\"PUSHOVER_USER\")\n",
+    "pushover_token = os.getenv(\"PUSHOVER_TOKEN\")\n",
+    "pushover_url = \"https://api.pushover.net/1/messages.json\"\n",
+    "\n",
+    "# function to send notifications\n",
+    "def push(message: str):\n",
+    "    if pushover_user and pushover_token:\n",
+    "        payload = {\"user\": pushover_user, \"token\": pushover_token, \"message\": message}\n",
+    "        try:\n",
+    "            requests.post(pushover_url, data=payload, timeout=5)\n",
+    "        except requests.exceptions.RequestError as e:\n",
+    "            print(f\"Pushover notification failed: {e}\")\n",
+    "    else:\n",
+    "        print(\"Pushover credentials not found. Skipping notification\")\n",
+    "\n",
+    "# Function to record the user details\n",
+    "def record_user_details(email: str, name: str='Name not provided', notes: str='Notes not provided'):\n",
+    "    push(f\"Recording interest from {name} with email {email} and notes {notes}\")\n",
+    "    return {\"recorded\": \"ok\"}\n",
+    "\n",
+    "# Tool to record user details\n",
+    "record_user_details_json = {\n",
+    "    \"name\": \"record_user_details\",\n",
+    "    \"description\": \"Use this tool to record that a user is interested in being touch and provided an email address\",\n",
+    "    \"parameters\": {\n",
+    "        \"type\": \"object\",\n",
+    "        \"properties\": {\n",
+    "            \"email\": {\"type\": \"string\", \"description\": \"The email address of this user\"},\n",
+    "            \"name\": {\"type\": \"string\", \"description\": \"The user's name, if they provided it\"},\n",
+    "            \"notes\": {\"type\": \"string\", \"description\": \"Any additional information about the conversation that's worth recording to give context\"}\n",
+    "        },\n",
+    "        \"required\": [\"email\"],\n",
+    "        \"additionalProperties\": False\n",
+    "    }\n",
+    "}\n",
+    "\n",
+    "# Tool to log unanswered questions\n",
+    "record_unknown_question_json = {\n",
+    "    \"name\": \"record_unknown_question\",\n",
+    "    \"description\": \"Always use this tool to record any question that couldn't be answered as you didn't know the answer\",\n",
+    "    \"parameters\": {\n",
+    "        \"type\": \"object\",\n",
+    "        \"properties\": {\n",
+    "            \"question\": {\"type\": \"string\", \"description\": \"The question that you couldn't answered\"}\n",
+    "        },\n",
+    "        \"required\": [\"question\"],\n",
+    "        \"additionalProperties\": False\n",
+    "    }\n",
+    "}\n",
+    "\n",
+    "# List of tools for the LLM\n",
+    "tools = [\n",
+    "    {\"type\": \"function\", \"function\": record_user_details_json},\n",
+    "    {\"type\": \"function\", \"function\": record_unknown_question_json}\n",
+    "]\n",
+    "\n",
+    "class ResumeChatbot:\n",
+    "    def __init__(self):\n",
+    "        self.open_ai = OpenAI()\n",
+    "\n",
+    "    def extract_text_from_pdf(self, pdf_path):\n",
+    "        \"\"\"Extracts text from a given PDF file path.\"\"\"\n",
+    "        try:\n",
+    "            doc = fitz.open(pdf_path)\n",
+    "            full_text = \"\"\n",
+    "            for page in doc:\n",
+    "                full_text += page.get_text()\n",
+    "            return full_text\n",
+    "        except Exception as e:\n",
+    "            print(f\"Error reading PDF: {e}\")\n",
+    "            return None\n",
+    "\n",
+    "    def handle_tool_call(self, tool_calls):\n",
+    "        results = []\n",
+    "        for tool_call in tool_calls:\n",
+    "            tool_name = tool_call.function.name\n",
+    "            arguments = json.loads(tool_call.function.arguments)\n",
+    "            tool = globals().get(tool_name)\n",
+    "            result = tool(**arguments) if tool else {}\n",
+    "            results.append({\n",
+    "                \"role\": \"tool\",\n",
+    "                \"content\": json.dumps(result),\n",
+    "                \"tool_call_id\": tool_call.id\n",
+    "            })\n",
+    "        return results\n",
+    "\n",
+    "    def get_system_prompt(self, resume_text):\n",
+    "        system_prompt = f\"\"\"\n",
+    "        You are acting as an expert assistant representing the individual whose resume is provided below.\n",
+    "        Your task is to answer questions strictly based on the information contained in the resume.\n",
+    "        Do not fabricate or assume any details that are not explicitly mentioned in the resume.\n",
+    "\n",
+    "        If asked about improvements or suggestions, respond with clear, concise, and focused points only.\n",
+    "        Keep your answers compact and to the point, and expand only if the user explicitly asks for more details.\n",
+    "\n",
+    "        If a user asks a question you cannot answer from the resume, use the record_unknown_question tool to log the unanswered query.\n",
+    "\n",
+    "        If the user expresses interest in following up or staying in touch, politely ask for their name and email,\n",
+    "        then record it using the record_user_details tool.\n",
+    "\n",
+    "        Resume Content:\n",
+    "        {resume_text}\n",
+    "        \"\"\"\n",
+    "        return system_prompt\n",
+    "\n",
+    "    def chat(self, message: str, history: list, resume_text: str):\n",
+    "        system_prompt = self.get_system_prompt(resume_text)\n",
+    "        \n",
+    "        # Convert Gradio chat_history to OpenAI messages format\n",
+    "        formatted_history = []\n",
+    "        for user_msg, bot_msg in history:\n",
+    "            if user_msg is not None: # User messages are not None when they've actually typed something\n",
+    "                formatted_history.append({\"role\": \"user\", \"content\": user_msg})\n",
+    "            if bot_msg is not None: # Bot messages are not None when they've responded\n",
+    "                formatted_history.append({\"role\": \"assistant\", \"content\": bot_msg})\n",
+    "\n",
+    "        # Construct the full message history: system prompt, formatted chat history, and new user message\n",
+    "        messages = [{\"role\": \"system\", \"content\": system_prompt}] + formatted_history + [{\"role\": \"user\", \"content\": message}]\n",
+    "        \n",
+    "        done = False  # Flag to track when the chat loop should stop\n",
+    "\n",
+    "        while not done:\n",
+    "            # Call the OpenAI chat model with messages and available tools\n",
+    "            response = self.open_ai.chat.completions.create(\n",
+    "                model=\"gpt-4o-mini\",       # Model to use\n",
+    "                messages=messages,          # Full conversation history\n",
+    "                tools=tools                 # Pass in tools so the LLM can invoke them\n",
+    "            )\n",
+    "\n",
+    "            # Check how the model decided to end its generation\n",
+    "            finish_reason = response.choices[0].finish_reason\n",
+    "\n",
+    "            # If the model wants to call a tool, handle the tool calls\n",
+    "            if finish_reason == \"tool_calls\":\n",
+    "                message_response = response.choices[0].message        # Extract the message containing the tool call\n",
+    "                tool_calls = message_response.tool_calls            # Get the list of tool calls\n",
+    "                results = self.handle_tool_call(tool_calls)         # Run the tools and get their results\n",
+    "                messages.append(message_response)                   # Add the original tool call message to history\n",
+    "                messages.extend(results)                            # Add tool results to message history for LLM to continue\n",
+    "            else:\n",
+    "                # If no tool call is needed, we're done and can return the final response\n",
+    "                done = True\n",
+    "\n",
+    "        # Return the final message content from the model as the assistant's reply\n",
+    "        return response.choices[0].message.content\n",
+    "\n",
+    "# Create a single instance of the Me class\n",
+    "chatbot_instance = ResumeChatbot()\n",
+    "\n",
+    "def upload_and_process_resume(file_obj):\n",
+    "    \"\"\"\n",
+    "    Gradio function to handle file uploads.\n",
+    "    It extracts text from the uploaded PDF and stores it.\n",
+    "    \"\"\"\n",
+    "    if file_obj is None:\n",
+    "        return None, [], \"Please upload a PDF resume to begin.\"\n",
+    "\n",
+    "    # The file_obj has a .name attribute which is the temporary path to the uploaded file\n",
+    "    resume_text = chatbot_instance.extract_text_from_pdf(file_obj.name)\n",
+    "    \n",
+    "    if resume_text is None or not resume_text.strip():\n",
+    "        return None, [], \"Could not read text from the uploaded PDF. Please try another file.\"\n",
+    "    \n",
+    "    # Clear chat history and provide a welcome message\n",
+    "    # The welcome message is structured to fit Gradio's chat history format\n",
+    "    initial_message = \"Thank you for uploading the resume. How can I help you today?\"\n",
+    "    chat_history = [[None, initial_message]] # User message is None for the initial bot message\n",
+    "    return resume_text, chat_history, \"\" # returns resume_text to state, updated chatbot, and clears textbox\n",
+    "\n",
+    "def respond(message: str, chat_history: list, resume_state: str):\n",
+    "    \"\"\"\n",
+    "    Gradio function to handle the chat interaction.\n",
+    "    It gets the resume text from the session's state.\n",
+    "    \"\"\"\n",
+    "    if not resume_state:\n",
+    "        # If no resume has been uploaded yet\n",
+    "        chat_history.append([message, \"Please upload a resume before starting the conversation.\"])\n",
+    "        return \"\", chat_history\n",
+    "    \n",
+    "    # Get the bot's response\n",
+    "    # The chat_history passed to chatbot_instance.chat is still in Gradio's format\n",
+    "    bot_message = chatbot_instance.chat(message, chat_history, resume_state)\n",
+    "    chat_history.append([message, bot_message]) # Append the new user message and bot response to Gradio's history\n",
+    "    return \"\", chat_history # Clears the textbox and returns the updated history\n",
+    "\n",
+    "# --- Gradio Interface ---\n",
+    "if __name__ == \"__main__\":\n",
+    "    with gr.Blocks(theme=gr.themes.Soft(), title=\"Resume Chatbot\") as demo:\n",
+    "        # State to hold the extracted resume text for the user's session\n",
+    "        resume_text_state = gr.State(None)\n",
+    "\n",
+    "        gr.Markdown(\"# Chat with a Resume\")\n",
+    "        gr.Markdown(\"Upload a PDF resume below, then ask questions about it.\")\n",
+    "\n",
+    "        with gr.Row():\n",
+    "            with gr.Column(scale=1):\n",
+    "                file_uploader = gr.File(\n",
+    "                    label=\"Upload PDF Resume\",\n",
+    "                    file_types=[\".pdf\"],\n",
+    "                    type=\"filepath\" # Passes the temporary filepath to the function\n",
+    "                )\n",
+    "            with gr.Column(scale=2):\n",
+    "                chatbot = gr.Chatbot(label=\"Conversation\", height=500)\n",
+    "                msg_box = gr.Textbox(label=\"Your Question\", placeholder=\"e.g., What are the key skills mentioned?\")\n",
+    "                submit_btn = gr.Button(\"Send\")\n",
+    "\n",
+    "        # Event handler for the file upload\n",
+    "        file_uploader.upload(\n",
+    "            fn=upload_and_process_resume,\n",
+    "            inputs=[file_uploader],\n",
+    "            outputs=[resume_text_state, chatbot, msg_box]\n",
+    "        )\n",
+    "\n",
+    "        # Event handlers for chat submission\n",
+    "        msg_box.submit(\n",
+    "            fn=respond,\n",
+    "            inputs=[msg_box, chatbot, resume_text_state],\n",
+    "            outputs=[msg_box, chatbot]\n",
+    "        )\n",
+    "        submit_btn.click(\n",
+    "            fn=respond,\n",
+    "            inputs=[msg_box, chatbot, resume_text_state],\n",
+    "            outputs=[msg_box, chatbot]\n",
+    "        )\n",
+    "\n",
+    "    demo.launch()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b5f2bca0-1932-4ce7-b67f-3121c39dc296",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python (venv-agents)",
+   "language": "python",
+   "name": "venv-agents"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.13.1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

Vanilla_Resume_Reader.ipynb

@@ -0,0 +1,296 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "f52b7c2e-2a60-43e5-8534-9074d61a65b2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Installing the libraries\n",
+    "from dotenv import load_dotenv\n",
+    "import os\n",
+    "import gradio as gr\n",
+    "from openai import OpenAI\n",
+    "from pypdf import PdfReader\n",
+    "import fitz  # PyMuPDF"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "da7b3295-d080-4b49-afde-6a4b37bbabd3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# loading the environment variables and API keys\n",
+    "load_dotenv(override=True)\n",
+    "\n",
+    "# Create the instance of OpenAI\n",
+    "openai = OpenAI()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "e219abce-0b05-4991-80da-85e9ea84b881",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# read the pdf file\n",
+    "def extract_text_from_pdf(pdf_path):\n",
+    "    doc = fitz.open(pdf_path)\n",
+    "    full_text = \"\"\n",
+    "    for page in doc:\n",
+    "        full_text += page.get_text()\n",
+    "    return full_text\n",
+    "\n",
+    "resume_text = extract_text_from_pdf(\"me/Sadashiv_Data_Scientist_Resume.pdf\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "239b0875-3d09-4ab4-98bb-254c5bcfcd20",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Sadashiv Nandanikar\n",
+      "ƒ 8431114989\n",
+      "# nandanikar.sadashiv0712@gmail.com\n",
+      "ï linkedin.com/in/sadashiv-nandanikar\n",
+      "§ github.com/07Sada\n",
+      "Technical Skills\n",
+      "Programming & Databases: Python, SQL, NoSQL (MongoDB)\n",
+      "Machine Learning & Computer Vision: YOLOv8, PyTorch, Scikit-learn, Supervised Learning, Unsupervised Learning,\n",
+      "Image Classification, Object Detection, Model Quantization (ONNX), Langchain, RAG (Retrieval-Augmented Generation)\n",
+      "Cloud & Deployment: Docker, AWS EC2\n",
+      "Data Augmentation: Albumentations\n",
+      "Vector Databases: FAISS, Chroma DB\n",
+      "Large Language Models: Google Gemini Model\n",
+      "Data Processing & Engineering: Pandas, NumPy, Data Cleaning, Feature Engineering, REST APIs (Flask), Streamlit\n",
+      "Experience\n",
+      "Maruti Suzuki India Limited\n",
+      "May 2024 – Present\n",
+      "Data Scientist\n",
+      "Bengaluru, India\n",
+      "• Developed a rule-based system to identify potential customer segments for Advanced Driver Assistance Systems (ADAS)\n",
+      "• Analyzed automotive sensor data to detect traffic scenarios and improve vehicle signal processing.\n",
+      "• Optimized scenario detection algorithms, enhancing processing efficiency and memory utilization.\n",
+      "• Collaborated with cross-functional teams to refine detection of high-stress driving conditions.\n",
+      "• Processed large telematics datasets, supporting product validation and customer insights.\n",
+      "Codify Software Services\n",
+      "September 2022 – May 2024\n",
+      "Machine Learning Engineer\n",
+      "Pune, India\n",
+      "• Built predictive models for preventive maintenance, reducing machine breakdown risks.\n",
+      "• Analyzed operational challenges and derived insights from diverse data sources.\n",
+      "• Collaborated with engineering teams to design ML infrastructure, including data cleansing, transformation, feature\n",
+      "engineering, analysis, and visualization.\n",
+      "Flex\n",
+      "February 2022 – September 2022\n",
+      "SBM-Master Data Mangement\n",
+      "Pune, India\n",
+      "• Analyzed supplier transaction data to optimize procurement strategies.\n",
+      "• Automated reports to support data-driven decision-making.\n",
+      "• Ensured vendor data integrity and streamlined onboarding processes.\n",
+      "Success Automation\n",
+      "January 2019 – February 2022\n",
+      "Design Engineer\n",
+      "Pune, India\n",
+      "• Developed data-driven solutions like a Production Efficiency Dashboard for real-time insights.\n",
+      "• Analyzed production data to enhance process efficiency and reduce downtime.\n",
+      "Projects\n",
+      "CropGuard: GitHub Repository (Personal Proof of Concept Project)\n",
+      "• Developed a web application leveraging machine learning to provide insights and recommendations for farmers.\n",
+      "• Key Features:\n",
+      "- Crop Recommendation System: Suggests suitable crops based on soil composition and climate conditions.\n",
+      "- Fertilizer Recommendation System: Offers personalized fertilizer advice to optimize crop growth.\n",
+      "- Plant Disease Classification: Detects plant diseases through image classification models using user-uploaded\n",
+      "images.\n",
+      "- Real-time Commodity Price Updates: Integrates a government API for daily commodity prices, aiding market\n",
+      "decisions.\n",
+      "• Aimed at enhancing agricultural productivity through data-driven solutions while emphasizing the importance of\n",
+      "verified data sources for reliable farming decisions.\n",
+      "Brand Detection: GitHub Repository (Personal Proof of Concept Project)\n",
+      "• Developed a web application utilizing YOLOv8 for real-time object detection to identify brand logos in visual content.\n",
+      "• Manually scraped and annotated data to train the model effectively.\n",
+      "• Containerized the application using Docker for easy deployment and scalability.\n",
+      "• Hosted the application on AWS EC2 to ensure accessibility and performance.\n",
+      "• This project demonstrates the potential of ML-powered computer vision in marketing by providing insights into\n",
+      "audience behavior and enhancing advertising strategies.\n",
+      "Vegetable Recognition: Google Colab Notebook (Personal Proof of Concept Project)\n",
+      "• Developed an image classification model using PyTorch to recognize various vegetables.\n",
+      "• Employed Albumentations techniques for data augmentation to improve model robustness.\n",
+      "• Implemented a hard-coded ResNet architecture tailored for the classification task.\n",
+      "• Trained and tested the model on a dataset of vegetable images to achieve high accuracy.\n",
+      "• Utilized ONNX for model quantization, optimizing performance for deployment.\n",
+      "Bike Share Demand Prediction: GitHub Repository\n",
+      "• Built a regression model to predict bike demand using hyperparameter-tuned ML algorithms.\n",
+      "• Engineered features from weather, time, and holiday data for better accuracy.\n",
+      "• Developed an interactive Streamlit-based web app for real-time predictions.\n",
+      "• Provided multiple deployment options for user flexibility.\n",
+      "Education\n",
+      "B.E (Bachelor of Engineering)\n",
+      "Visvesvaraya Technological University, Belgaum, India\n",
+      "2013 – 2017\n",
+      "Interest\n",
+      "Reading Books: Atomic Habits, Who Moved My Cheese?\n",
+      "Anime: One Piece, Naruto.\n",
+      "Declaration\n",
+      "I hereby declare that the information provided in this resume is true and accurate to the best of my knowledge and\n",
+      "belief.\n",
+      "Date:\n",
+      "Signature:\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(resume_text)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "c1170119-f9d1-4c16-9684-51990dbe5dba",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "system_prompt = f\"\"\"\n",
+    "You are acting as an expert assistant representing the individual whose resume is provided below.\n",
+    "Your task is to answer questions strictly based on the information contained in the resume.\n",
+    "Do not fabricate or assume any details that are not explicitly mentioned in the resume.\n",
+    "\n",
+    "If asked about improvements or suggestions, respond with clear, concise, and focused points only. \n",
+    "Keep your answers compact and to the point, expanding only if the user requests further clarification.\n",
+    "\n",
+    "Resume Content:\n",
+    "{resume_text}\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "3ffec2d8-ad62-4e21-857b-db41ae1e021c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Function for creating chat inferface with gradio\n",
+    "def chat(message, history):\n",
+    "    messages = [{\"role\": \"system\", \"content\": system_prompt}] + history + [{\"role\": \"user\", \"content\": message}]\n",
+    "    response = openai.chat.completions.create(model='gpt-4o-mini', messages=messages)\n",
+    "    return response.choices[0].message.content"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "64fc63bd-c682-4d23-bf58-8dff19a4efcd",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "* Running on local URL:  http://127.0.0.1:7861\n",
+      "* To create a public link, set `share=True` in `launch()`.\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div><iframe src=\"http://127.0.0.1:7861/\" width=\"100%\" height=\"500\" allow=\"autoplay; camera; microphone; clipboard-read; clipboard-write;\" frameborder=\"0\" allowfullscreen></iframe></div>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# launch the gradio interface\n",
+    "gr.ChatInterface(fn=chat, type='messages').launch()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "163ceb77-96d4-4d9f-8d77-a91b10901f7e",
+   "metadata": {},
+   "source": [
+    "Gradio handles chat history internally when you use:\n",
+    "\n",
+    "```python\n",
+    "gr.ChatInterface(fn=chat, type='messages')\n",
+    "```\n",
+    "\n",
+    "✅ How Gradio Handles `history`:\n",
+    "- When you use `type='messages'`, Gradio:\n",
+    "    - Automatically maintains a list of previous user and assistant messages in the format:\n",
+    "      ```python\n",
+    "          [\n",
+    "      {\"role\": \"user\", \"content\": \"Hi\"},\n",
+    "      {\"role\": \"assistant\", \"content\": \"Hello!\"},\n",
+    "      ...\n",
+    "        ]\n",
+    "      ```\n",
+    "  - This `history` is passed to your `chat()` function each time a new message is sent.\n",
+    "\n",
+    "💾 Where is history stored?\n",
+    "- It’s stored in memory inside the Gradio session (i.e., in the browser tab + backend process).\n",
+    "- It resets when:\n",
+    "      - The user reloads the page\n",
+    "      - The app restarts\n",
+    "      - You call `gr.ChatInterface(..., clear=True)` or implement a `\"Clear chat\"` button\n",
+    "\n",
+    "🔐 Is it reliable?\n",
+    "- Yes, for single-session usage, like prototyping, demos, or small-scale apps.\n",
+    "- No persistence across sessions, so:\n",
+    "   - If you need long-term history (e.g. save chats per user), you must store it yourself (e.g., in a database or file)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0d9b7819-e087-4c5f-8536-3f3d5f2c9aa7",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python (venv-agents)",
+   "language": "python",
+   "name": "venv-agents"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.13.1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

app.py

@@ -0,0 +1,238 @@
+from dotenv import load_dotenv
+from openai import OpenAI
+import json
+import os
+import requests
+import gradio as gr
+import fitz  # PyMuPDF
+
+# load the environment variables
+load_dotenv(override=True)
+
+# Setting up pushover for notification
+pushover_user = os.getenv("PUSHOVER_USER")
+pushover_token = os.getenv("PUSHOVER_TOKEN")
+pushover_url = "https://api.pushover.net/1/messages.json"
+
+# function to send notifications
+def push(message: str):
+    if pushover_user and pushover_token:
+        payload = {"user": pushover_user, "token": pushover_token, "message": message}
+        try:
+            requests.post(pushover_url, data=payload, timeout=5)
+        except requests.exceptions.RequestError as e:
+            print(f"Pushover notification failed: {e}")
+    else:
+        print("Pushover credentials not found. Skipping notification")
+
+# Function to record the user details
+def record_user_details(email: str, name: str='Name not provided', notes: str='Notes not provided'):
+    push(f"Recording interest from {name} with email {email} and notes {notes}")
+    return {"recorded": "ok"}
+
+# Tool to record user details
+record_user_details_json = {
+    "name": "record_user_details",
+    "description": "Use this tool to record that a user is interested in being touch and provided an email address",
+    "parameters": {
+        "type": "object",
+        "properties": {
+            "email": {"type": "string", "description": "The email address of this user"},
+            "name": {"type": "string", "description": "The user's name, if they provided it"},
+            "notes": {"type": "string", "description": "Any additional information about the conversation that's worth recording to give context"}
+        },
+        "required": ["email"],
+        "additionalProperties": False
+    }
+}
+
+# Tool to log unanswered questions
+record_unknown_question_json = {
+    "name": "record_unknown_question",
+    "description": "Always use this tool to record any question that couldn't be answered as you didn't know the answer",
+    "parameters": {
+        "type": "object",
+        "properties": {
+            "question": {"type": "string", "description": "The question that you couldn't answered"}
+        },
+        "required": ["question"],
+        "additionalProperties": False
+    }
+}
+
+# List of tools for the LLM
+tools = [
+    {"type": "function", "function": record_user_details_json},
+    {"type": "function", "function": record_unknown_question_json}
+]
+
+class ResumeChatbot:
+    def __init__(self):
+        self.open_ai = OpenAI()
+
+    def extract_text_from_pdf(self, pdf_path):
+        """Extracts text from a given PDF file path."""
+        try:
+            doc = fitz.open(pdf_path)
+            full_text = ""
+            for page in doc:
+                full_text += page.get_text()
+            return full_text
+        except Exception as e:
+            print(f"Error reading PDF: {e}")
+            return None
+
+    def handle_tool_call(self, tool_calls):
+        results = []
+        for tool_call in tool_calls:
+            tool_name = tool_call.function.name
+            arguments = json.loads(tool_call.function.arguments)
+            tool = globals().get(tool_name)
+            result = tool(**arguments) if tool else {}
+            results.append({
+                "role": "tool",
+                "content": json.dumps(result),
+                "tool_call_id": tool_call.id
+            })
+        return results
+
+    def get_system_prompt(self, resume_text):
+        system_prompt = f"""
+        You are acting as an expert assistant representing the individual whose resume is provided below.
+        Your task is to answer questions strictly based on the information contained in the resume.
+        Do not fabricate or assume any details that are not explicitly mentioned in the resume.
+
+        If asked about improvements or suggestions, respond with clear, concise, and focused points only.
+        Keep your answers compact and to the point, and expand only if the user explicitly asks for more details.
+
+        If a user asks a question you cannot answer from the resume, use the record_unknown_question tool to log the unanswered query.
+
+        If the user expresses interest in following up or staying in touch, politely ask for their name and email,
+        then record it using the record_user_details tool.
+
+        Resume Content:
+        {resume_text}
+        """
+        return system_prompt
+
+    def chat(self, message: str, history: list, resume_text: str):
+        system_prompt = self.get_system_prompt(resume_text)
+        
+        # Convert Gradio chat_history to OpenAI messages format
+        formatted_history = []
+        for user_msg, bot_msg in history:
+            if user_msg is not None: # User messages are not None when they've actually typed something
+                formatted_history.append({"role": "user", "content": user_msg})
+            if bot_msg is not None: # Bot messages are not None when they've responded
+                formatted_history.append({"role": "assistant", "content": bot_msg})
+
+        # Construct the full message history: system prompt, formatted chat history, and new user message
+        messages = [{"role": "system", "content": system_prompt}] + formatted_history + [{"role": "user", "content": message}]
+        
+        done = False  # Flag to track when the chat loop should stop
+
+        while not done:
+            # Call the OpenAI chat model with messages and available tools
+            response = self.open_ai.chat.completions.create(
+                model="gpt-4o-mini",       # Model to use
+                messages=messages,          # Full conversation history
+                tools=tools                 # Pass in tools so the LLM can invoke them
+            )
+
+            # Check how the model decided to end its generation
+            finish_reason = response.choices[0].finish_reason
+
+            # If the model wants to call a tool, handle the tool calls
+            if finish_reason == "tool_calls":
+                message_response = response.choices[0].message        # Extract the message containing the tool call
+                tool_calls = message_response.tool_calls            # Get the list of tool calls
+                results = self.handle_tool_call(tool_calls)         # Run the tools and get their results
+                messages.append(message_response)                   # Add the original tool call message to history
+                messages.extend(results)                            # Add tool results to message history for LLM to continue
+            else:
+                # If no tool call is needed, we're done and can return the final response
+                done = True
+
+        # Return the final message content from the model as the assistant's reply
+        return response.choices[0].message.content
+
+# Create a single instance of the Me class
+chatbot_instance = ResumeChatbot()
+
+def upload_and_process_resume(file_obj):
+    """
+    Gradio function to handle file uploads.
+    It extracts text from the uploaded PDF and stores it.
+    """
+    if file_obj is None:
+        return None, [], "Please upload a PDF resume to begin."
+
+    # The file_obj has a .name attribute which is the temporary path to the uploaded file
+    resume_text = chatbot_instance.extract_text_from_pdf(file_obj.name)
+    
+    if resume_text is None or not resume_text.strip():
+        return None, [], "Could not read text from the uploaded PDF. Please try another file."
+    
+    # Clear chat history and provide a welcome message
+    # The welcome message is structured to fit Gradio's chat history format
+    initial_message = "Thank you for uploading the resume. How can I help you today?"
+    chat_history = [[None, initial_message]] # User message is None for the initial bot message
+    return resume_text, chat_history, "" # returns resume_text to state, updated chatbot, and clears textbox
+
+def respond(message: str, chat_history: list, resume_state: str):
+    """
+    Gradio function to handle the chat interaction.
+    It gets the resume text from the session's state.
+    """
+    if not resume_state:
+        # If no resume has been uploaded yet
+        chat_history.append([message, "Please upload a resume before starting the conversation."])
+        return "", chat_history
+    
+    # Get the bot's response
+    # The chat_history passed to chatbot_instance.chat is still in Gradio's format
+    bot_message = chatbot_instance.chat(message, chat_history, resume_state)
+    chat_history.append([message, bot_message]) # Append the new user message and bot response to Gradio's history
+    return "", chat_history # Clears the textbox and returns the updated history
+
+# --- Gradio Interface ---
+if __name__ == "__main__":
+    with gr.Blocks(theme=gr.themes.Soft(), title="Resume Chatbot") as demo:
+        # State to hold the extracted resume text for the user's session
+        resume_text_state = gr.State(None)
+
+        gr.Markdown("# Chat with a Resume")
+        gr.Markdown("Upload a PDF resume below, then ask questions about it.")
+
+        with gr.Row():
+            with gr.Column(scale=1):
+                file_uploader = gr.File(
+                    label="Upload PDF Resume",
+                    file_types=[".pdf"],
+                    type="filepath" # Passes the temporary filepath to the function
+                )
+            with gr.Column(scale=2):
+                chatbot = gr.Chatbot(label="Conversation", height=500)
+                msg_box = gr.Textbox(label="Your Question", placeholder="e.g., What are the key skills mentioned?")
+                submit_btn = gr.Button("Send")
+
+        # Event handler for the file upload
+        file_uploader.upload(
+            fn=upload_and_process_resume,
+            inputs=[file_uploader],
+            outputs=[resume_text_state, chatbot, msg_box]
+        )
+
+        # Event handlers for chat submission
+        msg_box.submit(
+            fn=respond,
+            inputs=[msg_box, chatbot, resume_text_state],
+            outputs=[msg_box, chatbot]
+        )
+        submit_btn.click(
+            fn=respond,
+            inputs=[msg_box, chatbot, resume_text_state],
+            outputs=[msg_box, chatbot]
+        )
+
+    demo.launch()

me/Sadashiv_Data_Scientist_Resume.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dfa6fbf3d616b934f4a5fa7b9a07a1c206c2b2f4e0ffd48fc098fdb257886d7b
+size 113708