Tether MCP

Impede que agentes de codificação de IA se desviem da sua arquitetura — bloqueia dependências incorretas, impõe a estrutura de arquivos e dá aos agentes memória persistente das regras do seu projeto.

Documentação

Anchor

Tether MCP

O motor anti-deriva para agentes de codificação de IA.
Dê à sua IA memória persistente das regras do seu projeto. Um comando. Zero nuvem.

npm version npm downloads MIT License MCP Node.js


Agentes de IA como Cursor e Claude escrevem código rápido — mas sofrem de Deriva de Agente: alucinam dependências, violam limites arquiteturais e criam código espaguete. Tether é um Arquiteto Sênior persistente que sua IA deve consultar antes de fazer mudanças estruturais.

Sumário

O Problema

Você já passou por isso. Você pede a um agente de IA para adicionar um recurso e ele:

  • 🎲 Instala moment.js quando seu projeto já usa date-fns
  • 🏗️ Cria um servidor Express dentro do seu app Next.js
  • 🧩 Adiciona Riverpod quando seu time Flutter concordou em usar BLoC
  • 📝 Esquece toda a arquitetura depois de algumas mensagens

Cada sessão começa do zero. A IA não tem memória das suas regras, das suas decisões de stack ou dos seus limites arquiteturais. Isso é Deriva de Agente, e transforma codificação assistida por IA em uma fábrica de dívida técnica.

Início Rápido

1. Inicialize no Seu Projeto

npx tether-mcp init

Tether escaneia o manifesto do seu projeto (package.json, pubspec.yaml, .csproj, pyproject.toml, go.mod, Cargo.toml, build.gradle, pom.xml, ou Package.swift), detecta automaticamente seu framework em 8 ecossistemas e 90 frameworks, e gera um tether.config.json personalizado com padrões inteligentes.

2. Conecte ao Seu Agente de IA

Claude Code / Claude Desktop

Adicione ao ~/.claude/claude_desktop_config.json:

{
  "mcpServers": {
    "tether": {
      "command": "npx",
      "args": ["-y", "tether-mcp"]
    }
  }
}
Cursor

Adicione ao .cursor/mcp.json na raiz do seu projeto:

{
  "mcpServers": {
    "tether": {
      "command": "npx",
      "args": ["-y", "tether-mcp"]
    }
  }
}
Windsurf

Adicione à sua configuração MCP do Windsurf:

{
  "mcpServers": {
    "tether": {
      "command": "npx",
      "args": ["-y", "tether-mcp"]
    }
  }
}

3. Pronto. Seu Agente de IA Agora Tem Guardrails ⚓

Toda vez que a IA começa a trabalhar, ela consulta o Tether primeiro — lendo seus invariantes, verificando políticas de dependências, validando posicionamento de arquivos e registrando decisões estruturais. Sem mais deriva.

Como Funciona

┌──────────────┐     MCP Tools     ┌──────────────┐     Local Files     ┌──────────────────┐
│  AI Agent    │ ◄──────────────► │  Tether MCP  │ ◄─────────────────► │ tether.config.json│
│ (Claude,     │                  │  Server      │                     │ ARCHITECTURE.md   │
│  Cursor)     │                  │              │                     │ DECISIONS.md      │
└──────────────┘                  └──────────────┘                     └──────────────────┘

Ferramentas (6 no total)

FerramentaQuando ChamarO Que Faz
get_project_invariantsAntes de qualquer trabalho estruturalAlimenta a IA com seu stack tecnológico, regras de arquitetura e políticas de dependências
verify_dependency_additionAntes de npm install <pkg>Verifica se o pacote está bloqueado, avisado, permitido ou precisa de revisão
log_architectural_decisionDepois de criar um componente ou mudar o fluxo de dadosAdiciona uma entrada com timestamp ao DECISIONS.md
check_file_structureAntes de criar ou mover arquivosValida o caminho de arquivo proposto contra as convenções do projeto
verify_code_patternAntes de implementar um recursoVerifica se a abordagem de codificação segue padrões e invariantes aprovados
health_checkDiagnósticoRetorna status do servidor, ferramentas registradas e telemetria de sessão

Recursos MCP

Tether também expõe o contexto do projeto como Recursos MCP que os clientes podem assinar automaticamente:

RecursoURIDescrição
Configtether://configO tether.config.json completo — stack tecnológico, invariantes, políticas de dependências
Arquiteturatether://architectureO documento de ARCHITECTURE.md do projeto
Decisõestether://decisionsO registro de DECISIONS.md de todas as decisões registradas

Configuração

Edite o tether.config.json para corresponder ao seu projeto:

