Archcore MCP
oficialServidor MCP stdio local que permite que agentes de codificação de IA leiam e mantenham arquitetura estruturada, regras e decisões diretamente do seu repositório.
O que você pode fazer com Archcore MCP?
Archcore mantém especificações, decisões e regras como Markdown tipado em .archcore/, servido ao seu agente por meio de ferramentas MCP.
- Buscar contexto do projeto — Peça ao assistente para encontrar ADRs, regras ou especificações aplicáveis antes de editar, via
search_documents. - Registrar uma decisão — Peça ao assistente para criar um documento estruturado de ADR ou regra com
create_document. - Atualizar contexto existente — Peça ao assistente para revisar uma especificação ou plano usando
update_document. - Listar todos os documentos — Enumere todos os documentos de contexto em
.archcore/comlist_documents. - Buscar um documento — Recupere o conteúdo completo de um único documento com
get_document. - Vincular documentos relacionados — Conecte documentos com
add_relatione inspecione-os vialist_relations.
Documentação
Archcore CLI — Contexto Nativo de Git para Agentes de Codificação com IA
O Archcore é uma camada de contexto nativa de Git para agentes de codificação com IA.
A CLI mantém especificações, decisões de arquitetura, regras, planos e conhecimento do projeto em .archcore/, versionados junto com seu código, e serve o contexto relevante aos agentes de codificação por meio de MCP e session hooks.
Ele é distribuído como uma CLI e um servidor MCP local via stdio, para que qualquer agente de codificação compatível com MCP possa ler e escrever o contexto do seu projeto por meio de ferramentas padrão. Use-o para contexto persistente de projeto no Claude Code, Cursor, Codex CLI, GitHub Copilot, Gemini CLI, OpenCode, Roo Code e Cline.
Veja funcionando
Esse contexto veio de .archcore/ — documentos Markdown tipados versionados em Git, servidos a qualquer agente por meio de ferramentas MCP e session hooks.

