- </hype>
- Posts
- </hype> De smartphones a IA: Por que 'API-first, MCP-second' é o futuro
</hype> De smartphones a IA: Por que 'API-first, MCP-second' é o futuro
.join("A mesma revolução que criou APIs para mobile agora traz MCP para IA")

sudo apt-get update |
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:
Desacoplamento: Frontend e backend podem evoluir independentemente
Reutilização: Uma API bem projetada serve múltiplos clientes (web, iOS, Android, etc.)
Escalabilidade: Microserviços conectados via APIs
Developer Experience: Documentação, SDKs e ferramentas padronizadas
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
Tools (Controlados pelo modelo): Ações que a IA decide executar
Resources (Controlados pela aplicação): Contexto fornecido à IA
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:
APIs tradicionais continuam sendo a base da comunicação entre serviços
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)
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!