Servidor MCP Python para Banco de Dados Relacional

O gerador connection conecta um Servidor MCP Python a um projeto de Banco de Dados Relacional Python, disponibilizando a sessão do banco de dados para todas as ferramentas registradas no servidor.

Pré-requisitos

Antes de usar este gerador, certifique-se de ter:

Um projeto py#mcp-server
Um projeto py#rdb

Uso

Executar o Gerador

Execute este gerador@aws/nx-plugin:connection

CLI
VSCode

$ pnpm nx g @aws/nx-plugin:connection

$ yarn nx g @aws/nx-plugin:connection

$ npx nx g @aws/nx-plugin:connection

$ bunx nx g @aws/nx-plugin:connection

Instale o Nx Console VSCode Plugin se ainda não o fez
Abra o console Nx no VSCode
Clique em Generate (UI) na seção "Common Nx Commands"
Procure por @aws/nx-plugin - connection
Preencha os parâmetros obrigatórios
Clique em Generate

Monte seu comando5

sourceProjectObrigatório

targetProjectObrigatório

sourceComponent

targetComponent

preferInstallDependencies

true

--dry-runVocê também pode realizar uma execução simulada para ver quais arquivos seriam alterados

Selecione seu projeto de servidor MCP como origem e seu projeto de banco de dados relacional como destino. Se o projeto contiver múltiplos componentes de servidor MCP, especifique sourceComponent para desambiguar.

Opções

Opções do gerador5 opções

sourceProjectObrigatóriostring: O projeto de origem
targetProjectObrigatóriostring: O projeto de destino para conectar
sourceComponentstring: O componente de origem a partir do qual conectar (nome do componente, caminho relativo à raiz do projeto de origem, ou id do gerador). Use '.' para selecionar explicitamente o projeto como origem.
targetComponentstring: O componente de destino ao qual conectar (nome do componente, caminho relativo à raiz do projeto de destino, ou id do gerador). Use '.' para selecionar explicitamente o projeto como destino.
preferInstallDependenciesbooleanPadrão: true: Se deve preferir instalar dependências após a execução do gerador. Defina como false para adiar a instalação ao executar múltiplos geradores em lote (uma instalação ainda é executada se necessário para que os geradores subsequentes possam calcular o grafo de projetos Nx); instale uma vez no final.

Saída do Gerador

Directorypackages/my_service
- project.json Adiciona uma dependência de my_mcp_server-dev no target dev do banco de dados
- pyproject.toml Adiciona o pacote do banco de dados como uma dependência do workspace
- Directorymy_service
  - Directorymy_mcp_server
    Dockerfile Adiciona o pacote CA do RDS usado para conexões diretas ao Aurora (somente quando o infra do servidor MCP é agentcore-ecr)

Usando o Banco de Dados em Ferramentas MCP

Importe session_context do seu pacote de banco de dados e use-o dentro das ferramentas do seu servidor MCP:

from sqlmodel import select
from my_scope_my_db import session_context
from my_scope_my_db.models.example import ExampleModel

@mcp.tool()
async def list_examples() -> str:
    """List all example records."""
    async with session_context() as session:
        items = (await session.execute(select(ExampleModel))).scalars().all()
        return str([item.model_dump() for item in items])

Múltiplos Bancos de Dados

Executar o gerador novamente com um destino diferente adiciona o segundo banco de dados junto ao primeiro. Ambos os contextos de sessão ficam disponíveis para todas as ferramentas:

from my_scope_my_db import session_context as my_db_session_context
from my_scope_other_db import session_context as other_db_session_context

Infraestrutura

O construto de servidor MCP gerado implementa IGrantable e IConnectable, então você pode conceder acesso de rede e IAM ao banco de dados diretamente no construto.

CDK
Terraform

import { SecurityGroup } from 'aws-cdk-lib/aws-ec2';
import { RuntimeNetworkConfiguration } from 'aws-cdk-lib/aws-bedrockagentcore';
import { MyDatabase } from '@my-scope/common-constructs';

const db = new MyDatabase(this, 'Db', { vpc, ... });

