Welcome back to Putting Bedrock Models to Action with Strands Agents! You've made remarkable progress through this course, building intelligent agents from the ground up, enhancing them with calculation and custom tools, and connecting them to knowledge bases for powerful document retrieval. Now, in this final unit, we're expanding your agent's horizons beyond internal knowledge bases to embrace the broader ecosystem of external data sources through the Model Context Protocol (MCP).

This lesson introduces you to MCP integration with Strands agents, enabling your AWS Technical Assistant to access real-time information from external servers and services. We'll explore the strands.tools.mcp module, master MCP client configuration patterns, and connect to the AWS documentation MCP server for live access to the latest AWS service information. You'll discover how MCP tools can complement your existing agent capabilities, providing access to dynamic external data that traditional knowledge bases cannot offer.

By the end of this unit, your agent will seamlessly combine its established tool repertoire with MCP-powered external data access, creating a comprehensive system capable of both internal knowledge retrieval and real-time external information gathering. This integration represents the cutting edge of agent architecture, where AI reasoning meets the boundless landscape of external data sources.

Model Context Protocol (MCP) establishes a standardized framework for connecting AI agents to external data sources and services through a three-component architecture. At its core, MCP operates with a host (your AI application) and one or more servers (external services providing capabilities and context), each with a corresponding client that handles the communication between the host and the specific MCP server. This architecture enables your agents to seamlessly access live systems, real-time APIs, and dynamic data sources that extend far beyond traditional knowledge bases.

MCP operates through two distinct layers:

1. The data layer defines the types of information and capabilities that servers can expose. Specifically, it implements a JSON-RPC 2.0 based exchange protocol that defines the message structure and semantics, including lifecycle management, server and client features.
2. The transport layer manages the actual communication channels and authentication between clients and servers. It handles connection establishment, message framing, and secure communication between MCP participants. MCP supports two transport mechanisms:
   • stdio transport for direct process communication between local processes on the same machine.
   • streamable HTTP transport for client-to-server messages with optional Server-Sent Events for streaming capabilities. This transport enables remote server communication and supports standard HTTP authentication methods including bearer tokens, API keys, and custom headers. MCP recommends using OAuth to obtain authentication tokens.

This separation ensures that regardless of how you connect to an MCP server, the capabilities it provides remain consistent and predictable.

MCP servers expose their functionality through three primary components that extend your agent's reasoning capabilities. Tools represent executable functions that your agent can invoke to perform specific actions, such as searching documentation, retrieving data, or interacting with external APIs. Resources provide access to data objects like files, database records, or API responses that your agent can read and analyze. Prompts offer pre-defined interaction templates that guide how your agent should approach specific tasks or domains.

When your agent connects to an MCP server, it automatically discovers all available tools, resources, and prompts through a standardized discovery process. This dynamic capability detection means servers can be updated with new features without requiring changes to your agent code. The server handles the complexity of external system interactions, presenting a clean, consistent interface that your agent can reason about and utilize effectively.

The AWS documentation MCP server we'll be connecting to exemplifies this pattern, providing specialized tools for searching, reading, and discovering AWS service documentation in real time, ensuring your agent always has access to the most current information available.

Let's begin our MCP implementation by establishing the foundational imports and model configuration, building upon the patterns you've mastered throughout this course.

The key additions here are the MCP-specific imports: MCPClient from strands.tools.mcp provides the client interface for connecting to MCP servers, while stdio_client and StdioServerParameters from the mcp package enable communication over standard input/output streams. This stdio transport method is particularly well-suited for connecting to locally executed MCP servers or those launched through command-line interfaces. You should be familiar already with the rest of the setup.

Now we'll configure the connection parameters for the AWS documentation MCP server, which provides tools for searching, reading, and discovering AWS service documentation in real time.

The MCPClient configuration uses a lambda function that returns a stdio_client instance, enabling lazy connection establishment. The StdioServerParameters specify that we'll use the uvx command to execute the AWS documentation MCP server package, with the argument pointing to the latest version of awslabs.aws-documentation-mcp-server. This server provides specialized tools for interacting with AWS documentation, including search, content retrieval, and recommendation capabilities.

