AWS MCP Servers

Um conjunto de servidores MCP que fornecem a aplicações de IA acesso à documentação da AWS, orientação contextual e melhores práticas.

GitHubExperimente este MCPPatrocinado

Documentação

AWS MCP Servers

Um conjunto de servidores MCP especializados que ajudam você a aproveitar ao máximo a AWS, onde quer que use MCP.

GitHub License Codecov OSSF-Scorecard Score

Sumário

O que é o Model Context Protocol (MCP) e como ele funciona com os AWS MCP Servers?

O Model Context Protocol (MCP) é um protocolo aberto que permite integração perfeita entre aplicações de LLM e fontes de dados e ferramentas externas. Esteja você construindo uma IDE com IA, aprimorando uma interface de chat ou criando fluxos de trabalho de IA personalizados, o MCP fornece uma maneira padronizada de conectar LLMs ao contexto de que precisam.

— Model Context Protocol README

Um servidor MCP é um programa leve que expõe capacidades específicas por meio do Model Context Protocol padronizado. Aplicações host (como chatbots, IDEs e outras ferramentas de IA) possuem clientes MCP que mantêm conexões 1:1 com servidores MCP. Clientes MCP comuns incluem assistentes de codificação com IA agêntica (como Q Developer, Cline, Cursor, Windsurf), bem como aplicações de chatbot como Claude Desktop, com mais clientes em breve. Os servidores MCP podem acessar fontes de dados locais e serviços remotos para fornecer contexto adicional que melhora as saídas geradas pelos modelos.

Os AWS MCP Servers usam esse protocolo para fornecer a aplicações de IA acesso à documentação da AWS, orientação contextual e melhores práticas. Por meio da arquitetura padronizada de cliente-servidor MCP, as capacidades da AWS se tornam uma extensão inteligente do seu ambiente de desenvolvimento ou aplicação de IA.

Os AWS MCP Servers permitem desenvolvimento nativo em nuvem aprimorado, gerenciamento de infraestrutura e fluxos de trabalho de desenvolvimento — tornando a computação em nuvem assistida por IA mais acessível e eficiente.

O Model Context Protocol é um projeto de código aberto administrado pela Anthropic, PBC, e aberto a contribuições de toda a comunidade. Para mais informações sobre o MCP, você pode encontrar documentação adicional aqui

Remoção do Suporte a Server Sent Events

Aviso Importante: Em 26 de maio de 2025, o suporte a Server Sent Events (SSE) foi removido de todos os servidores MCP em suas versões principais mais recentes. Essa mudança está alinhada às diretrizes de compatibilidade retroativa da especificação do Model Context Protocol.

Estamos trabalhando ativamente para oferecer suporte a Streamable HTTP, que fornecerá capacidades de transporte aprimoradas para versões futuras.

Para aplicações que ainda exigem suporte a SSE, use a versão principal anterior do respectivo servidor MCP até que você possa migrar para métodos de transporte alternativos.

Por que AWS MCP Servers?

Os servidores MCP aprimoram as capacidades dos modelos de fundação (FMs) de várias maneiras importantes:

  • Qualidade de Saída Aprimorada: Ao fornecer informações relevantes diretamente no contexto do modelo, os servidores MCP melhoram significativamente as respostas do modelo para domínios especializados, como serviços da AWS. Isso reduz alucinações, fornece detalhes técnicos mais precisos, permite geração de código mais precisa e garante que as recomendações estejam alinhadas com as melhores práticas atuais da AWS e as capacidades dos serviços.

  • Acesso à Documentação Mais Recente: Os FMs podem não ter conhecimento de lançamentos, APIs ou SDKs recentes. Os servidores MCP preenchem essa lacuna ao buscar documentação atualizada, garantindo que seu assistente de IA sempre trabalhe com as capacidades mais recentes da AWS.

  • Automação de Fluxos de Trabalho: Os servidores MCP convertem fluxos de trabalho comuns em ferramentas que os modelos de fundação podem usar diretamente. Seja CDK, Terraform ou outros fluxos de trabalho específicos da AWS, essas ferramentas permitem que assistentes de IA executem tarefas complexas com maior precisão e eficiência.

  • Conhecimento Especializado de Domínio: Os servidores MCP fornecem conhecimento profundo e contextual sobre os serviços da AWS que pode não estar totalmente representado nos dados de treinamento dos modelos de fundação, permitindo respostas mais precisas e úteis para tarefas de desenvolvimento em nuvem.

