Skills, Tools e Function Calling em IA

1. Usuário faz uma requisição
       ↓
2. Modelo analisa e identifica necessidade de ferramenta
       ↓
3. Modelo gera chamada de função com parâmetros (JSON)
       ↓
4. Aplicação executa a função
       ↓
5. Resultado retorna ao modelo
       ↓
6. Modelo formula resposta em linguagem natural

// Requisição do usuário: "Qual o clima em São Paulo?"

// Modelo gera:
{
  "function": "get_weather",
  "parameters": {
    "city": "São Paulo",
    "country": "BR",
    "units": "metric"
  }
}

// Aplicação executa e retorna:
{
  "temperature": 25,
  "condition": "partly_cloudy",
  "humidity": 65
}

// Modelo responde:
"O clima em São Paulo está parcialmente nublado, 
com temperatura de 25°C e umidade de 65%."

from openai import OpenAI
from agents import Agent, WebSearchTool

agent = Agent(
    name="Research Assistant",
    instructions="Pesquise informações atualizadas",
    tools=[WebSearchTool()]
)

import anthropic

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    tools=[
        {
            "name": "get_stock_price",
            "description": "Obtém preço atual de ações",
            "input_schema": {
                "type": "object",
                "properties": {
                    "symbol": {
                        "type": "string",
                        "description": "Símbolo da ação (ex: AAPL)"
                    }
                },
                "required": ["symbol"]
            }
        }
    ],
    messages=[
        {"role": "user", "content": "Qual o preço da PETR4?"}
    ]
)

import google.generativeai as genai

def get_exchange_rate(currency_from: str, currency_to: str) -> dict:
    """Obtém taxa de câmbio entre moedas."""
    # Implementação...
    return {"rate": 5.45, "from": currency_from, "to": currency_to}

model = genai.GenerativeModel(
    model_name='gemini-2.5-pro',
    tools=[get_exchange_rate]
)

response = model.generate_content(
    "Quanto vale 100 dólares em reais?"
)

┌─────────────┐     ┌─────────────┐     ┌─────────────┐
│  MCP Client │────▶│ MCP Protocol│────▶│ MCP Server  │
│  (Claude,   │     │  (JSON-RPC) │     │  (GitHub,   │
│   Cursor)   │◀────│             │◀────│   Slack...) │
└─────────────┘     └─────────────┘     └─────────────┘

// Configuração no Claude Desktop
{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_TOKEN": "ghp_xxx"
      }
    }
  }
}

┌─────────────┐
│  PERCEPTION │ ← Contexto do código, estrutura, terminal
└──────┬──────┘
       ↓
┌─────────────┐
│  REASONING  │ ← Planejamento de modificações
└──────┬──────┘
       ↓
┌─────────────┐
│   ACTION    │ ← Execução de comandos e edições
└──────┬──────┘
       ↓
┌─────────────┐
│ OBSERVATION │ ← Leitura de resultados, auto-correção
└─────────────┘
       ↓
    (loop)

def create_skill():
    return {
        "type": "function",
        "function": {
            "name": "send_notification",
            "description": "Envia notificação push para usuário",
            "parameters": {
                "type": "object",
                "properties": {
                    "user_id": {
                        "type": "string",
                        "description": "ID do usuário"
                    },
                    "title": {
                        "type": "string",
                        "description": "Título da notificação"
                    },
                    "message": {
                        "type": "string",
                        "description": "Corpo da mensagem"
                    },
                    "priority": {
                        "type": "string",
                        "enum": ["low", "normal", "high"],
                        "description": "Prioridade da notificação"
                    }
                },
                "required": ["user_id", "title", "message"]
            }
        }
    }

// server.ts
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";

const server = new Server({
  name: "my-custom-server",
  version: "1.0.0"
}, {
  capabilities: {
    tools: {}
  }
});

server.setRequestHandler("tools/list", async () => ({
  tools: [{
    name: "calculate_tax",
    description: "Calcula impostos brasileiros",
    inputSchema: {
      type: "object",
      properties: {
        value: { type: "number" },
        tax_type: { type: "string", enum: ["ICMS", "ISS", "PIS", "COFINS"] }
      },
      required: ["value", "tax_type"]
    }
  }]
}));

server.setRequestHandler("tools/call", async (request) => {
  if (request.params.name === "calculate_tax") {
    const { value, tax_type } = request.params.arguments;
    // Lógica de cálculo...
    return { content: [{ type: "text", text: `Imposto: R$ ${result}` }] };
  }
});

const transport = new StdioServerTransport();
await server.connect(transport);