first push

Author: codecommit-at-091424816836

README.md

@@ -0,0 +1,49 @@
+# MCP on AWS Bedrock
+A simple and clear example for implementation and understanding Anthropic MCP (on AWS Bedrock, with Nova).
+
+## Overview
+This project demonstrates how to implement and use Anthropic's Model Context Protocol (MCP) with AWS Bedrock. It provides a client implementation that can interact with MCP-enabled tools through AWS Bedrock's runtime service.
+
+## Prerequisites
+- Python 3.10 or higher
+- AWS account with Bedrock access
+- Configured AWS credentials
+- UV package manager
+
+## Project Structure
+- `client.py`: Main client implementation for interacting with Bedrock and MCP tools
+- `mcp_simple_tool/`: Directory containing the MCP tool implementation
+  - `server.py`: MCP tool server implementation
+  - `__main__.py`: Entry point for the tool
+- `pyproject.toml`: Project dependencies and configuration
+
+## Usage
+Run the client with:
+```bash
+uv venv --python 3.13.1
+uv pip install boto3
+uv run client.py
+```
+
+The client will:
+1. Initialize a connection to AWS Bedrock
+2. Start the MCP tool server
+3. List available tools and convert them to the format required by Bedrock
+4. Handle communication between Bedrock and the MCP tools
+
+## Features
+- Seamless integration with AWS Bedrock runtime
+- Tool format conversion for Bedrock compatibility
+- Asynchronous communication handling
+- Structured logging for debugging
+
+## Contributing
+Feel free to submit issues and pull requests to improve the implementation.
+
+## License
+MIT License
+
+## References
+- [Anthropic MCP](https://modelcontextprotocol.io/)
+- [MCP Python SDK](https://github.com/modelcontextprotocol/python-sdk)
+- [AWS Bedrock](https://aws.amazon.com/bedrock/)

client.py

@@ -0,0 +1,129 @@
+import asyncio
+import json
+import boto3
+import logging
+from mcp.client.session import ClientSession
+from mcp.client.stdio import StdioServerParameters, stdio_client
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+def convert_tool_format(tools):
+    """
+    Converts tools into the format required for the Bedrock API.
+
+    Args:
+        tools (list): List of tool objects
+
+    Returns:
+        dict: Tools in the format required by Bedrock
+    """
+    converted_tools = []
+
+    for tool in tools:
+        converted_tool = {
+            "toolSpec": {
+                "name": tool.name,
+                "description": tool.description,
+                "inputSchema": {
+                    "json": tool.inputSchema
+                }
+            }
+        }
+        converted_tools.append(converted_tool)
+
+    return {"tools": converted_tools}
+
+
+async def main():
+    # Initialize Bedrock client
+    bedrock = boto3.client('bedrock-runtime')
+
+    async with stdio_client(
+        StdioServerParameters(command="uv", args=["run", "mcp-simple-tool"])
+    ) as (read, write):
+        async with ClientSession(read, write) as session:
+            await session.initialize()
+
+            # List available tools and convert to serializable format
+            tools_result = await session.list_tools()
+            tools_list = [{"name": tool.name, "description": tool.description,
+                          "inputSchema": tool.inputSchema} for tool in tools_result.tools]
+            logger.info("Available tools: %s", tools_list)
+
+            # Prepare the request for Nova Pro model
+            system = [
+                {
+                    "text": "You are a helpful AI assistant. You have access to the following tools: " +
+                    json.dumps(tools_list)
+                }
+            ]
+
+            messages = [
+                {
+                    "role": "user",
+                    "content": [{"text": "Hello, can you help me fetch the website 'https://www.example.com?'"}]
+                }
+            ]
+
+            while True:
+                # Call Bedrock with Nova Pro model
+                response = bedrock.converse(
+                    modelId='us.amazon.nova-pro-v1:0',
+                    messages=messages,
+                    system=system,
+                    inferenceConfig={
+                        "maxTokens": 300,
+                        "topP": 0.1,
+                        "temperature": 0.3
+                    },
+                    toolConfig=convert_tool_format(tools_result.tools)
+                )
+
+                output_message = response['output']['message']
+                messages.append(output_message)
+                stop_reason = response['stopReason']
+
+                # Print the model's response
+                for content in output_message['content']:
+                    if 'text' in content:
+                        print("Model:", content['text'])
+
+                if stop_reason == 'tool_use':
+                    # Tool use requested. Call the tool and send the result to the model.
+                    tool_requests = response['output']['message']['content']
+                    for tool_request in tool_requests:
+                        if 'toolUse' in tool_request:
+                            tool = tool_request['toolUse']
+                            logger.info("Requesting tool %s. Request: %s",
+                                        tool['name'], tool['toolUseId'])
+
+                            try:
+                                # Call the tool through the MCP session
+                                tool_response = await session.call_tool(tool['name'], tool['input'])
+
+                                # Convert tool response to expected format
+                                tool_result = {
+                                    "toolUseId": tool['toolUseId'],
+                                    "content": [{"text": str(tool_response)}]
+                                }
+                            except Exception as err:
+                                logger.error("Tool call failed: %s", str(err))
+                                tool_result = {
+                                    "toolUseId": tool['toolUseId'],
+                                    "content": [{"text": f"Error: {str(err)}"}],
+                                    "status": "error"
+                                }
+
+                            # Add tool result to messages
+                            messages.append({
+                                "role": "user",
+                                "content": [{"toolResult": tool_result}]
+                            })
+                else:
+                    # No more tool use requests, we're done
+                    break
+
+if __name__ == "__main__":
+    asyncio.run(main())

mcp_simple_tool/__init__.py

@@ -0,0 +1,5 @@
+import sys
+
+from server import main
+
+sys.exit(main())

mcp_simple_tool/__main__.py

@@ -0,0 +1,100 @@
+import anyio
+import click
+import httpx
+import mcp.types as types
+from mcp.server import Server
+
+
+async def fetch_website(
+    url: str,
+) -> list[types.TextContent | types.ImageContent | types.EmbeddedResource]:
+    headers = {
+        "User-Agent": "MCP Test Server (github.com/modelcontextprotocol/python-sdk)"
+    }
+    async with httpx.AsyncClient(follow_redirects=True, headers=headers) as client:
+        response = await client.get(url)
+        response.raise_for_status()
+        return [types.TextContent(type="text", text=response.text)]
+
+
+@click.command()
+@click.option("--port", default=8000, help="Port to listen on for SSE")
+@click.option(
+    "--transport",
+    type=click.Choice(["stdio", "sse"]),
+    default="stdio",
+    help="Transport type",
+)
+def main(port: int, transport: str) -> int:
+    app = Server("mcp-website-fetcher")
+
+    @app.call_tool()
+    async def fetch_tool(
+        name: str, arguments: dict
+    ) -> list[types.TextContent | types.ImageContent | types.EmbeddedResource]:
+        if name != "fetch":
+            raise ValueError(f"Unknown tool: {name}")
+        if "url" not in arguments:
+            raise ValueError("Missing required argument 'url'")
+        return await fetch_website(arguments["url"])
+
+    @app.list_tools()
+    async def list_tools() -> list[types.Tool]:
+        return [
+            types.Tool(
+                name="fetch",
+                description="Fetches a website and returns its content",
+                inputSchema={
+                    "type": "object",
+                    "required": ["url"],
+                    "properties": {
+                        "url": {
+                            "type": "string",
+                            "description": "URL to fetch",
+                        }
+                    },
+                },
+            )
+        ]
+
+    if transport == "sse":
+        from mcp.server.sse import SseServerTransport
+        from starlette.applications import Starlette
+        from starlette.routing import Route
+
+        sse = SseServerTransport("/messages")
+
+        async def handle_sse(request):
+            async with sse.connect_sse(
+                request.scope, request.receive, request._send
+            ) as streams:
+                await app.run(
+                    streams[0], streams[1], app.create_initialization_options()
+                )
+
+        async def handle_messages(request):
+            await sse.handle_post_message(request.scope, request.receive, request._send)
+
+        starlette_app = Starlette(
+            debug=True,
+            routes=[
+                Route("/sse", endpoint=handle_sse),
+                Route("/messages", endpoint=handle_messages, methods=["POST"]),
+            ],
+        )
+
+        import uvicorn
+
+        uvicorn.run(starlette_app, host="0.0.0.0", port=port)
+    else:
+        from mcp.server.stdio import stdio_server
+
+        async def arun():
+            async with stdio_server() as streams:
+                await app.run(
+                    streams[0], streams[1], app.create_initialization_options()
+                )
+
+        anyio.run(arun)
+
+    return 0

mcp_simple_tool/server.py

@@ -0,0 +1,42 @@
+[project]
+name = "mcp-simple-tool"
+version = "0.1.0"
+description = "A simple MCP server exposing a website fetching tool"
+readme = "README.md"
+requires-python = ">=3.10"
+authors = [{ name = "Anthropic, PBC." }]
+maintainers = [
+    { name = "David Soria Parra", email = "[email protected]" },
+    { name = "Justin Spahr-Summers", email = "[email protected]" },
+]
+keywords = ["mcp", "llm", "automation", "web", "fetch"]
+license = { text = "MIT" }
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+]
+dependencies = ["anyio>=4.5", "click>=8.1.0", "httpx>=0.27", "mcp"]
+
+[project.scripts]
+mcp-simple-tool = "mcp_simple_tool.server:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["mcp_simple_tool"]
+
+[tool.ruff.lint]
+select = ["E", "F", "I"]
+ignore = []
+
+[tool.ruff]
+line-length = 88
+target-version = "py310"
+
+[tool.uv]
+dev-dependencies = ["pyright>=1.1.378", "pytest>=8.3.3", "ruff>=0.6.9"]