added first version of langgraph agent implementation w memory

agent.py

@@ -1,97 +1,243 @@
-import anthropic
 import os
-from dotenv import load_dotenv
-from tools.search_tool import search_duckduckgo
-from tools.retriever_tool import Retriever
+from typing import Dict, List, Any, Optional
+from langchain_anthropic import ChatAnthropic
+from langgraph.graph import StateGraph, START, END
+from langgraph.checkpoint.memory import MemorySaver
+from langchain_core.messages import AIMessage, HumanMessage, SystemMessage
+from typing import TypedDict, List, Optional, Union
+import copy
 
-load_dotenv()
+from tools.retriever_tool import DocumentRetriever
+from tools.search_tool import WebSearchTool
+from tools.pdf_tool import PDFProcessor
 
-import logging
+class AgentState(TypedDict):
+    """State schema for the agent."""
+    messages: List[Union[HumanMessage, AIMessage]]
+    query: str
+    csv_results: Optional[str]
+    web_results: Optional[str]
+    pdf_results: Optional[str]
+    response: Optional[str]
 
-logging.basicConfig(
-    level=logging.DEBUG,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
-    handlers=[logging.FileHandler("debug.log"), logging.StreamHandler()]
-)
-
-logger = logging.getLogger(__name__)
-
-client = anthropic.Anthropic(
-    api_key=os.getenv("ANTHROPIC_API_KEY"),
-)
-# print("Anthropic API key:", os.getenv("ANTHROPIC_API_KEY"))
-
-retriever = Retriever(
-    top_k=3,
-    similarity_threshold=0.2,
-    batch_size=8 
-)
-
-def call_llm(prompt, model="claude-3-7-sonnet-20250219"):
-    response = client.messages.create(
-        model=model,
-        max_tokens=500,
-        temperature=0,
-        system="""You are an expert clinical AI assistant. You must strictly reply in ONLY one of the following formats: TOOL: [Document], TOOL: [Search], or TOOL: [Both].
-
-For questions about general medical information like recovery times, procedure durations, or standard practices, prefer TOOL: [Search].
-For questions about specific medical cases or rare conditions found in the document database, use TOOL: [Document].
-For questions that would benefit from both sources, use TOOL: [Both].
-
-Never explain, never say anything else.""",
-        messages=[
-            {"role": "user", "content": f"""Question: "{prompt}"
-
-Decide the best tool for answering it. Reply exactly with TOOL: [Document], TOOL: [Search], or TOOL: [Both]. No other text."""}
-        ]
-    )
-    return response.content[0].text
-
-def agent_respond(question):
-    logger.debug(f"Received question: {question}")
+class MedTranscriptAgent:
+    def __init__(self, anthropic_api_key: Optional[str] = None, debug: bool = False):
+        self.api_key = anthropic_api_key or os.getenv("ANTHROPIC_API_KEY")
+        if not self.api_key:
+            raise ValueError("Anthropic API key is required")
+        
+        self.llm = ChatAnthropic(
+            model="claude-3-7-sonnet-20250219",
+            anthropic_api_key=self.api_key,
+            temperature=0.1
+        )
+        
+        self.doc_retriever = DocumentRetriever()
+        self.web_search = WebSearchTool(debug=debug)
+        self.pdf_processor = PDFProcessor()
+        self.debug = debug
+        
+        self.memory_store = MemorySaver()
+        
+        self.conversation_threads = {}
+        
+        self.graph = self._build_graph()
     
