MCP Deployment AWS

Um guia e código de exemplo para implantar servidores MCP de forma econômica na AWS e integrá-los com frameworks de agentes de IA.

GitHub

Documentação

Implantação de Servidor MCP Econômica na AWS para Agentes de IA

Um guia abrangente para implantar servidores Model Context Protocol (MCP) nos serviços da AWS de forma econômica e integrá-los a frameworks de agentes de IA como o Google ADK.

Sumário

O que é MCP? (Comece por aqui)

Model Context Protocol (MCP) é como um tradutor universal que permite que aplicações de IA (como Claude, ChatGPT ou agentes de IA do Google) se conectem a ferramentas externas e fontes de dados de forma padronizada.

Pense desta forma:

  • Sem MCP: Cada ferramenta de IA precisa de código personalizado para se conectar a bancos de dados, APIs ou serviços
  • Com MCP: Ferramentas de IA usam uma "linguagem" padrão para conversar com qualquer servidor MCP, independentemente do que ele conecta

Exemplo do mundo real:

Em vez de criar integrações personalizadas para cada ferramenta, você cria um servidor MCP que pode:

  • Consultar o banco de dados da sua empresa
  • Chamar APIs externas
  • Analisar arquivos
  • Realizar cálculos

Então, qualquer agente de IA compatível com MCP pode usar todas essas capacidades instantaneamente.

Principais benefícios do MCP

  • Plug-and-Play: Conecte qualquer agente de IA a qualquer ferramenta por meio de uma interface padrão
  • Comunicação em tempo real: Troca de dados ao vivo com Server-Sent Events (SSE)
  • Seguro e auditável: Controle de acesso integrado e registro abrangente
  • Altamente extensível: Fácil adicionar novas capacidades sem alterar o código do agente de IA
  • Econômico: Compartilhe um servidor MCP entre vários agentes de IA e aplicações

Pré-requisitos

Antes de começar, certifique-se de ter:

Conhecimento necessário

  • Compreensão básica dos serviços da AWS (Lambda, EC2 ou contêineres)
  • Experiência em programação Python
  • Uso básico de linha de comando
  • Compreensão de APIs e JSON

Configuração da conta AWS

  • Conta AWS ativa com cobrança habilitada
  • AWS CLI instalado e configurado
  • Permissões IAM básicas para implantação em Lambda/Fargate

Ambiente de desenvolvimento

  • Python 3.9+ instalado
  • Node.js 18+ (para exemplos com CDK)
  • Docker (para implantações conteinerizadas)

Tempo estimado de investimento

  • Início rápido: 30 minutos
  • Implementação completa: 2-4 horas
  • Implantação em produção: 1-2 dias

Guia de início rápido

Etapa 1: Escolha seu método de implantação (5 minutos)

Para iniciantes: Comece com AWS Lambda (pague pelo uso, sem servidores para gerenciar) Para produção: Considere AWS Fargate (sempre ativo, custos mais previsíveis)

Etapa 2: Árvore de decisão rápida

Do you expect < 1 million requests per month?
├─ YES → Use AWS Lambda ($10-50/month)
└─ NO → Do you need 24/7 availability?
   ├─ YES → Use AWS Fargate ($50-200/month)
   └─ NO → Use AWS Lambda with provisioned concurrency

Etapa 3: Seu primeiro servidor MCP (15 minutos)

Vamos criar um servidor MCP simples que pode analisar texto e obter dados meteorológicos atuais.

Etapa 4: Teste e implante (10 minutos)

Teste localmente e depois implante na AWS com um único comando.

Fundamentos da arquitetura MCP

flowchart LR
    subgraph "Your Computer"
        Host["Host with MCP Client\n(Claude, IDEs, Tools)"]
        S1["MCP Server A"]
        S2["MCP Server B"]
        S3["MCP Server C"]
        Host <-->|"MCP Protocol"| S1
        Host <-->|"MCP Protocol"| S2
        Host <-->|"MCP Protocol"| S3
        S1 <--> D1[("Local\nData Source A")]
        S2 <--> D2[("Local\nData Source B")]
    end
    subgraph "Internet"
        S3 <-->|"Web APIs"| D3[("Remote\nService C")]
    end

