**Agents, Skills, MCP e outros conceitos essenciais das IAs modernas**

gistfile1.txt

## Visão geral

Pense na IA como uma empresa:

* **Modelo/LLM:** o cérebro do funcionário.
* **Prompt/instruções:** o cargo e as regras de trabalho.
* **Skill:** o conhecimento de como executar uma tarefa.
* **Tool:** o instrumento usado para executar a tarefa.
* **MCP:** o padrão de conexão entre a IA e os instrumentos.
* **Agent:** o funcionário completo, capaz de analisar, decidir e agir.
* **Workflow:** o processo que esse funcionário deve seguir.

## Modelo ou LLM

É a IA propriamente dita, como GPT, Claude ou Gemini.

Ela recebe texto, imagens ou outros dados e produz uma resposta. Sozinha, normalmente não acessa seu Gmail, banco de dados, terminal ou calendário.

É o **motor de raciocínio e geração**.

## Agent

Um **agente de IA** é um modelo configurado com instruções, ferramentas, permissões e, em alguns casos, memória. Ele pode executar um ciclo como:

1. Entender o objetivo.
2. Elaborar um plano.
3. Escolher uma ferramenta.
4. Executar uma ação.
5. Verificar o resultado.
6. Corrigir o plano.
7. Continuar até concluir.

A definição utilizada no Agents SDK da OpenAI é essencialmente: modelo + instruções + ferramentas + comportamentos como delegação, proteções e saídas estruturadas. ([OpenAI][1])

Uma fórmula simplificada seria:

```text
Agent = LLM + instruções + contexto + ferramentas + ciclo de execução + proteções
```

### Exemplo

Você pede:

> Analise meus e-mails, encontre os artistas que ainda não enviaram a música e prepare uma cobrança.

Um chatbot simples apenas explicaria como fazer.

Um agente poderia:

* pesquisar os e-mails;
* identificar os artistas;
* consultar uma planilha;
* verificar os prazos;
* redigir as mensagens;
* criar os rascunhos no Gmail;
* apresentar o resultado para sua aprovação.

## Skills

Uma **skill** é um pacote de conhecimento operacional para ensinar à IA **como realizar determinado trabalho**.

Pode conter:

* instruções;
* procedimentos;
* exemplos;
* critérios de qualidade;
* scripts;
* modelos de documentos;
* arquivos de referência.

Em algumas plataformas, uma skill é literalmente uma pasta com arquivos de instruções, scripts e recursos. O termo ainda não possui exatamente o mesmo significado em todas as empresas, mas geralmente representa uma capacidade modular e reutilizável. ([Claude Platform Docs][2])

### Diferença entre skill e tool

```text
Skill = saber como fazer
Tool = ter com o que fazer
```

Exemplo:

* **Skill:** saber preparar os metadados de um lançamento musical.
* **Tool:** acessar Google Drive, Gmail, planilha ou banco de dados.
* **Agent:** usar a skill e as tools para organizar o lançamento inteiro.

Uma skill sua poderia conter:

```text
Nome: Preparação de lançamento Monkey Forest

Regras:
• WAV 24-bit e 48 kHz
• verificar clipping
• conferir nome do artista e da faixa
• lançamento com pelo menos 40 dias de antecedência
• validar capa, ISRC, compositores e divisão de royalties
• nunca enviar nada sem aprovação do manager
```

## MCP

**MCP** significa **Model Context Protocol**.

É um protocolo aberto que padroniza a conexão entre aplicações de IA e sistemas externos. A documentação oficial compara o MCP a uma espécie de **USB-C para aplicações de IA**. ([Modelo de Contexto][3])

Sem MCP, cada integração precisa ser implementada de forma própria:

```text
IA → integração personalizada → GitHub
IA → integração personalizada → banco de dados
IA → integração personalizada → Google Drive
```

Com MCP:

```text
Aplicação de IA → MCP → servidores de GitHub, banco, Drive etc.
```

Um servidor MCP pode oferecer três elementos principais:

* **Tools:** ações executáveis.
* **Resources:** dados e arquivos que podem ser consultados.
* **Prompts:** instruções e modelos prontos. ([Modelo de Contexto][4])

