Update app.py

app.py

@@ -1,60 +1,193 @@
-def chat_stream(self, message, history):
-    messages = [{"role": "system", "content": self.system_prompt()}]
-    for msg in history:
-        if isinstance(msg, dict) and msg.get("role") in ["user", "assistant"]:
-            messages.append(msg)
-
-    messages.append({"role": "user", "content": message})
-    self.session_log.append({"role": "user", "content": message})
-
-    # First non-streamed call to check for tool calls
-    response = self.openai.chat.completions.create(
-        model="gpt-4o",
-        messages=messages,
-        tools=tools,
-        stream=False  # Check for tool calls
-    )
-
-    reply = response.choices[0].message
+from dotenv import load_dotenv
+from openai import OpenAI
+import json
+import os
+import requests
+from PyPDF2 import PdfReader
+import gradio as gr
+import gdown
+from datetime import datetime
+from pathlib import Path
+import zipfile
 
-    if reply.tool_calls:
-        tool_results = self.handle_tool_call(reply.tool_calls)
-        messages.append(reply)
-        messages.extend(tool_results)
+load_dotenv(override=True)
 
-        # Retry final response after tool call
-        final_response = self.openai.chat.completions.create(
-            model="gpt-4o",
-            messages=messages,
-            tools=tools,
-            stream=True
+def push(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}")
+    return {"recorded": "ok"}
+
+def record_unknown_question(question):
+    push(f"Recording {question}")
+    return {"recorded": "ok"}
+
+record_user_details_json = {
+    "name": "record_user_details",
+    "description": "Use this tool to record that a user is interested in being in touch and provided an email address",
+    "parameters": {
+        "type": "object",
+        "properties": {
+            "email": {"type": "string"},
+            "name": {"type": "string"},
+            "notes": {"type": "string"}
+        },
+        "required": ["email"],
+        "additionalProperties": False
+    }
+}
+
+record_unknown_question_json = {
+    "name": "record_unknown_question",
+    "description": "Record a question that couldn't be answered",
+    "parameters": {
+        "type": "object",
+        "properties": {
+            "question": {"type": "string"}
+        },
+        "required": ["question"],
+        "additionalProperties": False
+    }
+}
+
+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)
+
+        gdown.download("https://drive.google.com/uc?id=1xz2RowkImpI8odYv8zvKdlRHaKfILn40", "linkedin.pdf", quiet=False)
+        reader = PdfReader("linkedin.pdf")
+        self.linkedin = "".join(page.extract_text() or "" for page in reader.pages)
+
+        gdown.download("https://drive.google.com/uc?id=1hjJz082YFSVjFtpO0pwT6Tyy3eLYYj6-", "summary.txt", quiet=False)
+        with open("summary.txt", "r", encoding="utf-8") as f:
+            self.summary = f.read()
+
+        self.archive_logs()
+
+    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`.
 
-        full_response = ""
-        for chunk in final_response:
-            delta = chunk.choices[0].delta
-            if hasattr(delta, "content") and delta.content:
-                full_response += delta.content
-                yield full_response
+## Summary:
+{self.summary}
 
-    else:
-        # Normal streaming response
-        stream = self.openai.chat.completions.create(
+## 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)
+            tool = globals().get(tool_name)
+            result = tool(**arguments) if tool else {}
+            results.append({"role": "tool", "tool_call_id": tool_call.id, "content": json.dumps(result)})
+        return results
+
+    def chat_stream(self, message, history):
+        messages = [{"role": "system", "content": self.system_prompt()}]
+
+        for msg in history:
+            if isinstance(msg, dict) and msg.get("role") in ["user", "assistant"]:
+                messages.append(msg)
+
+        messages.append({"role": "user", "content": message})
+        self.session_log.append({"role": "user", "content": message})
+
+        # First check for tool calls
+        response = self.openai.chat.completions.create(
             model="gpt-4o",
             messages=messages,
             tools=tools,
-            stream=True
+            stream=False
         )
 
-        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
+        reply = response.choices[0].message
+
+        if reply.tool_calls:
+            tool_results = self.handle_tool_call(reply.tool_calls)
+            messages.append(reply)
+            messages.extend(tool_results)
+
+            final_response = self.openai.chat.completions.create(
+                model="gpt-4o",
+                messages=messages,
+                tools=tools,
+                stream=True
+            )
+
+            full_response = ""
+            for chunk in final_response:
+                delta = chunk.choices[0].delta
+                if hasattr(delta, "content") and delta.content:
+                    full_response += delta.content
+                    yield full_response
+        else:
+            stream = self.openai.chat.completions.create(
+                model="gpt-4o",
+                messages=messages,
+                tools=tools,
+                stream=True
+            )
 
-    # Always add follow-up message
-    full_response += "\n\n💬 Let me know if you’d like to follow up or need help connecting with Jacob."
-    self.session_log.append({"role": "assistant", "content": full_response})
-    self.save_session_log()
+            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
+
+        full_response += "\n\n💬 Let me know if you’d like to follow up or need help connecting with Jacob."
+        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)
+
+    def archive_logs(self):
+        zip_path = "chat_logs/weekly_archive.zip"
+        with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED) as archive:
+            for log_file in Path("chat_logs").glob("session_*.json"):
+                archive.write(log_file, arcname=log_file.name)
+
+me = Me()
+
+with gr.Blocks(title="Jacob Isaacson Chatbot") as iface:
+    with gr.Row():
+        gr.Image("jacob.png", width=100, show_label=False)
+        gr.Markdown("### Chat with Jacob Isaacson\nAsk about Jacob's background, skills, or career. \n🛡️ *All chats are logged for 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."],
+        type="messages"
+    )
 
+if __name__ == "__main__":
+    iface.launch()