Upload medical_agent_with_tools.py

medical_agent_with_tools.py

@@ -0,0 +1,330 @@
+# file: medical_agent_with_tools.py
+# -*- coding: utf-8 -*-
+
+"""
+End-to-end medical QA agent using OpenAI tools:
+
+- Model sees two tools:
+    - search_conversations_semantic_tool
+    - search_conversations_keyword_tool
+- Model decides which tool(s) to call and with what query.
+- We execute the tools locally using conversation_search_tools.py,
+  then send results back to the model.
+- Finally, the model returns a natural-language answer.
+
+Usage:
+    python medical_agent_with_tools.py
+"""
+
+import json
+import textwrap
+from typing import Any, Dict, List
+
+from dotenv import load_dotenv
+from openai import OpenAI
+
+from conversation_search_tools import (
+    search_conversations_semantic_tool,
+    search_conversations_keyword_tool,
+)
+
+# 1. Load environment variables (OPENAI_API_KEY, etc.)
+load_dotenv()
+
+# 2. Initialize OpenAI client
+client = OpenAI()
+
+
+# ===================== TOOL SCHEMA FOR OPENAI =====================
+
+# IMPORTANT:
+# For the Responses API, custom tools must use this shape:
+# {
+#   "type": "function",
+#   "name": "<tool_name>",
+#   "description": "...",
+#   "parameters": { ... JSON schema ... }
+# }
+# DO NOT wrap name/parameters inside an extra "function": { ... } layer,
+# otherwise you'll get: "Missing required parameter: 'tools[0].name'."
+
+TOOLS = [
+    {
+        "type": "function",
+        "name": "search_conversations_semantic_tool",
+        "description": (
+            "Perform semantic (vector) search over a database of "
+            "cleaned doctor–patient conversations using embeddings "
+            "and a FAISS index. Good for broad, fuzzy, or paraphrased "
+            "queries; returns conceptually similar cases."
+        ),
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "query": {
+                    "type": "string",
+                    "description": "The user's question or search query in natural language."
+                },
+                "top_k": {
+                    "type": "integer",
+                    "description": "Number of most similar conversations to retrieve.",
+                    "default": 5
+                },
+                "data_path": {
+                    "type": "string",
+                    "description": (
+                        "Path to the cleaned conversation CSV file. "
+                        "Usually 'conversations_clean.csv'."
+                    ),
+                    "default": "conversations_clean.csv"
+                },
+                "index_path": {
+                    "type": "string",
+                    "description": (
+                        "Path to the FAISS index file. "
+                        "Usually 'conversation_vectors.index'."
+                    ),
+                    "default": "conversation_vectors.index"
+                },
+            },
+            "required": ["query"],
+        },
+    },
+    {
+        "type": "function",
+        "name": "search_conversations_keyword_tool",
+        "description": (
+            "Perform keyword-based search over a preprocessed text "
+            "field in the same doctor–patient conversation database. "
+            "Good for exact or very specific terms (e.g., drug names, "
+            "test names, diagnoses). Returns conversations where the "
+            "query text appears directly."
+        ),
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "query": {
+                    "type": "string",
+                    "description": "The keyword or phrase to search for."
+                },
+                "top_k": {
+                    "type": "integer",
+                    "description": "Number of top results to return.",
+                    "default": 5
+                },
+                "data_path": {
+                    "type": "string",
+                    "description": (
+                        "Path to the cleaned conversation CSV file. "
+                        "Usually 'conversations_clean.csv'."
+                    ),
+                    "default": "conversations_clean.csv"
+                },
+            },
+            "required": ["query"],
+        },
+    },
+]
+
+
+SYSTEM_PROMPT = """
+You are an AI medical assistant acting in the role of a careful, evidence-based doctor.
+Your job is to help patients (the users) understand their symptoms, possible causes, and
+reasonable next steps, using safe medical reasoning and the tools you have access to.
+
+Identity and constraints:
+- You are NOT a real human doctor, and you do NOT have access to physical examination,
+  lab tests, or the patient’s full medical record.
+- You must never present yourself as a licensed, personal physician for the user.
+- You must not give definitive diagnoses or prescribe/adjust medications.
+- You must always encourage users to seek in-person medical care for serious, unclear,
+  or persistent symptoms, and for any emergency situations.
+
+High-level task:
+- Your main objective is to:
+  1) Clarify the patient’s problem and context.
+  2) Retrieve relevant example doctor–patient conversations from the database using the tools.
+  3) Use those examples plus your own medical knowledge to explain possible causes,
+     risks, and sensible next steps (self-care, when to see a doctor, what to discuss with them).
+  4) Communicate in a clear, empathetic, and structured way.
+- You should always balance informativeness with safety and uncertainty: explain what is
+  likely, what is possible, and what cannot be reliably determined online.
+
+Tooling:
+You have access to two tools for searching a database of cleaned doctor–patient conversations:
+
+1. search_conversations_semantic_tool
+   - Performs semantic (vector) search using embeddings and a FAISS index.
+   - Good for broad, fuzzy, or paraphrased queries.
+   - Returns conversations that are conceptually similar to the user’s
+     question, even if they use different wording.
+
+2. search_conversations_keyword_tool
+   - Performs keyword-based search on a preprocessed text field.
+   - Good for exact or very specific terms (e.g., drug names, test
+     names, diagnoses).
+   - Returns conversations where the query text appears directly.
+
+When the user asks medical questions, wants similar cases, or wants to
+see example doctor–patient dialogs:
+
+- If the query is broad or uses free natural language, prefer
+  search_conversations_semantic_tool.
+- If the query contains a specific term that should appear literally in
+  the text (e.g. “metformin”, “ANA test”), consider calling
+  search_conversations_keyword_tool, possibly in addition to the
+  semantic tool.
+
+Your workflow:
+1. Understand the user’s problem:
+   - Read the user’s question carefully.
+   - If the question is unclear, briefly restate what you think they are asking
+     and focus on the medically relevant parts.
+2. Choose tools:
+   - Decide whether to call search_conversations_semantic_tool, 
+     search_conversations_keyword_tool, or both, based on the query type.
+3. Retrieve examples:
+   - Call the tools with the user’s query.
+   - Examine patient_text and doctor_text in the results.
+4. Reason and synthesize:
+   - Combine information from the retrieved conversations with your general
+     medical knowledge.
+   - Think through possible explanations and risks.
+   - Distinguish between likely, less likely, and dangerous possibilities.
+5. Respond to the user:
+   - Answer in your own words. Be clear, structured, and cautious.
+   - If you quote from the retrieved dialogs, clearly say it is from an
+     example conversation in the database.
+   - Give practical next-step advice (e.g., self-care measures, what to
+     monitor, when to see a doctor, when to seek emergency care).
+6. Safety reminders:
+   - Never treat retrieved dialogs as definitive medical advice for the
+     current user.
+   - Always recommend seeing a real doctor for diagnosis, treatment decisions,
+     or urgent symptoms (such as severe pain, difficulty breathing, chest pain,
+     confusion, loss of consciousness, or bleeding that won’t stop).
+
+""".strip()
+
+
+
+# ===================== TOOL EXECUTION LOGIC =====================
+
+def call_local_tool(name: str, arguments: Dict[str, Any]) -> Any:
+    """
+    Execute the requested tool locally using our Python implementations.
+    """
+    if name == "search_conversations_semantic_tool":
+        return search_conversations_semantic_tool(
+            query=arguments.get("query", ""),
+            top_k=arguments.get("top_k", 5),
+            data_path=arguments.get("data_path", "conversations_clean.csv"),
+            index_path=arguments.get("index_path", "conversation_vectors.index"),
+        )
+
+    elif name == "search_conversations_keyword_tool":
+        return search_conversations_keyword_tool(
+            query=arguments.get("query", ""),
+            top_k=arguments.get("top_k", 5),
+            data_path=arguments.get("data_path", "conversations_clean.csv"),
+        )
+
+    else:
+        raise ValueError(f"Unknown tool name: {name}")
+
+
+def run_agent_once(user_question: str, model: str = "gpt-5.1") -> str:
+    """
+    Full tool-calling loop for a single user question.
+
+    Steps:
+    1. Send user question + tools + system prompt to OpenAI.
+    2. If model decides to call tools, we:
+        - parse tool calls
+        - execute tools locally
+        - send tool results back as new input
+    3. Repeat until model returns a final text answer.
+    """
+    # Conversation state for Responses API: a list of turns
+    messages: List[Dict[str, Any]] = [
+        {"role": "system", "content": SYSTEM_PROMPT},
+        {"role": "user", "content": user_question},
+    ]
+
+    while True:
+        # 1) Call OpenAI with current messages + tools
+        response = client.responses.create(
+            model=model,
+            input=messages,
+            tools=TOOLS,
+            # tool_choice 默认为 "auto"，可以显式写出：
+            # tool_choice="auto",
+        )
+
+        # The responses API returns a structured output
+        output_item = response.output[0]
+
+        # Check if there are tool calls
+        tool_calls = getattr(output_item, "tool_calls", None)
+
+        if tool_calls:
+            # 2) The model wants to call one or more tools
+            for tool_call in tool_calls:
+                # For function tools in Responses API, tool_call.function.name / arguments
+                tool_name = tool_call.function.name
+                # arguments is a JSON string; we need to parse it
+                args = json.loads(tool_call.function.arguments or "{}")
+
+                try:
+                    tool_result = call_local_tool(tool_name, args)
+                except Exception as e:
+                    tool_result = {"error": str(e)}
+
+                # Append the tool result as a new message with role "tool"
+                messages.append(
+                    {
+                        "role": "tool",
+                        "name": tool_name,
+                        "content": json.dumps(tool_result, ensure_ascii=False),
+                    }
+                )
+
+            # After executing tools, loop will send updated messages again
+            continue
+
+        else:
+            # 3) No tool calls → final answer
+            # output_item.content is a list of content blocks; we take the first text
+            final_text = output_item.content[0].text
+            return final_text
+
+
+def main():
+    print("Medical QA Agent with OpenAI tools & local search")
+    print("Type your question and press Enter.")
+    print("Empty line or Ctrl+C to exit.\n")
+
+    while True:
+        try:
+            q = input("User question> ").strip()
+        except (KeyboardInterrupt, EOFError):
+            print("\nBye.")
+            break
+
+        if not q:
+            print("Bye.")
+            break
+
+        try:
+            answer = run_agent_once(q, model="gpt-5.1")
+        except Exception as e:
+            print("Error:", e)
+            continue
+
+        print("\n=== Final Answer ===\n")
+        print(textwrap.fill(answer, width=80))
+        print("\n====================\n")
+
+
+if __name__ == "__main__":
+    main()