Componentes principais

  • Host MCP: A aplicação alimentada por LLM (Claude, agentes do Google ADK)
  • Cliente MCP: Mantém conexão 1:1 com o servidor MCP
  • Servidor MCP: Fornece contexto, ferramentas e prompts ao cliente

Opções de implantação na AWS

Prós:

  • Pague apenas pelo tempo de execução (sem custos ociosos)
  • Escalonamento automático
  • Sem gerenciamento de servidor
  • Ideal para cargas de trabalho variáveis/imprevisíveis
  • Otimizações de cold start disponíveis

Contras:

  • Limite de execução de 15 minutos
  • Latência de cold start (100ms-5 segundos)
  • Limitado a 10GB de memória
  • Complexo para processos de longa duração

Melhor para:

  • Servidores MCP orientados a eventos
  • Padrões de uso esporádicos
  • Implantações sensíveis a custo
  • Prototipagem rápida

2. AWS Fargate (Container-as-a-Service)

Prós:

  • Sem limites de tempo de execução
  • Melhor para processos de longa duração
  • Mais controle sobre o ambiente de execução
  • Sem cold starts após iniciar
  • Até 120GB de memória, 16 vCPU

Contras:

  • Custos mais altos devido à alocação contínua de recursos
  • Tempos de inicialização mais longos (35 segundos - 2 minutos)
  • Configuração mais complexa
  • Pague pelos recursos alocados mesmo se ociosos

Melhor para:

  • Implantações empresariais que exigem alta disponibilidade
  • Servidores MCP de longa duração
  • Requisitos de segurança complexos
  • Cargas de trabalho consistentes

3. Amazon ECS no EC2

Prós:

  • Máximo controle e personalização
  • Econômico para uso consistente e alto
  • Pode usar Reserved Instances para economizar

Contras:

  • Exige gerenciamento de servidor
  • Maior sobrecarga operacional
  • Não é verdadeiramente serverless

Melhor para:

  • Cargas de trabalho consistentes e de alto volume
  • Requisitos de infraestrutura personalizados

Análise comparativa de custos

Modelo de preços do Lambda

Cost = (Number of Requests × $0.20 per 1M requests) + 
       (Duration × Memory × $0.0001667 per GB-second)

Exemplo: 1M de requisições/mês, 1GB de memória, duração média de 2 segundos

  • Requisições: 1M × $0,20/1M = $0,20
  • Computação: 1M × 2s × 1GB × $0,0001667 = $333,40
  • Total: ~$333,60/mês

Modelo de preços do Fargate

Cost = (vCPU hours × $0.04048) + (GB memory hours × $0.004445)

Exemplo: 1 vCPU, 2GB de memória, executando 24/7

  • vCPU: 744 horas × $0,04048 = $30,12
  • Memória: 744 horas × 2GB × $0,004445 = $6,61
  • Total: ~$36,73/mês

Recomendações de otimização de custos

Padrão de usoServiço recomendadoCusto mensal estimadoMelhor para
< 100K requisições/mês, testesLambda$2-10Prototipagem, aprendizado
100K-1M requisições/mês, esporádicoLambda$10-50Aplicativos pequenos, projetos pessoais
1-10M requisições/mês, variávelLambda$50-200Aplicações em crescimento
> 10M requisições/mês, consistenteFargate$100-500Cargas de trabalho de produção estáveis
Empresarial, disponibilidade 24/7Fargate + Load Balancer$500-2000Sistemas críticos

Referência rápida: Quando usar o quê

🟢 USE LAMBDA WHEN:
✓ You're starting out or prototyping
✓ Traffic is unpredictable or sporadic  
✓ You want minimal operational overhead
✓ Cost optimization is priority #1
✓ You can handle 100ms-5s cold starts

🟡 USE FARGATE WHEN:
✓ You need consistent sub-100ms response times
✓ Traffic is predictable and consistent
✓ You're running 24/7 workloads
✓ You need complex networking or security
✓ You have containerized applications

