pushe all project files

.env.example

@@ -0,0 +1,11 @@
+OPENAI_API_KEY=""
+GROQ_API_KEY=""
+ANTHROPIC_API_KEY=""
+GOOGLE_API_KEY=""
+HF_TOKEN=""
+LANGSMITH_API_KEY=""
+
+LANGSMITH_ENDPOINT="https://api.smith.langchain.com"
+LANGSMITH_TRACING_V2=true
+LANGCHAIN_PROJECT=""
+PROFIL_NAME=""

.gitignore

@@ -205,3 +205,9 @@ cython_debug/
 marimo/_static/
 marimo/_lsp/
 __marimo__/
+
+# Mac
+.DS_Store
+
+# My folders
+/me/*.txt

README.md

@@ -1,2 +1,30 @@
-# profile-avatar-chat
-An interactive personal profile website where visitors can chat with an AI avatar to learn about my background and experience.
+---
+title: Your App Name
+emoji: 🤖
+sdk: gradio
+app_file: src/app.py
+pinned: false
+---
+
+
+# Profile Avatar Chat App
+
+This repository contains the code for a robust AI-powered chat service that acts as a personal profile avatar. The chat responds based on my LinkedIn profile, professional summary, current situation, recommendations, and other additional information.
+
+Key features implemented for robustness:
+
+ - Semantic QA cache: Reuses previous answers for repeated or similar questions to improve response speed and consistency.
+
+- Embedding-based similarity search: Uses OpenAI embeddings and cosine similarity to find semantically similar past questions and refine answers.
+
+- Sliding window conversation context: Keeps only the last n messages for token-efficient API calls while preserving relevant context.
+
+- Automated evaluation and rerun: Uses Google Gemini (via OpenAI API wrapper) to evaluate generated responses, automatically rerunning and refining answers when quality control flags them.
+
+- Traceability with LangSmith: Key functions are decorated for run tracking, enabling debugging and historical inspection of chat interactions.
+
+- PDF and text ingestion: Extracts profile information from LinkedIn PDF, summary, current situation, and recommendation text files.
+
+- Gradio integration: Provides an interactive chat interface for local testing and deployment.
+
+This chat service powers my portfolio website, which communicates with this deployed Hugging Face Space for live interactions.

notebooks/chat_with_avatar.ipynb

@@ -0,0 +1,378 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "3471e6b1",
+   "metadata": {},
+   "source": [
+    "# Chat With Avatar About My Experience and Skills"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5dcb5ef0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "from dotenv import load_dotenv\n",
+    "from openai import OpenAI\n",
+    "from pypdf import PdfReader\n",
+    "import gradio as gr"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f5176f5c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "load_dotenv(override=True)\n",
+    "\n",
+    "openai_api_key = os.getenv(\"OPENAI_API_KEY\")\n",
+    "google_api_key = os.getenv(\"GOOGLE_API_KEY\")\n",
+    "groq_api_key = os.getenv(\"GROQ_API_KEY\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "be1a140b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "openai = OpenAI()\n",
+    "gemini = OpenAI(api_key=google_api_key, base_url=\"https://generativelanguage.googleapis.com/v1beta/openai/\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "da87405b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "reader = PdfReader(\"../me/Linkedin_Profile.pdf\")\n",
+    "linkedin = \"\"\n",
+    "for page in reader.pages:\n",
+    "    text = page.extract_text()\n",
+    "    if text:\n",
+    "        linkedin += text"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "386847b5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# print(linkedin)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7ae1fd8d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with open(\"../me/summary.txt\", \"r\", encoding=\"utf-8\") as f:\n",
+    "    summary = f.read()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c08f3db9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with open(\"../me/current_situation.txt\", \"r\", encoding=\"utf-8\") as f:\n",
+    "    current_situation = f.read()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fac6fde8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "name = \"Mariusz Bronowicki\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3a20a2b4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "system_prompt = f\"You are acting as {name}. You are answering question on {name}'s website, \\\n",
+    "particularly question related to {name}'s career, background, skills and experience. \\\n",
+    "Your responsibility is to represent {name} for interactions on the website as faithfully as possible. \\\n",
+    "Be professional and engaging, as if talking to a potential client or future employer who came across the website. \\\n",
+    "If you do not know the answer, say so. \\\n",
+    "If you need to check e.g salary expectation question then use tools to see what range for such position is.\"\n",
+    "\n",
+    "system_prompt += f\"\\n\\n## Summary:\\n{summary}\\n\\n## Linkedin Profile:\\n{linkedin}\\n\\n## Current situation:\\n{current_situation}\\n\\n\"\n",
+    "system_prompt += f\"With this context, please chat with user, always staying in character as {name}.\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "61832d91",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "system_prompt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b1421ebf",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def chat_gpt(message, history):\n",
+    "    messages = [{\"role\": \"user\", \"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": null,
+   "id": "b7c32734",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1a96fabc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def chat_gemini(message, history):\n",
+    "    history = [{\"role\": h[\"role\"], \"content\": h[\"content\"]} for h in history]\n",
+    "    messages = [{\"role\": \"user\", \"content\": system_prompt}] + history + [{\"role\": \"user\", \"content\": message}]\n",
+    "    response = gemini.chat.completions.create(model=\"gemini-2.0-flash\", messages=messages)\n",
+    "    return response.choices[0].message.content"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "44aa35da",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "gr.ChatInterface(chat_gpt, type=\"messages\").launch()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d43f04f7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "gr.ChatInterface(chat_gemini, type=\"messages\").launch()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4a5ab195",
+   "metadata": {},
+   "source": [
+    "## Ask LLM to evaluate answer from previous model.\n",
+    "\n",
+    "All without any Agentic Framework!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8e1c26d8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Create a Pydantic model for the Evaluation\n",
+    "from pydantic import BaseModel\n",
+    "\n",
+    "class Evaluation(BaseModel):\n",
+    "    is_acceptable: bool\n",
+    "    feedback: str"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bfd6a08d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "evaluator_system_prompt = f\"You are an evaluator that decides whether a response to a question is acceeptable. \\\n",
+    "You are provided with a conversation btween a User and an Agent. Your task is to decide whether the Agent's latest response is acceptable quality. \\\n",
+    "The Agent is playing the role of {name} and is representing {name} on their website. \\\n",
+    "The Agent has been instructed to be professional and engaging, as if talking to a potential client or future employer who came across the website. \\\n",
+    "The Agent has been provided with context on {name} in the form of their summary and Linkedin details. Here's the information:\"\n",
+    "\n",
+    "evaluator_system_prompt += f\"\\n\\n## Summary:\\n{summary}\\n\\n## Linkedin Profile{linkedin}\\n\\n\"\n",
+    "evaluator_system_prompt += f\"With this context, please evaluate the latest response, replying with whether the response is acceptable and your feedback.\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "aaada426",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def evaluator_user_prompt(reply, message, history):\n",
+    "    user_prompt = f\"Here's the conversation between the User and the Agent: \\n\\n{history}\\n\\n\"\n",
+    "    user_prompt += f\"Here's the latest message from the User: \\n\\n{message}\\n\\n\"\n",
+    "    user_prompt += f\"Here's the latest response from the Agent: \\n\\n{reply}\\n\\n\"\n",
+    "    user_prompt += f\"Please evaluate the response, replying with whether it is acceptable and your feedback.\"\n",
+    "    return user_prompt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "522a926c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def evaluate(reply, message, history) -> Evaluation:\n",
+    "    messages = [{\"role\": \"system\", \"content\": evaluator_system_prompt}] + [{\"role\": \"user\", \"content\": evaluator_user_prompt(reply, message, history)}]\n",
+    "    response = gemini.chat.completions.parse(model=\"gemini-2.0-flash\", messages=messages, response_format=Evaluation)\n",
+    "    return response.choices[0].message.parsed"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "631098e3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "messages = [{\"role\": \"system\", \"content\": system_prompt}] + [{\"role\": \"user\", \"content\": \"What is your current situation?\"}]\n",
+    "response = openai.chat.completions.create(model=\"gpt-4o-mini\", messages=messages)\n",
+    "reply = response.choices[0].message.content"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e0338b90",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "reply"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7f271a3a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "evaluate(reply, \"What is your current situation?\", messages[:1])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "84923137",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def rerun(reply, message, history,feedback):\n",
+    "    updated_system_prompt = system_prompt + \"\\n\\n## Previous answer rejected\\n \\\n",
+    "    You just tried to reply, but the quality control rejected your reply\\n\"\n",
+    "    updated_system_prompt += f\"## Your attempted answer:\\n{reply}\\n\\n\"\n",
+    "    updated_system_prompt += f\"## Reason for rejection:\\n{feedback}\\n\\n\"\n",
+    "    messages = [{\"role\": \"system\", \"content\": updated_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": null,
+   "id": "943dc4d6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def chat(message, history):\n",
+    "    # if \"tell me about yourself\" in message:\n",
+    "    #     system = system_prompt + \"\\n\\nEverything in you reply needs to be in pig latin - \\\n",
+    "    #         it is mandatory that you response only and entirely in pig latin\"\n",
+    "    # else:\n",
+    "    #     system = system_prompt\n",
+    "    system = system_prompt\n",
+    "    messages = [{\"role\": \"system\", \"content\": system}] + history + [{\"role\": \"user\", \"content\": message}]\n",
+    "    response = openai.chat.completions.create(model=\"gpt-4o-mini\", messages=messages)\n",
+    "    reply = response.choices[0].message.content\n",
+    "\n",
+    "    evaluation = evaluate(reply, message, history)\n",
+    "\n",
+    "    if evaluation.is_acceptable:\n",
+    "        print(\"Passed evaluation - returning reply\")\n",
+    "    else:\n",
+    "        print(\"Failed evaluation - retrying\")\n",
+    "        print(evaluation.feedback)\n",
+    "        reply = rerun(reply, message, history, evaluation.feedback)\n",
+    "    return reply"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c74ee145",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "gr.ChatInterface(chat, type=\"messages\").launch()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "36cbe706",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "profile-avatar-chat",
+   "language": "python",
+   "name": "python3"
+  },
+  "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.12.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

pyproject.toml

@@ -0,0 +1,48 @@
+[project]
+name = "profile-avatar-chat"
+version = "0.1.0"
+description = "Add your description"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "dotenv>=0.9.9",
+    "anthropic>=0.49.0",
+    "autogen-agentchat>=0.4.9.2",
+    "autogen-ext[grpc,mcp,ollama,openai]>=0.4.9.2",
+    "bs4>=0.0.2",
+    "gradio>=5.22.0",
+    "httpx>=0.28.1",
+    "ipywidgets>=8.1.5",
+    "langchain-anthropic>=0.3.10",
+    "langchain-community>=0.3.20",
+    "langchain-experimental>=0.3.4",
+    "langchain-openai>=0.3.9",
+    "langgraph>=0.3.18",
+    "langgraph-checkpoint-sqlite>=2.0.6",
+    "langsmith>=0.3.18",
+    "lxml>=5.3.1",
+    "mcp-server-fetch>=2025.1.17",
+    "mcp[cli]>=1.5.0",
+    "openai>=1.68.2",
+    "openai-agents>=0.0.15",
+    "playwright>=1.51.0",
+    # "plotly>=6.0.1",
+    "polygon-api-client>=1.14.5",
+    "psutil>=7.0.0",
+    "pypdf>=5.4.0",
+    "pypdf2>=3.0.1",
+    "python-dotenv>=1.0.1",
+    "requests>=2.32.3",
+    "semantic-kernel>=1.25.0",
+    "sendgrid>=6.11.0",
+    "setuptools>=78.1.0",
+    "smithery>=0.1.0",
+    "speedtest-cli>=2.1.3",
+    "scikit-learn>=1.7.2",
+    #"wikipedia>=1.4.0",
+]
+
+[dependency-groups]
+dev = [
+    "ipykernel>=6.29.5",
+]

requirements.txt

@@ -0,0 +1,33 @@
+"dotenv>=0.9.9",
+"anthropic>=0.49.0",
+"autogen-agentchat>=0.4.9.2",
+"autogen-ext[grpc,mcp,ollama,openai]>=0.4.9.2",
+"bs4>=0.0.2",
+"gradio>=5.22.0",
+"httpx>=0.28.1",
+"ipywidgets>=8.1.5",
+"langchain-anthropic>=0.3.10",
+"langchain-community>=0.3.20",
+"langchain-experimental>=0.3.4",
+"langchain-openai>=0.3.9",
+"langgraph>=0.3.18",
+"langgraph-checkpoint-sqlite>=2.0.6",
+"langsmith>=0.3.18",
+"lxml>=5.3.1",
+"mcp-server-fetch>=2025.1.17",
+"mcp[cli]>=1.5.0",
+"openai>=1.68.2",
+"openai-agents>=0.0.15",
+"playwright>=1.51.0",
+"polygon-api-client>=1.14.5",
+"psutil>=7.0.0",
+"pypdf>=5.4.0",
+"pypdf2>=3.0.1",
+"python-dotenv>=1.0.1",
+"requests>=2.32.3",
+"semantic-kernel>=1.25.0",
+"sendgrid>=6.11.0",
+"setuptools>=78.1.0",
+"smithery>=0.1.0",
+"speedtest-cli>=2.1.3",
+"scikit-learn>=1.7.2",

src/app.py

@@ -0,0 +1,254 @@
+import os
+from dotenv import load_dotenv
+from pydantic import BaseModel
+from openai import OpenAI
+from pypdf import PdfReader
+import gradio as gr
+from prompts import system_prompt, evaluator_system_prompt
+from langsmith import Client, traceable
+from sklearn.metrics.pairwise import cosine_similarity
+import traceback
+
+import numpy as np
+
+class Evaluation(BaseModel):
+    is_acceptable: bool
+    feedback: str
+
+class Config:
+    def __init__(self):
+        load_dotenv(override=True)
+        self.openai_api_key = os.getenv("OPENAI_API_KEY")
+        self.google_api_key = os.getenv("GOOGLE_API_KEY")
+        self.langsmith_api_key = os.getenv("LANGSMITH_API_KEY")
+        self.langsmith_endpoint = os.getenv("LANGSMITH_ENDPOINT")
+
+        # Initialize LangSmith
+        self.langsmith_client = Client(api_key=self.langsmith_api_key)
+
+        # print(f"OpenAI Api Key: {self.openai_api_key[:7]}")
+
+class FileReader:
+    def __init__(self):
+        self.linkedin_profile = ""
+        try:
+            reader = PdfReader("../me/Linkedin_Profile.pdf")
+            for page in reader.pages:
+                text = page.extract_text()
+                if text:
+                    self.linkedin_profile += text
+        except Exception:
+            # If file missing, keep empty
+            self.linkedin_profile = ""
+        # NOT IMPLEMENTED ---> CREATE FILE AND CHANGE IN THE APP WHERE APPLICABLE
+        try:
+            with open("../me/additional_info.txt", "r", encoding="utf-8") as f:
+                self.additional_info = f.read()
+        except:
+            self.additional_info = ""
+
+
+class MyProfileAvatarChat(Config, FileReader):
+    def __init__(self, max_history_turns: int = 10, similarity_thresh: float = 0.80):
+        Config.__init__(self)
+        FileReader.__init__(self)
+
+        self.name = os.getenv("PROFIL_NAME")
+        self.openai = OpenAI(api_key=self.openai_api_key)
+        # gemini (evaluator) uses google_api_key via OpenAI wrapper
+        self.gemini = OpenAI(api_key=self.google_api_key, 
+                             base_url="https://generativelanguage.googleapis.com/v1beta/openai/")
+        
+        # Build system prompt once
+        self.system_prompt = system_prompt
+        self.system_prompt += f"## Linkedin Profile:\n{self.linkedin_profile}\n\n"
+        self.system_prompt += f"## Addidional Information:\n{self.additional_info}\n\n"
+        self.system_prompt += f"With this context, please chat with user, always staying in character as {self.name}."
+
+        self.evaluator_system_prompt = evaluator_system_prompt
+
+        # Settings
+        self.max_history_turns = max_history_turns
+        self.similarity_threshold = similarity_thresh
+
+        # QA cache (question -> answer -> embedding)
+        self.qa_cache = [] # list of dict: {"question": str, "answer": str, "embedding": np.array}
+        
+    
+    def format_history(self, history):
+        return "\n".join(f"{turn['role'].upper()}: {turn['content']}" for turn in history)
+    
+    def embed(self, text: str):
+        """Return embedding vector for text (uses OpenAI embeddings)."""
+        resp = self.openai.embeddings.create(
+            model="text-embedding-3-small",
+            input=text
+        )
+        return np.array(resp.data[0].embedding)
+    
+    def cosine_sim(self, a: np.ndarray, b: np.ndarray) -> float:
+        return float(cosine_similarity(a.reshape(1, -1), b.reshape(1, -1))[0][0])
+    
+    def find_similar_question(self, new_question: str):
+        if not self.qa_cache:
+            return None, 0.0
+        new_emb = self.embed(new_question)
+        best = None
+        best_sim = 0.0
+        for item in self.qa_cache:
+            sim = self.cosine_sim(new_emb, item["embedding"])
+            if sim > best_sim:
+                best_sim = sim
+                best = item
+        if best and best_sim >= self.similarity_threshold:
+            return best, best_sim
+        return None, best_sim
+    
+    def evaluator_user_prompt(self, reply, message, history):
+        formatted_history = self.format_history(history)
+        user_prompt = f"Here's the conversation between the User and the Agent: \n\n{formatted_history}\n\n"
+        user_prompt += f"Here's the latest message from the User: \n\n{message}\n\n"
+        user_prompt += f"Here's the latest response from the Agent: \n\n{reply}\n\n"
+        user_prompt += f"Please evaluate the response, replying with whether it is acceptable and your feedback."
+        return user_prompt
+
+    @traceable(run_type="tool", name="EvaluateReply")
+    def evaluate(self, reply, message, history, **kwargs) -> Evaluation:
+        messages = [{"role": "system", "content": self.evaluator_system_prompt}] + \
+                    [{"role": "user", "content": self.evaluator_user_prompt(reply, message, history)}]
+        response = self.gemini.chat.completions.parse(
+            model="gemini-2.0-flash",
+            messages=messages,
+            response_format=Evaluation
+        )
+        return response.choices[0].message.parsed
+    
+    @traceable(run_type="llm", name="RerunRejectedAnswer")
+    def rerun(self, reply, message, history, feedback, **kwargs):
+        # updated_system_prompt = self.system_prompt + "\n\n## Previous answer rejected\n \
+        # You just tried to reply, but the quality control rejected your reply\n"
+        # updated_system_prompt += f"## Your attempted answer:\n{reply}\n\n"
+        # updated_system_prompt += f"## Reason for rejection:\n{feedback}\n\n"
+
+        updated_system_prompt = (
+            self.system_prompt 
+            + "\n\n## Previous answer rejected\n"
+            + "You just tried to reply, but the quality control rejected your reply\n"
+            + f"## Your attempted answer:\n{reply}\n\n"
+            + f"## Reason for rejection:\n{feedback}\n\n"
+        )
+
+
+        messages = [{"role": "system", "content": updated_system_prompt}] + history + \
+                    [{"role": "user", "content": message}]
+        try:
+            response = self.openai.chat.completions.create(
+                model="gpt-4o-mini",
+                messages=messages
+            )
+            return response.choices[0].message.content
+        except Exception as e:
+            print(f"Error during rerun: {e}")
+            return reply
+        
+    def chat(self, message: str, history: list, **kwargs):
+        """Main chat. Uses semantic QA cache, sliding window for tokens, evaluation and rerun
+        
+        Args:
+            message: user message string
+            history: existing list of dicts [{"role":...., "content":....}]
+        Returns:
+            reply string
+        """
+
+        # Cache exact-match short-circuit
+        if message in (qa["question"] for qa in self.qa_cache):
+            # exact match
+            for qa in self.qa_cache:
+                if qa["question"] == message:
+                    print("Using exact cached reply")
+                    history.append({"role": "user", "content": message})
+                    history.append({"role": "assistant", "content": qa["answer"]})
+                    return qa["answer"]
+                
+        # Check for semantically similar previous question
+        similar, sim_score = self.find_similar_question(message)
+        if similar:
+            print(f"Reusing past answer (similarity={sim_score:.2%})")
+            refine_prompt = (
+                f"The user previously asked a similar question:\n"
+                + f"Old question: {similar['question']}\n"
+                + f"Old answer: {similar['answer']}\n\n"
+                + f"Now user asks: {message}\n\n"
+                + f"Please update or refine the old answer to match the new question."
+            )
+            messages = [{"role": "system", "content": self.system_prompt},
+                        {"role": "user", "content": refine_prompt}]
+            
+            try:
+                response = self.openai.chat.completions.create(
+                    model="gpt-4o-mini",
+                    messages=messages
+                )
+                reply = response.choices[0].message.content
+            except Exception as e:
+                print(f"Error calling OpenAI for refinement: {e}")
+                reply = similar["answer"]
+        
+        else:
+            # Build token-efficent context (sliding window)
+            temp_history = history + [{"role": "user", "content": message}]
+            context_for_api = temp_history[-self.max_history_turns:]
+            messages = [{"role": "system", "content": self.system_prompt}] + context_for_api
+
+            try:
+                response = self.openai.chat.completions.create(
+                    model="gpt-4o-mini",
+                    messages=messages
+                )
+                reply = response.choices[0].message.content
+            except Exception as e:
+                print(f"Error calling OpenAI: {e}")
+
+        # Evaluate the reply
+        try:
+            evaluation = self.evaluate(reply, message, history)
+        except Exception as e:
+            print(f"Error during evaluation: {e}")
+            evaluation = Evaluation(is_acceptable=True, feedback="Evaluation failed, accepting reply")
+
+        if not evaluation.is_acceptable:
+            reply = self.rerun(reply, message, history, evaluation.feedback)
+
+        try:
+            emb = self.embed(message)
+        except Exception as e:
+            print(f"Embedding Error: {e}")
+            traceback.print_exc()
+            emb = None
+        
+        self.qa_cache.append({
+            "question": message,
+            "answer": reply,
+            "embedding": emb
+        })
+
+        return reply
+    
+    @traceable(run_type="chain", name="ProfileChat")
+    def chat_traced(self, *args, **kwargs):
+        """Wrapper for LangSmith tracing. Accepts any extra arguments
+        (like from Gradio) and passes only message/history to chat()."""
+
+        if len(args) >=2:
+            message, history = args[0], args[1]
+        else:
+            message = kwargs.get("message")
+            history = kwargs.get("history")
+        return self.chat(message, history)
+        
+if __name__ == "__main__":
+
+    my_profile = MyProfileAvatarChat()
+    gr.ChatInterface(my_profile.chat_traced, type="messages").launch()
+

src/prompts.py

@@ -0,0 +1,19 @@
+import os
+from dotenv import load_dotenv
+
+load_dotenv(override=True)
+
+name = os.getenv("PROFIL_NAME")
+
+system_prompt = f"You are acting as {name}. You are answering question on {name}'s website, \
+particularly question related to {name}'s career, background, skills and experience. \
+Your responsibility is to represent {name} for interactions on the website as faithfully as possible. \
+Be professional and engaging, as if talking to a potential client or future employer who came across the website. \
+If you do not know the answer, say so. \
+If you need to check e.g salary expectation question then use tools to see what range for such position is."
+
+evaluator_system_prompt = f"You are an evaluator that decides whether a response to a question is acceeptable. \
+You are provided with a conversation btween a User and an Agent. Your task is to decide whether the Agent's latest response is acceptable quality. \
+The Agent is playing the role of {name} and is representing {name} on their website. \
+The Agent has been instructed to be professional and engaging, as if talking to a potential client or future employer who came across the website. \
+The Agent has been provided with context on {name} in the form of their summary and Linkedin details. Here's the information:"