Servidores MCP Disponíveis

Navegue pelo que você está construindo

📚 Acesso em tempo real à documentação oficial da AWS

🏗️ Infraestrutura e Implantação

Construa, implante e gerencie infraestrutura em nuvem com as melhores práticas de Infraestrutura como Código.

Infraestrutura como Código
Plataformas de Contêineres
Serverless e Funções
Suporte

🤖 IA e Aprendizado de Máquina

Aprimore aplicações de IA com recuperação de conhecimento, geração de conteúdo e capacidades de ML.

📊 Dados e Análises

Trabalhe com bancos de dados, sistemas de cache e fluxos de trabalho de processamento de dados.

Bancos de Dados SQL e NoSQL
Busca e Análises
Cache e Desempenho

🛠️ Ferramentas de Desenvolvimento e Suporte

Acelere o desenvolvimento com análise de código, documentação e utilitários de teste.

📡 Integração e Mensageria

Conecte sistemas com mensageria, fluxos de trabalho e serviços de localização.

💰 Custos e Operações

Monitore, otimize e gerencie sua infraestrutura e custos da AWS.

Navegue por como você está trabalhando

👨‍💻 Vibe Coding e Desenvolvimento

Assistentes de codificação por IA como Amazon Q Developer CLI, Cline, Cursor e Claude Code ajudando você a construir mais rápido

Fluxo de Trabalho de Desenvolvimento Principal
Infraestrutura como Código
Desenvolvimento de Aplicações
Desenvolvimento de Contêineres e Serverless
Testes e Dados

💬 Assistentes Conversacionais

Chatbots voltados para clientes, agentes de negócios e sistemas interativos de perguntas e respostas

Conhecimento e Pesquisa
Processamento e Geração de Conteúdo
Serviços de Negócios

🤖 Agentes Autônomos em Segundo Plano

Automação headless, pipelines ETL e sistemas operacionais

Operações de Dados e ETL
Cache e Desempenho
Fluxo de Trabalho e Integração
Operações e Monitoramento

Módulo MCP AWS Lambda Handler

Uma biblioteca Python para criar manipuladores HTTP serverless para o Model Context Protocol (MCP) usando AWS Lambda. Este módulo fornece uma estrutura flexível para construir endpoints HTTP MCP com gerenciamento de sessão plugável, incluindo suporte integrado ao DynamoDB.

Recursos:

  • Criação fácil de manipuladores HTTP MCP serverless usando AWS Lambda
  • Sistema de gerenciamento de sessão plugável
  • Suporte integrado ao backend de sessão DynamoDB
  • Autenticação e autorização personalizáveis
  • Implementações de exemplo e testes

Consulte src/mcp-lambda-handler/README.md para instruções completas de uso, instalação e desenvolvimento.

Casos de Uso para os Servidores

Por exemplo, você pode usar o AWS Documentation MCP Server para ajudar seu assistente de IA a pesquisar e gerar código atualizado para qualquer serviço AWS, como agentes inline do Amazon Bedrock. Alternativamente, você pode usar o CDK MCP Server ou o Terraform MCP Server para que seu assistente de IA crie implementações de infraestrutura como código que usam as APIs mais recentes e seguem as melhores práticas da AWS. Com o Cost Analysis MCP Server, você pode perguntar "Qual seria o custo mensal estimado para este projeto CDK antes de eu implantá-lo?" ou "Você pode me ajudar a entender as possíveis despesas de serviços AWS para este design de infraestrutura?" e receber estimativas detalhadas de custos e insights de planejamento orçamentário. O Valkey MCP Server permite interação em linguagem natural com armazenamentos de dados Valkey, permitindo que assistentes de IA gerenciem operações de dados de forma eficiente através de uma interface conversacional simples.