Implementação passo a passo

Fase 1: Crie seu primeiro servidor MCP (desenvolvimento local)

1. Configure a estrutura do projeto

mkdir my-mcp-server
cd my-mcp-server

# Create virtual environment
python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate

# Install dependencies
pip install mcp anthropic-mcp-server boto3

2. Crie um servidor MCP simples (mcp_server.py)

#!/usr/bin/env python3
"""
Simple MCP Server for AWS - Beginner Example
This server provides basic text analysis and AWS cost checking tools
"""

import asyncio
import logging
from mcp.server import Server
from mcp.server.stdio import stdio_server
import mcp.types as types

# Configure logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# Create the MCP server
app = Server("my-first-mcp-server")

@app.list_tools()
async def list_tools() -> list[types.Tool]:
    """List available tools for the MCP client"""
    return [
        types.Tool(
            name="text-analyzer",
            description="Analyze text for word count, sentiment, and key phrases",
            inputSchema={
                "type": "object",
                "properties": {
                    "text": {
                        "type": "string", 
                        "description": "Text to analyze"
                    },
                    "analysis_type": {
                        "type": "string",
                        "enum": ["word_count", "sentiment", "summary"],
                        "description": "Type of analysis to perform"
                    }
                },
                "required": ["text", "analysis_type"]
            }
        ),
        types.Tool(
            name="aws-simple-cost-check",
            description="Get basic AWS cost information (demo version)",
            inputSchema={
                "type": "object",
                "properties": {
                    "service": {
                        "type": "string",
                        "description": "AWS service to check (e.g., 'lambda', 'ec2')"
                    }
                },
                "required": ["service"]
            }
        )
    ]

@app.call_tool()
async def call_tool(name: str, arguments: dict) -> list[types.TextContent]:
    """Handle tool calls from the MCP client"""
    
    if name == "text-analyzer":
        text = arguments["text"]
        analysis_type = arguments["analysis_type"]
        
        if analysis_type == "word_count":
            word_count = len(text.split())
            char_count = len(text)
            result = f"Word count: {word_count}\nCharacter count: {char_count}"
            
        elif analysis_type == "sentiment":
            # Simple sentiment analysis (in production, use a proper NLP library)
            positive_words = ["good", "great", "excellent", "amazing", "wonderful"]
            negative_words = ["bad", "terrible", "awful", "horrible", "disappointing"]
            
            text_lower = text.lower()
            positive_count = sum(1 for word in positive_words if word in text_lower)
            negative_count = sum(1 for word in negative_words if word in text_lower)
            
            if positive_count > negative_count:
                sentiment = "Positive"
            elif negative_count > positive_count:
                sentiment = "Negative"
            else:
                sentiment = "Neutral"
                
            result = f"Sentiment: {sentiment}\nPositive indicators: {positive_count}\nNegative indicators: {negative_count}"
            
        elif analysis_type == "summary":
            sentences = text.split('. ')
            result = f"Text summary:\n- Total sentences: {len(sentences)}\n- First sentence: {sentences[0] if sentences else 'No sentences found'}"
        
        return [types.TextContent(type="text", text=result)]
    
    elif name == "aws-simple-cost-check":
        service = arguments["service"]
        
        # Mock cost data (in production, use boto3 and AWS Cost Explorer)
        mock_costs = {
            "lambda": "$12.50 this month (estimated)",
            "ec2": "$45.30 this month (estimated)", 
            "s3": "$8.75 this month (estimated)"
        }
        
        cost_info = mock_costs.get(service.lower(), "Cost data not available for this service")
        result = f"AWS {service.upper()} costs: {cost_info}"
        
        return [types.TextContent(type="text", text=result)]
    
    raise ValueError(f"Unknown tool: {name}")

async def main():
    """Run the MCP server"""
    logger.info("Starting MCP server...")
    
    async with stdio_server() as streams:
        await app.run(
            streams[0], streams[1], app.create_initialization_options()
        )

if __name__ == "__main__":
    asyncio.run(main())

3. Teste seu servidor MCP localmente

