Archcore MCP

oficial

Servidor 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/ com list_documents.
  • Buscar um documento — Recupere o conteúdo completo de um único documento com get_document.
  • Vincular documentos relacionados — Conecte documentos com add_relation e inspecione-os via list_relations.

Documentação

Archcore CLI — Contexto Nativo de Git para Agentes de Codificação com IA

License Go Release Platform

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.

archcore demo

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.

AgenteHooksMCP
Claude Codesimsim
Cursorsimsim
Gemini CLIsimsim
GitHub Copilotsimsim
OpenCodesim
Codex CLIsim
Roo Codesim
Clinemanual

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

  1. Inicializearchcore init cria .archcore/ e instala as integrações de agente.
  2. Capture — decisões, regras, planos e guias são armazenados como documentos Markdown tipados com frontmatter YAML.
  3. 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.
  4. 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 lacunaO que o Archcore faz em vez disso
NadaO agente reaprende seu repositório a cada sessão e reabre decisões já resolvidasCarrega 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 ferramentaDocumentos 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 fornecedorArmazenam 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 únicoArmazenam os artefatos — um grafo de contexto vivo que evolui com o código
RAG / uma janela de contexto maiorRecuperam 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

TipoNome completoDescrição
adrArchitecture Decision RecordRegistra uma decisão técnica finalizada com contexto, alternativas e consequências
rfcRequest for CommentsPropõe uma mudança significativa aberta à revisão e feedback do time
ruleRulePadrão de codificação ou processo com orientação imperativa e exemplos
guideGuideInstruções passo a passo para concluir uma tarefa específica
docDocumentDocumentação de referência, registros e material descritivo
specSpecificationContrato normativo de comportamento para um limite ou recurso/subsistema do qual outros dependem

Visão

TipoNome completoDescrição
prdProduct Requirements DocumentObjetivos, histórias de usuário, critérios de aceite e métricas de sucesso
ideaIdeaCaptura leve de uma ideia de produto ou técnica para exploração futura
planPlanLista de tarefas em fases com critérios de aceite e dependências
rndResearchInvestigaçã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:

TipoNome completoDescrição
mrdMarket Requirements DocumentPanorama de mercado, TAM/SAM/SOM, análise competitiva e necessidades de mercado
brdBusiness Requirements DocumentObjetivos de negócio, stakeholders, ROI e regras de negócio
urdUser Requirements DocumentPersonas 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:

TipoNome completoDescrição
brsBusiness Requirements SpecificationMissão, metas, objetivos e conceito operacional de negócio
strsStakeholder Requirements SpecificationNecessidades dos stakeholders, conceito operacional e requisitos de usuário
syrsSystem Requirements SpecificationFunções do sistema, interfaces, desempenho e restrições de design
srsSoftware Requirements SpecificationFunçõ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

TipoNome completoDescrição
task-typeTask TypeChecklist e fluxo de trabalho reutilizáveis para uma tarefa recorrente
cpatCode Change PatternAná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.

CampoDescriçãoValores
syncModo de sincronização. Cloud e on-prem estão chegando em breve.none (somente local), cloud, on-prem
languageIdioma 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