Como Construir Data Pipelines que se Auto-Corrigem com Claude MCP e Agentes Autonomos

O Problema: Pipelines de Dados Quebram em Silencio

Todo engenheiro de dados ja viveu esse cenario. Um pipeline falha as 3 da manha. O engenheiro de plantao acorda, investiga por uma hora e descobre que foi uma mudanca de schema no sistema de origem. A correcao leva cinco minutos. A investigacao levou sessenta.

Agora multiplique isso por dezenas de pipelines, centenas de tabelas e um time que ja esta sobrecarregado. A abordagem tradicional -- monitorar, alertar, acordar alguem, corrigir manualmente -- nao escala. E se o pipeline pudesse se corrigir sozinho?

Isso nao e um experimento teorico. Eu construi. A implementacao completa esta open-source em github.com/michael-eng-ai/agentic-data-pipeline-mcp.

Por Que o MCP Muda Tudo para Infraestrutura de Dados

O Model Context Protocol (MCP) se tornou rapidamente o protocolo padrao para conectividade de agentes de IA. Originalmente introduzido pela Anthropic, o MCP padroniza como modelos de IA interagem com ferramentas externas, bancos de dados e APIs. O Pinterest recentemente demonstrou o MCP em escala de producao em todo seu ecossistema de dados, validando o que muitos de nos percebemos cedo: o MCP e para agentes de IA o que o REST foi para servicos web.

Para engenharia de dados, o MCP desbloqueia algo especifico e poderoso. Em vez de construir integracoes customizadas entre um LLM e cada ferramenta do seu stack (Spark, dbt, Great Expectations, Airflow), voce expoe cada ferramenta como um servidor MCP. O agente se conecta a todas atraves de um unico protocolo. Adicionou uma nova ferramenta? Adicione um novo servidor MCP. O agente se adapta imediatamente.

Essa e a base do projeto agentic-data-pipeline-mcp. O Claude se conecta a sua infraestrutura de dados atraves de servidores MCP, ganhando a capacidade de inspecionar schemas, executar verificacoes de qualidade, aplicar correcoes e registrar cada acao -- tudo atraves de uma interface padronizada.

Arquitetura: Tres Camadas de Auto-Correcao

O sistema e projetado em torno de tres camadas distintas, cada uma com niveis crescentes de autonomia e risco.

+--------------------------------------------------+
|              CAMADA DE ORQUESTRACAO               |
|  Airflow / Prefect / Cron                        |
|  Dispara execucoes, monitora resultados          |
+--------------------------------------------------+
           |                    |
           v                    v
+---------------------+  +---------------------+
|   DATA PIPELINE     |  |   CAMADA DE AGENTES |
|   Spark / dbt       |  |   Claude + MCP      |
|   Extract, Transform|  |   Detectar, Diagn.  |
|   Load              |  |   Corrigir, Auditar |
+---------------------+  +---------------------+
           |                    |
           v                    v
+--------------------------------------------------+
|              ENGINE DE GUARDRAILS                 |
|  Permissoes em camadas: AUTO / REVIEW / BLOCKED  |
|  Definicoes policy-as-code                       |
+--------------------------------------------------+
           |
           v
+--------------------------------------------------+
|              LOG DE AUDITORIA ESTRUTURADO         |
|  Cada decisao, cada acao, rastreabilidade total   |
+--------------------------------------------------+

Camada 1: Deteccao

O agente monitora a execucao do pipeline atraves de ferramentas de observabilidade conectadas via MCP. Quando uma execucao falha ou uma verificacao de qualidade sinaliza uma anomalia, o agente recebe o contexto: qual tabela, qual verificacao, quais eram os valores esperados vs reais.

A deteccao cobre tres categorias:

• Schema drift: Uma tabela de origem adicionou, removeu ou alterou uma coluna. O agente compara o schema atual contra o data contract registrado e identifica o delta.
• Degradacao de qualidade: Taxas de null disparam, distribuicoes de valores mudam, SLAs de freshness sao perdidos. Resultados do Great Expectations e Soda alimentam o agente.
• Falhas de execucao: Erros de runtime, problemas de timeout, falhas de dependencia. O agente le os logs de erro e stack traces diretamente.

Camada 2: Diagnostico e Decisao

Aqui e onde o sistema de guardrails em camadas se torna critico. Nem toda correcao deve ser automatizada. O agente classifica cada problema e mapeia para um dos tres niveis:

Nivel AUTO -- O agente corrige imediatamente, sem aprovacao humana. Exemplos:

• Uma nova coluna nullable apareceu em uma tabela de origem. O data contract e atualizado, o modelo downstream ignora a nova coluna, pipeline retoma.
• Um SLA de freshness foi perdido porque o sistema de origem atrasou 30 minutos. O agente redispara a extracao com uma janela de backoff.

Nivel REVIEW -- O agente propoe uma correcao mas aguarda aprovacao humana. Exemplos:

• Uma coluna foi renomeada no sistema de origem. O agente gera o script de migracao e o data contract atualizado, mas um humano deve aprovar antes da execucao.
• Uma verificacao de qualidade mostra uma mudanca de distribuicao que pode ser mudanca legitima de negocio ou pode ser um problema de dados.

Nivel BLOCKED -- O agente nao pode e nao deve tentar uma correcao. Exemplos:

• Uma tabela foi removida do sistema de origem inteiramente.
• Dados contem PII que nao estava presente antes, disparando preocupacoes de compliance.

