feat: implement Ticket MCP integration with FastMCP client and add REST endpoints for ticket management

Signed-off-by: Andre Bossard <anbossar@microsoft.com>

Author: abossard

backend/agents.py

@@ -41,15 +41,12 @@
 
 # Local - Import operations registry for automatic tool discovery
 from api_decorators import get_langchain_tools
-
 # Third-party - FastMCP client for external MCP servers
 from fastmcp import Client as MCPClient
 from langchain_core.tools import StructuredTool
-
 # Third-party - LangChain and LangGraph
 from langchain_openai import AzureChatOpenAI
 from langgraph.prebuilt import create_react_agent
-
 # Third-party - Pydantic for validation
 from pydantic import BaseModel, Field, create_model, field_validator
 
@@ -143,8 +140,8 @@ class AgentResponse(BaseModel):
 AZURE_OPENAI_DEPLOYMENT = "gpt-5-mini"
 AZURE_OPENAI_API_VERSION = "2025-04-01-preview"
 
-# External MCP server URL (hardcoded)
-MCP_SERVER_URL = "https://yodrrscbpxqnslgugwow.supabase.co/functions/v1/mcp"
+# External MCP server URL for ticket management (hardcoded)
+TICKET_MCP_SERVER_URL = "https://yodrrscbpxqnslgugwow.supabase.co/functions/v1/mcp/a7f2b8c4-d3e9-4f1a-b5c6-e8d9f0123456"
 
 
 # ============================================================================
@@ -262,48 +259,48 @@ def __init__(self):
         # These are the actual Python functions decorated with @tool
         self.tools = get_langchain_tools()
 
-        # MCP client state (lazy initialization)
-        self._mcp_client: Optional[MCPClient] = None
-        self._mcp_tools_loaded = False
+        # Ticket MCP client state (lazy initialization)
+        self._ticket_mcp_client: Optional[MCPClient] = None
+        self._ticket_mcp_tools_loaded = False
 
-    async def _ensure_mcp_connection(self):
+    async def _ensure_ticket_mcp_connection(self):
         """
-        Ensure MCP client is connected and tools are loaded.
+        Ensure ticket MCP client is connected and tools are loaded.
         
-        Opens a persistent connection to the external MCP server and
+        Opens a persistent connection to the external ticket MCP server and
         converts its tools to LangChain format. Called lazily on first
         agent run.
         """
-        if self._mcp_tools_loaded:
+        if self._ticket_mcp_tools_loaded:
             return
 
         try:
-            # Create and connect MCP client (keep connection open)
-            client = MCPClient(MCP_SERVER_URL)
+            # Create and connect ticket MCP client (keep connection open)
+            client = MCPClient(TICKET_MCP_SERVER_URL)
             await client.__aenter__()
-            self._mcp_client = client
+            self._ticket_mcp_client = client
 
-            # Fetch and convert MCP tools
+            # Fetch and convert ticket MCP tools
             mcp_tools = await client.list_tools()
             for tool in mcp_tools:
                 lc_tool = _mcp_tool_to_langchain(client, tool)
                 self.tools.append(lc_tool)
 
-            print(f"DEBUG: Loaded {len(mcp_tools)} tools from MCP server {MCP_SERVER_URL}")
-            self._mcp_tools_loaded = True
+            print(f"DEBUG: Loaded {len(mcp_tools)} ticket tools from MCP server {TICKET_MCP_SERVER_URL}")
+            self._ticket_mcp_tools_loaded = True
 
         except Exception as e:
-            print(f"WARNING: Failed to load MCP tools from {MCP_SERVER_URL}: {e}")
-            # Continue without MCP tools - local tools still work
+            print(f"WARNING: Failed to load ticket MCP tools from {TICKET_MCP_SERVER_URL}: {e}")
+            # Continue without ticket MCP tools - local tools still work
 
     async def close(self):
-        """Close the MCP client connection."""
-        if self._mcp_client:
+        """Close the ticket MCP client connection."""
+        if self._ticket_mcp_client:
             try:
-                await self._mcp_client.__aexit__(None, None, None)
+                await self._ticket_mcp_client.__aexit__(None, None, None)
             except Exception:
                 pass
-            self._mcp_client = None
+            self._ticket_mcp_client = None
 
     async def run_agent(self, request: AgentRequest) -> AgentResponse:
         """
@@ -329,8 +326,8 @@ async def run_agent(self, request: AgentRequest) -> AgentResponse:
         Raises:
             ValueError: If agent execution fails
         """
-        # Ensure MCP tools are loaded (lazy initialization)
-        await self._ensure_mcp_connection()
+        # Ensure ticket MCP tools are loaded (lazy initialization)
+        await self._ensure_ticket_mcp_connection()
 
         try:
             # Create ReAct agent with LangGraph tools

backend/app.py

@@ -29,14 +29,20 @@
 
 # Import unified operation system
 from api_decorators import operation