Instalação e Configuração

Cada servidor tem instruções de instalação específicas. Geralmente, você pode:

  1. Instale uv do Astral
  2. Instale Python usando uv python install 3.10
  3. Configure as credenciais AWS com acesso aos serviços necessários
  4. Adicione o servidor à configuração do seu cliente MCP

Exemplo de configuração para Amazon Q CLI MCP (~/.aws/amazonq/mcp.json):

{
  "mcpServers": {
    "awslabs.core-mcp-server": {
      "command": "uvx",
      "args": [
        "awslabs.core-mcp-server@latest"
      ],
      "env": {
        "FASTMCP_LOG_LEVEL": "ERROR"
      }
    },
    "awslabs.nova-canvas-mcp-server": {
      "command": "uvx",
      "args": [
        "awslabs.nova-canvas-mcp-server@latest"
      ],
      "env": {
        "AWS_PROFILE": "your-aws-profile",
        "AWS_REGION": "us-east-1",
        "FASTMCP_LOG_LEVEL": "ERROR"
      }
    },
    "awslabs.bedrock-kb-retrieval-mcp-server": {
      "command": "uvx",
      "args": [
        "awslabs.bedrock-kb-retrieval-mcp-server@latest"
      ],
      "env": {
        "AWS_PROFILE": "your-aws-profile",
        "AWS_REGION": "us-east-1",
        "FASTMCP_LOG_LEVEL": "ERROR"
      }
    },
    "awslabs.cost-analysis-mcp-server": {
      "command": "uvx",
      "args": [
        "awslabs.cost-analysis-mcp-server@latest"
      ],
      "env": {
        "AWS_PROFILE": "your-aws-profile",
        "FASTMCP_LOG_LEVEL": "ERROR"
      }
    },
    "awslabs.cdk-mcp-server": {
      "command": "uvx",
      "args": [
        "awslabs.cdk-mcp-server@latest"
      ],
      "env": {
        "FASTMCP_LOG_LEVEL": "ERROR"
      }
    },
    "awslabs.aws-documentation-mcp-server": {
      "command": "uvx",
      "args": [
        "awslabs.aws-documentation-mcp-server@latest"
      ],
      "env": {
        "FASTMCP_LOG_LEVEL": "ERROR"
      },
      "disabled": false,
      "autoApprove": []
    },
    "awslabs.lambda-tool-mcp-server": {
      "command": "uvx",
      "args": [
        "awslabs.lambda-tool-mcp-server@latest"
      ],
      "env": {
        "AWS_PROFILE": "your-aws-profile",
        "AWS_REGION": "us-east-1",
        "FUNCTION_PREFIX": "your-function-prefix",
        "FUNCTION_LIST": "your-first-function, your-second-function",
        "FUNCTION_TAG_KEY": "your-tag-key",
        "FUNCTION_TAG_VALUE": "your-tag-value"
      }
    },
    "awslabs.terraform-mcp-server": {
      "command": "uvx",
      "args": [
        "awslabs.terraform-mcp-server@latest"
      ],
      "env": {
        "FASTMCP_LOG_LEVEL": "ERROR"
      },
      "disabled": false,
      "autoApprove": []
    },
    "awslabs.frontend-mcp-server": {
      "command": "uvx",
      "args": [
        "awslabs.frontend-mcp-server@latest"
      ],
      "env": {
        "FASTMCP_LOG_LEVEL": "ERROR"
      },
      "disabled": false,
      "autoApprove": []
    },
    "awslabs.valkey-mcp-server": {
      "command": "uvx",
      "args": [
        "awslabs.valkey-mcp-server@latest"
      ],
      "env": {
        "VALKEY_HOST": "127.0.0.1",
        "VALKEY_PORT": "6379",
        "FASTMCP_LOG_LEVEL": "ERROR"
      },
      "autoApprove": [],
      "disabled": false
    },
    "awslabs.aws-location-mcp-server": {
      "command": "uvx",
      "args": [
        "awslabs.aws-location-mcp-server@latest"
      ],
      "env": {
        "AWS_PROFILE": "your-aws-profile",
        "AWS_REGION": "us-east-1",
        "FASTMCP_LOG_LEVEL": "ERROR"
      },
      "disabled": false,
      "autoApprove": []
    },
    "awslabs.memcached-mcp-server": {
      "command": "uvx",
      "args": [
        "awslabs.memcached-mcp-server@latest"
      ],
      "env": {
        "MEMCACHED_HOST": "127.0.0.1",
        "MEMCACHED_PORT": "11211",
        "FASTMCP_LOG_LEVEL": "ERROR"
      },
      "autoApprove": [],
      "disabled": false
    },
    "awslabs.git-repo-research-mcp-server": {
      "command": "uvx",
      "args": [
        "awslabs.git-repo-research-mcp-server@latest"
      ],
      "env": {
        "AWS_PROFILE": "your-aws-profile",
        "AWS_REGION": "us-east-1",
        "FASTMCP_LOG_LEVEL": "ERROR",
        "GITHUB_TOKEN": "your-github-token"
      },
      "disabled": false,
      "autoApprove": []
    },
    "awslabs.cloudformation": {
      "command": "uvx",
      "args": [
        "awslabs.cfn-mcp-server@latest"
      ],
      "env": {
        "AWS_PROFILE": "your-aws-profile"
      },
      "disabled": false,
      "autoApprove": []
    }
  }
}

