Doc updates

Author: dmytrostruk

agent-framework/tutorials/agents/TOC.yml

@@ -6,14 +6,10 @@
   href: multi-turn-conversation.md
 - name: Using function tools with an agent
   href: function-tools.md
-- name: Using function tools with human in the loop approvals
-  href: function-tools-approvals.md
 - name: Producing Structured Output with agents
   href: structured-output.md
 - name: Using an agent as a function tool
   href: agent-as-function-tool.md
-- name: Exposing an agent as an MCP tool
-  href: agent-as-mcp-tool.md
 - name: Enabling observability for agents
   href: enable-observability.md
 - name: Adding middleware to agents

agent-framework/tutorials/workflows/TOC.yml

@@ -9,6 +9,4 @@
 - name: Handle requests and responses in workflows
   href: requests-and-responses.md
 - name: Checkpointing and resuming workflows
-  href: checkpointing-and-resuming.md
-- name: Visualizing workflows
-  href: visualization.md
+  href: checkpointing-and-resuming.md

agent-framework/user-guide/model-context-protocol/using-mcp-tools.md

@@ -129,7 +129,122 @@ The full source code and instructions to run this sample is available [here](htt
 ::: zone-end
 ::: zone pivot="programming-language-python"
 
-Coming soon.
+The Python Agent Framework provides comprehensive support for integrating with Model Context Protocol (MCP) servers through multiple connection types. This allows your agents to access external tools and services seamlessly.
+
+## MCP Tool Types
+
+The Agent Framework supports three types of MCP connections:
+
+### MCPStdioTool - Local MCP Servers
+
+Use `MCPStdioTool` to connect to MCP servers that run as local processes using standard input/output:
+
+```python
+import asyncio
+from agent_framework import ChatAgent, MCPStdioTool
+from agent_framework.openai import OpenAIChatClient
+
+async def local_mcp_example():
+    """Example using a local MCP server via stdio."""
+    async with (
+        MCPStdioTool(
+            name="calculator", 
+            command="uvx", 
+            args=["mcp-server-calculator"]
+        ) as mcp_server,
+        ChatAgent(
+            chat_client=OpenAIChatClient(),
+            name="MathAgent",
+            instructions="You are a helpful math assistant that can solve calculations.",
+        ) as agent,
+    ):
+        result = await agent.run(
+            "What is 15 * 23 + 45?", 
+            tools=mcp_server
+        )
+        print(result)
+
+if __name__ == "__main__":
+    asyncio.run(local_mcp_example())
+```
+
+### MCPStreamableHTTPTool - HTTP/SSE MCP Servers
+
+Use `MCPStreamableHTTPTool` to connect to MCP servers over HTTP with Server-Sent Events:
+
+```python
+import asyncio
+from agent_framework import ChatAgent, MCPStreamableHTTPTool
+from agent_framework.azure import AzureAIAgentClient
+from azure.identity.aio import AzureCliCredential
+
+async def http_mcp_example():
+    """Example using an HTTP-based MCP server."""
+    async with (
+        AzureCliCredential() as credential,
+        MCPStreamableHTTPTool(
+            name="Microsoft Learn MCP",
+            url="https://learn.microsoft.com/api/mcp",
+            headers={"Authorization": "Bearer your-token"},
+        ) as mcp_server,
+        ChatAgent(
+            chat_client=AzureAIAgentClient(async_credential=credential),
+            name="DocsAgent",
+            instructions="You help with Microsoft documentation questions.",
+        ) as agent,
+    ):
+        result = await agent.run(
+            "How to create an Azure storage account using az cli?",
+            tools=mcp_server
+        )
+        print(result)
+
+if __name__ == "__main__":
+    asyncio.run(http_mcp_example())
+```
+
+### MCPWebsocketTool - WebSocket MCP Servers
+
+Use `MCPWebsocketTool` to connect to MCP servers over WebSocket connections:
+
+```python
+import asyncio
+from agent_framework import ChatAgent, MCPWebsocketTool
+from agent_framework.openai import OpenAIChatClient
+
+async def websocket_mcp_example():
+    """Example using a WebSocket-based MCP server."""
+    async with (
+        MCPWebsocketTool(
+            name="realtime-data",
+            url="wss://api.example.com/mcp",
+        ) as mcp_server,
+        ChatAgent(
+            chat_client=OpenAIChatClient(),
+            name="DataAgent",
+            instructions="You provide real-time data insights.",
+        ) as agent,
+    ):
+        result = await agent.run(
+            "What is the current market status?",
+            tools=mcp_server
+        )
+        print(result)
+
+if __name__ == "__main__":
+    asyncio.run(websocket_mcp_example())
+```
+
+## Popular MCP Servers
+
+Common MCP servers you can use with Python Agent Framework:
+
+- **Calculator**: `uvx mcp-server-calculator` - Mathematical computations
+- **Filesystem**: `uvx mcp-server-filesystem` - File system operations  
+- **GitHub**: `npx @modelcontextprotocol/server-github` - GitHub repository access
+- **SQLite**: `uvx mcp-server-sqlite` - Database operations
+
+Each server provides different tools and capabilities that extend your agent's functionality while maintaining the security and standardization benefits of the Model Context Protocol.
 
 ::: zone-end
 

agent-framework/user-guide/model-context-protocol/using-mcp-with-foundry-agents.md

@@ -144,11 +144,107 @@ await persistentAgentsClient.Administration.DeleteAgentAsync(agent.Id);
 ::: zone-end
 ::: zone pivot="programming-language-python"
 
-Coming soon.
+## Python Azure AI Foundry MCP Integration
 
-::: zone-end
+Azure AI Foundry provides seamless integration with Model Context Protocol (MCP) servers through the Python Agent Framework. The service manages the MCP server hosting and execution, eliminating infrastructure management while providing secure, controlled access to external tools.
+
+### Environment Setup
+
+Configure your Azure AI Foundry project credentials through environment variables:
+
+```python
+import os
+from azure.identity.aio import AzureCliCredential
+from agent_framework.azure import AzureAIAgentClient
+
+# Required environment variables
+os.environ["AZURE_AI_PROJECT_ENDPOINT"] = "https://<your-project>.cognitiveservices.azure.com"
+os.environ["AZURE_AI_MODEL_DEPLOYMENT_NAME"] = "gpt-4o-mini"  # Optional, defaults to this
+```
 
-To learn more refer to the [Azure AI Foundry Model Context Protocol documentation](/azure/ai-foundry/agents/how-to/tools/model-context-protocol).
+### Basic MCP Integration
+
+Create an Azure AI Foundry agent with hosted MCP tools:
+
+```python
+import asyncio
+from agent_framework import HostedMCPTool
+from agent_framework.azure import AzureAIAgentClient
+from azure.identity.aio import AzureCliCredential
+
+async def basic_foundry_mcp_example():
+    """Basic example of Azure AI Foundry agent with hosted MCP tools."""
+    async with (
+        AzureCliCredential() as credential,
+        AzureAIAgentClient(async_credential=credential) as chat_client,
+    ):
+        # Enable Azure AI observability (optional but recommended)
+        await chat_client.setup_azure_ai_observability()
+        
+        # Create agent with hosted MCP tool
+        agent = chat_client.create_agent(
+            name="MicrosoftLearnAgent", 
+            instructions="You answer questions by searching Microsoft Learn content only.",
+            tools=HostedMCPTool(
+                name="Microsoft Learn MCP",
+                url="https://learn.microsoft.com/api/mcp",
+            ),
+        )
+        
+        # Simple query without approval workflow
+        result = await agent.run(
+            "Please summarize the Azure AI Agent documentation related to MCP tool calling?"
+        )
+        print(result)
+
+if __name__ == "__main__":
+    asyncio.run(basic_foundry_mcp_example())
+```
+
+### Multi-Tool MCP Configuration
+
+Use multiple hosted MCP tools with a single agent:
+
+```python
+async def multi_tool_mcp_example():
+    """Example using multiple hosted MCP tools."""
+    async with (
+        AzureCliCredential() as credential,
+        AzureAIAgentClient(async_credential=credential) as chat_client,
+    ):
+        await chat_client.setup_azure_ai_observability()
+        
+        # Create agent with multiple MCP tools
+        agent = chat_client.create_agent(
+            name="MultiToolAgent",
+            instructions="You can search documentation and access GitHub repositories.",
+            tools=[
+                HostedMCPTool(
+                    name="Microsoft Learn MCP",
+                    url="https://learn.microsoft.com/api/mcp",
+                    approval_mode="never_require",  # Auto-approve documentation searches
+                ),
+                HostedMCPTool(
+                    name="GitHub MCP", 
+                    url="https://api.github.com/mcp",
+                    approval_mode="always_require",  # Require approval for GitHub operations
+                    headers={"Authorization": "Bearer github-token"},
+                ),
+            ],
+        )
+        
+        result = await agent.run(
+            "Find Azure documentation and also check the latest commits in microsoft/semantic-kernel"
+        )
+        print(result)
+
+if __name__ == "__main__":
+    asyncio.run(multi_tool_mcp_example())
+```
+
+The Python Agent Framework provides seamless integration with Azure AI Foundry's hosted MCP capabilities, enabling secure and scalable access to external tools while maintaining the flexibility and control needed for production applications.
+
+::: zone-end
 
 ## Next steps
 

agent-framework/user-guide/workflows/TOC.yml

@@ -12,9 +12,4 @@
   href: request-and-response.md
 - name: Shared States
   href: shared-states.md
-- name: Checkpoints
-  href: checkpoints.md
-- name: Observability
-  href: observability.md
-- name: Visualization
-  href: visualization.md
+  

agent-framework/user-guide/workflows/orchestrations/TOC.yml

@@ -4,7 +4,5 @@
   href: concurrent.md
 - name: Sequential
   href: sequential.md
-- name: Handoff
-  href: handoff.md
 - name: Magentic
   href: magentic.md

agent-framework/user-guide/workflows/orchestrations/overview.md

@@ -22,7 +22,6 @@ Traditional single-agent systems are limited in their ability to handle complex,
 | ----------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------- |
 | [Concurrent](./concurrent.md) | Broadcasts a task to all agents, collects results independently.                                                                                                                    | Parallel analysis, independent subtasks, ensemble decision making.    |
 | [Sequential](./sequential.md) | Passes the result from one agent to the next in a defined order.                                                                                                                    | Step-by-step workflows, pipelines, multi-stage processing.            |
-| [Handoff](./handoff.md)       | Dynamically passes control between agents based on context or rules.                                                                                                                | Dynamic workflows, escalation, fallback, or expert handoff scenarios. |
 | [Magentic](./magentic.md)     | Inspired by [MagenticOne](https://www.microsoft.com/en-us/research/articles/magentic-one-a-generalist-multi-agent-system-for-solving-complex-tasks/). | Complex, generalist multi-agent collaboration.                        |
 
 ## Next Steps