-from mcp import handle_mcp_request
-from ollama_service import ChatRequest, ChatResponse, ModelListResponse, OllamaService
+# FastMCP client for direct ticket MCP calls (no AI)
+from fastmcp import Client as MCPClient
+
+# Ticket MCP server URL (same as in agents.py)
+TICKET_MCP_SERVER_URL = "https://yodrrscbpxqnslgugwow.supabase.co/functions/v1/mcp/a7f2b8c4-d3e9-4f1a-b5c6-e8d9f0123456"
+from mcp_handler import handle_mcp_request
+from ollama_service import (ChatRequest, ChatResponse, ModelListResponse,
+                            OllamaService)
 from pydantic import ValidationError
 from quart import Quart, jsonify, request, send_from_directory
 from quart_cors import cors
-
 # Import Pydantic models and service
-from tasks import Task, TaskCreate, TaskFilter, TaskService, TaskStats, TaskUpdate
+from tasks import (Task, TaskCreate, TaskFilter, TaskService, TaskStats,
+                   TaskUpdate)
 
 # ============================================================================
 # APPLICATION SETUP
@@ -299,6 +305,130 @@ async def rest_list_ollama_models():
         return jsonify({"error": str(e)}), 500
 
 
+# ============================================================================
+# TICKET MCP EXAMPLE - Direct FastMCP client usage (no AI)
+# ============================================================================
+
+async def _call_ticket_mcp_tool(tool_name: str, args: dict | None = None) -> list[dict]:
+    """
+    Helper: Call a tool on the Ticket MCP server and extract results.
+    
+    This demonstrates using FastMCP client programmatically without any AI.
+    The connection is opened, tool is called, and connection is closed.
+    
+    Args:
+        tool_name: Name of the MCP tool to call (e.g., "list_tickets")
+        args: Optional dict of arguments for the tool
+        
+    Returns:
+        List of parsed JSON results from the tool response
+    """
+    args = args or {}
+    results = []
+    
+    async with MCPClient(TICKET_MCP_SERVER_URL) as client:
+        response = await client.call_tool(tool_name, args)
+        
+        # Extract text content from MCP response
+        if hasattr(response, 'content') and response.content:
+            for content_item in response.content:
+                # Only process TextContent items (use getattr for type safety)
+                text = getattr(content_item, 'text', None)
+                if text is not None and isinstance(text, str):
+                    try:
+                        # Parse JSON if possible
+                        results.append(json.loads(text))
+                    except json.JSONDecodeError:
+                        results.append({"text": text})
+    
+    return results
+    
+    return results
+
+
+@app.route("/api/tickets", methods=["GET"])
+async def rest_list_tickets():
+    """
+    List tickets from external Ticket MCP server.
+    
+    Example of calling MCP tools directly via FastMCP client.
+    No AI involved - just pure MCP protocol.
+    
+    Query params:
+        - status: Filter by status (new, assigned, in_progress, etc.)
+        - priority: Filter by priority (critical, high, medium, low)
+        - search: Full-text search in summary/description
+        - page: Page number (default: 1)
+        - page_size: Results per page (default: 20)
+    """
+    try:
+        # Build args from query params
+        args = {}
+        for param in ["status", "priority", "city", "service", "search"]:
+            if val := request.args.get(param):
+                args[param] = val
+        for param in ["page", "page_size"]:
+            if val := request.args.get(param):
+                args[param] = int(val)
+        
+        results = await _call_ticket_mcp_tool("list_tickets", args)
+        return jsonify(results[0] if len(results) == 1 else results), 200
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+
+@app.route("/api/tickets/<ticket_id>", methods=["GET"])
+async def rest_get_ticket(ticket_id: str):
+    """
+    Get a single ticket by ID from the Ticket MCP server.
+    
+    Demonstrates calling MCP tool with path parameter.
+    """
+    try:
+        results = await _call_ticket_mcp_tool("get_ticket", {"ticket_id": ticket_id})
+        if not results:
+            return jsonify({"error": "Ticket not found"}), 404
+        return jsonify(results[0]), 200
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+
+@app.route("/api/tickets/stats", methods=["GET"])
+async def rest_get_ticket_stats():
+    """
+    Get ticket statistics from the Ticket MCP server.
+    
+    Returns aggregated counts by status, priority, service, city.
+    """
+    try:
+        args = {}
+        if time_from := request.args.get("time_from"):
+            args["time_from"] = time_from
+        if time_to := request.args.get("time_to"):
+            args["time_to"] = time_to
+            
+        results = await _call_ticket_mcp_tool("get_ticket_stats", args)
+        return jsonify(results[0] if len(results) == 1 else results), 200
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+
+@app.route("/api/tickets/search", methods=["POST"])
+async def rest_search_tickets():
+    """
+    Advanced ticket search with multiple filters.
+    
+    Body JSON:
+        - query: Full-text search string
+        - filters: {status: [...], priority: [...], city: [...], service: [...]}
+        - limit: Max results
+    """
+    try:
+        data = await request.get_json() or {}
+        results = await _call_ticket_mcp_tool("search_tickets", data)
+        return jsonify(results[0] if len(results) == 1 else results), 200
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
 
 
 # ============================================================================