-    tool_decision = call_llm(
-        f"""Decide which tool(s) are needed to answer this question: "{question}".
-        Available tools:
-        - Document RAG (for clinical facts)
-        - Search (for public info)
-
-        Reply in format:
-        TOOL: [Document/Search/Both/All]
+    def _build_graph(self) -> StateGraph:
+        """Build the LangGraph workflow for conversational QA"""
+        
+        workflow = StateGraph(AgentState)
+        
+        workflow.add_node("query_router", self._route_query)
+        workflow.add_node("document_search", self._perform_doc_search)
+        workflow.add_node("web_search", self._perform_web_search)
+        workflow.add_node("pdf_search", self._perform_pdf_search)
+        workflow.add_node("combine_results", self._generate_response)
+        
+        workflow.add_edge(START, "query_router")
+        workflow.add_edge("query_router", "document_search")
+        workflow.add_edge("query_router", "web_search")
+        workflow.add_edge("query_router", "pdf_search")
+        workflow.add_edge("document_search", "combine_results")
+        workflow.add_edge("web_search", "combine_results")
+        workflow.add_edge("pdf_search", "combine_results")
+        workflow.add_edge("combine_results", END)
+        
+        return workflow.compile(checkpointer=self.memory_store)
+    
+    def _route_query(self, state: AgentState) -> Dict[str, Any]:
+        """Determine which tool(s) to use for the query"""
+        
+        query = state["query"]
+        messages = state.get("messages", [])
+        
+        if self.debug:
+            print(f"[Router] Processing query with {len(messages)} existing messages")
+        
+        conversation_history = self._format_conversation_history(messages)
+        
+        routing_prompt = f"""
+        You are a medical query router. Your job is to determine whether a query about medical topics should be:
+        1. Answered using document search (for specific patient data or medical transcript information)
+        2. Answered using web search (for general medical knowledge)
+        3. Answered using PDF search (for detailed medical protocol or research documents)
+        
+        Consider the conversation history and the current query when making your decision.
+        
+        Conversation history:
+        {conversation_history}
+        
+        Current query: {query}
+        
+        Respond with one or more of: "document", "web", "pdf"
         """
-    )
+        
+        route = self.llm.invoke(routing_prompt).content.strip().lower()
+        
+        if self.debug:
+            print(f"[Router] Decision: {route}")
+        
+        next_steps = []
+        if "document" in route:
+            next_steps.append("document_search")
+        if "web" in route:
+            next_steps.append("web_search")
+        if "pdf" in route:
+            next_steps.append("pdf_search")
+        
+        if not next_steps:  
+            next_steps = ["document_search", "web_search", "pdf_search"]
+            
+        return {"next": next_steps}
     
-    logger.debug(f"Tool decision raw response: '{tool_decision}'")
+    def _perform_doc_search(self, state: AgentState) -> Dict[str, Any]:
+        """Perform document search and return results"""
+        query = state["query"]
+        if self.debug:
+            print(f"[Document Search] Searching for: {query}")
+        results = self.doc_retriever.query(query)
+        
+        return {"csv_results": results}
     
-    use_document = "document" in tool_decision.lower()
-    use_search = "search" in tool_decision.lower()
+    def _perform_web_search(self, state: AgentState) -> Dict[str, Any]:
+        """Perform web search and return results"""
+        query = state["query"]
+        if self.debug:
+            print(f"[Web Search] Searching for: {query}")
+        results = self.web_search.search(query)
+        
+        return {"web_results": results}
     
-    logger.debug(f"Parsed decision - Use Document: {use_document}, Use Search: {use_search}")
+    def _perform_pdf_search(self, state: AgentState) -> Dict[str, Any]:
+        """Perform PDF search and return results"""
+        query = state["query"]
+        if self.debug:
+            print(f"[PDF Search] Searching for: {query}")
+        results = self.pdf_processor.search(query)
+        
+        return {"pdf_results": results}
+    
+    def _generate_response(self, state: AgentState) -> Dict[str, Any]:
+        """Generate a response based on search results and conversation history"""
+        query = state["query"]
+        messages = state.get("messages", [])
+        
+        if self.debug:
+            print(f"[Generate Response] Processing with {len(messages)} messages in history")
+        
+        csv_results = state.get("csv_results", "No document results available")
+        web_results = state.get("web_results", "No web results available")
+        pdf_results = state.get("pdf_results", "No PDF results available")
+        
+        conversation_history = self._format_conversation_history(messages)
+        
+        response_prompt = f"""
+        You are a helpful medical assistant answering questions about medical transcripts and general medical knowledge.
+        You have access to three types of information sources: medical transcripts (CSV), web search results, and PDF documents.
+        
+        Conversation history:
+        {conversation_history}
+        
+        Current query: {query}
+        
+        Document search results: {csv_results}
+        
+        Web search results: {web_results}
+        
+        PDF search results: {pdf_results}
+        
+        Based on all available information and your medical knowledge, provide a helpful, accurate, and compassionate response to the query.
+        Make sure to consider the conversation history for context and continuity.
+        When citing information, clearly indicate the source (Document, Web, or PDF).
+        """
+        
+        response = self.llm.invoke(response_prompt).content
+        
+        updated_messages = messages + [
+            HumanMessage(content=query),
+            AIMessage(content=response)
+        ]
+        
+        if self.debug:
+            print(f"[Generate Response] History now has {len(updated_messages)} messages")
+        
+        return {
+            "response": response,
+            "messages": updated_messages
+        }
     
-    results = []
+    def _format_conversation_history(self, messages: List) -> str:
+        """Format conversation history for inclusion in prompts"""
+        if not messages:
+            return "No previous conversation"
+        
+        formatted = []
+        for i in range(0, len(messages), 2):
+            if i < len(messages):
+                user_msg = messages[i].content if i < len(messages) else ""
+                ai_msg = messages[i+1].content if i+1 < len(messages) else ""
+                formatted.append(f"Human: {user_msg}\nAI: {ai_msg}")
+        
+        return "\n\n".join(formatted)
     
-    if use_document:
-        logger.debug("Retrieving from documents...")
-        try:
-            doc_info = retriever.query(question)
-            logger.debug(f"Document retrieval returned {len(doc_info)} characters")
-            results.append(f"Document info:\n{doc_info}")
-        except Exception as e:
-            logger.error(f"Document retrieval error: {e}")
-            results.append(f"Document retrieval error: {str(e)}")
+    def load_pdf(self, file_path: str) -> str:
+        """Load a PDF document into the agent"""
+        return self.pdf_processor.load_pdf(file_path)
     
-    if use_search:
-        logger.debug("Searching web...")
+    def chat(self, message: str, thread_id: str = "default") -> str:
+        """Process a message in a conversation thread"""
+        if thread_id in self.conversation_threads:
+            messages = self.conversation_threads[thread_id]
+            if self.debug:
+                print(f"[Chat] Retrieved {len(messages)} messages for thread {thread_id}")
+        else:
+            messages = []
+            if self.debug:
+                print(f"[Chat] Started new conversation thread {thread_id}")
+        
+        state = {
+            "query": message,
+            "messages": copy.deepcopy(messages)  
+        }
+        
+        if self.debug:
+            print(f"[Chat] Processing query with initial state containing {len(state['messages'])} messages")
+        
         try:
-            search_info = search_duckduckgo(question)
-            logger.debug(f"Search returned {len(search_info)} characters")
-            results.append(f"Search info:\n{search_info}")
+            result = self.graph.invoke(
+                state, 
+                config={"configurable": {"thread_id": thread_id}}
+            )
+            
+            updated_messages = result.get("messages", [])
+            
+            self.conversation_threads[thread_id] = copy.deepcopy(updated_messages)
+            
+            if self.debug:
+                print(f"[Chat] Updated thread {thread_id} with {len(updated_messages)} messages")
+            
+            return result["response"]
         except Exception as e:
-            logger.error(f"Search error: {e}")
-            results.append(f"Search error: {str(e)}")
-    
-    if results:
-        return "\n\n".join(results)
-    else:
-        logger.warning("No results from either tool")
-        return "Could not determine the right tool to use or both tools failed."
+            error_msg = f"Error processing message: {str(e)}"
+            print(f"[ERROR] {error_msg}")
+            return error_msg

agent_v1.py

@@ -0,0 +1,97 @@
+import anthropic
+import os
+from dotenv import load_dotenv
+from tools.search_tool import search_duckduckgo
+from tools.retriever_tool import Retriever
+
+load_dotenv()
+
+import logging
+
+logging.basicConfig(
+    level=logging.DEBUG,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[logging.FileHandler("debug.log"), logging.StreamHandler()]
+)
+
+logger = logging.getLogger(__name__)
+
+client = anthropic.Anthropic(
+    api_key=os.getenv("ANTHROPIC_API_KEY"),
+)
+# print("Anthropic API key:", os.getenv("ANTHROPIC_API_KEY"))
+
+retriever = Retriever(
+    top_k=3,
+    similarity_threshold=0.2,
+    batch_size=8 
+)
+
+def call_llm(prompt, model="claude-3-7-sonnet-20250219"):
+    response = client.messages.create(
+        model=model,
+        max_tokens=500,
+        temperature=0,
+        system="""You are an expert clinical AI assistant. You must strictly reply in ONLY one of the following formats: TOOL: [Document], TOOL: [Search], or TOOL: [Both].
+
+For questions about general medical information like recovery times, procedure durations, or standard practices, prefer TOOL: [Search].
+For questions about specific medical cases or rare conditions found in the document database, use TOOL: [Document].
+For questions that would benefit from both sources, use TOOL: [Both].
+
+Never explain, never say anything else.""",
+        messages=[
+            {"role": "user", "content": f"""Question: "{prompt}"
+
+Decide the best tool for answering it. Reply exactly with TOOL: [Document], TOOL: [Search], or TOOL: [Both]. No other text."""}
+        ]
+    )
+    return response.content[0].text
+
+def agent_respond(question):
+    logger.debug(f"Received question: {question}")
+    
+    tool_decision = call_llm(
+        f"""Decide which tool(s) are needed to answer this question: "{question}".
+        Available tools:
+        - Document RAG (for clinical facts)
+        - Search (for public info)
+
+        Reply in format:
+        TOOL: [Document/Search/Both/All]
+        """
+    )
+    
+    logger.debug(f"Tool decision raw response: '{tool_decision}'")
+    
+    use_document = "document" in tool_decision.lower()
+    use_search = "search" in tool_decision.lower()
+    
+    logger.debug(f"Parsed decision - Use Document: {use_document}, Use Search: {use_search}")
+    
+    results = []
+    
+    if use_document:
+        logger.debug("Retrieving from documents...")
+        try:
+            doc_info = retriever.query(question)
+            logger.debug(f"Document retrieval returned {len(doc_info)} characters")
+            results.append(f"Document info:\n{doc_info}")
+        except Exception as e:
+            logger.error(f"Document retrieval error: {e}")
+            results.append(f"Document retrieval error: {str(e)}")
+    
+    if use_search:
+        logger.debug("Searching web...")
+        try:
+            search_info = search_duckduckgo(question)
+            logger.debug(f"Search returned {len(search_info)} characters")
+            results.append(f"Search info:\n{search_info}")
+        except Exception as e:
+            logger.error(f"Search error: {e}")
+            results.append(f"Search error: {str(e)}")
+    
+    if results:
+        return "\n\n".join(results)
+    else:
+        logger.warning("No results from either tool")
+        return "Could not determine the right tool to use or both tools failed."

app.log

@@ -0,0 +1,81 @@
+2025-05-02 18:14:51,276 - sentence_transformers.SentenceTransformer - INFO - Use pytorch device_name: mps
+2025-05-02 18:14:51,276 - sentence_transformers.SentenceTransformer - INFO - Load pretrained SentenceTransformer: all-MiniLM-L6-v2
+2025-05-02 18:15:40,513 - sentence_transformers.SentenceTransformer - INFO - Use pytorch device_name: mps
+2025-05-02 18:15:40,514 - sentence_transformers.SentenceTransformer - INFO - Load pretrained SentenceTransformer: sentence-transformers/all-mpnet-base-v2
+2025-05-02 18:15:42,134 - __main__ - INFO - Starting Medical Transcript Q&A System...
+2025-05-02 18:15:42,134 - __main__ - INFO - API Key present: Yes
+2025-05-02 18:15:42,217 - httpx - INFO - HTTP Request: GET http://127.0.0.1:7861/gradio_api/startup-events "HTTP/1.1 200 OK"
+2025-05-02 18:15:42,218 - httpx - INFO - HTTP Request: GET https://api.gradio.app/pkg-version "HTTP/1.1 200 OK"
+2025-05-02 18:15:42,226 - httpx - INFO - HTTP Request: HEAD http://127.0.0.1:7861/ "HTTP/1.1 200 OK"
+2025-05-02 18:16:27,475 - __main__ - INFO - User message: Was any meniscus tear found in the Arthroscopic Meniscoplasty?
+
+
+2025-05-02 18:16:27,475 - __main__ - INFO - Current history length: 0
+2025-05-02 18:16:27,475 - __main__ - INFO - Current conversation ID: None
+2025-05-02 18:16:27,578 - __main__ - INFO - Processing user message: Was any meniscus tear found in the Arthroscopic Me...
+2025-05-02 18:16:27,578 - __main__ - INFO - Created new conversation with ID: f85e94c5-9bb8-43aa-8731-0fe380de9859
+2025-05-02 18:16:27,578 - __main__ - INFO - Processing message for conversation f85e94c5-9bb8-43aa-8731-0fe380de9859: Was any meniscus tear found in the Arthroscopic Meniscoplasty?
+2025-05-02 18:16:28,519 - httpx - INFO - HTTP Request: POST https://api.anthropic.com/v1/messages "HTTP/1.1 200 OK"
+2025-05-02 18:16:29,504 - primp - INFO - response: https://lite.duckduckgo.com/lite/ 200
+2025-05-02 18:16:36,709 - httpx - INFO - HTTP Request: POST https://api.anthropic.com/v1/messages "HTTP/1.1 200 OK"
+2025-05-02 18:16:36,714 - __main__ - INFO - Thread f85e94c5-9bb8-43aa-8731-0fe380de9859 now has 2 messages
+2025-05-02 18:16:53,596 - __main__ - INFO - User message: what are the usual surgeries for these
+
+2025-05-02 18:16:53,596 - __main__ - INFO - Current history length: 2
+2025-05-02 18:16:53,597 - __main__ - INFO - Current conversation ID: f85e94c5-9bb8-43aa-8731-0fe380de9859
+2025-05-02 18:16:53,648 - __main__ - INFO - Processing user message: what are the usual surgeries for these...
+2025-05-02 18:16:53,649 - __main__ - INFO - Processing message for conversation f85e94c5-9bb8-43aa-8731-0fe380de9859: what are the usual surgeries for these
+2025-05-02 18:16:55,113 - httpx - INFO - HTTP Request: POST https://api.anthropic.com/v1/messages "HTTP/1.1 200 OK"
+2025-05-02 18:16:55,959 - primp - INFO - response: https://html.duckduckgo.com/html 200
+2025-05-02 18:17:04,935 - httpx - INFO - HTTP Request: POST https://api.anthropic.com/v1/messages "HTTP/1.1 200 OK"
+2025-05-02 18:17:04,941 - __main__ - INFO - Thread f85e94c5-9bb8-43aa-8731-0fe380de9859 now has 4 messages
+2025-05-02 18:21:46,013 - sentence_transformers.SentenceTransformer - INFO - Use pytorch device_name: mps
+2025-05-02 18:21:46,014 - sentence_transformers.SentenceTransformer - INFO - Load pretrained SentenceTransformer: all-MiniLM-L6-v2
+2025-05-02 18:22:34,286 - sentence_transformers.SentenceTransformer - INFO - Use pytorch device_name: mps
+2025-05-02 18:22:34,286 - sentence_transformers.SentenceTransformer - INFO - Load pretrained SentenceTransformer: sentence-transformers/all-mpnet-base-v2
+2025-05-02 18:22:35,944 - __main__ - INFO - Starting Medical Transcript Q&A System...
+2025-05-02 18:22:35,944 - __main__ - INFO - API Key present: Yes
+2025-05-02 18:22:36,024 - httpx - INFO - HTTP Request: GET http://127.0.0.1:7861/gradio_api/startup-events "HTTP/1.1 200 OK"
+2025-05-02 18:22:36,032 - httpx - INFO - HTTP Request: HEAD http://127.0.0.1:7861/ "HTTP/1.1 200 OK"
+2025-05-02 18:22:36,069 - httpx - INFO - HTTP Request: GET https://api.gradio.app/pkg-version "HTTP/1.1 200 OK"
+2025-05-02 18:22:54,999 - __main__ - INFO - User message: What was the diagnosis for the ORIF surgery?
+2025-05-02 18:22:54,999 - __main__ - INFO - Current history length: 0
+2025-05-02 18:22:54,999 - __main__ - INFO - Current conversation ID: None
+2025-05-02 18:22:55,101 - __main__ - INFO - Processing user message: What was the diagnosis for the ORIF surgery?...
+2025-05-02 18:22:55,101 - __main__ - INFO - Created new conversation with ID: 88e3c12d-a85a-4a5a-b0ec-cfc44290fc60
+2025-05-02 18:22:55,101 - __main__ - INFO - Processing message for conversation 88e3c12d-a85a-4a5a-b0ec-cfc44290fc60: What was the diagnosis for the ORIF surgery?
+2025-05-02 18:22:56,413 - httpx - INFO - HTTP Request: POST https://api.anthropic.com/v1/messages "HTTP/1.1 200 OK"
+2025-05-02 18:22:57,290 - primp - INFO - response: https://html.duckduckgo.com/html 200
+2025-05-02 18:23:03,557 - httpx - INFO - HTTP Request: POST https://api.anthropic.com/v1/messages "HTTP/1.1 200 OK"
+2025-05-02 18:23:03,563 - __main__ - INFO - Thread 88e3c12d-a85a-4a5a-b0ec-cfc44290fc60 now has 2 messages
+2025-05-02 18:23:29,388 - __main__ - INFO - Clearing conversation history
+2025-05-02 18:23:29,389 - __main__ - INFO - Created new conversation with ID: 465ebf30-3f9c-4fea-a20f-77e2f6ee8d14
+2025-05-02 18:23:31,781 - __main__ - INFO - User message: Summarize the Knee Arthroplasty surgical procedure.
+2025-05-02 18:23:31,781 - __main__ - INFO - Current history length: 0
+2025-05-02 18:23:31,781 - __main__ - INFO - Current conversation ID: 465ebf30-3f9c-4fea-a20f-77e2f6ee8d14
+2025-05-02 18:23:31,832 - __main__ - INFO - Processing user message: Summarize the Knee Arthroplasty surgical procedure...
+2025-05-02 18:23:31,833 - __main__ - INFO - Processing message for conversation 465ebf30-3f9c-4fea-a20f-77e2f6ee8d14: Summarize the Knee Arthroplasty surgical procedure.
+2025-05-02 18:23:33,174 - httpx - INFO - HTTP Request: POST https://api.anthropic.com/v1/messages "HTTP/1.1 200 OK"
+2025-05-02 18:23:33,993 - primp - INFO - response: https://html.duckduckgo.com/html 200
+2025-05-02 18:23:47,236 - httpx - INFO - HTTP Request: POST https://api.anthropic.com/v1/messages "HTTP/1.1 200 OK"
+2025-05-02 18:23:47,243 - __main__ - INFO - Thread 465ebf30-3f9c-4fea-a20f-77e2f6ee8d14 now has 2 messages
+2025-05-02 18:24:31,630 - __main__ - INFO - Clearing conversation history
+2025-05-02 18:24:31,630 - __main__ - INFO - Created new conversation with ID: ca5bf619-2a57-426c-8dfc-74736d20c035
+2025-05-02 18:24:50,632 - __main__ - INFO - User message: What surgery was done in the Knee Arthroplasty sample?
+2025-05-02 18:24:50,632 - __main__ - INFO - Current history length: 0
+2025-05-02 18:24:50,632 - __main__ - INFO - Current conversation ID: ca5bf619-2a57-426c-8dfc-74736d20c035
+2025-05-02 18:24:50,685 - __main__ - INFO - Processing user message: What surgery was done in the Knee Arthroplasty sam...
+2025-05-02 18:24:50,685 - __main__ - INFO - Processing message for conversation ca5bf619-2a57-426c-8dfc-74736d20c035: What surgery was done in the Knee Arthroplasty sample?
+2025-05-02 18:24:51,735 - httpx - INFO - HTTP Request: POST https://api.anthropic.com/v1/messages "HTTP/1.1 200 OK"
+2025-05-02 18:24:53,046 - primp - INFO - response: https://lite.duckduckgo.com/lite/ 200
+2025-05-02 18:25:00,726 - httpx - INFO - HTTP Request: POST https://api.anthropic.com/v1/messages "HTTP/1.1 200 OK"
+2025-05-02 18:25:00,731 - __main__ - INFO - Thread ca5bf619-2a57-426c-8dfc-74736d20c035 now has 2 messages
+2025-05-02 18:25:20,720 - __main__ - INFO - User message: what is the average recovery time for this
+2025-05-02 18:25:20,720 - __main__ - INFO - Current history length: 2
+2025-05-02 18:25:20,720 - __main__ - INFO - Current conversation ID: ca5bf619-2a57-426c-8dfc-74736d20c035
+2025-05-02 18:25:20,822 - __main__ - INFO - Processing user message: what is the average recovery time for this...
+2025-05-02 18:25:20,822 - __main__ - INFO - Processing message for conversation ca5bf619-2a57-426c-8dfc-74736d20c035: what is the average recovery time for this
+2025-05-02 18:25:21,720 - httpx - INFO - HTTP Request: POST https://api.anthropic.com/v1/messages "HTTP/1.1 200 OK"
+2025-05-02 18:25:22,679 - primp - INFO - response: https://html.duckduckgo.com/html 200
+2025-05-02 18:25:29,706 - httpx - INFO - HTTP Request: POST https://api.anthropic.com/v1/messages "HTTP/1.1 200 OK"
+2025-05-02 18:25:29,711 - __main__ - INFO - Thread ca5bf619-2a57-426c-8dfc-74736d20c035 now has 4 messages

app.py

@@ -1,59 +1,173 @@
+import os
 import gradio as gr
-from agent import agent_respond
-
-def agent_interface(user_question, debug_mode=True):
-    return agent_respond(user_question)
-
-custom_css = """
-.gradio-container {
-    max-width: 1400px !important;
-    margin-left: auto;
-    margin-right: auto;
-}
-.output-box {
-    min-height: 500px !important;
-    font-size: 16px !important;
-}
-.input-box {
-    min-height: 150px !important;
-    font-size: 16px !important;
-}
-"""
-
-with gr.Blocks(css=custom_css, theme=gr.themes.Base()) as demo:
-    gr.Markdown("# Medical transcripts QA agent")
-    gr.Markdown("An agent that uses document retrieval and live web search to answer questions on medical transcripts.")
+import tempfile
+import json
+from agent import MedTranscriptAgent
+from dotenv import load_dotenv
+import logging
+
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler("app.log"),
+        logging.StreamHandler()
+    ]
+)
+logger = logging.getLogger(__name__)
+
+load_dotenv()
+
+if not os.getenv("ANTHROPIC_API_KEY"):
+    logger.error("ANTHROPIC_API_KEY not found in environment variables or .env file")
+    raise ValueError("ANTHROPIC_API_KEY is required. Please add it to your .env file.")
+
+agent = MedTranscriptAgent(debug=True)
+
+conversation_threads = {}
+
+def process_message(message, conversation_id=None, pdf_file=None):
+    if not conversation_id:
+        import uuid
+        conversation_id = str(uuid.uuid4())
+        conversation_threads[conversation_id] = True
+        logger.info(f"Created new conversation with ID: {conversation_id}")
+    
+    if pdf_file is not None:
+        temp_dir = tempfile.mkdtemp()
+        temp_path = os.path.join(temp_dir, "uploaded.pdf")
+        
+        with open(temp_path, "wb") as f:
+            f.write(pdf_file)
+        
+        pdf_id = agent.load_pdf(temp_path)
+        logger.info(f"Loaded PDF '{pdf_id}' for conversation {conversation_id}")
+    
+    logger.info(f"Processing message for conversation {conversation_id}: {message}")
+    response = agent.chat(message, thread_id=conversation_id)
+    
+    if hasattr(agent, "conversation_threads") and conversation_id in agent.conversation_threads:
+        thread_msgs = agent.conversation_threads[conversation_id]
+        logger.info(f"Thread {conversation_id} now has {len(thread_msgs)} messages")
+    
+    return response, conversation_id
+
+with gr.Blocks(title="Medical Transcript Q&A System") as demo:
+    gr.Markdown("# Medical Transcript Q&A System")
+    gr.Markdown("Ask questions about medical procedures, treatments, or general medical information.")
+    
+    conversation_id = gr.State(None)
     
     with gr.Row():
+        with gr.Column(scale=3):
+            chatbot = gr.Chatbot(
+                height=500,
+                type="messages",
+                avatar_images=("👤", "🩺"),
+                label="Conversation"
+            )
+            msg = gr.Textbox(
+                label="Your Question", 
+                placeholder="Ask a medical question...",
+                lines=3
+            )
+            
+            with gr.Row():
+                submit_btn = gr.Button("Submit", variant="primary", scale=2)
+                clear_btn = gr.Button("Clear Conversation", scale=1)
+        
         with gr.Column(scale=1):
-            user_question = gr.Textbox(
-                lines=4, 
-                placeholder="Ask a healthcare question...", 
-                elem_classes="input-box",
-                label="Question"
+            pdf_input = gr.File(
+                label="Upload PDF Document (Optional)", 
+                file_types=[".pdf"],
+                type="binary"
             )
-            debug_mode = gr.Checkbox(label="Debug Mode", value=True)
-            submit_btn = gr.Button("Submit")
-            clear_btn = gr.Button("Clear")
-        
-        with gr.Column(scale=2):
-            output = gr.Textbox(
-                lines=30, 
-                elem_classes="output-box",
-                label="Response"
+            debug_info = gr.Textbox(
+                label="Debug Info", 
+                visible=True, 
+                interactive=False,
+                lines=5
             )
     
+    def user(message, history, conv_id, pdf):
+        """Add user message to chat history"""
+        logger.info(f"User message: {message}")
+        logger.info(f"Current history length: {len(history) if history else 0}")
+        logger.info(f"Current conversation ID: {conv_id}")
+        
+        if history is None:
+            history = []
+        history.append({"role": "user", "content": message})
+        
+        return "", history, conv_id, pdf
+    
+    def bot(history, conv_id, pdf):
+        """Process user message and add bot response to chat history"""
+        if not history or len(history) == 0:
+            return history, conv_id, pdf, "Error: No message to process"
+        
+        user_message = history[-1]["content"]
+        logger.info(f"Processing user message: {user_message[:50]}...")
+        
+        try:
+            response, new_conv_id = process_message(user_message, conv_id, pdf)
+            
+            history.append({"role": "assistant", "content": response})
+            
+            thread_msg_count = 0
+            if hasattr(agent, "conversation_threads") and new_conv_id in agent.conversation_threads:
+                thread_msg_count = len(agent.conversation_threads[new_conv_id])
+            
+            debug_text = f"Conversation ID: {new_conv_id}\n"
+            debug_text += f"UI Messages: {len(history)}\n"
+            debug_text += f"Agent Thread Messages: {thread_msg_count}\n"
+            debug_text += f"PDF Uploaded: {'Yes' if pdf else 'No'}\n"
+            
+            return history, new_conv_id, None, debug_text
+        except Exception as e:
+            error_msg = str(e)
+            logger.error(f"Error processing message: {error_msg}")
+            
+            history.append({"role": "assistant", "content": f"Error: {error_msg}"})
+            return history, conv_id, None, f"Error occurred: {error_msg}"
+    
+    def clear_conversation():
+        """Clear the current conversation and start a new one"""
+        logger.info("Clearing conversation history")
+        
+        import uuid
+        new_id = str(uuid.uuid4())
+        logger.info(f"Created new conversation with ID: {new_id}")
+        
+        return new_id, gr.update(value=None), [], None, f"Started new conversation with ID: {new_id}"
+    
+    msg.submit(
+        user, 
+        [msg, chatbot, conversation_id, pdf_input], 
+        [msg, chatbot, conversation_id, pdf_input]
+    ).then(
+        bot, 
+        [chatbot, conversation_id, pdf_input], 
+        [chatbot, conversation_id, pdf_input, debug_info]
+    )
+    
     submit_btn.click(
-        fn=agent_interface,
-        inputs=[user_question, debug_mode],
-        outputs=output
+        user, 
+        [msg, chatbot, conversation_id, pdf_input], 
+        [msg, chatbot, conversation_id, pdf_input]
+    ).then(
+        bot, 
+        [chatbot, conversation_id, pdf_input], 
+        [chatbot, conversation_id, pdf_input, debug_info]
     )
     
     clear_btn.click(
-        fn=lambda: "",
-        inputs=None,
-        outputs=[user_question, output]
+        clear_conversation, 
+        None, 
+        [conversation_id, msg, chatbot, pdf_input, debug_info]
     )
 
 if __name__ == "__main__":
+    logger.info("Starting Medical Transcript Q&A System...")
+    logger.info(f"API Key present: {'Yes' if os.getenv('ANTHROPIC_API_KEY') else 'No'}")
     demo.launch()

app_v1.py

@@ -0,0 +1,59 @@
+import gradio as gr
+from agent_v1 import agent_respond
+
+def agent_interface(user_question, debug_mode=True):
+    return agent_respond(user_question)
+
+custom_css = """
+.gradio-container {
+    max-width: 1400px !important;
+    margin-left: auto;
+    margin-right: auto;
+}
+.output-box {
+    min-height: 500px !important;
+    font-size: 16px !important;
+}
+.input-box {
+    min-height: 150px !important;
+    font-size: 16px !important;
+}
+"""
+
+with gr.Blocks(css=custom_css, theme=gr.themes.Base()) as demo:
+    gr.Markdown("# Medical transcripts QA agent")
+    gr.Markdown("An agent that uses document retrieval and live web search to answer questions on medical transcripts.")
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            user_question = gr.Textbox(
+                lines=4, 
+                placeholder="Ask a healthcare question...", 
+                elem_classes="input-box",
+                label="Question"
+            )
+            debug_mode = gr.Checkbox(label="Debug Mode", value=True)
+            submit_btn = gr.Button("Submit")
+            clear_btn = gr.Button("Clear")
+        
+        with gr.Column(scale=2):
+            output = gr.Textbox(
+                lines=30, 
+                elem_classes="output-box",
+                label="Response"
+            )
+    
+    submit_btn.click(
+        fn=agent_interface,
+        inputs=[user_question, debug_mode],
+        outputs=output
+    )
+    
+    clear_btn.click(
+        fn=lambda: "",
+        inputs=None,
+        outputs=[user_question, output]
+    )
+
+if __name__ == "__main__":
+    demo.launch()

requirements.txt

@@ -7,3 +7,10 @@ sentence-transformers
 pandas
 duckduckgo_search
 gradio
+## for langraph and langchain
+langgraph>=0.0.25
+pypdf>=3.15.1
+langchain>=0.1.0
+langchain-anthropic>=0.1.0
+langchain-community>=0.0.13
+langchain-text-splitters>=0.0.1

run_agent.py

@@ -1,4 +1,4 @@
-from agent import agent_respond
+from agent_v1 import agent_respond
 
 def main():
     print("Welcome to the Healthcare Assistant!")

tools/pdf_tool.py

@@ -0,0 +1,82 @@
+import os
+from typing import List, Dict, Any, Optional
+from pypdf import PdfReader
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+from langchain_community.vectorstores import FAISS
+from langchain_community.embeddings import HuggingFaceEmbeddings
+
+
+class PDFProcessor:
+    def __init__(self, debug: bool = False):
+        self.debug = debug
+        self.pdf_docs = {}  
+        self.vector_stores = {} 
+        
+        self.embeddings = HuggingFaceEmbeddings(
+            model_name="sentence-transformers/all-mpnet-base-v2"
+        )
+    
+    def load_pdf(self, file_path: str) -> str:
+        if not os.path.exists(file_path):
+            raise FileNotFoundError(f"PDF file not found at {file_path}")
+        
+        doc_id = os.path.basename(file_path).split('.')[0]
+        
+        text = ""
+        reader = PdfReader(file_path)
+        for page in reader.pages:
+            text += page.extract_text() + "\n"
+        
+        text_splitter = RecursiveCharacterTextSplitter(
+            chunk_size=1500,
+            chunk_overlap=150
+        )
+        chunks = text_splitter.create_documents([text])
+        
+        for i, chunk in enumerate(chunks):
+            page_num = i // 3  
+            chunk.metadata["source"] = f"{doc_id}_page_{page_num}"
+        
+        self.pdf_docs[doc_id] = chunks
+        
+        vector_store = FAISS.from_documents(chunks, self.embeddings)
+        self.vector_stores[doc_id] = vector_store
+        
+        if self.debug:
+            print(f"Loaded PDF {doc_id} with {len(chunks)} chunks")
+        
+        return doc_id
+    
+    def search(self, query: str, doc_id: Optional[str] = None, k: int = 4) -> str:
+        if not self.pdf_docs:
+            return "No PDF documents have been loaded yet."
+            
+        if doc_id and doc_id not in self.pdf_docs:
+            return f"Document with ID {doc_id} not found."
+            
+        stores_to_search = [self.vector_stores[doc_id]] if doc_id else list(self.vector_stores.values())
+        
+        all_docs = []
+        for store in stores_to_search:
+            docs = store.similarity_search(query, k=min(k, len(store.index_to_docstore_id)))
+            all_docs.extend(docs)
+        
+        if len(stores_to_search) > 1:
+            all_docs = all_docs[:k]
+        
+        if not all_docs:
+            return "No relevant information found in the PDF documents."
+        
+        results = []
+        for i, doc in enumerate(all_docs):
+            source = doc.metadata.get("source", "Unknown")
+            content = doc.page_content.strip()
+            results.append(f"[PDF-{i+1}] {source}:\n{content}\n")
+        
+        formatted_results = "\n".join(results)
+        
+        if self.debug:
+            print(f"PDF search results for query '{query}':")
+            print(formatted_results)
+        
+        return formatted_results

tools/retriever_tool.py

@@ -7,7 +7,7 @@ import os
 import time
 from sentence_transformers import SentenceTransformer
 
-class Retriever:
+class DocumentRetriever:
     def __init__(self, csv_path="data/mtsamples_surgery.csv", top_k=3, similarity_threshold=0.2, batch_size=8):
         self.model = SentenceTransformer('all-MiniLM-L6-v2')
         self.dimension = self.model.get_sentence_embedding_dimension()
@@ -77,7 +77,6 @@ class Retriever:
         if new_metadata:
             self.metadata.extend(new_metadata)
         
-        # Encode and add to index
         for i in range(0, len(processed_texts), self.batch_size):
             batch = processed_texts[i:i+min(self.batch_size, len(processed_texts)-i)]
             batch_embeddings = self.model.encode(batch, show_progress_bar=False)

tools/search_tool.py

@@ -1,16 +1,27 @@
 from duckduckgo_search import DDGS
 
 
-def search_duckduckgo(query, max_results=3):
-    """Perform a DuckDuckGo search for the given query."""
-    results = []
-    try:
-        with DDGS() as ddgs:
-            for r in ddgs.text(query, max_results=max_results):
-                results.append(f"Title: {r.get('title', 'No title')}\nSource: {r.get('href', 'No source')}\n{r['body']}")
-        if results:
-            return "\n\n".join(results)
-        else:
-            return "No relevant information found."
-    except Exception as e:
-        return f"Search error: {str(e)}"
+class WebSearchTool:
+    
+    def __init__(self, debug=False):
+        self.debug = debug
+
+    def search_duckduckgo(self, query, max_results=3):
+
+        results = []
+        try:
+            with DDGS() as ddgs:
+                for r in ddgs.text(query, max_results=max_results):
+                    results.append(f"Title: {r.get('title', 'No title')}\nSource: {r.get('href', 'No source')}\n{r['body']}")
+            if results:
+                return "\n\n".join(results)
+            else:
+                return "No relevant information found."
+        except Exception as e:
+            return f"Search error: {str(e)}"
+    
+    def search(self, query, max_results=3):
+        """Interface method that matches the expected API in agent.py"""
+        if self.debug:
+            print(f"Searching for: {query}")
+        return self.search_duckduckgo(query, max_results)