Consulte os READMEs individuais dos servidores para requisitos específicos e opções de configuração.

Se você tiver problemas com a configuração MCP ou quiser verificar se os parâmetros apropriados estão em vigor, você pode tentar o seguinte:

# Run MCP server manually with timeout 15s
$ timeout 15s uv tool run <MCP Name> <args> 2>&1 || echo "Command completed or timed out"

# Example (Aurora MySQL MCP Server)
$ timeout 15s uv tool run awslabs.mysql-mcp-server --resource_arn <Your Resource ARN> --secret_arn <Your Secret ARN> ... 2>&1 || echo "Command completed or timed out"

# If the arguments are not set appropriately, you may see the following message:
usage: awslabs.mysql-mcp-server [-h] --resource_arn RESOURCE_ARN --secret_arn SECRET_ARN --database DATABASE
                                --region REGION --readonly READONLY
awslabs.mysql-mcp-server: error: the following arguments are required: --resource_arn, --secret_arn, --database, --region, --readonly

Nota sobre desempenho ao usar o sufixo uvx "@latest":

Usar o sufixo "@latest" verifica e baixa o pacote mais recente do servidor MCP do pypi toda vez que você inicia seus clientes MCP, mas isso tem o custo de aumentar os tempos de carregamento inicial. Se você quiser minimizar o tempo de carregamento inicial, remova "@latest" e gerencie seu cache uv você mesmo usando uma destas abordagens:

  • uv cache clean <tool>: onde {tool} é o servidor mcp que você deseja excluir do cache e instalar novamente (ex.: "awslabs.lambda-tool-mcp-server") (lembre-se de remover os '<>').
  • uvx <tool>@latest: isso atualizará a ferramenta com a versão mais recente e a adicionará ao cache uv.

Executando servidores MCP em contêineres

Este exemplo usa docker com o "awslabs.nova-canvas-mcp-server e pode ser repetido para cada servidor MCP

  • Construa e marque a imagem

    cd src/nova-canvas-mcp-server
docker build -t awslabs/nova-canvas-mcp-server .

  • Opcionalmente, salve variáveis de ambiente sensíveis em um arquivo:

    # contents of a .env file with fictitious AWS temporary credentials
