Enabling MCP Tools

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.

import os
from strands import Agent
from strands.models import BedrockModel
from strands.tools.mcp import MCPClient
from mcp import stdio_client, StdioServerParameters

# Define the Bedrock model ID
model_id = "us.anthropic.claude-sonnet-4-20250514-v1:0"

# Read guardrail info from environment variables
guardrail_id = os.getenv("GUARDRAIL_ID")
guardrail_version = os.getenv("GUARDRAIL_VERSION", "DRAFT")

# Create a Bedrock model
model = BedrockModel(
    model_id=model_id,
    guardrail_id=guardrail_id,
    guardrail_version=guardrail_version
)

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.

# Define the MCP client for AWS documentation
stdio_mcp_client = MCPClient(
    lambda: stdio_client(
        StdioServerParameters(
            command="uvx",
            args=["awslabs.aws-documentation-mcp-server@latest"]
        )
    )
)

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.

# Create an agent with MCP tools for AWS documentation access
with stdio_mcp_client:
    # Get the tools from the MCP server
    mcp_tools = stdio_mcp_client.list_tools_sync()

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.

for tool in mcp_tools:
  print(f"Tool: {tool.tool_name}, type: {tool.tool_type}")
  spec = tool.tool_spec
  print(spec["description"])
  print(spec["inputSchema"])

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:

Tool: read_documentation, type: python
Fetch and convert an AWS documentation page to markdown format.

    ## Usage

    This tool retrieves the content of an AWS documentation page and converts it to markdown format.
    For long documents, you can make multiple calls with different start_index values to retrieve
    the entire content in chunks.

    ## URL Requirements

    - Must be from the docs.aws.amazon.com domain
    - Must end with .html

    ## Example URLs

    - https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucketnamingrules.html
    - https://docs.aws.amazon.com/lambda/latest/dg/lambda-invocation.html

    ## Output Format
    [...]
    
{'json': {'properties': {'max_length': {'default': 5000,
                                        'description': 'Maximum number of '
                                                       'characters to return.',
                                        'exclusiveMaximum': 1000000,
                                        'exclusiveMinimum': 0,
                                        'title': 'Max Length',
                                        'type': 'integer'},
                         'start_index': {'default': 0,
                                         'description': 'On return output '
                                                        'starting at this '
                                                        'character index, '
                                                        'useful if a previous '
                                                        'fetch was truncated '
                                                        'and more content is '
                                                        'required.',
                                         'minimum': 0,
                                         'title': 'Start Index',
                                         'type': 'integer'},
                         'url': {'description': 'URL of the AWS documentation '
                                                'page to read',
                                 'title': 'Url',
                                 'type': 'string'}},
          'required': ['url'],
          'title': 'read_documentationArguments',
          'type': 'object'}}

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 inputSchema reveals the tool's flexible parameter structure: while only the url parameter is required, the optional max_length and start_index parameters enable sophisticated content retrieval strategies. The schema's validation rules, such as the exclusive maximum of 1,000,000 characters for max_length, provide clear boundaries for safe tool usage.

This detailed schema information is crucial because it enables your agent to understand not just what parameters are available, but also their constraints, default values, and relationships. Your agent can use this information to make intelligent decisions about how to invoke the tool, such as automatically chunking large document reads or setting appropriate content length limits based on the specific query context.

The AWS documentation MCP server also provides two additional complementary tools: search_documentation for discovering relevant AWS documentation pages across the entire knowledge base using search phrases, and recommend for finding related content, newly released features, and commonly accessed pages based on a given documentation URL. These three tools work synergistically, enabling your agent to search for information, read specific content, and discover related resources in comprehensive information-gathering workflows.

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

    # Define the system prompt for AWS Technical Assistant
    system_prompt = "You are an AWS Technical Assistant. Provide clear, accurate information about AWS services."

    # Create an agent with MCP tools
    agent = Agent(
        model=model,
        system_prompt=system_prompt,
        tools=[mcp_tools]
    )

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.

    # Send your first message to the agent asking about recent AWS features
    agent("What are the most recent AWS Bedrock features released in 2025?")

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.

I'll help you find the most recent AWS Bedrock features released in 2025. Let me search for recent Bedrock documentation and then look for newly released information.
Tool #1: search_documentation
Let me search more specifically for Amazon Bedrock documentation and then check for new features:
Tool #2: search_documentation
Great! I found the Bedrock User Guide and document history. Let me check the document history to see the most recent updates:
Tool #3: read_documentation
Let me get the continuation to see more recent features:
Tool #4: read_documentation
Let me also check the recommendations for the Bedrock main page to see if there are any additional new features or recently updated pages:
Tool #5: recommend
Let me also read about some of the most recent features mentioned in the document history:
Tool #6: read_documentation

Tool #7: read_documentation
Based on my research of the AWS Bedrock documentation, here are the most recent AWS Bedrock features released in 2025:

## **Most Recent AWS Bedrock Features Released in 2025**

### **August 2025**
1. **OpenAI Batch API Support** (August 27, 2025)
   - Amazon Bedrock now supports the OpenAI Batch API for running batch inference jobs
   - Compatible with all OpenAI models available in Bedrock
   - Supports both HTTP requests and OpenAI SDK integration

2. **Token Count Estimation** (August 21, 2025)
   - New capability to estimate token count before running inference
   - Helps with cost planning and request optimization

3. **New Models Added:**
   - **OpenAI gpt-oss-20b and gpt-oss-120b** (August 5, 2025)
   - **TwelveLabs TwelveLabs Pegasus 1.2** - expanded to US East (N. Virginia) and Asia Pacific (Seoul) (August 14, 2025)

4. **Automated Reasoning Checks for Guardrails** (August 5, 2025)
   - Mathematical validation of natural language content against defined policies
   - Higher accuracy with fewer false positives compared to pattern-matching
   - Particularly valuable for regulated industries and compliance scenarios

### **July 2025**
5. **Custom Model On-Demand Deployment** (July 16, 2025)
   - Deploy custom models for pay-per-token inference without provisioned throughput
   - More flexible pricing model for custom models

6. **SageMaker AI-trained Nova Model Import** (July 16, 2025)
   - Import SageMaker AI-trained Amazon Nova models into Bedrock as custom models

7. **Amazon Bedrock API Keys** (July 7, 2025)
   - Easy authentication method for making calls to the Amazon Bedrock API
   - Simplified integration for developers

8. **New Models Added:**
   - **Anthropic Claude Opus 4.1** (July 31, 2025)
   - **TwelveLabs Marengo Embed 2.7** (July 15, 2025)

### **June 2025**
[...]

This remarkable response demonstrates the sophisticated multi-tool workflow your agent orchestrated autonomously: it searched for Bedrock documentation, discovered the document history page, read through multiple sections to gather comprehensive information, used recommendations to find additional sources, and synthesized everything into a well-structured summary of the latest features. The agent executed seven different MCP tool calls to ensure complete coverage of the requested information, showcasing the power of MCP integration for complex information-gathering tasks.

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.