### Exemplo de ferramenta MCP

Um servidor MCP de calendário poderia disponibilizar:

```text
listar_eventos
buscar_horario_livre
criar_evento
cancelar_evento
```

A IA descobre essas ferramentas, escolhe a adequada e envia os parâmetros necessários. Servidores MCP podem conectar sistemas como bancos de dados, GitHub, Slack, calendários e sistemas de arquivos. ([Modelo de Contexto][5])

### MCP não é uma IA

O MCP não pensa e não toma decisões.

Ele é apenas o **protocolo de comunicação**.

```text
Agent decide o que fazer.
Skill ensina como fazer.
Tool executa a ação.
MCP conecta a IA à tool.
```

## Tools

Tools são funções que a IA pode chamar.

Exemplos:

```text
pesquisar_web("novidades do Ableton")
buscar_email("OneRPM")
executar_codigo(...)
criar_evento(...)
consultar_banco(...)
gerar_imagem(...)
```

A IA não precisa necessariamente saber como a função foi programada. Ela recebe uma descrição, os parâmetros aceitos e o resultado da execução. Ferramentas podem pesquisar dados, executar código, acessar APIs e operar computadores. ([OpenAI][6])

## Function calling

É o mecanismo pelo qual o modelo solicita a execução de uma função de maneira estruturada.

Em vez de responder:

> Vou consultar a previsão.

Ele produz algo semelhante a:

```json
{
  "tool": "consultar_previsao",
  "arguments": {
    "cidade": "Ribeirão Preto"
  }
}
```

O sistema executa a função, devolve o resultado ao modelo e o modelo continua a resposta.

MCP pode transportar e padronizar tools, mas **function calling e MCP não são exatamente a mesma coisa**.

## Contexto

Contexto é tudo o que está disponível para o modelo durante uma execução:

* sua mensagem;
* mensagens anteriores;
* instruções do sistema;
* documentos recuperados;
* resultados de ferramentas;
* arquivos enviados;
* dados do projeto.

O contexto é limitado pela chamada **janela de contexto**, medida em tokens.

## Memória

Memória é informação preservada entre sessões ou execuções.

Exemplos:

* sua preferência por PT-BR;
* regras da Monkey Forest;
* formato dos lançamentos;
* artistas do catálogo;
* decisões tomadas anteriormente.

Diferença:

```text
Contexto = o que está sobre a mesa agora.
Memória = o que foi guardado para ser utilizado depois.
```

## RAG

**RAG** significa **Retrieval-Augmented Generation**, ou geração aumentada por recuperação.

Antes de responder, o sistema procura informações relevantes em:

* documentos;
* PDFs;
* bancos de dados;
* base de conhecimento;
* Google Drive;
* banco vetorial.

Depois, insere os trechos encontrados no contexto do modelo.

```text
Pergunta
   ↓
Pesquisa nos documentos
   ↓
Recuperação dos trechos relevantes
   ↓
LLM produz a resposta utilizando esses trechos
```

RAG **não é treinamento do modelo**. Os dados são consultados no momento da resposta.

## Embeddings e banco vetorial

**Embedding** é uma representação numérica do significado de um texto, imagem ou áudio.

Textos com significados semelhantes tendem a ficar próximos matematicamente. Isso permite pesquisas semânticas.

Por exemplo, uma busca por:

> regras para mandar música

pode encontrar um documento chamado:

> Especificações técnicas para submissão de masters

Mesmo sem utilizar exatamente as mesmas palavras.

Um banco vetorial armazena esses embeddings para permitir esse tipo de busca. É muito utilizado em sistemas RAG.

## Workflow

Workflow é uma sequência organizada de etapas.

### Workflow fixo

```text
Receber arquivo
→ validar formato
→ extrair metadados
→ salvar no banco
→ enviar confirmação
```

As etapas já estão definidas.

### Workflow agentic

O agente decide dinamicamente:

```text
Receber solicitação
→ analisar o caso
→ escolher ferramentas
→ decidir a próxima etapa
→ verificar o resultado
→ adaptar o processo
```

Workflow é mais previsível. Agent é mais flexível, mas também exige mais controle.