# Test the server
python mcp_server.py

# In another terminal, you can test with:
echo '{"jsonrpc": "2.0", "id": 1, "method": "tools/list"}' | python mcp_server.py

Fase 2: Implante na AWS Lambda (pronto para produção)

1. Crie o pacote de implantação

# Create requirements.txt
cat > requirements.txt << EOF
mcp>=1.0.0
boto3>=1.26.0
anthropic-mcp-server>=0.1.0
EOF

# Create lambda deployment package
mkdir lambda_package
pip install -r requirements.txt -t lambda_package/
cp mcp_server.py lambda_package/

2. Crie um handler compatível com Lambda (lambda_package/lambda_handler.py)

import json
import asyncio
import logging
from mcp_server import app

logger = logging.getLogger()
logger.setLevel(logging.INFO)

def lambda_handler(event, context):
    """AWS Lambda handler for MCP server"""
    
    try:
        # Extract MCP request from Lambda event
        if 'body' in event:
            # API Gateway event
            mcp_request = json.loads(event['body'])
        else:
            # Direct Lambda invocation
            mcp_request = event
        
        # Process MCP request
        response = asyncio.run(process_mcp_request(mcp_request))
        
        return {
            'statusCode': 200,
            'headers': {
                'Content-Type': 'application/json',
                'Access-Control-Allow-Origin': '*'
            },
            'body': json.dumps(response)
        }
        
    except Exception as e:
        logger.error(f"Error processing MCP request: {str(e)}")
        return {
            'statusCode': 500,
            'body': json.dumps({'error': str(e)})
        }

async def process_mcp_request(request):
    """Process MCP request and return response"""
    
    method = request.get('method')
    params = request.get('params', {})
    request_id = request.get('id')
    
    try:
        if method == 'tools/list':
            tools = await app.list_tools()
            result = [tool.model_dump() for tool in tools]
            
        elif method == 'tools/call':
            tool_name = params.get('name')
            arguments = params.get('arguments', {})
            result = await app.call_tool(tool_name, arguments)
            result = [content.model_dump() for content in result]
            
        else:
            raise ValueError(f"Unknown method: {method}")
        
        return {
            'jsonrpc': '2.0',
            'id': request_id,
            'result': result
        }
        
    except Exception as e:
        return {
            'jsonrpc': '2.0',
            'id': request_id,
            'error': {
                'code': -32603,
                'message': str(e)
            }
        }

3. Implante com AWS CLI

# Create deployment zip
cd lambda_package
zip -r ../mcp-server-lambda.zip .
cd ..

# Create Lambda function
aws lambda create-function \
  --function-name my-mcp-server \
  --runtime python3.11 \
  --role arn:aws:iam::YOUR-ACCOUNT:role/lambda-execution-role \
  --handler lambda_handler.lambda_handler \
  --zip-file fileb://mcp-server-lambda.zip \
  --timeout 300 \
  --memory-size 512

Fase 3: Conecte-se a agentes de IA

1. Teste com Claude Desktop

Adicione à sua configuração do Claude Desktop:

{
  "mcpServers": {
    "my-mcp-server": {
      "command": "python",
      "args": ["/path/to/your/mcp_server.py"]
    }
  }
}

2. Conecte via API HTTP

import requests

def call_mcp_server(tool_name, arguments):
    """Call MCP server via HTTP API"""
    
    payload = {
        "jsonrpc": "2.0",
        "id": 1,
        "method": "tools/call",
        "params": {
            "name": tool_name,
            "arguments": arguments
        }
    }
    
    response = requests.post(
        "YOUR-LAMBDA-API-URL",
        json=payload,
        headers={"Content-Type": "application/json"}
    )
    
    return response.json()

# Example usage
result = call_mcp_server("text-analyzer", {
    "text": "This is a great example of MCP!",
    "analysis_type": "sentiment"
})
print(result)

Estratégia 1: Lambda Serverless Puro (mais econômico)

# Basic MCP Server on Lambda
import json
import asyncio
from mcp.server import Server
from mcp.server.stdio import stdio_server
import mcp.types as types