O que muda
❌ Sem o Archcore
Toda sessão começa do zero. O agente:
- adivinha sua arquitetura e quebra suas convenções
- duplica lógica que já existe
- reabre decisões que seu time já tomou
- precisa que o mesmo contexto seja reexplicado em todo chat
✅ Com o Archcore
Suas decisões, regras e convenções vivem no Git como contexto estruturado. O agente:
- carrega as decisões e regras aplicáveis no início da sessão
- coloca o código onde sua arquitetura determina
- respeita os ADRs, especificações e regras já presentes no repositório
- registra novas decisões como contexto durável — revisável em PRs, portável entre agentes
O agente para de adivinhar e passa a seguir o sistema.
Comece em 60 segundos
curl -fsSL https://archcore.ai/install.sh | bash # macOS / Linux
cd your-project && archcore init
archcore init cria a estrutura de .archcore/, detecta seus agentes de codificação e configura hooks e MCP para eles.
Em seguida, abra seu agente e diga:
"Estamos usando PostgreSQL para armazenamento principal. Registre esta decisão."
Pronto — agora existe um ADR estruturado em .archcore/ que toda sessão futura, em qualquer agente, poderá ver.
No Windows: irm https://archcore.ai/install.ps1 | iex. Para WSL, go install e compilação a partir do código-fonte, consulte Métodos de instalação abaixo ou o guia de instalação completo.
Funciona com seu agente
A CLI é, por si só, um servidor MCP local via stdio — uma única superfície de integração para todo agente compatível com MCP. Os hooks adicionam contexto no início da sessão onde o agente os suporta.
| Agente | Hooks | MCP |
|---|---|---|
| Claude Code | sim | sim |
| Cursor | sim | sim |
| Gemini CLI | sim | sim |
| GitHub Copilot | sim | sim |
| OpenCode | — | sim |
| Codex CLI | — | sim |
| Roo Code | — | sim |
| Cline | — | manual |
archcore init configura os agentes detectados automaticamente. Para conectar um manualmente:
archcore mcp install --agent cursor # write MCP config for a specific agent
archcore hooks install # install session-start hooks for detected agents
claude mcp add --transport stdio archcore -- archcore mcp # or add the server manually
Como funciona
- Inicialize —
archcore initcria.archcore/e instala as integrações de agente. - Capture — decisões, regras, planos e guias são armazenados como documentos Markdown tipados com frontmatter YAML.
- Reutilize — os agentes leem, criam, atualizam e vinculam documentos por meio de ferramentas MCP enquanto trabalham; os hooks carregam o contexto no início da sessão.
- Mantenha no Git — revise mudanças de contexto como código, evolua-as ao longo do tempo e mantenha-as portáveis entre ferramentas.
.archcore/
├── settings.json
├── auth/
│ ├── jwt-strategy.adr.md
│ └── auth-redesign.prd.md
├── backend/
│ └── error-wrapping.rule.md
├── incidents/
│ └── connection-pool-exhaustion.cpat.md
└── notifications/
└── notifications-implementation.plan.md
A estrutura é livre — organize por domínio, recurso ou time. O tipo de um documento está no nome do arquivo (slug.type.md): 19 tipos em três camadas — conhecimento (ADRs, regras, especificações, guias), visão (PRDs, planos, ideias, trilhas de requisitos) e experiência (padrões de incidentes, tarefas recorrentes). O próprio .archcore/ deste repositório é um exemplo funcional.
Pergunte ao seu agente
"Antes de tocar no módulo de autenticação, quais decisões e regras se aplicam aqui?"
Carrega os ADRs e regras vinculados àquela área antes de o agente editar uma única linha.
"Temos uma convenção: sempre encapsular erros com fmt.Errorf e %w. Transforme isso em uma regra."
Cria backend/error-wrapping.rule.md com orientação imperativa, justificativa e exemplos bons/ruins.
"Na semana passada tivemos um incidente de esgotamento do connection pool. Documente para não repetirmos."
Cria incidents/connection-pool-exhaustion.cpat.md com análise de causa raiz e etapas de prevenção.
Como se compara
| Se você depende de… | A lacuna | O que o Archcore faz em vez disso |
|---|---|---|
| Nada | O agente reaprende seu repositório a cada sessão e reabre decisões já resolvidas | Carrega decisões, regras e convenções no início da sessão — em qualquer agente |
Arquivos de instrução simples (CLAUDE.md, .cursorrules) | Uma parede de texto crescente — sem tipos, sem links, sem ciclo de vida, copiada e colada por ferramenta | Documentos tipados, grafo de relações, ciclo de vida rascunho → aceito, uma única configuração para cada agente |
| Ferramentas de memória (claude-mem, Mem0) | Lembram o que você fez — volátil, opaco, vinculado ao fornecedor | Armazenam como o sistema é construído e o que foi decidido — versionado em Git, de sua propriedade |
| Kits de metodologia (BMAD, Spec Kit, Agent OS) | Prescrevem um processo, muitas vezes como um repasse único | Armazenam os artefatos — um grafo de contexto vivo que evolui com o código |
| RAG / uma janela de contexto maior | Recuperam o que o código diz, não o que foi decidido e por quê | Mantém decisões e justificativas explícitas e seletivas — o agente carrega o que se aplica, não tudo |
Não é para — memória de chat, biblioteca de prompts ou gerador pontual de especificação-para-código. O Archcore é uma camada de verdade do repositório para agentes de codificação, não um kit de metodologia.
Referência
O que acompanha o pacote: 19 tipos de documento, 4 tipos de relação, 10 ferramentas MCP, integrações de hook para 4 agentes e integrações MCP para 8.
Tipos de documento — 19 tipos entre visão, conhecimento e experiência
Conhecimento
| Tipo | Nome completo | Descrição |
|---|---|---|
adr | Architecture Decision Record | Registra uma decisão técnica finalizada com contexto, alternativas e consequências |
rfc | Request for Comments | Propõe uma mudança significativa aberta à revisão e feedback do time |
rule | Rule | Padrão de codificação ou processo com orientação imperativa e exemplos |
guide | Guide | Instruções passo a passo para concluir uma tarefa específica |
doc | Document | Documentação de referência, registros e material descritivo |
spec | Specification | Contrato normativo de comportamento para um limite ou recurso/subsistema do qual outros dependem |
Visão
| Tipo | Nome completo | Descrição |
|---|---|---|
prd | Product Requirements Document | Objetivos, histórias de usuário, critérios de aceite e métricas de sucesso |
idea | Idea | Captura leve de uma ideia de produto ou técnica para exploração futura |
plan | Plan | Lista de tarefas em fases com critérios de aceite e dependências |
rnd | Research | Investigação com prazo definido que responde a uma pergunta que bloqueia uma decisão |
Duas trilhas adicionais de requisitos para times que precisam de descoberta estruturada ou decomposição formal:
Trilha de fontes (MRD → BRD → URD) — captura de onde vêm os requisitos:
| Tipo | Nome completo | Descrição |
|---|---|---|
mrd | Market Requirements Document | Panorama de mercado, TAM/SAM/SOM, análise competitiva e necessidades de mercado |
brd | Business Requirements Document | Objetivos de negócio, stakeholders, ROI e regras de negócio |
urd | User Requirements Document | Personas de usuário, jornadas, requisitos de usabilidade e critérios de aceite |
Trilha ISO/IEC/IEEE 29148:2018 (BRS → StRS → SyRS → SRS) — captura como os requisitos se decompõem:
| Tipo | Nome completo | Descrição |
|---|---|---|
brs | Business Requirements Specification | Missão, metas, objetivos e conceito operacional de negócio |
strs | Stakeholder Requirements Specification | Necessidades dos stakeholders, conceito operacional e requisitos de usuário |
syrs | System Requirements Specification | Funções do sistema, interfaces, desempenho e restrições de design |
srs | Software Requirements Specification | Funções de software, interfaces externas e especificações comportamentais detalhadas |
Use PRD para a maioria dos projetos; adicione a trilha de fontes para descoberta estruturada de requisitos e a ISO 29148 para rastreabilidade formal em sistemas regulados ou multi-time complexos. Misture livremente.
Experiência
| Tipo | Nome completo | Descrição |
|---|---|---|
task-type | Task Type | Checklist e fluxo de trabalho reutilizáveis para uma tarefa recorrente |
cpat | Code Change Pattern | Análise de causa raiz de um bug ou incidente com etapas de prevenção |
Cada documento é um arquivo Markdown com frontmatter YAML:
---
title: "Use PostgreSQL for Primary Storage"
status: draft
tags: [database, infrastructure]
---
## Context
...
Status válidos: draft, accepted, rejected. As tags são opcionais e de formato livre.
Ferramentas MCP e relações
Ferramentas MCP
10 ferramentas: init_project, list_documents, get_document, search_documents, create_document, update_document, remove_document, add_relation, remove_relation, list_relations. O servidor também funciona em um repositório vazio — os agentes podem inicializar o .archcore/ por conta própria via init_project.
Relações
Os documentos se conectam por relações direcionadas: related (associação geral), implements (a origem implementa o que o destino especifica), extends (a origem se baseia no destino), depends_on (a origem requer o destino). Gerenciadas pelo agente por meio das ferramentas MCP.
Servidor MCP local
archcore mcp serve documentos do diretório atual via stdio. Passe --project /path/to/repo (ou defina ARCHCORE_PROJECT_ROOT) quando o servidor for iniciado a partir de um diretório que não seja seu workspace — por exemplo, por uma integração de editor.
Comandos
| Command | Descrição | | ------------------------ | ------------------------------------------------ | | `archcore init` | Inicializa o diretório `.archcore/` interativamente | | `archcore doctor` | Verifica sua configuração do archcore e corrige problemas | | `archcore status` | Verifica a estrutura de `.archcore/` e a saúde dos documentos | | `archcore config` | Visualiza ou modifica configurações | | `archcore hooks install` | Instala hooks para agentes de IA detectados | | `archcore mcp` | Executa o servidor MCP stdio | | `archcore mcp install` | Instala a configuração MCP para agentes detectados | | `archcore update` | Atualiza o Archcore para a versão mais recente |archcore update verifica os lançamentos do GitHub, baixa a versão mais recente, verifica a soma de verificação SHA-256 e substitui o binário atomicamente.
Métodos de instalação
macOS / Linux
curl -fsSL https://archcore.ai/install.sh | bash
Windows
irm https://archcore.ai/install.ps1 | iex
Instala o archcore.exe em %LOCALAPPDATA%\Programs\archcore e o adiciona ao seu usuário PATH. Abra uma nova janela do PowerShell após a instalação.
Windows (WSL)
Instale o WSL e execute o script macOS/Linux dentro dele.
Go install
go install github.com/archcore-ai/cli@latest
A partir do código-fonte
git clone https://github.com/archcore-ai/cli.git
cd cli
go build -o archcore .
Plataformas suportadas: macOS, Linux, Windows — amd64 e arm64.
Para variáveis de ambiente (ARCHCORE_VERSION, ARCHCORE_INSTALL_DIR, GITHUB_TOKEN) e solução de problemas de PATH, consulte o guia de instalação completo.
Configuração
As configurações ficam em .archcore/settings.json, criadas por archcore init.
| Campo | Descrição | Valores |
|---|---|---|
sync | Modo de sincronização. Cloud e on-prem estão chegando em breve. | none (somente local), cloud, on-prem |
language | Idioma do documento. Ajuda o agente a gerar documentação no idioma correto. | String, padrão é en |
archcore config # show all settings
archcore config get <key> # get a specific value
archcore config set <key> <value> # set a value
Ecossistema
- Archcore Plugin — usando Claude Code ou Cursor? O plugin se integra à CLI: mesmo mecanismo, além de skills, comandos de intenção e guardrails. Um produto, dois pontos de entrada — a CLI sozinha cobre todos os outros agentes.
- docs.archcore.ai — documentação completa.
.archcore/neste repositório — um exemplo vivo: a CLI é construída com sua própria camada de contexto.
Desenvolvimento
Requer Go 1.25+.
go build -o archcore . # build
go test ./... # run all tests
Links e licença
- Documentação: docs.archcore.ai
- Site: archcore.ai
- Plugin (Claude Code, Cursor): github.com/archcore-ai/archcore-plugin
- Issues: github.com/archcore-ai/cli/issues
- Licença: Apache 2.0