## Multi-agent e subagents

Um sistema pode possuir vários agentes especializados:

```text
Agente coordenador
├── agente de pesquisa
├── agente jurídico
├── agente financeiro
├── agente de programação
└── agente de revisão
```

O agente principal pode delegar partes do trabalho para agentes especializados. Essa delegação costuma ser chamada de **handoff**. ([OpenAI][7])

Nem toda tarefa precisa de vários agentes. Muitas vezes, um único agente bem configurado é mais barato, rápido e confiável.

## Guardrails

Guardrails são proteções e validações.

Podem impedir que o agente:

* envie um e-mail sem aprovação;
* apague arquivos;
* publique conteúdo diretamente;
* acesse dados não autorizados;
* gere uma resposta fora do formato exigido;
* execute comandos perigosos.

Exemplo:

```text
O agente pode criar um rascunho de e-mail,
mas somente o usuário pode autorizar o envio.
```

## Orquestração

Orquestração é o código que controla o sistema:

* qual agente será chamado;
* quais tools estão disponíveis;
* quando pedir autorização;
* quando repetir uma etapa;
* quando interromper;
* como registrar erros;
* como delegar para outro agente.

O agente é o trabalhador. A orquestração é a gerência operacional.

## Connector

Connector é uma integração pronta com um serviço:

* Gmail;
* Google Drive;
* Slack;
* GitHub;
* Notion;
* calendário.

Um connector pode ser implementado com API própria, OAuth, MCP ou uma combinação dessas tecnologias.

## Fine-tuning

Fine-tuning é um treinamento adicional do modelo com exemplos específicos para alterar seu comportamento.

Serve para coisas como:

* padronizar respostas;
* classificar dados;
* produzir uma estrutura específica;
* adaptar linguagem e comportamento.

Não é normalmente a melhor solução para fornecer informações atualizadas.

```text
RAG = dá informações ao modelo.
Skill = dá procedimentos ao modelo.
Fine-tuning = modifica padrões internos do modelo.
Tool = permite que o modelo aja.
```

## Resumo geral

```text
LLM
É o cérebro.

Prompt
É a instrução imediata.

Contexto
É o material disponível durante a execução.

Memória
É a informação preservada.

Skill
É o procedimento ou conhecimento especializado.

Tool
É uma função que permite consultar ou executar algo.

MCP
É o padrão que conecta aplicações de IA a tools e dados.

Agent
É o sistema que analisa, decide, usa tools e acompanha resultados.

Workflow
É a sequência de etapas do processo.

RAG
É a busca de informações externas antes de responder.

Guardrails
São as permissões, bloqueios e verificações de segurança.
```

Um exemplo aplicado ao seu trabalho seria:

```text
Modelo: GPT
Agent: gerente de lançamentos da Monkey Forest
Skills: distribuição, metadados, royalties e comunicação
Tools: Gmail, Drive, planilhas e calendário
MCP: conexão padronizada com essas ferramentas
RAG: consulta aos documentos e regras da gravadora
Memória: artistas, parceiros e padrões da marca
Workflow: receber música → validar → preparar lançamento
Guardrails: não publicar nem enviar mensagens sem aprovação
```

[1]: https://openai.github.io/openai-agents-python/agents/?utm_source=chatgpt.com "OpenAI Agents SDK"
[2]: https://docs.anthropic.com/en/docs/claude-code/skills?utm_source=chatgpt.com "Extend Claude with skills - Claude Code Docs"
[3]: https://modelcontextprotocol.io/docs/getting-started/intro?utm_source=chatgpt.com "What is the Model Context Protocol (MCP)?"
[4]: https://modelcontextprotocol.io/docs/develop/build-server?utm_source=chatgpt.com "Build an MCP server"
[5]: https://modelcontextprotocol.io/docs/learn/server-concepts?utm_source=chatgpt.com "Understanding MCP servers"
[6]: https://openai.github.io/openai-agents-python/tools/?utm_source=chatgpt.com "Tools - OpenAI Agents SDK"
[7]: https://openai.github.io/openai-agents-python/handoffs/?utm_source=chatgpt.com "Handoffs - OpenAI Agents SDK"