Update app.py

app.py

@@ -6,18 +6,23 @@ import requests
 from PyPDF2 import PdfReader
 import gradio as gr
 import gdown
+from datetime import datetime
+from pathlib import Path
 
 load_dotenv(override=True)
 
 def push(text):
-    requests.post(
-        "https://api.pushover.net/1/messages.json",
-        data={
-            "token": os.getenv("PUSHOVER_TOKEN"),
-            "user": os.getenv("PUSHOVER_USER"),
-            "message": text,
-        }
-    )
+    try:
+        requests.post(
+            "https://api.pushover.net/1/messages.json",
+            data={
+                "token": os.getenv("PUSHOVER_TOKEN"),
+                "user": os.getenv("PUSHOVER_USER"),
+                "message": text,
+            }
+        )
+    except Exception as e:
+        print(f"Pushover error: {e}")
 
 def record_user_details(email, name="Name not provided", notes="not provided"):
     push(f"Recording {name} with email {email} and notes {notes}")
@@ -33,18 +38,9 @@ record_user_details_json = {
     "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"
-            }
+            "email": {"type": "string", "description": "Their email address"},
+            "name": {"type": "string", "description": "Their name"},
+            "notes": {"type": "string", "description": "Conversation context"}
         },
         "required": ["email"],
         "additionalProperties": False
@@ -53,88 +49,112 @@ record_user_details_json = {
 
 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",
+    "description": "Record questions that couldn't be answered",
     "parameters": {
         "type": "object",
         "properties": {
-            "question": {
-                "type": "string",
-                "description": "The question that couldn't be answered"
-            },
+            "question": {"type": "string", "description": "The unknown question"},
         },
         "required": ["question"],
         "additionalProperties": False
     }
 }
 
-tools = [{"type": "function", "function": record_user_details_json},
-         {"type": "function", "function": record_unknown_question_json}]
+tools = [
+    {"type": "function", "function": record_user_details_json},
+    {"type": "function", "function": record_unknown_question_json}
+]
 
 class Me:
-
     def __init__(self):
         self.openai = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
         self.name = "Jacob Isaacson"
+        self.session_log = []
+        Path("chat_logs").mkdir(exist_ok=True)
 
-        # Download LinkedIn PDF using gdown
+        # Download LinkedIn PDF
         linkedin_id = "1xz2RowkImpI8odYv8zvKdlRHaKfILn40"
-        linkedin_path = "Linkedin.pdf"
-        gdown.download(f"https://drive.google.com/uc?id={linkedin_id}", linkedin_path, quiet=False)
-        reader = PdfReader(linkedin_path)
+        gdown.download(f"https://drive.google.com/uc?id={linkedin_id}", "linkedin.pdf", quiet=False)
+        reader = PdfReader("linkedin.pdf")
+        self.linkedin = "".join(page.extract_text() or "" for page in reader.pages)
 
-        self.linkedin = ""
-        for page in reader.pages:
-            text = page.extract_text()
-            if text:
-                self.linkedin += text
-
-        # Download summary.txt using gdown
+        # Download summary.txt
         summary_id = "1hjJz082YFSVjFtpO0pwT6Tyy3eLYYj6-"
-        summary_path = "summary.txt"
-        gdown.download(f"https://drive.google.com/uc?id={summary_id}", summary_path, quiet=False)
-
-        with open(summary_path, "r", encoding="utf-8") as f:
+        gdown.download(f"https://drive.google.com/uc?id={summary_id}", "summary.txt", quiet=False)
+        with open("summary.txt", "r", encoding="utf-8") as f:
             self.summary = f.read()
 
+    def system_prompt(self):
+        return f"""You are acting as {self.name}. You're answering questions on {self.name}'s website about his career, experience, and skills.
+Be professional and conversational, as if talking to a potential employer or client.
+
+If you can't answer something, call `record_unknown_question`. If a user seems interested, ask for their email and use `record_user_details`.
+
+## Summary:
+{self.summary}
+
+## LinkedIn Profile:
+{self.linkedin}
+"""
+
     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)
-            print(f"Tool called: {tool_name}", flush=True)
             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})
+            results.append({"role": "tool", "tool_call_id": tool_call.id, "content": json.dumps(result)})
         return results
 
-    def system_prompt(self):
-        system_prompt = f"You are acting as {self.name}. You are answering questions on {self.name}'s website, \
-particularly questions related to {self.name}'s career, background, skills and experience. \
-Your responsibility is to represent {self.name} for interactions on the website as faithfully as possible. \
-You are given a summary of {self.name}'s background and LinkedIn profile which you can use to answer questions. \
-Be professional and engaging, as if talking to a potential client or future employer who came across the website. \
-If you don't know the answer to any question, use your record_unknown_question tool to record the question that you couldn't answer, even if it's about something trivial or unrelated to career. \
-If the user is engaging in discussion, try to steer them towards getting in touch via email; ask for their email and record it using your record_user_details tool."
-
-        system_prompt += f"\n\n## Summary:\n{self.summary}\n\n## LinkedIn Profile:\n{self.linkedin}\n\n"
-        system_prompt += f"With this context, please chat with the user, always staying in character as {self.name}."
-        return system_prompt
-
-    def chat(self, message, history):
-        messages = [{"role": "system", "content": self.system_prompt()}] + history + [{"role": "user", "content": message}]
-        done = False
-        while not done:
-            response = self.openai.chat.completions.create(model="gpt-4o-mini", messages=messages, tools=tools)
-            if response.choices[0].finish_reason == "tool_calls":
-                message = response.choices[0].message
-                tool_calls = message.tool_calls
-                results = self.handle_tool_call(tool_calls)
-                messages.append(message)
-                messages.extend(results)
-            else:
-                done = True
-        return response.choices[0].message.content
+    def chat_stream(self, message, history):
+        messages = [{"role": "system", "content": self.system_prompt()}]
+        for user, assistant in history:
+            messages.append({"role": "user", "content": user})
+            messages.append({"role": "assistant", "content": assistant})
+
+        messages.append({"role": "user", "content": message})
+        self.session_log.append({"role": "user", "content": message})
+
+        stream = self.openai.chat.completions.create(
+            model="gpt-4o",
+            messages=messages,
+            tools=tools,
+            stream=True
+        )
+
+        full_response = ""
+        for chunk in stream:
+            delta = chunk.choices[0].delta
+            if hasattr(delta, "content") and delta.content:
+                full_response += delta.content
+                yield full_response
+
+        self.session_log.append({"role": "assistant", "content": full_response})
+        self.save_session_log()
+
+    def save_session_log(self):
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        filename = f"chat_logs/session_{timestamp}.json"
+        with open(filename, "w", encoding="utf-8") as f:
+            json.dump(self.session_log, f, indent=2)
+
+me = Me()
+
+with gr.Blocks(title="Jacob Isaacson Chatbot") as iface:
+    with gr.Row():
+        gr.Image("jacob.png", width=120, show_label=False)
+        gr.Markdown("### Chat with Jacob Isaacson\nAsk about Jacob's background, skills, or career. \n🛡️ *Your chat will be logged for quality and improvement purposes.*")
+
+    gr.ChatInterface(
+        fn=me.chat_stream,
+        chatbot=gr.Chatbot(show_copy_button=True),
+        examples=["What is Jacob's experience with AI?", "Tell me about his recent projects."],
+        retry_btn="🔁 Retry",
+        clear_btn="🗑️ Clear",
+        submit_btn="💬 Send",
+    )
 
 if __name__ == "__main__":
-    me = Me()
-    gr.ChatInterface(me.chat, type="messages").launch()
+    iface.launch()
+