feat: enhance Gradio UI with MCP server support and new tool interfaces

- Updated the Gradio app to include support for the MCP server, enabling integration with Claude Desktop.
- Added new interfaces for PubMed, Clinical Trials, bioRxiv, and a comprehensive search tool, enhancing the research capabilities.
- Modified the demo creation function to reflect these updates and ensure a seamless user experience.

Files modified:
- src/app.py

README.md

@@ -30,11 +30,35 @@ uv sync
 
 ```bash
 # Start the Gradio app
-uv run python -m src.app
+uv run python src/app.py
 ```
 
 Open your browser to `http://localhost:7860`.
 
+### 3. Connect via MCP
+
+This application exposes a Model Context Protocol (MCP) server, allowing you to use its search tools directly from Claude Desktop or other MCP clients.
+
+**MCP Server URL**: `http://localhost:7860/gradio_api/mcp/`
+
+**Claude Desktop Configuration**:
+Add this to your `claude_desktop_config.json`:
+```json
+{
+  "mcpServers": {
+    "deepcritical": {
+      "url": "http://localhost:7860/gradio_api/mcp/"
+    }
+  }
+}
+```
+
+**Available Tools**:
+- `search_pubmed`: Search peer-reviewed biomedical literature.
+- `search_clinical_trials`: Search ClinicalTrials.gov.
+- `search_biorxiv`: Search bioRxiv/medRxiv preprints.
+- `search_all`: Search all sources simultaneously.
+
 ## Development
 
 ### Run Tests
@@ -53,13 +77,12 @@ make check
 
 DeepCritical uses a Vertical Slice Architecture:
 
-1.  **Search Slice**: Retrieving evidence from PubMed and the Web.
+1.  **Search Slice**: Retrieving evidence from PubMed, ClinicalTrials.gov, and bioRxiv.
 2.  **Judge Slice**: Evaluating evidence quality using LLMs.
 3.  **Orchestrator Slice**: Managing the research loop and UI.
 
 Built with:
 - **PydanticAI**: For robust agent interactions.
 - **Gradio**: For the streaming user interface.
-- **PubMed**: For biomedical literature.
-- **DuckDuckGo**: For general web search.
-
+- **PubMed, ClinicalTrials.gov, bioRxiv**: For biomedical data.
+- **MCP**: For universal tool access.

src/app.py

@@ -1,4 +1,4 @@
-"""Gradio UI for DeepCritical agent."""
+"""Gradio UI for DeepCritical agent with MCP server support."""
 
 import os
 from collections.abc import AsyncGenerator
@@ -7,6 +7,12 @@ from typing import Any
 import gradio as gr
 
 from src.agent_factory.judges import JudgeHandler, MockJudgeHandler
+from src.mcp_tools import (
+    search_all_sources,
+    search_biorxiv,
+    search_clinical_trials,
+    search_pubmed,
+)
 from src.orchestrator_factory import create_orchestrator
 from src.tools.biorxiv import BioRxivTool
 from src.tools.clinicaltrials import ClinicalTrialsTool
