Estava refletindo sobre a evolução das APIs e da conectividade entre sistemas, e o Model Context Protocol (MCP), que a Anthropic lançou em novembro de 2024, me trouxe uma reflexão: será que estamos presenciando o próximo grande salto na evolução das APIs?

A jornada de 70 anos: Como chegamos até aqui

A evolução das APIs: Uma linha do tempo completa

Anos 1950: O nascimento da ideia O conceito de API nasceu em 1951, no livro "The Preparation of Programs for an Electronic Digital Computer" de Maurice Wilkes e David Wheeler. Na época, APIs eram simples interfaces de linha de comando para interagir com computadores.

Anos 1960-70: Expandindo horizontes Em 1974, o termo "API" foi formalmente introduzido no paper "The Relational and Network Approaches: Comparison of the Application Programming Interface". APIs começaram a conectar mainframes com terminais e impressoras, estabelecendo independência de hardware.

Anos 1980: Preparando o terreno para a internet Redes de computadores se tornaram comuns, e APIs possibilitaram Remote Procedure Calls (RPCs). A compatibilidade cross-platform se tornou realidade.

Anos 1990: O boom da internet Carl Malamud definiu APIs como "um conjunto de serviços disponíveis para programadores executarem certas tarefas". APIs passaram a permitir comunicação entre aplicações em diferentes sistemas através da internet.

Anos 2000: REST domina

• Roy Fielding define REST em sua dissertação de 2000

• Salesforce, eBay e Amazon pioneiros em web APIs

• Apple lança iPhone em 2007, quando APIs já haviam revolucionado a infraestrutura

• Amazon pioneira no modelo "API-first", mandatando que todos recursos compartilhados tenham uma API

Nesta época, SOAP ainda dominava com seus protocolos pesados baseados em XML:

<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/envelope/">
  <soap:Body>
    <GetProducts xmlns="http://tempuri.org/">
      <Category>Electronics</Category>
    </GetProducts>
  </soap:Body>
</soap:Envelope>

Anos 2010: Microserviços e GraphQL

• Redes sociais impulsionam nova geração de APIs

• Kubernetes promove sistemas distribuídos com microserviços

• 2012: Facebook cria GraphQL para resolver over-fetching e under-fetching do REST

• Cada serviço implementa sua própria API

Anos 2020: API-first como padrão

• COVID-19 acelera dependência de web services

• APIs vitais para IoT e construção de IA

• Desenvolvedores adotam abordagem "API-first": projetam APIs primeiro, depois constroem aplicações ao redor delas

E agora, 2024: MCP second

• Anthropic introduz Model Context Protocol

• APIs ganham camada de inteligência artificial

• Nova mentalidade: API-first, MCP-second

• Foco em como IA interage com nossos sistemas

O que essa jornada nos ensinou

Esta evolução de 70 anos nos mostra um padrão claro: cada geração de APIs surge para resolver limitações da anterior, mas sem eliminá-la completamente.

• 1950s → 1980s: Conectividade básica entre sistemas

• 1990s: Internet muda tudo

• 2000s: REST simplifica e padroniza

• 2010s: GraphQL otimiza transferência de dados

• 2020s: MCP conecta IA com dados reais

A revolução do "um backend, múltiplas plataformas"

Um ponto crucial na evolução das APIs foi a necessidade de escalar aplicações para ambientes diferentes. Quando os smartphones explodiram e as empresas precisaram estar presentes simultaneamente na web, em apps iOS, Android, e mais tarde em smart TVs, IoT, etc., ficou claro que recriar toda a lógica de negócio para cada plataforma era insustentável.

A ideia de disponibilizar um único backend que pudesse servir todos esses clientes foi revolucionária:

• 2007: iPhone muda tudo - empresas precisam de apps além da web

• 2008: Android surge - agora são 3 plataformas (web + 2 mobile)

• 2010s: Explosion de dispositivos - tablets, smart TVs, wearables

• Resultado: APIs se tornam a única forma viável de manter consistência

A mentalidade API-first, consolidada nos anos 2020, nos trouxe:

1. Desacoplamento: Frontend e backend podem evoluir independentemente

2. Reutilização: Uma API bem projetada serve múltiplos clientes (web, iOS, Android, etc.)

3. Escalabilidade: Microserviços conectados via APIs

4. Developer Experience: Documentação, SDKs e ferramentas padronizadas

5. Consistência: Mesma lógica de negócio em todas as plataformas

O cenário atual: Preparando para a próxima expansão

Hoje vivemos a mesma necessidade de expansão, mas agora para um novo "cliente": sistemas de IA.

Assim como nos anos 2000-2010 precisávamos servir web + mobile, agora precisamos servir:

• Aplicações tradicionais (web, mobile, desktop)

• Sistemas de IA (chatbots, agentes, assistentes)

E aqui está a beleza: a infraestrutura API-first que construímos já nos preparou para isso. MCP é apenas a ponte que faltava.

• Fragmentação: Cada serviço com sua própria API

• Contexto perdido: Modelos de IA isolados de dados reais

• Integrações customizadas: M×N implementações para conectar M aplicações com N sistemas

Enter MCP: O "USB-C" para AI