AWS_ACCESS_KEY_ID=ASIAIOSFODNN7EXAMPLE
AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
AWS_SESSION_TOKEN=AQoEXAMPLEH4aoAH0gNCAPy...truncated...zrkuWJOgQs8IZZaIv2BXIa2R4Olgk

  • Use as opções do docker: --env, --env-file e --volume conforme necessário, pois os "env": {} não estão disponíveis dentro do contêiner.

    {
  "mcpServers": {
    "awslabs.nova-canvas-mcp-server": {
      "command": "docker",
      "args": [
        "run",
        "--rm",
        "--interactive",
        "--env",
        "FASTMCP_LOG_LEVEL=ERROR",
        "--env",
        "AWS_REGION=us-east-1",
        "--env-file",
        "/full/path/to/.env",
        "--volume",
        "/full/path/to/.aws:/app/.aws",
        "awslabs/nova-canvas-mcp-server:latest"
      ],
      "env": {}
    }
  }
}

Começando com Cline e Amazon Bedrock

Getting Started with Cline and Amazon Bedrock

IMPORTANTE: Seguir estas instruções pode incorrer em custos e está sujeito ao Preço do Amazon Bedrock. Você é responsável por quaisquer custos associados. Além de selecionar o modelo desejado nas configurações do Cline, certifique-se de que o modelo selecionado (ex.: anthropic.claude-3-7-sonnet) também esteja habilitado no Amazon Bedrock. Para mais informações, consulte estes documentos da AWS sobre como habilitar o acesso a modelos no Amazon Bedrock Foundation Models (FMs).

  1. Siga os passos acima na seção Instalação e Configuração para instalar uv do Astral, instalar Python e configurar as credenciais AWS com os serviços necessários.

  2. Se estiver usando o Visual Studio Code, instale a Extensão Cline para VS Code (ou extensão equivalente para sua IDE preferida). Depois de instalada, clique na extensão para abri-la. Quando solicitado, selecione o nível que desejar. Neste caso, usaremos o Amazon Bedrock, então o nível gratuito do Cline é suficiente, pois enviaremos solicitações usando a API do Amazon Bedrock em vez da API do Cline.

  1. Selecione o botão MCP Servers.

  1. Selecione a aba Instalado e clique em Configurar Servidores MCP para abrir o arquivo cline_mcp_settings.json.

  1. No arquivo cline_mcp_settings.json, adicione os servidores MCP desejados no objeto mcpServers. Veja o exemplo a seguir que usará alguns dos servidores AWS MCP atuais disponíveis neste repositório. Certifique-se de salvar o arquivo para instalar os servidores MCP.

cline_mcp_settings.json

{
  "mcpServers": {
    "awslabs.core-mcp-server": {
      "command": "uvx",
      "args": ["awslabs.core-mcp-server@latest"],
      "env": {
        "FASTMCP_LOG_LEVEL": "ERROR",
        "MCP_SETTINGS_PATH": "path to your mcp settings file"
      }
    },
    "awslabs.nova-canvas-mcp-server": {
      "command": "uvx",
      "args": ["awslabs.nova-canvas-mcp-server@latest"],
      "env": {
        "AWS_PROFILE": "your-aws-profile",
        "AWS_REGION": "us-east-1",
        "FASTMCP_LOG_LEVEL": "ERROR"
      }
    },
    "awslabs.terraform-mcp-server": {
      "command": "uvx",
      "args": ["awslabs.terraform-mcp-server@latest"],
      "env": {
        "FASTMCP_LOG_LEVEL": "ERROR"
      },
      "disabled": false,
      "autoApprove": []
    },
   }
 }
  1. Depois de instalados, você deve ver uma lista dos seus Servidores MCP na aba Servidores MCP Instalados, e eles devem ter um controle deslizante verde para mostrar que estão habilitados. Veja o seguinte exemplo com dois dos possíveis Servidores AWS MCP. Clique em Concluído quando terminar. Agora você deve ver a interface de chat do Cline.

  1. Por padrão, o Cline será definido como provedor de API, que tem limites para o nível gratuito. Em seguida, vamos atualizar o provedor de API para AWS Bedrock, para que possamos usar os LLMs através do Bedrock, o que fará a cobrança passar pela sua conta AWS conectada.

  2. Clique no ícone de engrenagem para abrir as configurações do Cline. Em seguida, em Provedor de API, altere de Cline para AWS Bedrock e selecione AWS Profile para o tipo de autenticação. Como nota, a opção AWS Credentials também funciona, porém usa credenciais estáticas (Access Key ID e Secret Access Key) em vez de credenciais temporárias que são redistribuídas automaticamente quando o token expira, então as credenciais temporárias com um Perfil AWS são o método mais seguro e recomendado.

  1. Preencha a configuração com base no Perfil AWS existente que você deseja usar, selecione a Região AWS desejada e habilite a inferência entre regiões.

  1. Em seguida, role para baixo na página de configurações até chegar à caixa de texto que diz Instruções Personalizadas. Cole o trecho a seguir para garantir que o servidor mcp-core seja usado como ponto de partida para cada prompt:
