MCP (Model Context Protocol)

// 1. Client descobre capacidades do Server
→ { "jsonrpc": "2.0", "method": "initialize",
    "params": { "capabilities": { "tools": {} } } }
← { "result": { "capabilities": { "tools": {} },
    "serverInfo": { "name": "postgres-server" } } }

// 2. Client lista tools disponiveis
→ { "jsonrpc": "2.0", "method": "tools/list" }
← { "result": { "tools": [
    { "name": "query", "description": "Execute SQL query",
      "inputSchema": { "type": "object", ... } }
   ] } }

// 3. LLM decide chamar tool, Client executa via Server
→ { "jsonrpc": "2.0", "method": "tools/call",
    "params": { "name": "query",
    "arguments": { "sql": "SELECT * FROM users LIMIT 5" } } }
← { "result": { "content": [
    { "type": "text", "text": "[{\"id\":1,...}]" }
   ] } }

// Listar resources disponiveis
server.listResources(() => ({
  resources: [
    {
      uri: "file:///project/README.md",
      name: "Project README",
      mimeType: "text/markdown"
    },
    {
      uri: "db://customers/recent",
      name: "Recent Customers",
      mimeType: "application/json"
    }
  ]
}));

// Ler conteudo de um resource
server.readResource(({ uri }) => {
  if (uri === "db://customers/recent") {
    const data = db.customers.findMany({ take: 10 });
    return {
      contents: [{
        uri, mimeType: "application/json",
        text: JSON.stringify(data)
      }]
    };
  }
});

server.tool(
  "create_issue",
  "Cria uma issue no repositorio GitHub",
  {
    repo: z.string().describe("Owner/repo (ex: 'user/project')"),
    title: z.string().describe("Titulo da issue"),
    body: z.string().optional().describe("Descricao detalhada"),
    labels: z.array(z.string()).optional()
      .describe("Labels para classificar")
  },
  async ({ repo, title, body, labels }) => {
    const issue = await github.issues.create({
      owner: repo.split("/")[0],
      repo: repo.split("/")[1],
      title, body, labels
    });
    return {
      content: [{
        type: "text",
        text: `Issue #${issue.number} criada: ${issue.html_url}`
      }]
    };
  }
);

server.prompt(
  "review_code",
  "Revisa codigo e sugere melhorias de qualidade",
  [
    { name: "language", description: "Linguagem do codigo",
      required: true },
    { name: "focus", description: "Foco da revisao (security, perf, style)",
      required: false }
  ],
  ({ language, focus = "general" }) => ({
    messages: [{
      role: "user",
      content: {
        type: "text",
        text: `Revise este codigo ${language} com foco em ${focus}. ` +
          `Aponte: bugs, vulnerabilidades de seguranca, ` +
          `problemas de performance, e melhorias de legibilidade. ` +
          `Formate como checklist com severidade (alta/media/baixa).`
      }
    }]
  })
);

# Criar projeto
mkdir meu-mcp-server && cd meu-mcp-server
npm init -y
npm install @modelcontextprotocol/sdk zod
npm install -D typescript @types/node

# tsconfig.json
{
  "compilerOptions": {
    "target": "ES2022",
    "module": "Node16",
    "outDir": "./dist",
    "strict": true
  }
}

// src/index.ts
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport }
  from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";

// 1. Criar instancia do server
const server = new McpServer({
  name: "saas-analytics",
  version: "1.0.0"
});

// 2. Registrar tool: buscar metricas
server.tool(
  "get_metrics",
  "Busca metricas de negocio do SaaS: MRR, churn, " +
  "usuarios ativos. Use quando o usuario pedir dados " +
  "de performance ou KPIs.",
  {
    metric: z.enum(["mrr", "churn", "active_users", "revenue"])
      .describe("Tipo de metrica"),
    period: z.enum(["today", "last_7_days", "last_30_days", "last_90_days"])
      .default("last_30_days")
      .describe("Periodo de analise")
  },
  async ({ metric, period }) => {
    // Sua logica de negocio aqui
    const data = await fetchMetrics(metric, period);
    return {
      content: [{
        type: "text",
        text: JSON.stringify(data, null, 2)
      }]
    };
  }
);

// 3. Registrar tool: executar acao
server.tool(
  "send_report",
  "Envia relatorio por email para stakeholders. " +
  "Use quando o usuario pedir para compartilhar dados.",
  {
    to: z.string().email().describe("Email do destinatario"),
    subject: z.string().describe("Assunto do email"),
    metrics: z.array(z.string()).describe("Metricas para incluir")
  },
  async ({ to, subject, metrics }) => {
    await sendEmail(to, subject, metrics);
    return {
      content: [{
        type: "text",
        text: `Relatorio enviado para ${to} com sucesso.`
      }]
    };
  }
);

// 4. Conectar transporte e iniciar
const transport = new StdioServerTransport();
await server.connect(transport);

# pip install mcp[cli]

from mcp.server.fastmcp import FastMCP

# 1. Criar instancia
mcp = FastMCP("saas-analytics")

# 2. Registrar tool com decorator
@mcp.tool()
def get_metrics(
    metric: str,   # mrr, churn, active_users, revenue
    period: str = "last_30_days"
) -> dict:
    """Busca metricas de negocio do SaaS.
    Use quando o usuario pedir KPIs ou dados de performance."""
    data = fetch_metrics(metric, period)
    return data

@mcp.tool()
def send_report(
    to: str,       # Email do destinatario
    subject: str,  # Assunto
    metrics: list[str]  # Metricas para incluir
) -> str:
    """Envia relatorio por email para stakeholders."""
    send_email(to, subject, metrics)
    return f"Relatorio enviado para {to}"

# 3. Registrar resource
@mcp.resource("db://dashboard/summary")
def dashboard_summary() -> str:
    """Resumo atual do dashboard com KPIs principais."""
    return json.dumps(get_dashboard_data())

# 4. Iniciar com stdio
if __name__ == "__main__":
    mcp.run(transport="stdio")

// ~/Library/Application Support/Claude/claude_desktop_config.json
// ou ~/.config/claude/claude_desktop_config.json (Linux)
{
  "mcpServers": {
    "saas-analytics": {
      "command": "node",
      "args": ["/path/to/meu-mcp-server/dist/index.js"],
      "env": {
        "DATABASE_URL": "postgresql://localhost:5432/mydb",
        "SMTP_HOST": "smtp.sendgrid.net"
      }
    }
  }
}

# Filesystem - acesso a arquivos locais
npx -y @modelcontextprotocol/server-filesystem /home/user/projetos

# GitHub - acesso a repositorios
GITHUB_TOKEN=ghp_xxx npx -y @modelcontextprotocol/server-github

# PostgreSQL - acesso a banco de dados
npx -y @modelcontextprotocol/server-postgres \
  postgresql://user:pass@localhost:5432/mydb

# Testar qualquer server com o Inspector
npx @modelcontextprotocol/inspector \
  npx -y @modelcontextprotocol/server-filesystem /tmp

meu-saas-mcp-server/
  src/
    index.ts             # Entry point + server setup
    tools/
      search-customers.ts  # Tool: busca de clientes
      get-metrics.ts       # Tool: calcular metricas
      send-notification.ts # Tool: enviar notificacao
    resources/
      dashboard.ts         # Resource: dados do dashboard
      customers.ts         # Resource: dados de clientes
    db.ts                  # Conexao com banco de dados
  package.json
  tsconfig.json
  claude_desktop_config.json  # Exemplo de config
  .env.example                # Template de variaveis
  README.md