O Model Context Protocol da Anthropic promete resolver exatamente isso. Think of MCP like a USB-C port for AI applications. Just as USB-C provides a standardized way to connect your devices to various peripherals and accessories, MCP provides a standardized way to connect AI models to different data sources and tools.

Como funciona o MCP

O protocolo é surpreendentemente elegante:

• Servidores MCP: Expõem dados, ferramentas e prompts padronizados

• Clientes MCP: Aplicações de IA que consomem esses recursos

• JSON-RPC over stdio: Protocolo de comunicação simples e confiável

// Exemplo de servidor MCP básico
interface MCPServer {
  tools: Tool[];        // Ações que a IA pode executar
  resources: Resource[]; // Dados que a IA pode acessar
  prompts: Prompt[];     // Templates pré-definidos
}

Três pilares do MCP

1. Tools (Controlados pelo modelo): Ações que a IA decide executar

2. Resources (Controlados pela aplicação): Contexto fornecido à IA

3. Prompts (Controlados pelo usuário): Interações específicas invocadas pelo usuário

API-first, MCP-second: Uma nova mentalidade

Aqui está o ponto crucial: MCP não substitui APIs. Ele estabelece uma nova mentalidade onde, daqui pra frente, sempre vamos pensar em criar um servidor MCP para melhorar a maneira como pessoas interagem com nosso produto através de IA.

É uma evolução natural do pensamento: primeiro construímos APIs robustas para servir múltiplas plataformas, agora expondo-as via MCP para torná-las acessíveis a sistemas de IA. API-first, MCP-second como padrão.

Quando usar cada um:

API-first tradicional:

• Comunicação entre serviços

• Integrações B2B

• Aplicações web e mobile

• Quando você precisa de controle total sobre o protocolo

MCP:

• Conectar IA com dados empresariais

• RAG (Retrieval-Augmented Generation) padronizado

• Ferramentas de desenvolvimento assistidas por IA

• Quando você quer que modelos de IA tenham acesso contextual a sistemas

O exemplo prático

Imagine que você tem:

• Um sistema de CRM (REST API)

• Um banco de dados de documentos (GraphQL API)

• Um repositório Git (Git API)

Abordagem tradicional: Criar integrações específicas para cada sistema Abordagem MCP: Expor cada sistema via servidor MCP padronizado

// Configuração MCP no Claude Desktop
{
  "mcpServers": {
    "crm": {
      "command": "node",
      "args": ["./servers/crm-server.js"]
    },
    "docs": {
      "command": "python",
      "args": ["./servers/docs-server.py"]
    },
    "git": {
      "command": "node", 
      "args": ["./servers/git-server.js"]
    }
  }
}

A adoção está crescendo

Desde o lançamento em novembro de 2024, empresas como Block e Apollo já integraram MCP em seus sistemas, enquanto ferramentas de desenvolvimento como Replit, Codeium e Sourcegraph estão adicionando suporte ao protocolo.

A Anthropic disponibilizou servidores MCP pré-construídos para:

• Google Drive

• Slack

• GitHub

• PostgreSQL

• Puppeteer

Insights dos dados que coletei

Analisando os repositórios em tendência no GitHub, vemos que:

Python: DeepSeek-V3, AutoGPT e vários projetos de IA dominam JavaScript: React, Next.js continuam fortes, mas Open WebUI (interface para IA) está crescendo

Isso mostra que a comunidade está abraçando ferramentas que facilitam a integração com IA - exatamente o que MCP promete padronizar.

O futuro: API-first, MCP-second como padrão

Acredito que estamos caminhando para um mundo onde:

1. APIs tradicionais continuam sendo a base da comunicação entre serviços

2. MCP se torna uma camada obrigatória de qualquer produto que queira ser AI-friendly (assim como APIs se tornaram obrigatórias para produtos multi-plataforma)

3. Aplicações modernas serão desenvolvidas sempre pensando: "Como nossa API pode ser consumida via MCP?"

Nova mentalidade de desenvolvimento:

•  ✅ Criar API robusta e bem documentada

•  ✅ Expor funcionalidades via servidor MCP

•  ✅ Permitir que IA interaja naturalmente com seu produto

•  ✅ Melhorar a experiência do usuário através de automação inteligente

Evolution, not revolution

MCP não é uma revolução, é evolução. GraphQL's features are not a revolution, but what makes GraphQL powerful is that the level of polish, integration, and ease-of-use make it more than the sum of its parts. O mesmo pode ser dito sobre MCP.

Assim como GraphQL não matou REST, MCP não vai matar APIs tradicionais. Cada ferramenta tem seu lugar no ecossistema.

A pergunta não é "API first ou MCP second?"

A pergunta é: "Como podemos estabelecer API-first, MCP-second como o novo padrão de desenvolvimento?"

É uma mudança de mentalidade: toda vez que construirmos uma API, já devemos pensar em como ela será consumida por IA para melhorar a experiência do usuário.

sudo shutdown --reboot=monday

Esta newsletter está em constante desenvolvimento (always beta). Estou aprendendo a cada edição e seu feedback é essencial!

Compartilhe com outros devs que podem gostar e me conte o que achou:

• O que você quer ver nas próximas edições?

• Algum tema específico que devemos abordar?

• Sugestões para melhorar o formato?

Todo pull request de ideias é bem-vindo!