Skip to content
Back to search

mcp-proxy-for-aws

AWS MCP Proxy Server

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/aws/mcp-proxy-for-aws with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/aws/mcp-proxy-for-aws'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/aws--mcp-proxy-for-aws/badge.svg)](/listings/aws--mcp-proxy-for-aws)

HTML

<a href="/listings/aws--mcp-proxy-for-aws"><img src="/api/listings/aws--mcp-proxy-for-aws/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Using PyPi

For CLI and `uvx` use, install **`mcp-proxy-for-aws-cli`**. It is a thin, version-pinned distribution: it freezes the proxy's entire transitive dependency tree to tested versions, so a fresh install cannot silently pull in a newer — possibly compromised — release of a dependency. (The unsuffixed `mcp-proxy-for-aws` is the library distribution with loose, co-resolvable ranges, for importing `mcp_proxy_for_aws` in your own code — see [Programmatic Access](#programmatic-access).)

# Run the server (pinned CLI distribution)
uvx mcp-proxy-for-aws-cli@latest <SigV4 MCP endpoint URL>

**Note:** Because `mcp-proxy-for-aws-cli` pins its entire dependency tree inside the package, even `@latest` installs a tested, frozen set. Check [PyPI](https://pypi.org/project/mcp-proxy-for-aws-cli/) for available versions.

**Note:** The first run may take tens of seconds as `uvx` downloads and caches dependencies. Subsequent runs will start in seconds. Actual startup time depends on your network and hardware.

Using a local repository

git clone https://github.com/aws/mcp-proxy-for-aws.git
cd mcp-proxy-for-aws
uv run mcp_proxy_for_aws/server.py <SigV4 MCP endpoint URL>

Using Docker

Docker images are published to the [public AWS ECR registry](https://gallery.ecr.aws/mcp-proxy-for-aws/mcp-proxy-for-aws).

You can use the pre-built image:

# Pull the latest image
docker pull public.ecr.aws/mcp-proxy-for-aws/mcp-proxy-for-aws:latest

# Or pull a specific version
docker pull public.ecr.aws/mcp-proxy-for-aws/mcp-proxy-for-aws:1.1.6

Or build the image locally:

# Build the Docker image
docker build -t mcp-proxy-for-aws .

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 477 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. # MCP Proxy for AWS
  2. ## Overview
  3. The **MCP Proxy for AWS** package provides two ways to connect AI applications to MCP servers on AWS:
  4. 1. **Using it as a proxy** - It becomes a lightweight, client-side bridge between MCP clients (AI assistants like Claude Desktop, Kiro CLI) and MCP servers on AWS. (See [MCP Proxy](#mcp-proxy))
  5. 2. **Using it as a library** - Programmatically connect popular AI agent frameworks (LangChain, LlamaIndex, Strands Agents, etc.) to MCP servers on AWS. (See [Programmatic Access](#programmatic-access))
  6. ### When Do You Need This Package?
  7. - You want to connect to **MCP servers on AWS** (e.g., using Amazon Bedrock AgentCore) that use AWS IAM authentication (SigV4) instead of OAuth
  8. - You're using MCP clients (like Claude Desktop, Kiro CLI) that don't natively support AWS IAM authentication
  9. - You're building AI agents with popular frameworks like LangChain, Strands Agents, LlamaIndex, etc., that need to connect to MCP servers on AWS
  10. - You want to avoid building custom SigV4 request signing logic yourself
  11. ### How This Package Helps
  12. **The Problem:** The official MCP specification supports OAuth-based authentication, but MCP servers on AWS can also use AWS IAM authentication (SigV4). Standard MCP clients don't know how to sign requests with AWS credentials.
  13. **The Solution:** This package bridges that gap by:
  14. - **Handling SigV4 authentication automatically** - Uses your local AWS credentials (from AWS CLI, environment variables, or IAM roles) to sign all MCP requests using [SigV4](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_sigv.html)
  15. - **Providing seamless integration** - Works with existing MCP clients and frameworks
  16. - **Eliminating custom code** - No need to build your own MCP client with SigV4 signing logic
  17. ## Which Feature Should I Use?
  18. **Use as a proxy if you want to:**
  19. - Connect MCP clients like Claude Desktop or Kiro CLI to MCP servers on AWS with IAM credentials
  20. - Add MCP servers on AWS to your AI assistant's configuration
  21. - Use a command-line tool that runs as a bridge between your MCP client and AWS
  22. → Install **`mcp-proxy-for-aws-cli`**, the version-pinned CLI distribution: it freezes the entire dependency tree to tested versions. See [MCP Proxy](#mcp-proxy).
  23. **Use as a library if you want to:**
  24. - Build AI agents programmatically using popular frameworks like LangChain, Strands Agents, or LlamaIndex
  25. - Integrate AWS IAM-secured MCP servers directly into your Python applications
  26. - Have fine-grained control over the MCP session lifecycle in your code
  27. → Install **`mcp-proxy-for-aws`**, the library distribution: it keeps loose, co-resolvable dependency ranges so it resolves alongside your own dependencies. See [Programmatic Access](#programmatic-access).
  28. ## Prerequisites
  29. * [Install Python 3.11+](https://www.python.org/downloads/release/python-3110/)
  30. * [Install the `uv` package manager](https://docs.astral.sh/uv/getting-started/installation/)
  31. * AWS credentials configured (via [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html), environment variables, or IAM roles)
  32. * (Optional, for docker users) [Install Docker Desktop](https://www.docker.com/products/docker-desktop)
  33. ---
  34. ## MCP Proxy
  35. The MCP Proxy serves as a lightweight, client-side bridge between MCP clients (AI assistants and developer tools) and IAM-secured MCP servers on AWS. The proxy handles SigV4 authentication using local AWS credentials and provides dynamic tool discovery.
  36. ### Installation
  37. #### Using PyPi
  38. For CLI and `uvx` use, install **`mcp-proxy-for-aws-cli`**. It is a thin, version-pinned distribution: it freezes the proxy's entire transitive dependency tree to tested versions, so a fresh install cannot silently pull in a newer — possibly compromised — release of a dependency. (The unsuffixed `mcp-proxy-for-aws` is the library distribution with loose, co-resolvable ranges, for importing `mcp_proxy_for_aws` in your own code — see [Programmatic Access](#programmatic-access).)
  39. ```bash
  40. # Run the server (pinned CLI distribution)
  41. uvx mcp-proxy-for-aws-cli@latest <SigV4 MCP endpoint URL>
  42. ```
  43. **Note:** Because `mcp-proxy-for-aws-cli` pins its entire dependency tree inside the package, even `@latest` installs a tested, frozen set. Check [PyPI](https://pypi.org/project/mcp-proxy-for-aws-cli/) for available versions.
  44. **Note:** The first run may take tens of seconds as `uvx` downloads and caches dependencies. Subsequent runs will start in seconds. Actual startup time depends on your network and hardware.
  45. #### Using a local repository
  46. ```bash
  47. git clone https://github.com/aws/mcp-proxy-for-aws.git
  48. cd mcp-proxy-for-aws
  49. uv run mcp_proxy_for_aws/server.py <SigV4 MCP endpoint URL>
  50. ```
  51. #### Using Docker
  52. Docker images are published to the [public AWS ECR registry](https://gallery.ecr.aws/mcp-proxy-for-aws/mcp-proxy-for-aws).
  53. You can use the pre-built image:
  54. ```bash
  55. # Pull the latest image
  56. docker pull public.ecr.aws/mcp-proxy-for-aws/mcp-proxy-for-aws:latest
  57. # Or pull a specific version
  58. docker pull public.ecr.aws/mcp-proxy-for-aws/mcp-proxy-for-aws:1.1.6
  59. ```
  60. Or build the image locally:
  61. ```bash
  62. # Build the Docker image
  63. docker build -t mcp-proxy-for-aws .
  64. ```
  65. ### Configuration Parameters
  66. | Parameter | Description | Default |Required |
  67. |----------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------|--- |
  68. | `endpoint` | MCP endpoint URL (e.g., `https://your-service.us-east-1.amazonaws.com/mcp`) | N/A |Yes |
  69. | --- | --- | --- |--- |
  70. | `--service` | AWS service name for SigV4 signing, if omitted we try to infer this from the url | Inferred from endpoint if not provided |No |
  71. | `--profile` | AWS profile(s) to use. First profile is the default. Additional profiles enable per-call switching via `aws_profile` tool parameter (e.g., `--profile prod-readonly dev staging`) | Falls back to `AWS_PROFILE` if `--profile` and `AWS_MCP_PROXY_PROFILES` are not set |No |
  72. | `--region` | AWS region to use | Uses `AWS_REGION` environment variable if not set |No |
  73. | `--metadata` | Metadata to inject into MCP requests as key=value pairs (e.g., `--metadata KEY1=value1 KEY2=value2`) | `AWS_REGION` is automatically injected based on `--region` if not provided |No |
  74. | `--header` | Extra HTTP header as a key=value pair, repeat the flag for more (e.g., `--header x-tenant=acme --header x-trace=abc123`). Sent as real HTTP headers and covered by the SigV4 signature; values are redacted from logs. Headers set by signing (`authorization`, `date`, `x-amz-date`, `x-amz-security-token`) are rejected. | None |No |
  75. | `--read-only` | Disable tools which may require write permissions (tools which DO NOT require write permissions are annotated with [`readOnlyHint=true`](https://modelcontextprotocol.io/specification/2025-06-18/schema#toolannotations-readonlyhint)) | `False` |No |
  76. | `--retries` | Configures number of retries done when calling upstream services, setting this to 0 disables retries. | 0 |No |
  77. | `--log-level` | Set the logging level (`DEBUG/INFO/WARNING/ERROR/CRITICAL`) | `INFO` |No |
  78. | `--timeout` | Set desired timeout in seconds across all operations | 180 |No |
  79. | `--connect-timeout` | Set desired connect timeout in seconds | 60 |No |
  80. | `--read-timeout` | Set desired read timeout in seconds | 120 |No |
  81. | `--write-timeout` | Set desired write timeout in seconds | 180 |No |
  82. | `--tool-timeout` | Maximum seconds a tool call may take before being cancelled. When set, returns a graceful error to the agent instead of hanging indefinitely | 300 |No |
  83. | `--skip-auth` | Skip request signing when AWS credentials are unavailable instead of failing | `False` |No |
  84. | `--disable-telemetry` | Disables telemetry data collection | `False` |No |
  85. ### Optional Environment Variables
  86. Set the environment variables for the MCP Proxy for AWS:
  87. ```bash
  88. # Credentials through profile
  89. export AWS_PROFILE=<aws_profile>
  90. # Credentials through parameters
  91. export AWS_ACCESS_KEY_ID=<access_key_id>
  92. export AWS_SECRET_ACCESS_KEY=<secret_access_key>
  93. export AWS_SESSION_TOKEN=<session_token>
  94. # AWS Region
  95. export AWS_REGION=<aws_region>
  96. # Multi-profile switching (alternative to --profile flag, useful for plugin integration)
  97. export AWS_MCP_PROXY_PROFILES="prod-readonly dev staging"
  98. ```
  99. > [!NOTE]
  100. > `AWS_MCP_PROXY_PROFILES` takes precedence over `--profile` / `AWS_PROFILE` when set.
  101. > [!NOTE]
  102. > When getting a `NoRegionError` (surfaced by MCP clients as `-32603: You must specify a region.`) and using `aws login` profiles, please configure the region for the given profile using `aws configure set region <region>` or set `AWS_REGION`.
  103. ### Multi-account access
  104. The proxy supports per-call AWS profile switching, allowing agents to work across multiple accounts without restarting.
  105. **Configuration:**
  106. ```bash
  107. # Via CLI flag (first profile is default, rest are switchable)
  108. mcp-proxy-for-aws-cli https://aws-mcp.us-east-1.api.aws/mcp --profile prod-readonly dev staging
  109. # Via environment variable (same behavior, for plugin integration)
  110. AWS_MCP_PROXY_PROFILES="prod-readonly dev staging" mcp-proxy-for-aws-cli https://aws-mcp.us-east-1.api.aws/mcp
  111. ```
  112. **How it works:**
  113. - The proxy injects an `aws_profile` parameter into auth-requiring tools
  114. - The agent can pass `aws_profile` on any call to route it through a specific profile's credentials
  115. - If `aws_profile` is omitted, the default (first) profile is used
  116. - Invalid profiles are rejected with an error listing allowed values
  117. - Each non-default profile gets its own dedicated connection to the backend
  118. **Example MCP config (Kiro):**
  119. ```json
  120. {
  121. "mcpServers": {
  122. "aws": {
  123. "command": "uvx",
  124. "args": ["mcp-proxy-for-aws-cli@latest", "https://aws-mcp.us-east-1.api.aws/mcp"],
  125. "env": {
  126. "AWS_MCP_PROXY_PROFILES": "prod-readonly dev staging"
  127. }
  128. }
  129. }
  130. }
  131. ```
  132. ### Setup Examples
  133. Add the following configuration to your MCP client config file (e.g., for Kiro CLI, edit `~/.kiro/settings/mcp.json`):
  134. **Note** Add your own endpoint by replacing `<SigV4 MCP endpoint URL>`
  135. #### Running from local - using uv
  136. ```json
  137. {
  138. "mcpServers": {
  139. "<mcp server name>": {
  140. "disabled": false,
  141. "type": "stdio",
  142. "command": "uv",
  143. "args": [
  144. "--directory",
  145. "/path/to/mcp_proxy_for_aws",
  146. "run",
  147. "server.py",
  148. "<SigV4 MCP endpoint URL>",
  149. "--service",
  150. "<your service code>",
  151. "--profile",
  152. "default",
  153. "--region",
  154. "us-east-1",
  155. "--read-only",
  156. "--log-level",
  157. "INFO",
  158. ]
  159. }
  160. }
  161. }
  162. ```
  163. > [!NOTE]
  164. > Cline users should not use `--log-level` argument because Cline checks the log messages in stderr for text "error" (case insensitive).
  165. #### Using Docker
  166. Using the pre-built public ECR image:
  167. ```json
  168. {
  169. "mcpServers": {
  170. "<mcp server name>": {
  171. "command": "docker",
  172. "args": [
  173. "run",
  174. "-i",
  175. "--rm",
  176. "--volume",
  177. "/full/path/to/.aws:/app/.aws:ro",
  178. "public.ecr.aws/mcp-proxy-for-aws/mcp-proxy-for-aws:latest",
  179. "<SigV4 MCP endpoint URL>"
  180. ],
  181. "env": {}
  182. }
  183. }
  184. }
  185. ```
  186. Or using a locally built image:
  187. ```json
  188. {
  189. "mcpServers": {
  190. "<mcp server name>": {
  191. "command": "docker",
  192. "args": [
  193. "run",
  194. "--rm",
  195. "--volume",
  196. "/full/path/to/.aws:/app/.aws:ro",
  197. "mcp-proxy-for-aws",
  198. "<SigV4 MCP endpoint URL>"
  199. ],
  200. "env": {}
  201. }
  202. }
  203. }
  204. ```
  205. ---
  206. ## Programmatic Access
  207. The MCP Proxy for AWS enables programmatic integration of IAM-secured MCP servers into AI agent frameworks. The library provides authenticated transport layers that work with popular Python AI frameworks.
  208. By default, the library resolves AWS credentials automatically from the standard [boto3 credential chain](https://docs.aws.amazon.com/boto3/latest/guide/credentials.html#configuring-credentials) (environment variables, shared credentials file, etc.). You can optionally pass credentials programmatically via the `credentials` parameter. When provided, these take precedence over the `aws_profile` parameter. Note that `aws_region` must be explicitly specified when using `credentials`.
  209. ```python
  210. from botocore.credentials import Credentials
  211. from mcp_proxy_for_aws.client import aws_iam_streamablehttp_client
  212. creds = Credentials(access_key='...', secret_key='...', token='...')
  213. mcp_client = aws_iam_streamablehttp_client(
  214. endpoint=mcp_url,
  215. aws_region=region,
  216. aws_service=service,
  217. credentials=creds, # Optional: explicitly pass AWS credentials
  218. )
  219. ```
  220. #### Injecting Metadata
  221. You can inject metadata into the MCP `_meta` field on every request using the `metadata` parameter. This is useful for passing additional context to the server that cannot be sent as HTTP headers due to size limits.
  222. ```python
  223. from mcp_proxy_for_aws.client import aws_iam_streamablehttp_client
  224. mcp_client = aws_iam_streamablehttp_client(
  225. endpoint=mcp_url,
  226. aws_region=region,
  227. aws_service=service,
  228. metadata={
  229. 'custom/session-context': 'my-value',
  230. 'custom/tracking-id': 'abc-123',
  231. },
  232. )
  233. ```
  234. ### Integration Patterns
  235. The library supports two integration patterns depending on your framework:
  236. #### Pattern 1: Client Factory Integration
  237. **Use with:** Frameworks that accept a factory function that returns an MCP client, e.g. Strands Agents, Microsoft Agent Framework. The `aws_iam_streamablehttp_client` is passed as a factory to the framework, which handles the connection lifecycle internally.
  238. **Example - Strands Agents:**
  239. ```python
  240. from mcp_proxy_for_aws.client import aws_iam_streamablehttp_client
  241. mcp_client_factory = lambda: aws_iam_streamablehttp_client(
  242. endpoint=mcp_url, # The URL of the MCP server
  243. aws_region=region, # The region of the MCP server
  244. aws_service=service # The underlying AWS service, e.g. "bedrock-agentcore"
  245. )
  246. with MCPClient(mcp_client_factory) as mcp_client:
  247. mcp_tools = mcp_client.list_tools_sync()
  248. agent = Agent(tools=mcp_tools, ...)
  249. ```
  250. **Example - Microsoft Agent Framework:**
  251. ```python
  252. from mcp_proxy_for_aws.client import aws_iam_streamablehttp_client
  253. mcp_client_factory = lambda: aws_iam_streamablehttp_client(
  254. endpoint=mcp_url, # The URL of the MCP server
  255. aws_region=region, # The region of the MCP server
  256. aws_service=service # The underlying AWS service, e.g. "bedrock-agentcore"
  257. )
  258. mcp_tools = MCPStreamableHTTPTool(name="MCP Tools", url=mcp_url)
  259. mcp_tools.get_mcp_client = mcp_client_factory
  260. async with mcp_tools:
  261. agent = ChatAgent(tools=[mcp_tools], ...)
  262. ```
  263. #### Pattern 2: Direct MCP Session Integration
  264. **Use with:** Frameworks that require direct access to the MCP sessions, e.g. LangChain, LlamaIndex. The `aws_iam_streamablehttp_client` provides the authenticated transport streams, which are then used to create an MCP `ClientSession`.
  265. > `aws_iam_streamablehttp_client` yields two streams, a reader and a writer. Frameworks that
  266. > cap the MCP Python SDK below the major this project requires (currently Microsoft Agent
  267. > Framework and the LangChain MCP adapters) cannot consume them.
  268. **Example - LangChain:**
  269. ```python
  270. from mcp_proxy_for_aws.client import aws_iam_streamablehttp_client
  271. mcp_client = aws_iam_streamablehttp_client(
  272. endpoint=mcp_url, # The URL of the MCP server
  273. aws_region=region, # The region of the MCP server
  274. aws_service=service # The underlying AWS service, e.g. "bedrock-agentcore"
  275. )
  276. async with mcp_client as (read, write):
  277. async with ClientSession(read, write) as session:
  278. mcp_tools = await load_mcp_tools(session)
  279. agent = create_langchain_agent(tools=mcp_tools, ...)
  280. ```
  281. **Example - LlamaIndex:**
  282. ```python
  283. from mcp_proxy_for_aws.client import aws_iam_streamablehttp_client
  284. mcp_client = aws_iam_streamablehttp_client(
  285. endpoint=mcp_url, # The URL of the MCP server
  286. aws_region=region, # The region of the MCP server
  287. aws_service=service # The underlying AWS service, e.g. "bedrock-agentcore"
  288. )
  289. async with mcp_client as (read, write):
  290. async with ClientSession(read, write) as session:
  291. mcp_tools = await McpToolSpec(client=session).to_tool_list_async()
  292. agent = ReActAgent(tools=mcp_tools, ...)
  293. ```
  294. ### Running Examples
  295. Explore complete working examples for different frameworks in the [`./examples/mcp-client`](./examples/mcp-client) directory:
  296. **Available examples:**
  297. - **[LangChain](./examples/mcp-client/langchain/)**
  298. - **[LlamaIndex](./examples/mcp-client/llamaindex/)**
  299. - **[Microsoft Agent Framework](./examples/mcp-client/agent-framework/)**
  300. - **[Strands Agents SDK](./examples/mcp-client/strands/)**
  301. Run examples individually:
  302. ```bash
  303. cd examples/mcp-client/[framework] # e.g. examples/mcp-client/strands
  304. uv run main.py
  305. ```
  306. ### Installation
  307. For programmatic/library use, install **`mcp-proxy-for-aws`** — the distribution with loose, co-resolvable dependency ranges. (For CLI/`uvx` use, install `mcp-proxy-for-aws-cli` instead, which pins the whole dependency tree — see [MCP Proxy](#mcp-proxy).)
  308. The client library is included when you install the package:
  309. ```bash
  310. pip install mcp-proxy-for-aws
  311. ```
  312. For development:
  313. ```bash
  314. git clone https://github.com/aws/mcp-proxy-for-aws.git
  315. cd mcp-proxy-for-aws
  316. uv sync
  317. ```
  318. ---
  319. ## Troubleshooting
  320. ### Authentication errors
  321. We try to autodetect the service from the url, sometimes this fails, ensure that `--service` is set correctly to the
  322. service you are attempting to connect to.
  323. Otherwise the SigV4 signing will not be able to be verified by the service you connect to, resulting in this error.
  324. Also ensure that you have valid IAM credentials on your machine before retrying.
  325. For long-running sessions, consider using long-lived credentials:
  326. - Use an AWS profile via `--profile`
  327. - Use IAM Identity Center and run `aws sso login` before starting the proxy
  328. The proxy reads fresh credentials from disk on every request, so credential refreshes and account switches take effect immediately — no restart or retry required. Simply refresh your credentials (e.g., `aws sso login`) and the next request will use them.
  329. ### Client hangs on tool calls
  330. If your MCP client hangs waiting for a tool call response (e.g., due to an unresponsive endpoint), use `--tool-timeout` to set a maximum duration in seconds for each tool call. When the timeout is exceeded, the proxy returns a graceful error to the agent instead of hanging indefinitely.
  331. ### Unsigned requests
  332. By default, the proxy signs all outgoing requests with [SigV4](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_sigv.html) using your local AWS credentials. If you need to connect to an MCP endpoint that does not require SigV4 credentials (e.g., a local development server or a publicly accessible endpoint), use the `--skip-auth` flag:
  333. ```bash
  334. uvx mcp-proxy-for-aws-cli@latest https://my-endpoint.example.com/mcp --skip-auth
  335. ```
  336. When `--skip-auth` is set, the proxy sends requests without signing them if AWS credentials are unavailable. If credentials _are_ available, requests are still signed as usual — the flag only changes behavior when credentials cannot be resolved.
  337. ## Development & Contributing
  338. For development setup, testing, and contribution guidelines, see:
  339. * [DEVELOPMENT.md](DEVELOPMENT.md) - Development environment setup and testing
  340. * [CONTRIBUTING.md](CONTRIBUTING.md) - How to contribute to this project
  341. Resources to understand SigV4:
  342. - SigV4 User Guide: <https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_sigv.html>
  343. - SigV4 Signers: <https://github.com/boto/botocore/blob/develop/botocore/signers.py>
  344. - SigV4a: <https://github.com/aws-samples/sigv4a-signing-examples/blob/main/python/sigv4a_sign.py>
  345. ## License
  346. Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  347. Licensed under the Apache License, Version 2.0 (the "License").
  348. ## Disclaimer
  349. LLMs are non-deterministic and they make mistakes, we advise you to always thoroughly test and follow the best practices of your organization before using these tools on customer facing accounts. Users of this package are solely responsible for implementing proper security controls and MUST use AWS Identity and Access Management (IAM) to manage access to AWS resources. You are responsible for configuring appropriate IAM policies, roles, and permissions, and any security vulnerabilities resulting from improper IAM configuration are your sole responsibility. By using this package, you acknowledge that you have read and understood this disclaimer and agree to use the package at your own risk.
  350. <!-- mcp-name: io.github.aws/mcp-proxy-for-aws -->
  351. <!-- mcp-name: io.github.aws/aws-mcp -->
  352. <!-- mcp-name: aws.api.us-east-1.eks-mcp/server -->
  353. <!-- mcp-name: aws.api.us-east-1.ecs-mcp/server -->

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.