feat: Introduce Gradio UI for interactive query and expiry sweep, add a multi-server MCP client, and simplify app startup to directly launch Gradio.

app.py

@@ -1,39 +1,10 @@
-import os
 import sys
-import asyncio
-from fastapi import FastAPI
-import gradio as gr
-import uvicorn
+import os
 
 # Add src to path so we can import the package
 sys.path.append(os.path.join(os.path.dirname(__file__), "src"))
 
-from credentialwatch_agent.main import demo, mcp_client
-
-from contextlib import asynccontextmanager
-
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    """Manage application lifespan."""
-    print("Connecting to MCP servers...")
-    try:
-        await mcp_client.connect()
-    except Exception as e:
-        print(f"Error connecting to MCP servers: {e}")
-    
-    yield
-    
-    print("Closing MCP connections...")
-    await mcp_client.close()
-
-# Create FastAPI app with lifespan
-app = FastAPI(lifespan=lifespan)
-
-# Mount Gradio app
-# path="/" mounts it at the root
-app = gr.mount_gradio_app(app, demo, path="/")
+from credentialwatch_agent.main import demo
 
 if __name__ == "__main__":
-    # Run with uvicorn
-    # This ensures everything runs on the same async loop
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+    demo.launch()

pyproject.toml

@@ -11,9 +11,7 @@ dependencies = [
     "mcp>=0.1.0",
     "gradio[mcp]>=6.0.1",
     "python-dotenv>=1.0.0",
-    "httpx>=0.25.0",
-    "fastapi>=0.100.0",
-    "uvicorn>=0.20.0"
+    "httpx>=0.25.0"
 ]
 
 [build-system]

src/credentialwatch_agent/main.py

@@ -16,6 +16,7 @@ async def run_expiry_sweep(window_days: int = 90) -> Dict[str, Any]:
     """
     Runs the expiry sweep workflow.
     """
+    await mcp_client.connect()
     print(f"Starting expiry sweep for {window_days} days...")
     # Initialize state
     initial_state = {
@@ -45,6 +46,7 @@ async def run_chat_turn(message: str, history: List[List[str]]) -> str:
     """
     Runs a turn of the interactive query agent.
     """
+    await mcp_client.connect()
     # Convert history to LangChain format
     messages = []
     for item in history:

src/credentialwatch_agent/mcp_client.py

@@ -20,43 +20,48 @@ class MCPClient:
         
         self._exit_stack = AsyncExitStack()
         self._sessions: Dict[str, ClientSession] = {}
+        self._connected = False
+        self._connect_lock = asyncio.Lock()
 
     async def connect(self):
-        """Establishes connections to all MCP servers."""
-        # In a real app, we might want to connect lazily or in parallel.
-        # For simplicity, we'll try to connect to all.
-        
-        # Connect to NPI MCP
-        try:
-            # Note: mcp.client.sse.sse_client is a context manager that yields (read_stream, write_stream)
-            # We need to keep the context open.
-            npi_transport = await self._exit_stack.enter_async_context(sse_client(self.npi_url))
-            self._sessions["npi"] = await self._exit_stack.enter_async_context(
-                ClientSession(npi_transport[0], npi_transport[1])
-            )
-            await self._sessions["npi"].initialize()
-        except Exception as e:
-            print(f"Warning: Failed to connect to NPI MCP at {self.npi_url}. Using mock data. Error: {e}")
+        """Establishes connections to all MCP servers. Idempotent."""
+        async with self._connect_lock:
+            if self._connected:
+                return
+
+            # Connect to NPI MCP
+            try:
+                # Note: mcp.client.sse.sse_client is a context manager that yields (read_stream, write_stream)
+                # We need to keep the context open.
+                npi_transport = await self._exit_stack.enter_async_context(sse_client(self.npi_url))
+                self._sessions["npi"] = await self._exit_stack.enter_async_context(
+                    ClientSession(npi_transport[0], npi_transport[1])
+                )
+                await self._sessions["npi"].initialize()
+            except Exception as e:
+                print(f"Warning: Failed to connect to NPI MCP at {self.npi_url}. Using mock data. Error: {e}")
 
-        # Connect to Cred DB MCP
-        try:
-            cred_transport = await self._exit_stack.enter_async_context(sse_client(self.cred_db_url))
-            self._sessions["cred_db"] = await self._exit_stack.enter_async_context(
-                ClientSession(cred_transport[0], cred_transport[1])
-            )
-            await self._sessions["cred_db"].initialize()
-        except Exception as e:
-            print(f"Warning: Failed to connect to Cred DB MCP at {self.cred_db_url}. Using mock data. Error: {e}")
+            # Connect to Cred DB MCP
+            try:
+                cred_transport = await self._exit_stack.enter_async_context(sse_client(self.cred_db_url))
+                self._sessions["cred_db"] = await self._exit_stack.enter_async_context(
+                    ClientSession(cred_transport[0], cred_transport[1])
+                )
+                await self._sessions["cred_db"].initialize()
+            except Exception as e:
+                print(f"Warning: Failed to connect to Cred DB MCP at {self.cred_db_url}. Using mock data. Error: {e}")
 
-        # Connect to Alert MCP
-        try:
-            alert_transport = await self._exit_stack.enter_async_context(sse_client(self.alert_url))
-            self._sessions["alert"] = await self._exit_stack.enter_async_context(
-                ClientSession(alert_transport[0], alert_transport[1])
-            )
-            await self._sessions["alert"].initialize()
-        except Exception as e:
-            print(f"Warning: Failed to connect to Alert MCP at {self.alert_url}. Using mock data. Error: {e}")
+            # Connect to Alert MCP
+            try:
+                alert_transport = await self._exit_stack.enter_async_context(sse_client(self.alert_url))
+                self._sessions["alert"] = await self._exit_stack.enter_async_context(
+                    ClientSession(alert_transport[0], alert_transport[1])
+                )
+                await self._sessions["alert"].initialize()
+            except Exception as e:
+                print(f"Warning: Failed to connect to Alert MCP at {self.alert_url}. Using mock data. Error: {e}")
+            
+            self._connected = True
 
     async def close(self):
         """Closes all connections."""