A atribuicao de nivel nao e hardcoded por tipo de erro. E policy-as-code: uma configuracao YAML que mapeia padroes de problemas para niveis, com regras de override baseadas em criticidade da tabela, sensibilidade dos dados e impacto no negocio.

Camada 3: Execucao e Auditoria

Para correcoes AUTO, o agente executa a remediacao atraves de ferramentas MCP. Para REVIEW, cria um pull request ou uma notificacao no Slack com a correcao proposta. Para BLOCKED, escala com contexto diagnostico completo.

Cada acao -- deteccao, diagnostico, decisao, execucao -- e gravada em um log de auditoria estruturado. Isso e inegociavel. O log captura timestamp, pipeline, tipo de problema, nivel, acao tomada, confianca do agente, status de aprovacao humana e duracao.

Essa trilha de auditoria e o que torna o sistema pronto para producao. Cada decisao autonoma e rastreavel, revisavel e auditavel.

Deteccao de Schema Drift na Pratica

Schema drift e a falha silenciosa mais comum em pipelines de dados. Um sistema de origem muda o tipo de uma coluna de integer para string, e de repente seu pipeline produz lixo sem nenhum erro.

O agente lida com isso atraves de um loop de comparacao de schema:

1. Antes de cada extracao, o agente busca o schema atual da fonte via MCP.
2. Compara contra o data contract registrado (armazenado como YAML versionado).
3. Se ha um delta, classifica a mudanca: aditiva (nova coluna), destrutiva (coluna removida) ou mutacao (mudanca de tipo).
4. Mudancas aditivas em tabelas nao-criticas vao para AUTO. Mudancas destrutivas sempre vao para BLOCKED. Mutacoes vao para REVIEW com uma estrategia de casting proposta.

Esse padrao sozinho eliminou aproximadamente 60% das nossas intervencoes manuais em pipeline durante os testes.

Agentes de Correcao de Qualidade: Alem de Simples Retries

Os agentes de correcao de qualidade sao sub-agentes especializados, cada um treinado em uma categoria especifica de problema de qualidade de dados:

• Freshness Agent: Lida com violacoes de SLA verificando status do sistema de origem, ajustando janelas de extracao e redisparando com backoff apropriado.
• Completeness Agent: Investiga picos de null comparando contra baselines historicas e saude do sistema upstream.
• Consistency Agent: Detecta violacoes de integridade referencial e propoe remediacao.
• Accuracy Agent: Sinaliza anomalias estatisticas em distribuicoes de valores e cruza com calendarios de eventos de negocio.

Essa abordagem multi-agent espelha como o Pinterest estrutura seu ecossistema MCP: agentes especializados para dominios especializados, coordenados por um orquestrador. A diferenca e que cada agente opera dentro do mesmo sistema de guardrails em camadas.

Conectando ao Ecossistema MCP Mais Amplo

O projeto e projetado para ser composavel. Cada servidor MCP e independente:

• mcp-server-spark: Inspecao de schema, amostragem de dados, submissao de jobs
• mcp-server-quality: Execucao de checks Great Expectations e Soda
• mcp-server-contracts: Operacoes CRUD de data contracts
• mcp-server-git: Criacao de branch, commit, submissao de PR para correcoes REVIEW
• mcp-server-notifications: Integracao Slack, email, PagerDuty

Voce pode usar qualquer subconjunto. Se quer apenas deteccao de schema drift sem correcao autonoma, use apenas os servidores de contracts e spark. Se quer o loop completo de auto-correcao, conecte todos os cinco.

Essa composabilidade e exatamente por que o MCP esta vencendo como padrao para conectividade de agentes de IA. O protocolo lida com a complexidade de registro de ferramentas, autenticacao e passagem de contexto. Voce foca na logica de dominio.

O Que Isso Nao E

Deixe-me ser direto sobre os limites:

• Isso nao substitui engenharia de dados bem feita. Voce ainda precisa de pipelines bem projetados, data contracts limpos e orquestracao solida.
• Isso nao e uma solucao magica para cultura de dados ruim. Se sua organizacao nao valoriza qualidade de dados, nenhum agente vai salvar voce.
• Isso nao e totalmente autonomo. O sistema de guardrails em camadas existe precisamente porque algumas decisoes requerem julgamento humano. O objetivo e lidar com os 70% de incidentes que sao mecanicos e repetitivos, liberando engenheiros para os 30% que realmente precisam de expertise.

Como Comecar

A implementacao completa, incluindo os servidores MCP, engine de guardrails, log de auditoria e pipelines de exemplo, esta disponivel em github.com/michael-eng-ai/agentic-data-pipeline-mcp.

O repositorio inclui:

• Implementacoes completas de servidores MCP para cada integracao
• Templates YAML de policy-as-code para guardrails
• Schema de log de auditoria estruturado e exemplos de query
• Setup Docker Compose para desenvolvimento local
• Testes de integracao para cada tipo de agente

Comece pelo agente de deteccao de schema drift. E o ponto de entrada com maior valor e menor risco. Quando voce vir seu pipeline automaticamente atualizando um data contract para uma nova coluna nullable as 3 da manha em vez de te acordar, voce vai entender por que essa abordagem importa.

O futuro da engenharia de dados nao e escrever mais pipelines. E construir pipelines que se mantem sozinhos. MCP e agentes autonomos tornam esse futuro pratico hoje.