app = Server("aws-lambda-mcp-server")

@app.list_tools()
async def list_tools() -> list[types.Tool]:
    return [
        types.Tool(
            name="aws-cost-analyzer",
            description="Analyze AWS costs and usage",
            inputSchema={
                "type": "object",
                "properties": {
                    "service": {"type": "string"},
                    "region": {"type": "string"}
                }
            }
        )
    ]

@app.call_tool()
async def call_tool(name: str, arguments: dict) -> list[types.TextContent]:
    if name == "aws-cost-analyzer":
        # Implement cost analysis logic
        result = analyze_aws_costs(arguments)
        return [types.TextContent(type="text", text=result)]
    
    raise ValueError(f"Unknown tool: {name}")

def lambda_handler(event, context):
    # Lambda handler implementation
    return asyncio.run(handle_mcp_request(event))

Estratégia 2: Fargate para empresas (alta disponibilidade)

# docker-compose.yml for Fargate deployment
version: '3.8'
services:
  mcp-server:
    build: .
    ports:
      - "8080:8080"
    environment:
      - AWS_REGION=us-east-1
      - LOG_LEVEL=INFO
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8080/health"]
      interval: 30s
      timeout: 10s
      retries: 3

Estratégia 3: Abordagem híbrida

  • Lambda: Para ferramentas MCP leves e orientadas a eventos
  • Fargate: Para servidores MCP intensivos em recursos e de longa duração
  • API Gateway: Para endpoints de servidor MCP baseados em HTTP

Solução de problemas

Problemas comuns e soluções

1. "Module 'mcp' not found"

Problema: O Python não consegue encontrar a biblioteca MCP Solução:

# Make sure you're in the virtual environment
source venv/bin/activate

# Install the correct package
pip install mcp>=1.0.0

# Alternative: Try the anthropic package
pip install anthropic-mcp-server

2. A implantação do Lambda falha com "Role does not exist"

Problema: Falta a função IAM para execução do Lambda Solução:

# Create basic Lambda execution role
aws iam create-role \
  --role-name lambda-execution-role \
  --assume-role-policy-document '{
    "Version": "2012-10-17",
    "Statement": [
      {
        "Effect": "Allow",
        "Principal": {"Service": "lambda.amazonaws.com"},
        "Action": "sts:AssumeRole"
      }
    ]
  }'

# Attach basic execution policy
aws iam attach-role-policy \
  --role-name lambda-execution-role \
  --policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole

3. O servidor MCP responde com "Unknown method"

Problema: O cliente está enviando um método MCP não suportado Solução: Verifique se você está implementando os métodos MCP necessários:

# Required methods for basic MCP server
@app.list_tools()        # For tools/list
@app.call_tool()         # For tools/call  
@app.list_resources()    # Optional: for resources/list
@app.list_prompts()      # Optional: for prompts/list

4. Erros de permissões da API AWS

Problema: O Lambda não consegue acessar os serviços da AWS (S3, DynamoDB, etc.) Solução: Adicione permissões IAM à sua função do Lambda:

# Example: Add S3 access
aws iam attach-role-policy \
  --role-name lambda-execution-role \
  --policy-arn arn:aws:iam::aws:policy/AmazonS3ReadOnlyAccess

5. Timeouts de cold start

Problema: O Lambda demora muito para iniciar Soluções:

  • Reduza o tamanho do pacote (remova dependências desnecessárias)
  • Use provisioned concurrency para funções críticas
  • Considere migrar para Fargate para desempenho consistente

6. O cliente MCP não consegue se conectar ao servidor

Problema: Problemas de conexão entre cliente e servidor Etapas de depuração:

# Test MCP server locally
python mcp_server.py

# Test with curl (for HTTP endpoints)
curl -X POST your-api-endpoint \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'

# Check CloudWatch logs for Lambda
aws logs describe-log-groups --log-group-name-prefix /aws/lambda/my-mcp-server

Dicas de otimização de desempenho

1. Reduza cold starts

# Initialize expensive resources outside the handler
import boto3