For every new project, always look at your MCP servers and use mcp-core as the starting point every time. Also after a task completion include the list of MCP servers used in the operation.

  1. Depois que o prompt personalizado for colado, clique em Concluído para retornar à interface de chat.
  2. Agora você pode começar a fazer perguntas e testar a funcionalidade dos seus AWS MCP Servers instalados. A opção padrão na interface de chat é Plan, que fornecerá a saída para você tomar ação manual (por exemplo, fornecendo uma configuração de exemplo que você copia e cola em um arquivo). No entanto, você pode opcionalmente alternar para Act, que permitirá que o Cline aja em seu nome (por exemplo, pesquisando conteúdo usando um navegador web, clonando um repositório, executando código, etc). Você pode opcionalmente ativar a seção "Auto-approve" para evitar ter que clicar para aprovar as sugestões, no entanto, recomendamos deixar isso desativado durante os testes, especialmente se você tiver a opção Act selecionada.

Nota: Para obter os melhores resultados, por favor, solicite ao Cline que use o AWS MCP Server desejado que você deseja usar. Por exemplo, Using the Terraform MCP Server, do...

Começando com o Cursor

Começando com o Cursor

  1. Siga os passos acima na seção Instalação e Configuração para instalar uv do Astral, instalar Python e configurar as credenciais AWS com os serviços necessários.

  2. Você pode colocar a configuração MCP em dois locais, dependendo do seu caso de uso:

A. Configuração do Projeto - Para ferramentas específicas de um projeto, crie um arquivo .cursor/mcp.json no diretório do seu projeto. - Isso permite que você defina servidores MCP que estão disponíveis apenas dentro daquele projeto específico.

B. Configuração Global - Para ferramentas que você deseja usar em todos os projetos, crie um arquivo ~/.cursor/mcp.json no seu diretório inicial. - Isso torna os servidores MCP disponíveis em todos os seus espaços de trabalho do Cursor.