For local development scenarios, you can also connect to a custom MCP server by launching a local Python script. If you have a local mcp.py file implementing your own MCP server, you would configure the connection using StdioServerParameters(command="python", args=["mcp.py"]) instead. This approach enables you to develop and test custom MCP tools locally before deploying them to production environments.

Proper MCP client lifecycle management ensures reliable connections and clean resource handling throughout your agent's operation cycle.

The with statement creates a context manager that handles MCP client initialization, connection establishment, and cleanup automatically. This pattern ensures that the MCP server process is properly started, communication channels are established, and resources are cleaned up when the context exits, even if errors occur during operation.

Within the context, list_tools_sync() performs synchronous tool discovery, querying the connected MCP server to retrieve all available tools and their specifications. This discovery process is essential because it allows your agent to understand what capabilities the external server provides before attempting to use them.

Let's examine the tools that the AWS documentation MCP server provides and understand their capabilities through detailed inspection.

This inspection loop reveals the structure and capabilities of each MCP tool, providing essential information about how to use them effectively within your agent workflows. Let's focus on the first available tool:

The read_documentation tool exemplifies the rich interface that MCP tools provide. The comprehensive description explains not only what the tool does but also important usage patterns, such as handling document chunking for large files and URL format requirements. The reveals the tool's flexible parameter structure: while only the parameter is required, the optional and parameters enable sophisticated content retrieval strategies. The schema's validation rules, such as the exclusive maximum of 1,000,000 characters for , provide clear boundaries for safe tool usage.

With the MCP tools discovered and understood, we can now create an agent that seamlessly integrates these external capabilities with its core reasoning abilities.

The agent creation follows the familiar pattern you've learned throughout this course, but now includes mcp_tools in the tools list. The Strands framework automatically integrates these external MCP tools with the same ease as built-in tools, enabling your agent to autonomously decide when to search AWS documentation, read specific pages, or discover related content based on the context of user queries.

This integration creates a powerful hybrid system in which your agent can reason about questions, determine the appropriate information sources, and execute complex information-gathering workflows that span multiple MCP tool invocations to provide comprehensive responses.

Now let's witness the full power of MCP integration by querying your agent about current AWS features, demonstrating how it autonomously utilizes multiple MCP tools to gather comprehensive information.

This query triggers a sophisticated workflow in which your agent recognizes the need for current information about AWS services, autonomously searches the AWS documentation, reads relevant pages, and synthesizes the information into a comprehensive response about the latest Bedrock features.

The response we just witnessed reveals the true sophistication of MCP-enabled agents. Your agent demonstrated autonomous tool chaining, where it intelligently sequenced multiple MCP tool invocations to build a comprehensive understanding of current AWS Bedrock features. This workflow included initial searches to locate relevant documentation, targeted reading of specific pages, recommendation discovery to find additional sources, and continued reading to gather complete information.

The agent's ability to recognize when it needed more information and autonomously invoke additional tools represents a significant advancement over traditional static knowledge bases. While knowledge bases provide excellent access to curated organizational content, MCP tools enable agents to actively explore, discover, and synthesize information from live external sources in real time, ensuring responses reflect the most current available information.

This integration pattern creates agents capable of research-grade information gathering, in which complex queries trigger multi-step investigation workflows that combine search, discovery, and analysis capabilities. The result is comprehensive, current, and thoroughly researched responses that exceed what would be possible through any single information source.

Congratulations on completing this final lesson of Putting Bedrock Models to Action with Strands Agents! You've successfully mastered the integration of Model Context Protocol tools with Strands agents, transforming your AWS Technical Assistant into a sophisticated system capable of accessing real-time external data sources alongside its established internal capabilities. Throughout this course, you've built a comprehensive understanding of modern AI agent architecture: from basic agent creation and tool integration to knowledge base connectivity and now external data access through MCP.

The MCP integration you've mastered opens infinite possibilities for extending agent capabilities beyond traditional boundaries, positioning you at the forefront of modern AI agent development. The upcoming practice exercises will solidify your MCP expertise and prepare you for the exciting journey ahead, where you'll advance to Deploying Agents to AWS with Bedrock AgentCore to discover how to take these powerful agents from development environments into production-ready cloud deployments with persistent memory and scalable enterprise solutions.