# Global initialization (runs once per container)
s3_client = boto3.client('s3')
dynamodb = boto3.resource('dynamodb')

def lambda_handler(event, context):
    # Handler runs for each request
    # Use pre-initialized clients
    pass

2. Implemente cache

import json
from functools import lru_cache

@lru_cache(maxsize=100)
def expensive_operation(input_data):
    """Cache expensive operations"""
    # Your expensive logic here
    return result

3. Use connection pooling

import boto3
from botocore.config import Config

# Configure connection pooling
config = Config(
    max_pool_connections=10,
    retries={'max_attempts': 3}
)

client = boto3.client('dynamodb', config=config)

Checklist de depuração

  • Ambiente virtual ativado
  • Todas as dependências instaladas
  • Credenciais AWS configuradas
  • Funções e políticas IAM configuradas
  • Servidor MCP responde a métodos básicos
  • Logs do CloudWatch habilitados
  • API Gateway configurado (se usar HTTP)
  • Configuração do cliente corresponde ao endpoint do servidor

Integração com Google ADK

Visão geral da arquitetura

flowchart TD
    A[Google ADK Agent] --> B[MCP Client]
    B --> C[AWS Lambda MCP Server]
    B --> D[AWS Fargate MCP Server]
    C --> E[AWS Services]
    D --> F[External APIs]
    E --> G[DynamoDB]
    E --> H[S3]
    E --> I[CloudWatch]

Configuração do agente ADK

# Google ADK agent with MCP integration
from google.adk import Agent, Tool
from mcp_client import MCPClient

class AWSMCPTool(Tool):
    def __init__(self):
        self.mcp_client = MCPClient()
        super().__init__(
            name="aws-mcp-tool",
            description="Access AWS services via MCP server"
        )
    
    async def execute(self, **kwargs):
        # Connect to MCP server on AWS
        await self.mcp_client.connect("https://your-mcp-server.amazonaws.com")
        
        # Execute tool via MCP
        result = await self.mcp_client.call_tool(
            name="aws-cost-analyzer",
            arguments=kwargs
        )
        
        return result

# ADK Agent setup
agent = Agent(
    name="AWS Cost Assistant",
    model="gemini-2.0-flash-exp",
    tools=[AWSMCPTool()],
    instructions="You are an AWS cost optimization assistant..."
)

Colaboração multiagente

# Multi-agent setup with MCP
from google.adk.a2a import AgentCommunication

# Cost Analysis Agent
cost_agent = Agent(
    name="Cost Analyzer",
    tools=[AWSCostMCPTool()],
    instructions="Analyze AWS costs and identify optimization opportunities"
)

# Resource Optimization Agent
optimize_agent = Agent(
    name="Resource Optimizer", 
    tools=[AWSResourceMCPTool()],
    instructions="Implement cost optimization recommendations"
)

# A2A Communication
comm = AgentCommunication([cost_agent, optimize_agent])

# Workflow
async def cost_optimization_workflow(query):
    # Step 1: Analyze costs
    analysis = await cost_agent.process(query)
    
    # Step 2: Get optimization recommendations
    recommendations = await optimize_agent.process(analysis)
    
    return recommendations

Exemplos de implementação

1. Servidor MCP em AWS Lambda com CDK

// CDK Infrastructure
import * as cdk from 'aws-cdk-lib';
import * as lambda from 'aws-cdk-lib/aws-lambda';
import * as apigateway from 'aws-cdk-lib/aws-apigateway';

export class MCPServerStack extends cdk.Stack {
  constructor(scope: Construct, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    // Lambda function for MCP server
    const mcpServer = new lambda.Function(this, 'MCPServer', {
      runtime: lambda.Runtime.PYTHON_3_11,
      handler: 'mcp_server.lambda_handler',
      code: lambda.Code.fromAsset('src'),
      timeout: cdk.Duration.minutes(15),
      memorySize: 1024,
      environment: {
        LOG_LEVEL: 'INFO'
      }
    });

    // API Gateway for HTTP access
    const api = new apigateway.RestApi(this, 'MCPServerAPI', {
      restApiName: 'MCP Server Service'
    });

    const integration = new apigateway.LambdaIntegration(mcpServer);
    api.root.addMethod('POST', integration);
  }
}