.cursor/mcp.json

 {
  "mcpServers": {
    "awslabs.core-mcp-server": {
      "command": "uvx",
      "args": ["awslabs.core-mcp-server@latest"],
      "env": {
        "FASTMCP_LOG_LEVEL": "ERROR"
      }
    },
    "awslabs.nova-canvas-mcp-server": {
      "command": "uvx",
      "args": ["awslabs.nova-canvas-mcp-server@latest"],
      "env": {
        "AWS_PROFILE": "your-aws-profile",
        "AWS_REGION": "us-east-1",
        "FASTMCP_LOG_LEVEL": "ERROR"
      }
    },
    "awslabs.bedrock-kb-retrieval-mcp-server": {
      "command": "uvx",
      "args": ["awslabs.bedrock-kb-retrieval-mcp-server@latest"],
      "env": {
        "AWS_PROFILE": "your-aws-profile",
        "AWS_REGION": "us-east-1",
        "FASTMCP_LOG_LEVEL": "ERROR"
      }
    },
    "awslabs.cost-analysis-mcp-server": {
      "command": "uvx",
      "args": ["awslabs.cost-analysis-mcp-server@latest"],
      "env": {
        "AWS_PROFILE": "your-aws-profile",
        "FASTMCP_LOG_LEVEL": "ERROR"
      }
    },
    "awslabs.cdk-mcp-server": {
      "command": "uvx",
      "args": ["awslabs.cdk-mcp-server@latest"],
      "env": {
        "FASTMCP_LOG_LEVEL": "ERROR"
      }
    },
    "awslabs.aws-documentation-mcp-server": {
      "command": "uvx",
      "args": ["awslabs.aws-documentation-mcp-server@latest"],
      "env": {
        "FASTMCP_LOG_LEVEL": "ERROR"
      },
      "disabled": false,
      "autoApprove": []
    },
    "awslabs.lambda-tool-mcp-server": {
      "command": "uvx",
      "args": ["awslabs.lambda-tool-mcp-server@latest"],
      "env": {
        "AWS_PROFILE": "your-aws-profile",
        "AWS_REGION": "us-east-1",
        "FUNCTION_PREFIX": "your-function-prefix",
        "FUNCTION_LIST": "your-first-function, your-second-function",
        "FUNCTION_TAG_KEY": "your-tag-key",
        "FUNCTION_TAG_VALUE": "your-tag-value"
      }
    },
    "awslabs.terraform-mcp-server": {
       "command": "uvx",
       "args": ["awslabs.terraform-mcp-server@latest"],
       "env": {
         "FASTMCP_LOG_LEVEL": "ERROR"
       },
       "disabled": false,
       "autoApprove": []
     },
    "awslabs.frontend-mcp-server": {
       "command": "uvx",
       "args": ["awslabs.frontend-mcp-server@latest"],
       "env": {
         "FASTMCP_LOG_LEVEL": "ERROR"
       },
       "disabled": false,
       "autoApprove": []
     },
      "awslabs.valkey-mcp-server": {
        "command": "uvx",
        "args": ["awslabs.valkey-mcp-server@latest"],
        "env": {
          "VALKEY_HOST": "127.0.0.1",
          "VALKEY_PORT": "6379",
          "FASTMCP_LOG_LEVEL": "ERROR"
        },
        "autoApprove": [],
        "disabled": false
      },
    "awslabs.aws-location-mcp-server": {
       "command": "uvx",
       "args": ["awslabs.aws-location-mcp-server@latest"],
       "env": {
         "AWS_PROFILE": "your-aws-profile",
         "AWS_REGION": "us-east-1",
         "FASTMCP_LOG_LEVEL": "ERROR"
       },
       "disabled": false,
       "autoApprove": []
    },
    "awslabs.memcached-mcp-server": {
        "command": "uvx",
        "args": ["awslabs.memcached-mcp-server@latest"],
        "env": {
          "MEMCACHED_HOST": "127.0.0.1",
          "MEMCACHED_PORT": "11211",
          "FASTMCP_LOG_LEVEL": "ERROR"
        },
        "autoApprove": [],
        "disabled": false
    },
    "awslabs.git-repo-research-mcp-server": {
      "command": "uvx",
      "args": ["awslabs.git-repo-research-mcp-server@latest"],
      "env": {
        "AWS_PROFILE": "your-aws-profile",
        "AWS_REGION": "us-east-1",
        "FASTMCP_LOG_LEVEL": "ERROR",
        "GITHUB_TOKEN": "your-github-token"
      },
      "disabled": false,
      "autoApprove": []
    },
    "awslabs.cloudformation": {
      "command": "uvx",
      "args": ["awslabs.cfn-mcp-server@latest"],
      "env": {
        "AWS_PROFILE": "your-aws-profile"
      },
      "disabled": false,
      "autoApprove": []
    }
  }
}

  1. Usando MCP no Chat O Composer Agent usará automaticamente qualquer ferramenta MCP listada em Ferramentas Disponíveis na página de configurações do MCP se ele determinar que são relevantes. Para solicitar o uso intencional de ferramentas, por favor, solicite ao Cursor que use o AWS MCP Server desejado que você deseja usar. Por exemplo, Using the Terraform MCP Server, do...

  2. Aprovação de Ferramentas Por padrão, quando o Agent deseja usar uma ferramenta MCP, ele exibirá uma mensagem pedindo sua aprovação. Você pode usar a seta ao lado do nome da ferramenta para expandir a mensagem e ver com quais argumentos o Agent está chamando a ferramenta.