{
  "projectName": "my-app",
  "techStack": {
    "frontend": ["Next.js", "React"],
    "backend": ["Node.js"],
    "orm": ["Prisma"]
  },
  "invariants": [
    "All API routes must validate input with Zod.",
    "Database access must go through Prisma — no raw SQL.",
    "Use Server Components by default — client components only when needed."
  ],
  "dependencies": {
    "blocked": [
      {
        "name": "moment",
        "reason": "Use date-fns instead.",
        "alternatives": ["date-fns"],
        "severity": "block"
      },
      {
        "name": "lodash",
        "reason": "Tree-shaking issues. Use native JS or lodash-es.",
        "alternatives": ["lodash-es", "remeda"],
        "severity": "warn"
      }
    ]
  },
  "fileStructure": [
    {
      "pattern": "component",
      "allowedPaths": ["src/components/", "src/app/"],
      "reason": "All React components must live in src/components/ or src/app/"
    },
    {
      "pattern": "api-route",
      "allowedPaths": ["src/app/api/"],
      "reason": "API routes must use Next.js Route Handlers in app/api/"
    }
  ],
  "codePatterns": [
    {
      "name": "State Management",
      "rule": "Use React Context + useReducer for complex state — no Redux or Zustand",
      "scope": "frontend/state"
    },
    {
      "name": "Data Fetching",
      "rule": "Use Server Components for data fetching — no client-side fetch in components",
      "scope": "frontend"
    }
  ]
}

Comandos CLI

npx tether-mcp init       # Scan project & generate tether.config.json
npx tether-mcp serve      # Start the MCP server (stdio)
npx tether-mcp status     # Show project config summary & health
npx tether-mcp validate   # Validate tether.config.json against schema
npx tether-mcp --version  # Show version
npx tether-mcp --help     # Show all commands

Níveis de Severidade de Dependências

Dependências bloqueadas agora suportam níveis de severidade:

SeveridadeComportamento
"block" (padrão)Parada total — a IA é informada de que o pacote é proibido
"warn"Aviso suave — a IA é desencorajada, mas não bloqueada
{
  "dependencies": {
    "blocked": [
      { "name": "moment", "reason": "Deprecated.", "alternatives": ["date-fns"], "severity": "block" },
      { "name": "axios", "reason": "Prefer native fetch.", "alternatives": ["fetch"], "severity": "warn" }
    ]
  }
}

O Que É Gerado

Quando você executa npx tether-mcp init em um projeto Next.js + Prisma + Tailwind, o Tether gera:

{
  "projectName": "my-next-app",
  "techStack": {
    "frontend": ["Next.js", "React"],
    "styling": ["Tailwind CSS"],
    "orm": ["Prisma"],
    "language": ["TypeScript"]
  },
  "invariants": [
    "Use Next.js App Router for all new routes — do not use the Pages Router.",
    "All database access must go through Prisma — no raw SQL queries.",
    "Use Tailwind utility classes for styling — no inline styles.",
    "All new code must be written in TypeScript with strict mode enabled."
  ],
  "dependencies": {
    "blocked": [
      { "name": "express", "reason": "Next.js has built-in API routes.", "alternatives": ["Next.js Route Handlers"] },
      { "name": "moment",  "reason": "Deprecated and large bundle size.", "alternatives": ["date-fns"] }
    ]
  }
}

O Registro de Decisões

Toda decisão estrutural que a IA toma é registrada no DECISIONS.md:

## Added Redis caching layer

| Field | Value |
|-------|-------|
| **Date** | 2026-03-10T01:30:00.000Z |
| **Scope** | `api/cache` |

### Summary

Added Redis via ioredis for caching frequently accessed product data.
Chose Redis over Memcached for pub/sub support and persistence options.

Isso cria uma trilha de auditoria imutável de cada escolha arquitetural — visível para o próximo desenvolvedor e para a próxima sessão de IA.

Telemetria de Sessão

A ferramenta health_check retorna estatísticas locais de sessão:

{
  "status": "healthy",
  "session": {
    "sessionStartedAt": "2026-03-12T10:00:00.000Z",
    "totalCalls": 7,
    "toolStats": {
      "get_project_invariants": { "callCount": 3, "lastCalledAt": "...", "errors": 0 },
      "verify_dependency_addition": { "callCount": 2, "lastCalledAt": "...", "errors": 0 }
    }
  }
}

Nenhum dado sai da sua máquina. A telemetria é redefinida quando o servidor reinicia.

Detecção de Frameworks Suportados

Tether detecta automaticamente 90 frameworks em 8 ecossistemas:

JavaScript / TypeScript (package.json)

CategoriaDetectado
FrontendNext.js, React, Vue.js, Svelte, Angular, Nuxt, Remix, Astro, SolidJS
BackendExpress, Fastify, NestJS, Hono, Koa, Elysia
ORM / DBPrisma, Drizzle, TypeORM, Sequelize, Mongoose
TestesVitest, Jest, Playwright, Cypress
EstilizaçãoTailwind CSS, Styled Components, Emotion
EstadoZustand, Redux Toolkit
AutenticaçãoNextAuth.js
BuildVite
LinguagemTypeScript

Python (pyproject.toml, requirements.txt)