2. Servidor MCP em Fargate com alta disponibilidade

# AWS ECS Task Definition
version: '1'
taskDefinition:
  family: mcp-server
  networkMode: awsvpc
  requiresCompatibilities:
    - FARGATE
  cpu: '256'
  memory: '512'
  containerDefinitions:
    - name: mcp-server
      image: your-account.dkr.ecr.region.amazonaws.com/mcp-server:latest
      portMappings:
        - containerPort: 8080
          protocol: tcp
      environment:
        - name: AWS_REGION
          value: us-east-1
      logConfiguration:
        logDriver: awslogs
        options:
          awslogs-group: /ecs/mcp-server
          awslogs-region: us-east-1
          awslogs-stream-prefix: ecs

3. Servidor MCP com otimização de custos

# AWS Cost Analysis MCP Server
import boto3
from datetime import datetime, timedelta
from mcp.server import Server
import mcp.types as types

app = Server("aws-cost-mcp-server")

@app.list_tools()
async def list_tools():
    return [
        types.Tool(
            name="get-cost-breakdown",
            description="Get AWS cost breakdown by service",
            inputSchema={
                "type": "object",
                "properties": {
                    "days": {"type": "integer", "default": 30},
                    "granularity": {"type": "string", "enum": ["DAILY", "MONTHLY"]}
                }
            }
        ),
        types.Tool(
            name="identify-unused-resources",
            description="Identify unused AWS resources",
            inputSchema={
                "type": "object",
                "properties": {
                    "services": {"type": "array", "items": {"type": "string"}}
                }
            }
        )
    ]

@app.call_tool()
async def call_tool(name: str, arguments: dict):
    ce_client = boto3.client('ce')  # Cost Explorer
    
    if name == "get-cost-breakdown":
        end_date = datetime.now()
        start_date = end_date - timedelta(days=arguments.get('days', 30))
        
        response = ce_client.get_cost_and_usage(
            TimePeriod={
                'Start': start_date.strftime('%Y-%m-%d'),
                'End': end_date.strftime('%Y-%m-%d')
            },
            Granularity=arguments.get('granularity', 'MONTHLY'),
            Metrics=['BlendedCost'],
            GroupBy=[{'Type': 'DIMENSION', 'Key': 'SERVICE'}]
        )
        
        # Process and format results
        cost_breakdown = format_cost_data(response)
        
        return [types.TextContent(
            type="text",
            text=f"AWS Cost Breakdown:\n{cost_breakdown}"
        )]
    
    elif name == "identify-unused-resources":
        # Implement unused resource identification
        unused_resources = find_unused_resources(arguments.get('services', []))
        
        return [types.TextContent(
            type="text", 
            text=f"Unused Resources Found:\n{unused_resources}"
        )]

Monitoramento e otimização

Dashboards do CloudWatch

{
  "widgets": [
    {
      "type": "metric",
      "properties": {
        "metrics": [
          ["AWS/Lambda", "Duration", "FunctionName", "mcp-server"],
          ["AWS/Lambda", "Invocations", "FunctionName", "mcp-server"],
          ["AWS/Lambda", "Errors", "FunctionName", "mcp-server"]
        ],
        "period": 300,
        "stat": "Average",
        "region": "us-east-1",
        "title": "MCP Server Lambda Metrics"
      }
    }
  ]
}

Alertas de custo

# CloudWatch Cost Alarm
import boto3

cloudwatch = boto3.client('cloudwatch')

cloudwatch.put_metric_alarm(
    AlarmName='MCP-Server-High-Cost',
    ComparisonOperator='GreaterThanThreshold',
    EvaluationPeriods=1,
    MetricName='EstimatedCharges',
    Namespace='AWS/Billing',
    Period=86400,
    Statistic='Maximum',
    Threshold=100.0,
    ActionsEnabled=True,
    AlarmActions=[
        'arn:aws:sns:us-east-1:123456789012:billing-alerts'
    ],
    AlarmDescription='Alert when MCP server costs exceed $100'
)