Começando com o Windsurf

Começando com o Windsurf

  1. Siga os passos acima na seção Instalação e Configuração para instalar uv do Astral, instalar Python e configurar as credenciais AWS com os serviços necessários.

  2. Acessar Configurações do MCP

    • Navegue até Windsurf - Configurações > Configurações Avançadas ou use a Paleta de Comandos > Abrir Página de Configurações do Windsurf
    • Procure pela seção "Model Context Protocol (MCP) Servers"

  3. Adicionar Servidores MCP

    • Clique em "Add Server" para adicionar um novo servidor MCP
    • Você pode escolher entre modelos disponíveis como GitHub, Puppeteer, PostgreSQL, etc.
    • Alternativamente, clique em "Add custom server" para configurar seu próprio servidor

  4. Configuração Manual

    • Você também pode editar manualmente o arquivo de configuração MCP localizado em ~/.codeium/windsurf/mcp_config.json

~/.codeium/windsurf/mcp_config.json

{
  "mcpServers": {
    "awslabs.core-mcp-server": {
      "command": "uvx",
      "args": ["awslabs.core-mcp-server@latest"],
      "env": {
        "FASTMCP_LOG_LEVEL": "ERROR",
        "MCP_SETTINGS_PATH": "path to your mcp settings file"
      }
    },
    "awslabs.nova-canvas-mcp-server": {
      "command": "uvx",
      "args": ["awslabs.nova-canvas-mcp-server@latest"],
      "env": {
        "AWS_PROFILE": "your-aws-profile",
        "AWS_REGION": "us-east-1",
        "FASTMCP_LOG_LEVEL": "ERROR"
      }
    },
    "awslabs.terraform-mcp-server": {
      "command": "uvx",
      "args": ["awslabs.terraform-mcp-server@latest"],
      "env": {
        "FASTMCP_LOG_LEVEL": "ERROR"
      },
      "disabled": false,
      "autoApprove": []
    },
   }
 }

Exemplos

Exemplos prontos para uso de AWS MCP Servers em ação estão disponíveis no diretório samples. Esses exemplos fornecem código funcional e guias passo a passo para ajudá-lo a começar com cada servidor MCP.

Vibe coding

Você pode usar esses servidores MCP com seu assistente de codificação de IA para vibe code. Para dicas e truques sobre como melhorar sua experiência de vibe coding, consulte nosso guia.

Recursos Adicionais

Segurança

Consulte CONTRIBUTING para mais informações.

Contribuindo

Um grande agradecimento aos nossos incríveis contribuidores! Obrigado por tornar este projeto melhor!

contributors

Contribuições de todos os tipos são bem-vindas! Consulte nosso guia do contribuidor para mais informações.

Guia do desenvolvedor

Se você deseja adicionar um novo MCP Server à biblioteca, consulte nosso guia de desenvolvimento e certifique-se de seguir nossas diretrizes de design.

Licença

Este projeto é licenciado sob a Licença Apache-2.0.

Aviso Legal

Antes de usar um MCP Server, você deve considerar realizar sua própria avaliação independente para garantir que seu uso esteja em conformidade com suas próprias práticas e padrões específicos de segurança e controle de qualidade, bem como as leis, regras e regulamentos que regem você e seu conteúdo.