update format, broken chat

Author: seligj95

README.md

@@ -83,16 +83,50 @@ The application combines three key components:
                        └──────────────────┘
 ```
 
-## MCP Tools
+## Model Context Protocol (MCP)
+
+This application implements a complete MCP server following the [MCP specification](https://modelcontextprotocol.io/introduction). The MCP server exposes todo management functionality as tools that AI agents can discover and use.
+
+### MCP Documentation and Resources
+
+See **[Connect to Model Context Protocol servers (preview)](https://learn.microsoft.com/azure/ai-foundry/agents/how-to/tools/model-context-protocol#how-it-works)** to learn about the agent integration this is used in this app.
+
+### Important Limitations and Requirements
+
+⚠️ **Azure AI Foundry MCP Connectivity**: Currently, Azure AI Foundry may have network restrictions that prevent connecting to external MCP servers. This is a known limitation in certain Azure regions and configurations.
+
+**Requirements for MCP in Azure:**
+- Azure AI Foundry project must be in a supported region. See the supported regions [here](https://learn.microsoft.com/azure/ai-foundry/agents/how-to/tools/model-context-protocol#how-it-works).
+- Network policies must allow outbound connections to MCP servers
+- MCP server must be publicly accessible with proper CORS configuration
+- API version compatibility with Azure AI Agents service
+
+**Workaround**: While MCP integration is implemented and working locally, you can still use the AI chat functionality through the direct agent API endpoints.
+
+### MCP Tools Available
 
 The application exposes these tools for AI agents:
 
-- `create_todo` - Create new todos
-- `list_todos` - List all or filtered todos  
-- `update_todo` - Update existing todos
-- `delete_todo` - Delete todos
+- `create_todo` - Create new todos with title, description, and priority
+- `list_todos` - List all todos or filter by completion status  
+- `update_todo` - Update existing todo properties
+- `delete_todo` - Delete todos by ID
 - `mark_todo_complete` - Toggle completion status
 
+### Testing MCP Locally
+
+You can test the MCP server directly:
+
+```bash
+# Test MCP server info
+curl http://localhost:8000/mcp/stream
+
+# Test tool discovery
+curl -X POST http://localhost:8000/mcp/stream \
+  -H "Content-Type: application/json" \
+  -d '{"jsonrpc": "2.0", "id": 1, "method": "tools/list"}'
+```
+
 ## API Endpoints
 
 ### Web Interface

debug_mcp.py

@@ -0,0 +1,127 @@
+#!/usr/bin/env python3
+"""
+Debug script to test MCP integration with Azure AI Agents
+Based on the working sample script
+"""
+import os
+import asyncio
+from azure.identity import DefaultAzureCredential
+from azure.ai.agents import AgentsClient
+from azure.ai.agents.models import McpTool
+
+# Configuration from our deployed environment
+PROJECT_ENDPOINT = "https://az-tda-foundry-wgznky2irncfe.services.ai.azure.com/api/projects/az-tda-project-wgznky2irncfe"
+MODEL_DEPLOYMENT = "gpt-4o"
+MCP_SERVER_URL = "https://az-tda-app-wgznky2irncfe.azurewebsites.net/mcp/stream"
+MCP_SERVER_LABEL = "todolist"
+
+def main():
+    print("Testing MCP integration with Azure AI Agents...")
+    print(f"Project Endpoint: {PROJECT_ENDPOINT}")
+    print(f"MCP Server: {MCP_SERVER_URL}")
+    
+    # Connect to the agents client
+    agents_client = AgentsClient(
+        endpoint=PROJECT_ENDPOINT,
+        credential=DefaultAzureCredential()
+    )
+    
+    # Initialize agent MCP tool
+    mcp_tool = McpTool(
+        server_label=MCP_SERVER_LABEL,
+        server_url=MCP_SERVER_URL,
+    )
+    print(f"MCP Tool initialized: {mcp_tool.server_label} at {mcp_tool.server_url}")
+    
+    # Create agent with MCP tool and process agent run
+    with agents_client:
+        try:
+            # Create a new agent with the mcp tool definitions
+            agent = agents_client.create_agent(
+                model=MODEL_DEPLOYMENT,
+                name="debug-mcp-agent",
+                instructions="""
+                You are a helpful agent that can use MCP tools to assist users. 
+                Use the available MCP tools to answer questions and perform tasks.""",
+                tools=mcp_tool.definitions,
+            )
+            print(f"Created agent, ID: {agent.id}")
+            print(f"MCP Tool definitions: {len(mcp_tool.definitions) if mcp_tool.definitions else 0} tools")
+            
+            # Create thread for communication
+            thread = agents_client.threads.create()
+            print(f"Created thread, ID: {thread.id}")
+            
+            # Create a message on the thread
+            message = agents_client.messages.create(
+                thread_id=thread.id,
+                role="user",
+                content="Create a high priority todo to buy groceries.",
+            )
+            print(f"Created message, ID: {message.id}")
+            
+            # Set approval mode
+            mcp_tool.set_approval_mode("never")
+            print("Set MCP tool approval mode to 'never'")
+            
+            # Create and process agent run in thread with MCP tools
+            print("Creating and processing run...")
+            run = agents_client.runs.create_and_process(
+                thread_id=thread.id, 
+                agent_id=agent.id, 
+                tool_resources=mcp_tool.resources
+            )
+            print(f"Created run, ID: {run.id}")
+            
+            # Check run status
+            print(f"Run completed with status: {run.status}")
+            if run.status == "failed":
+                print(f"Run failed: {getattr(run, 'last_error', 'Unknown error')}")
+                
+            # Display run steps and tool calls
+            try:
+                run_steps = agents_client.run_steps.list(thread_id=thread.id, run_id=run.id)
+                print(f"Retrieved run steps...")
+                for step in run_steps:
+                    print(f"Step {step.id} status: {step.status}")
+                    
+                    # Check if there are tool calls in the step details
+                    step_details = getattr(step, 'step_details', None)
+                    if step_details:
+                        tool_calls = getattr(step_details, 'tool_calls', [])
+                        
+                        if tool_calls:
+                            # Display the MCP tool call details
+                            print("  MCP Tool calls:")
+                            for call in tool_calls:
+                                print(f"    Tool Call ID: {getattr(call, 'id', 'N/A')}")
+                                print(f"    Type: {getattr(call, 'type', 'N/A')}")
+                                print(f"    Name: {getattr(call, 'name', 'N/A')}")
+                        else:
+                            print("  No tool calls in this step")
+                    else:
+                        print("  No step details available")
+            except Exception as e:
+                print(f"Error retrieving run steps: {e}")
+            
+            # Fetch and log all messages
+            messages = agents_client.messages.list(thread_id=thread.id)
+            print("\nConversation:")
+            print("-" * 50)
+            for msg in messages:
+                if msg.text_messages:
+                    last_text = msg.text_messages[-1]
+                    print(f"{msg.role.upper()}: {last_text.text.value}")
+                    print("-" * 50)
+            
+            # Clean-up and delete the agent once the run is finished.
+            agents_client.delete_agent(agent.id)
+            print("Deleted agent")
+            
+        except Exception as e:
+            print(f"Error during agent interaction: {e}")
+            import traceback
+            traceback.print_exc()
+
+if __name__ == "__main__":
+    main()

infra/main.bicep

@@ -91,7 +91,7 @@ resource gpt4oDeployment 'Microsoft.CognitiveServices/accounts/deployments@2024-
   name: 'gpt-4o'
   sku: {
     name: 'GlobalStandard'
-    capacity: 50
+    capacity: 100
   }
   properties: {
     model: {

main.py

@@ -13,7 +13,7 @@
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.staticfiles import StaticFiles
 from fastapi.templating import Jinja2Templates
-from fastapi.responses import HTMLResponse
+from fastapi.responses import HTMLResponse, JSONResponse
 from pydantic import BaseModel
 from dotenv import load_dotenv
 
@@ -28,7 +28,7 @@
 try:
     from azure.identity import DefaultAzureCredential
     from azure.ai.agents import AgentsClient
-    from azure.ai.agents.models import McpTool
+    from azure.ai.agents.models import McpTool, RunStatus
     AZURE_AI_AVAILABLE = True
     logger.info("✓ Azure AI packages imported successfully")
 except ImportError as e:
@@ -202,17 +202,18 @@ async def chat_with_agent(self, message: str) -> ChatResponse:
                 credential=DefaultAzureCredential()
             )
 
-            # Initialize MCP tool
+            # Re-enable MCP tool integration with proper implementation
             mcp_tool = McpTool(
                 server_label=MCP_SERVER_LABEL,
                 server_url=MCP_SERVER_URL,
             )
 
-            # Default instructions
+            # Default instructions for MCP-enabled agent
             instructions = """
-            You are a helpful agent that can use MCP tools to assist users with todo management. 
-            Use the available MCP tools to answer questions and perform tasks like creating, 
-            listing, updating, and deleting todos.
+            You are a helpful AI assistant with access to todo management tools via MCP. 
+            You can help users create, list, update, and delete todo items using the available MCP tools.
+            When users ask about todos, use the MCP tools to perform the requested actions.
+            Always be helpful and provide clear feedback about what actions you've taken.
             """
 
             with fresh_client:
@@ -242,22 +243,61 @@ async def chat_with_agent(self, message: str) -> ChatResponse:
 
                 # Create and process agent run with MCP tools
                 run = fresh_client.runs.create_and_process(
-                    thread_id=thread.id, 
-                    agent_id=agent.id, 
+                    thread_id=thread.id,
+                    agent_id=agent.id,
                     tool_resources=mcp_tool.resources
                 )
-                logger.info(f"Created run, ID: {run.id}")
+                logger.info(f"Created run, ID: {run.id}, Status: {run.status}")
+                
+                # Check run status (detailed debugging like sample script)
+                logger.info(f"Run completed with status: {run.status}")
+                if str(run.status) == "RunStatus.FAILED":
+                    logger.error(f"Run failed: {getattr(run, 'last_error', 'Unknown error')}")
+                    assistant_response = f"Run failed: {getattr(run, 'last_error', 'Unknown error')}"
 
-                # Get the response
-                messages = fresh_client.messages.list(thread_id=thread.id)
+                # Display run steps and tool calls (like sample script)
+                try:
+                    run_steps = fresh_client.run_steps.list(thread_id=thread.id, run_id=run.id)
+                    for step in run_steps:
+                        logger.info(f"Step {step.id} status: {step.status}")
+                        
+                        # Check if there are tool calls in the step details
+                        step_details = getattr(step, 'step_details', {})
+                        tool_calls = getattr(step_details, 'tool_calls', []) if step_details else []
+                        
+                        if tool_calls:
+                            logger.info("  MCP Tool calls:")
+                            for call in tool_calls:
+                                logger.info(f"    Tool Call ID: {getattr(call, 'id', 'N/A')}")
+                                logger.info(f"    Type: {getattr(call, 'type', 'N/A')}")
+                                logger.info(f"    Name: {getattr(call, 'name', 'N/A')}")
+                except Exception as e:
+                    logger.error(f"Error retrieving run steps: {e}")
 
-                # Extract the assistant's response
-                assistant_response = "No response generated"
-                for msg in messages:
-                    if msg.role == "assistant" and msg.text_messages:
-                        last_text = msg.text_messages[-1]
-                        assistant_response = last_text.text.value
-                        break
+                if str(run.status) == "RunStatus.COMPLETED":
+                    # Get the response
+                    messages_paged = fresh_client.messages.list(thread_id=thread.id)
+                    messages = list(messages_paged)  # Convert ItemPaged to list
+                    logger.info(f"Retrieved {len(messages)} messages from thread")
+                    
+                    # Log all messages for debugging
+                    for i, msg in enumerate(messages):
+                        logger.info(f"Message {i}: role={msg.role}, has_text={bool(msg.text_messages)}")
+                        if msg.text_messages:
+                            for j, text_msg in enumerate(msg.text_messages):
+                                logger.info(f"  Text {j}: {text_msg.text.value[:100]}...")
+                    
+                    # Extract the assistant's response (get the last assistant message)
+                    assistant_response = "No response generated"
+                    assistant_messages = [msg for msg in messages if msg.role == "assistant"]
+                    if assistant_messages:
+                        last_assistant_msg = assistant_messages[-1]
+                        if last_assistant_msg.text_messages:
+                            assistant_response = last_assistant_msg.text_messages[-1].text.value
+                            logger.info(f"Found assistant response: {assistant_response[:100]}...")
+                else:
+                    logger.warning(f"Run completed with unexpected status: {run.status}")
+                    assistant_response = f"Run completed with status: {run.status}"
 
                 # Clean up - delete the agent
                 fresh_client.delete_agent(agent.id)
@@ -692,40 +732,80 @@ async def handle_tool_call(self, params: dict) -> dict:
 # MCP Server endpoints (for direct MCP client access)
 @app.get("/mcp/stream")
 async def mcp_stream_info():
-    """Information about the MCP stream endpoint"""
+    """Information about the MCP stream endpoint with enhanced compatibility info"""
     return {
-        "info": "MCP Streamable HTTP Transport Endpoint",
+        "info": "MCP Streamable HTTP Transport Endpoint", 
         "description": "This endpoint provides access to todo management tools via MCP",
         "mcp_server_url": MCP_SERVER_URL,
+        "protocol_version": "2024-11-05",
+        "transport": "http",
+        "capabilities": {
+            "tools": {
+                "listChanged": True
+            }
+        },
+        "server_info": {
+            "name": "Todo MCP Server",
+            "version": "1.0.0"
+        },
         "available_tools": [
             "create_todo", 
             "list_todos", 
             "update_todo", 
             "delete_todo", 
             "mark_todo_complete"
-        ]
+        ],
+        "endpoints": {
+            "jsonrpc": f"{MCP_SERVER_URL}",
+            "methods": ["initialize", "tools/list", "tools/call"]
+        }
     }
 
 @app.post("/mcp/stream")
 async def mcp_stream_endpoint(request: Request):
-    """Main MCP endpoint with JSON-RPC support"""
+    """Main MCP endpoint with JSON-RPC support and enhanced compatibility"""
     try:
+        # Get request data
         request_data = await request.json()
-        logger.info(f"MCP request: {request_data}")
+        logger.info(f"MCP request received: method={request_data.get('method')}, id={request_data.get('id')}")
 
+        # Handle the request through our MCP server
         response_data = await mcp_server.handle_request(request_data)
-        logger.info(f"MCP response: {response_data}")
+        logger.info(f"MCP response: id={response_data.get('id')}, has_result={bool(response_data.get('result'))}, has_error={bool(response_data.get('error'))}")
 
-        return response_data
+        # Return with proper headers for compatibility
+        return JSONResponse(
+            content=response_data,
+            headers={
+                "Content-Type": "application/json",
+                "Access-Control-Allow-Origin": "*",
+                "Access-Control-Allow-Methods": "POST, OPTIONS",
+                "Access-Control-Allow-Headers": "Content-Type, Accept, Authorization",
+                "Cache-Control": "no-cache"
+            }
+        )
 
     except Exception as e:
         logger.error(f"Error in MCP endpoint: {e}")
         logger.error(f"Full traceback: {traceback.format_exc()}")
-        return {
+        
+        error_response = {
             "jsonrpc": "2.0",
-            "id": None,
-            "error": {"code": -32603, "message": f"Internal error: {str(e)}"}
+            "id": request_data.get("id") if "request_data" in locals() else None,
+            "error": {
+                "code": -32603,
+                "message": f"Internal error: {str(e)}"
+            }
         }
+        
+        return JSONResponse(
+            content=error_response,
+            status_code=500,
+            headers={
+                "Content-Type": "application/json",
+                "Access-Control-Allow-Origin": "*"
+            }
+        )
 
 @app.options("/mcp/stream")
 async def mcp_stream_options():