Melhores práticas

1. Otimização de custos

  • Use Lambda para cargas de trabalho esporádicas (< 1M requisições/mês)
  • Use Fargate para cargas de trabalho consistentes (> 10M requisições/mês)
  • Implemente cache adequado para reduzir chamadas de API redundantes
  • Use AWS Savings Plans para cargas de trabalho previsíveis
  • Monitore e configure alertas de custo

2. Otimização de desempenho

  • Minimize cold starts do Lambda com provisioned concurrency
  • Use connection pooling para conexões de banco de dados
  • Implemente tratamento de erros e novas tentativas adequados
  • Use CloudWatch insights para monitoramento de desempenho

3. Melhores práticas de segurança

  • Use funções IAM com princípio do menor privilégio
  • Habilite endpoints VPC para acesso seguro aos serviços da AWS
  • Implemente autenticação adequada para endpoints MCP
  • Use AWS WAF para proteção de API
  • Habilite CloudTrail para registro de auditoria

4. Considerações de escalabilidade

  • Projete para escalonamento horizontal
  • Use SQS para processamento assíncrono
  • Implemente circuit breakers para chamadas de API externas
  • Use Auto Scaling para implantações Fargate

Recursos

Documentação oficial

Implementações de exemplo

Calculadoras de custo

Recursos da comunidade

Caminho de migração: do protótipo à produção

Fase 1: Desenvolvimento (Semana 1)

  • Comece com: Desenvolvimento local do servidor MCP
  • Foco em: Funcionalidade principal e implementação de ferramentas
  • Custo: $0 (apenas desenvolvimento local)

Fase 2: Testes (Semana 2)

  • Implante em: AWS Lambda (configuração básica)
  • Foco em: Testes de integração e depuração
  • Custo: $5-20/mês (uso baixo)

Fase 3: Produção (Mês 2)

  • Escale para: Lambda com API Gateway OU Fargate
  • Foco em: Otimização de desempenho e monitoramento
  • Custo: $50-500/mês (dependendo do uso)

Fase 4: Empresarial (Mês 3+)

  • Atualize para: Fargate multirregional com balanceamento de carga
  • Foco em: Alta disponibilidade e recursos avançados
  • Custo: $500-2000+/mês (recursos empresariais completos)

Conclusão

Para iniciantes: comece simples

  1. Siga o guia passo a passo acima para criar seu primeiro servidor MCP localmente
  2. Implante no Lambda para economia imediata de custos e simplicidade
  3. Teste com Claude Desktop ou chamadas HTTP simples
  4. Itere e melhore com base nas suas necessidades específicas

Para produção: escolha com base no uso

Se você tem...Escolha...Porque...
< 1M requisições/mêsAWS LambdaMais econômico, escalonamento automático
> 10M requisições/mêsAWS FargateMelhor desempenho, sem cold starts
Requisitos empresariaisFargate + Load BalancerAlta disponibilidade, melhores SLAs
Tráfego imprevisívelLambda com auto-scalingPague apenas pelo que usar

Principais fatores de sucesso

  • Comece Simples: Comece com o exemplo básico e expanda gradualmente
  • Monitore os Custos: Configure alertas de cobrança desde o primeiro dia
  • Teste Localmente Primeiro: Depure problemas localmente antes de implantar na AWS
  • Use o Guia de Solução de Problemas: A maioria dos problemas tem soluções conhecidas
  • Planeje o Crescimento: Projete pensando na escalabilidade futura

Próximos Passos

  1. Clone o código de exemplo e execute-o localmente
  2. Implante sua primeira função Lambda seguindo o guia
  3. Conecte-a ao seu agente de IA favorito (Claude, Google ADK)
  4. Monitore o uso e os custos durante o primeiro mês
  5. Escale com base nos padrões de uso reais

A combinação da padronização do MCP com as opções de implantação econômicas da AWS torna mais fácil do que nunca criar integrações poderosas de agentes de IA. Comece com o básico, aprenda com o uso real e escale conforme necessário.