@@ -115,10 +121,10 @@ async def research_agent(
 
 def create_demo() -> Any:
     """
-    Create the Gradio demo interface.
+    Create the Gradio demo interface with MCP support.
 
     Returns:
-        Configured Gradio Blocks interface
+        Configured Gradio Blocks interface with MCP server enabled
     """
     with gr.Blocks(
         title="DeepCritical - Drug Repurposing Research Agent",
@@ -137,9 +143,10 @@ def create_demo() -> Any:
         - "What existing medications show promise for Long COVID?"
         """)
 
+        # Main chat interface (existing)
         gr.ChatInterface(
             fn=research_agent,
-            type="messages",
+            type="messages",  # type: ignore
             title="",
             examples=[
                 "What drugs could be repurposed for Alzheimer's disease?",
@@ -157,24 +164,74 @@ def create_demo() -> Any:
             ],
         )
 
+        # MCP Tool Interfaces (exposed via MCP protocol)
+        gr.Markdown("---\n## MCP Tools (Also Available via Claude Desktop)")
+
+        with gr.Tab("PubMed Search"):
+            gr.Interface(
+                fn=search_pubmed,
+                inputs=[
+                    gr.Textbox(label="Query", placeholder="metformin alzheimer"),
+                    gr.Slider(1, 50, value=10, step=1, label="Max Results"),
+                ],
+                outputs=gr.Markdown(label="Results"),
+                api_name="search_pubmed",
+            )
+
+        with gr.Tab("Clinical Trials"):
+            gr.Interface(
+                fn=search_clinical_trials,
+                inputs=[
+                    gr.Textbox(label="Query", placeholder="diabetes phase 3"),
+                    gr.Slider(1, 50, value=10, step=1, label="Max Results"),
+                ],
+                outputs=gr.Markdown(label="Results"),
+                api_name="search_clinical_trials",
+            )
+
+        with gr.Tab("Preprints"):
+            gr.Interface(
+                fn=search_biorxiv,
+                inputs=[
+                    gr.Textbox(label="Query", placeholder="long covid treatment"),
+                    gr.Slider(1, 50, value=10, step=1, label="Max Results"),
+                ],
+                outputs=gr.Markdown(label="Results"),
+                api_name="search_biorxiv",
+            )
+
+        with gr.Tab("Search All"):
+            gr.Interface(
+                fn=search_all_sources,
+                inputs=[
+                    gr.Textbox(label="Query", placeholder="metformin cancer"),
+                    gr.Slider(1, 20, value=5, step=1, label="Max Per Source"),
+                ],
+                outputs=gr.Markdown(label="Results"),
+                api_name="search_all",
+            )
+
         gr.Markdown("""
         ---
         **Note**: This is a research tool and should not be used for medical decisions.
         Always consult healthcare professionals for medical advice.
 
-        Built with 🤖 PydanticAI + 🔬 PubMed, ClinicalTrials.gov & bioRxiv
+        Built with PydanticAI + PubMed, ClinicalTrials.gov & bioRxiv
+
+        **MCP Server**: Available at `/gradio_api/mcp/` for Claude Desktop integration
         """)
 
     return demo
 
 
 def main() -> None:
-    """Run the Gradio app."""
+    """Run the Gradio app with MCP server enabled."""
     demo = create_demo()
     demo.launch(
         server_name="0.0.0.0",
         server_port=7860,
         share=False,
+        mcp_server=True,  # Enable MCP server
     )
 
 

tests/integration/test_mcp_server.py

@@ -0,0 +1,24 @@
+"""Integration tests for MCP server functionality."""
+
+import pytest
+
+
+class TestMCPServerIntegration:
+    """Integration tests for MCP server (requires running app)."""
+
+    @pytest.mark.integration
+    @pytest.mark.asyncio
+    async def test_mcp_tools_work_end_to_end(self) -> None:
+        """Test that MCP tools execute real searches."""
+        from src.mcp_tools import search_pubmed
+
+        result = await search_pubmed("metformin diabetes", 3)
+
+        assert isinstance(result, str)
+        assert "PubMed Results" in result
+        # Should have actual content (not just "no results")
+        # Typical queries should return something.
+        # The wrapper returns "No PubMed results found" string if empty.
+
+        if "No PubMed results found" not in result:
+            assert len(result) > 10

tests/unit/test_mcp_tools.py

@@ -184,17 +184,17 @@ class TestMCPTypeHints:
         sig = inspect.signature(search_pubmed)
 
         # Check parameter hints
-        assert sig.parameters["query"].annotation == str
-        assert sig.parameters["max_results"].annotation == int
+        assert sig.parameters["query"].annotation is str
+        assert sig.parameters["max_results"].annotation is int
 
         # Check return hint
-        assert sig.return_annotation == str
+        assert sig.return_annotation is str
 
     def test_search_clinical_trials_type_hints(self) -> None:
         """All parameters and return must have type hints."""
         import inspect
 
         sig = inspect.signature(search_clinical_trials)
-        assert sig.parameters["query"].annotation == str
-        assert sig.parameters["max_results"].annotation == int
-        assert sig.return_annotation == str
+        assert sig.parameters["query"].annotation is str
+        assert sig.parameters["max_results"].annotation is int
+        assert sig.return_annotation is str