const myMcpServer = new MyMcpServer(this, 'MyMcpServer', {
  networkConfiguration: RuntimeNetworkConfiguration.usingVpc(this, {
    vpc,
    vpcSubnets: { subnetType: SubnetType.PRIVATE_WITH_EGRESS },
    securityGroups: [
      new SecurityGroup(this, 'MyMcpServerSecurityGroup', { vpc, allowAllOutbound: true }),
    ],
  }),
});

db.allowDefaultPortFrom(myMcpServer);
db.grantConnect(myMcpServer);

allowDefaultPortFrom abre a regra do grupo de segurança para que o runtime do servidor MCP possa alcançar a porta do banco de dados. grantConnect concede a permissão IAM rds-db:connect à função de execução do servidor.

Execute o servidor MCP dentro da mesma VPC do banco de dados, conceda a ele rds-db:connect via additional_iam_policy_statements, e abra o caminho de rede com um par de regras de grupo de segurança. Os recursos aws_vpc.main e aws_subnet são definidos no guia de implantação do banco de dados:

module "my_database" {
  source              = "../../common/terraform/src/app/dbs/my-database"
  vpc_id              = aws_vpc.main.id
  database_subnet_ids = aws_subnet.database[*].id
  lambda_subnet_ids   = aws_subnet.private[*].id
}

module "my_mcp_server" {
  source     = "../../common/terraform/src/app/mcp-servers/my-mcp-server"
  enable_vpc = true
  vpc_id     = aws_vpc.main.id
  subnet_ids = aws_subnet.private[*].id

  appconfig_application_id  = module.runtime_config_appconfig.application_id
  appconfig_application_arn = module.runtime_config_appconfig.application_arn

  additional_iam_policy_statements = [
    {
      Effect = "Allow"
      Action = ["rds-db:connect"]
      Resource = [
        "arn:aws:rds-db:${data.aws_region.current.region}:${data.aws_caller_identity.current.account_id}:dbuser:${module.my_database.connect_resource_id}/${module.my_database.database_runtime_user}"
      ]
    }
  ]
}

resource "aws_vpc_security_group_ingress_rule" "mcp_server_to_database" {
  description                  = "Allow the MCP server runtime to connect to the database"
  security_group_id            = module.my_database.security_group_id
  referenced_security_group_id = module.my_mcp_server.security_group_id
  from_port                    = module.my_database.cluster_port
  to_port                      = module.my_database.cluster_port
  ip_protocol                  = "tcp"
}

resource "aws_vpc_security_group_egress_rule" "mcp_server_to_database" {
  description                  = "Allow outbound traffic from the MCP server runtime to the database"
  security_group_id            = module.my_mcp_server.security_group_id
  referenced_security_group_id = module.my_database.security_group_id
  from_port                    = module.my_database.cluster_port
  to_port                      = module.my_database.cluster_port
  ip_protocol                  = "tcp"
}

appconfig_application_id/appconfig_application_arn vêm da configuração de runtime compartilhada do AppConfig declarada uma vez no seu módulo raiz, não do módulo do banco de dados. Essa aplicação expõe o namespace database por padrão, então a entrada de configuração de runtime do módulo do banco de dados é implantada sem configuração adicional.

Requisitos SSL ao Conectar Sem RDS Proxy

Quando o servidor MCP se conecta diretamente ao cluster Aurora (sem RDS Proxy), o gerador de conexão atualiza o Dockerfile do servidor MCP gerado para instalar o pacote CA do Amazon RDS no armazenamento de confiança do sistema:

ADD https://truststore.pki.rds.amazonaws.com/global/global-bundle.pem /usr/local/share/ca-certificates/rds-global-bundle.crt
RUN update-ca-certificates

Ao usar RDS Proxy, você não precisa configurar o pacote CA do RDS no runtime do servidor MCP.

Desenvolvimento Local

pnpm nx <mcp-server-name>-dev <project-name>

yarn nx <mcp-server-name>-dev <project-name>

npx nx <mcp-server-name>-dev <project-name>

bunx nx <mcp-server-name>-dev <project-name>

Isso inicia o servidor MCP e todos os bancos de dados conectados. A variável de ambiente LOCAL_DEV=true faz com que o cliente do banco de dados se conecte ao seu banco de dados Docker local em vez do Aurora.