CategoriaDetectado
BackendDjango, Flask, FastAPI
ORMSQLAlchemy
Testespytest
ValidaçãoPydantic
Fila de TarefasCelery
Ciência de DadosNumPy, pandas
MLTensorFlow, PyTorch
FrontendStreamlit

Dart / Flutter (pubspec.yaml)

CategoriaDetectado
FrameworkFlutter
EstadoBLoC, Riverpod, GetX, Provider
HTTPDio
BackendFirebase
RoteamentoGoRouter
Geração de CódigoFreezed

C# / .NET (.csproj)

CategoriaDetectado
BackendASP.NET Core
ORMEntity Framework Core, Dapper
FrontendBlazor
Mobile.NET MAUI
TestesxUnit, NUnit
ArquiteturaMediatR
LoggingSerilog
ValidaçãoFluentValidation

Go (go.mod)

CategoriaDetectado
BackendGin, Echo, Fiber, Chi
ORMGORM
TestesTestify
RoteamentoGorilla Mux

Rust (Cargo.toml)

CategoriaDetectado
BackendActix Web, Axum, Rocket
AsyncTokio
ORMDiesel, SeaORM
SerializaçãoSerde
Banco de DadosSQLx
CLIClap

Java / Kotlin (build.gradle, pom.xml)

CategoriaDetectado
BackendSpring Boot, Ktor
ORMHibernate
TestesJUnit 5
FrontendJetpack Compose

Swift (Package.swift)

CategoriaDetectado
BackendVapor
HTTPAlamofire
CLISwift Argument Parser
Banco de DadosGRDB

Cada detecção adiciona invariantes direcionados e regras inteligentes de pacotes bloqueados específicos para seu stack.

Referência de Configuração

CampoTipoDescrição
projectNamestringNome de exibição do projeto
techStackRecord<string, string[]>Seu stack tecnológico imposto por categoria
invariantsstring[]Regras arquiteturais imutáveis que a IA deve seguir
dependencies.allowedstring[]Pacotes pré-aprovados
dependencies.blockedarrayPacotes proibidos com motivo, alternativas e severidade opcional
dependencies.reviewRequiredstring[]Pacotes que precisam de justificativa
fileStructurearrayRegras de posicionamento de arquivos com padrão, caminhos permitidos e motivo
codePatternsarrayRegras de padrões de código com nome, regra e escopo
architectureFilestringCaminho para o documento de arquitetura (padrão: ARCHITECTURE.md)
decisionsFilestringCaminho para o registro de decisões (padrão: DECISIONS.md)

FAQ

"Preciso escrever o arquivo de configuração eu mesmo?"

Não. Execute npx tether-mcp init e ele gera automaticamente o tether.config.json escaneando seu projeto. Você pode personalizá-lo depois, mas os padrões já são inteligentes o suficiente.

"Preciso dizer à IA para usar o Tether?"

Não. As ferramentas MCP são descobertas automaticamente. A IA vê as ferramentas do Tether em sua caixa de ferramentas e as chama ao fazer mudanças estruturais — assim como usa file_read ou terminal.

"Isso não vai gastar mais tokens?"

~500-1.500 tokens por sessão para guardrails vs. 5.000-20.000 tokens desperdiçados corrigindo erros de deriva. O Tether se paga no primeiro bloqueio de dependência ruim.

"Por que não usar apenas o Claude Opus — ele é inteligente o suficiente?"

Inteligente ≠ onisciente. O Claude não sabe que seu time decidiu usar date-fns há três meses. Ele não lembra das decisões da Sessão #1 na Sessão #10. E quando você fecha a aba, o contexto se vai. O Tether dá à IA memória persistente baseada em arquivos das suas regras — em todas as sessões, todos os agentes.

"E se eu trabalhar em vários projetos?"

Cada projeto tem seu próprio tether.config.json em seu próprio diretório. As regras do Projeto A nunca vazam para o Projeto B.

"Isso é apenas um CLAUDE.md sofisticado?"

Não. O CLAUDE.md é passivo — a IA pode ou não lê-lo. O Tether é ativo — ele valida dependências, bloqueia pacotes ruins com alternativas, verifica a estrutura de arquivos, valida padrões de código e mantém uma trilha de auditoria. Ele funciona com Claude, Cursor, Windsurf e qualquer agente compatível com MCP.

Contribuindo

Contribuições são bem-vindas! Aqui estão algumas formas de ajudar:

  • Adicione uma assinatura de framework — detecte um novo framework no src/utils/detect-stack.ts
  • Melhore invariantes — melhores padrões para frameworks existentes
  • Relatórios de bugs — abra uma issue
  • Solicitações de recursos — ideias para novas ferramentas ou recursos
git clone https://github.com/MoayadEsam/tether-mcp.git
cd tether-mcp
npm install
npm run build

Licença

MIT — feito com ♥ para desenvolvedores cansados de limpar a bagunça dos seus agentes de IA.