Archcore MCP Server

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.

GitHub

Documentação

Archcore CLI

Seu agente de IA para de adivinhar e começa a seguir sua arquitetura.

Git envia seu código. CI/CD envia sua entrega. Archcore envia seu entendimento.

O Archcore armazena suas decisões, regras e convenções no Git — para que seu agente de IA as siga automaticamente. Funciona com Claude Code, Cursor, Copilot, Gemini CLI, Codex, OpenCode, Roo Code e Cline.

O Archcore é distribuído como uma CLI e um servidor MCP stdio local — qualquer agente de codificação compatível com MCP pode ler e escrever o contexto do seu repositório através de ferramentas padrão, enquanto o plugin para Claude Code / Cursor adiciona uma camada de fluxo de trabalho de nível superior.

Usando Claude Code ou Cursor? Combine a CLI com o Plugin Archcore — mesmo motor, além de habilidades, comandos de intenção e barreiras de proteção prontos para uso. Usar apenas a CLI também é ótimo — funciona com todos os outros agentes.

Em 60 segundos

curl -fsSL https://archcore.ai/install.sh | bash
cd your-project && archcore init

Então abra seu agente de IA e diga:

"Estamos usando PostgreSQL para armazenamento primário. Registre esta decisão."

Pronto. Agora existe uma ADR estruturada em .archcore/ que toda sessão futura — em qualquer agente — pode ler.

No Windows? Use PowerShell: irm https://archcore.ai/install.ps1 | iex. Para WSL, go install e outras opções, veja Métodos de instalação ou o guia completo de instalação.

Pergunte ao seu agente de IA coisas como

Quando seu repositório tiver alguns documentos, seu agente pode usá-los. Experimente:

"Antes de mexer no módulo de autenticação, quais ADRs e regras se aplicam aqui?"

O agente carrega as decisões e regras relevantes vinculadas àquela área antes de editar uma única linha.

"Adicione um novo manipulador de API e siga as convenções deste repositório."

O agente encontra a regra correspondente (ex.: "manipuladores ficam em src/api/handlers/") e coloca o código onde sua arquitetura determina.

"Qual é a nossa regra para tratamento de erros?"

O agente lê error-wrapping.rule.md diretamente de .archcore/ em vez de adivinhar a partir de alguns exemplos na base de código.

Experimente estes primeiro

Estes prompts capturam novo contexto — decisões, regras, planos, incidentes. Cada um cria um documento estruturado que o agente (ou qualquer colega de equipe) pode reutilizar depois.

Repositório novo? archcore init cria .archcore/. O servidor MCP também funciona em um repositório vazio e expõe uma ferramenta init_project, para que o agente possa fazer a inicialização para você.

"Decidimos usar PostgreSQL em vez de MongoDB para nosso banco de dados principal. Registre esta decisão."

Cria infrastructure/use-postgres.adr.md com contexto, decisão, alternativas consideradas e consequências.

"Temos uma convenção de equipe: sempre envolva erros com contexto usando fmt.Errorf e %w. Torne isso uma regra."

Cria backend/error-wrapping.rule.md com orientação imperativa, justificativa e exemplos de código bom/ruim.

"Na semana passada tivemos um incidente de esgotamento do pool de conexões porque as conexões ociosas não estavam sendo recicladas. Documente isso para não repetirmos."

Cria incidents/connection-pool-exhaustion.cpat.md com análise de causa raiz e etapas de prevenção.

"Preciso de um PRD para o recurso de notificações do usuário — push, resumos por e-mail e alertas no aplicativo."

Cria notifications/user-notifications.prd.md com objetivos, histórias de usuário, requisitos e métricas de sucesso.

"Crie um plano de implementação para o PRD de notificações e vincule-os."

Cria notifications/notifications-implementation.plan.md e então o vincula ao PRD com uma relação implements.

Se algum desses ressoar com você, o resto do Archcore é mais do mesmo — apenas estruturado.

O que muda após a instalação

Sem o Archcore, o agente:

ignora sua arquitetura
quebra suas convenções
duplica lógica que já existe
rediscute decisões que sua equipe já tomou
precisa que as mesmas convenções sejam repetidas em cada chat
perde a verdade do projeto no momento em que a sessão termina

Com o Archcore, as mesmas solicitações produzem código que:

fica onde sua arquitetura determina
respeita ADRs, especificações e regras já no Git
segue as convenções da equipe carregadas automaticamente no início da sessão
reflete novas decisões como barreiras de proteção futuras, não como cemitérios de markdown

A IA deve seguir seu sistema, não adivinhá-lo.

Use o Archcore quando

Seu agente escreve código, mas não da maneira que este repositório espera
Seu CLAUDE.md / .cursorrules / AGENTS.md continua crescendo e se desviando
Você trabalha com 2 ou mais agentes ou 2 ou mais ferramentas hospedeiras (Claude Code + Cursor + Copilot)
Você quer decisões, regras e especificações no Git — não no histórico do chat

Não é para — memória de chat, uma biblioteca de prompts ou um gerador único 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.

Por que não apenas arquivos de instrução?

CLAUDE.md, AGENTS.md e instruções de repositório são pontos de partida úteis, mas falham quando sua equipe precisa:

mais de um arquivo de memória plano
tipos de documentos estruturados — ADRs, regras, planos, incidentes
contexto reutilizável em várias ferramentas de IA
conhecimento de projeto versionado que cresce com a base de código
relações entre documentos (um plano que implementa um PRD, uma RFC que estende uma ADR)
aprendizados de incidentes e fluxos de trabalho recorrentes que os agentes podem retomar depois

Arquivos de instrução dizem ao agente o que você quer. O Archcore diz ao agente como seu sistema funciona — para que o agente possa seguir seu sistema em vez de adivinhá-lo.

Agentes suportados

A CLI do Archcore é em si um servidor MCP stdio local — essa é a superfície de integração compartilhada para cada agente compatível com MCP na tabela abaixo. Hooks adicionam contexto proativo 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

Como funciona

Inicialize seu repositório archcore init cria .archcore/ e instala integrações para os agentes suportados.
Capture contexto durável Armazene decisões de arquitetura, regras, planos, documentos de produto e aprendizados de incidentes como arquivos Markdown estruturados.
Deixe os agentes reutilizá-lo Hooks e MCP permitem que seus agentes de codificação leiam o contexto existente e criem ou atualizem documentos durante o trabalho real.
Mantenha no Git Revise as mudanças de contexto como código, evolua-as ao longo do tempo e mantenha-as portáteis entre ferramentas.

Modelo mental

A CLI do Archcore é o compilador de contexto — transforma documentos dispersos em contexto estruturado e legível por máquina. MCP e hooks são o runtime — a superfície que os agentes usam para consumir esse contexto durante o trabalho real. O Plugin Archcore para Claude Code e Cursor é um runtime de nível superior construído sobre isso.

implicit repo knowledge  →  structured context  →  AI-readable system

O que vive em `.archcore/`

.archcore/
├── settings.json
├── .sync-state.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 os documentos por domínio, funcionalidade, equipe ou o que melhor se adequar ao seu repositório. As categorias são virtuais e inferidas do tipo de documento no nome do arquivo (slug.type.md).

Use .archcore/ para:

decisões de arquitetura
regras e convenções de codificação
planos de implementação
requisitos de produto
incidentes e postmortems
conhecimento de fluxo de trabalho reutilizável

Veja o próprio repositório da CLI do Archcore para um exemplo funcional: .archcore/ neste repositório

O que vem incluído

18 tipos de documentos abrangendo visão, conhecimento e experiência
4 tipos de relação — related, implements, extends, depends_on
10 ferramentas MCP — list_documents, get_document, create_document, update_document, remove_document, search_documents, init_project, além de gerenciamento de relações (add_relation, remove_relation, list_relations)
5 prompts de múltiplos documentos — acionam cascatas invocáveis como comandos de barra de agentes compatíveis com MCP
Integrações de Hook para 4 agentes (Claude Code, Cursor, Gemini CLI, GitHub Copilot) e integrações MCP para 8

Tipos de documentos

O Archcore organiza o contexto em 3 camadas de conhecimento: Visão, Conhecimento e Experiência.

Visão

Tipo	Nome Completo	Descrição
`prd`	Documento de Requisitos de Produto	Objetivos, histórias de usuário, critérios de aceitação e métricas de sucesso
`idea`	Ideia	Captura leve de uma ideia de produto ou técnica para exploração futura
`plan`	Plano	Lista de tarefas em fases com critérios de aceitação e dependências

O Archcore também suporta duas trilhas de requisitos adicionais para equipes que precisam de descoberta estruturada ou decomposição formal:

Trilha de Fontes (MRD → BRD → URD) — captura de onde os requisitos vêm:

Tipo	Nome Completo	Descrição
`mrd`	Documento de Requisitos de Mercado	Cenário de mercado, TAM/SAM/SOM, análise competitiva e necessidades de mercado
`brd`	Documento de Requisitos de Negócio	Objetivos de negócio, partes interessadas, ROI e regras de negócio
`urd`	Documento de Requisitos de Usuário	Personas de usuário, jornadas, requisitos de usabilidade e critérios de aceitação

Trilha ISO/IEC/IEEE 29148:2018 (BRS → StRS → SyRS → SRS) — captura como os requisitos se decompõem:

Tipo	Nome Completo	Descrição
`brs`	Especificação de Requisitos de Negócio	Missão, metas, objetivos e conceito operacional de negócio
`strs`	Especificação de Requisitos das Partes Interessadas	Necessidades das partes interessadas, conceito operacional e requisitos de usuário
`syrs`	Especificação de Requisitos de Sistema	Funções do sistema, interfaces, desempenho e restrições de design
`srs`	Especificação de Requisitos de Software	Funções de software, interfaces externas e especificações comportamentais detalhadas

Use PRD para a maioria dos projetos. Adicione a trilha de fontes quando precisar de descoberta estruturada de requisitos. Adicione ISO 29148 quando precisar de rastreabilidade formal para sistemas regulados ou complexos com múltiplas equipes. Misture livremente — algumas funcionalidades podem usar um PRD enquanto outras usam a cascata completa.

Conhecimento

Tipo	Nome Completo	Descrição
`adr`	Registro de Decisão de Arquitetura	Captura uma decisão técnica finalizada com contexto, alternativas e consequências
`rfc`	Solicitação de Comentários	Propõe uma mudança significativa aberta para revisão e feedback da equipe
`rule`	Regra	Padrão de codificação ou processo com orientação imperativa e exemplos
`guide`	Guia	Instruções passo a passo para completar uma tarefa específica
`doc`	Documento	Documentação de referência, registros e material descritivo
`spec`	Especificação	Contrato normativo canônico para um sistema, componente, interface ou protocolo

Experiência

Tipo	Nome Completo	Descrição
`task-type`	Tipo de Tarefa	Checklist e fluxo de trabalho reutilizável para uma tarefa recorrente
`cpat`	Padrão de Mudança de Código	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 e rejected. Tags são opcionais e de forma livre — use-as para marcar tópicos transversais (security, golang, frontend).

Relações entre documentos

Documentos podem ser vinculados com relações direcionadas a outros documentos:

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 para prosseguir

As relações são armazenadas em .sync-state.json e gerenciadas automaticamente pelo agente de IA através das ferramentas MCP.

Integração com agentes de IA

O Archcore integra-se com agentes de codificação de IA de três maneiras:

Hooks injetam contexto no início da sessão, para que o agente esteja ciente dos seus documentos .archcore/ desde a primeira mensagem.
Ferramentas MCP dão ao agente capacidades para listar, pesquisar, ler, criar, atualizar e vincular documentos em tempo real. O servidor MCP também funciona em um repositório vazio e expõe uma ferramenta init_project, para que os agentes possam inicializar .archcore/ por conta própria.
Prompts MCP são fluxos de trabalho prontos de múltiplos documentos que você aciona do seu agente como comandos de barra.

Prompts

Prompts orquestram cascatas completas de documentos em uma chamada — o agente cria e vincula cada documento na trilha para você. A maioria dos agentes compatíveis com MCP os exibe como comandos de barra (ex.: /architecture_track); o prefixo exato depende do cliente.

Prompt	O que faz
`product_track`	ideia → PRD → plano (fluxo leve de funcionalidade)
`architecture_track`	ADR → especificação → plano (design técnico + implementação)
`standard_track`	ADR → regra → guia (codificar um padrão da equipe)
`sources_track`	MRD → BRD → URD (descoberta de mercado / negócio / usuário)
`iso_track`	BRS → StRS → SyRS → SRS (cascata formal ISO 29148)

Exemplo. No seu agente, execute /product_track feature="user notifications". O agente elabora uma ideia, deriva um PRD, constrói um plano de implementação e os vincula automaticamente.

Servidor MCP local

O Archcore não requer um serviço hospedado. A CLI executa um servidor MCP stdio local:

archcore mcp

Por padrão, archcore mcp serve documentos do diretório atual. Passe --project /path/to/repo (ou defina ARCHCORE_PROJECT_ROOT) para apontar para outro lugar — útil quando o servidor é iniciado de um diretório que não é seu espaço de trabalho (por exemplo, por uma integração de editor).

Conecte-o ao Claude Code:

claude mcp add --transport stdio archcore -- archcore mcp

Ou instale automaticamente para um agente suportado:

archcore mcp install --agent cursor

Instalar integrações

# Auto-detect agents in your project and install everything
archcore hooks install

# Or target a specific agent
archcore mcp install --agent opencode
archcore hooks install --agent cursor

Comandos

Comando	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 .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 update`	Atualiza o Archcore para a versão mais recente
`archcore mcp`	Executa o servidor MCP stdio
`archcore mcp install`	Instala configuração MCP para agentes detectados

Atualizar

archcore update

O comando verifica as Releases do GitHub por uma versão mais recente, faz o download, verifica a soma de verificação SHA-256 e substitui atomicamente o binário atual.

Métodos de instalação

macOS / Linux

curl -fsSL https://archcore.ai/install.sh | bash

Windows

irm https://archcore.ai/install.ps1 | iex

Instala archcore.exe em %LOCALAPPDATA%\Programs\archcore e o adiciona ao seu PATH de usuário. Abra uma nova janela do PowerShell após a instalação para que a alteração no PATH seja aplicada.

Windows (WSL)

Instale o WSL e então execute dentro dele:

curl -fsSL https://archcore.ai/install.sh | bash

Instalação via Go

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, veja o guia completo de instalação em docs.archcore.ai.

Configuração

As configurações são armazenadas em .archcore/settings.json e criadas durante archcore init.

Campo	Descrição	Valores
`sync`	Modo de sincronização. Cloud e on-prem estarão disponíveis em breve.	`none` (apenas 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

Desenvolvimento

Pré-requisitos

Go 1.24+

Build e teste

# Build
go build -o archcore .

# Run all tests
go test ./...

# Run a specific package
go test ./cmd/

# Run a single test
go test ./cmd/ -run TestConfigCmd

Estrutura do projeto

├── cmd/              # Cobra commands (init, doctor, config, status, hooks, mcp, ...)
├── internal/
│   ├── agents/       # Supported AI agents with hooks/MCP capabilities
│   ├── api/          # HTTP client for archcore server
│   ├── config/       # Settings management and directory init
│   ├── display/      # Terminal output formatting (lipgloss)
│   ├── update/       # Self-update logic (version check, download, verify, replace)
│   ├── mcp/          # MCP stdio server, tools, and prompts
│   └── sync/         # Sync logic
├── templates/        # Document type templates
├── install.sh        # Install script
└── .goreleaser.yaml  # Release configuration

O Archcore é como BMAD / Spec Kit / Memory Bank?

Não — estes resolvem problemas diferentes. Mapa rápido:

Ferramenta	Categoria	O que é	Como o Archcore difere
BMAD	Metodologia	Metodologia de SDLC agêntica — 12+ papéis, 34+ fluxos de trabalho	Archcore armazena artefatos; BMAD prescreve processo
Spec Kit	Metodologia	Fluxo de trabalho orientado a especificações: `specify → plan → tasks → implement`, único	Spec Kit é uma entrega única; Archcore mantém um grafo vivo que evolui com a base de código
Agent OS	Metodologia	Extração de padrões da base de código + desenvolvimento orientado a especificações	Posicionamento mais próximo. Archcore adiciona documentos tipados, relações validadas e uma cascata ISO opcional
claude-mem / Mem0	Memória	Captura automática de memória de sessão, recuperação entre agentes	Ferramentas de memória lembram o que você fez; Archcore armazena como o sistema é construído e o que foi decidido
Cline Memory Bank	Documentos	Arquivos markdown de esquema fixo (`projectbrief`, `activeContext`, `systemPatterns`…)	Mesmo espírito, menos cerimônia. Archcore adiciona relações tipadas, validação MCP e cascatas de múltiplas etapas
CLAUDE.md / .cursorrules	Instruções	Arquivo plano único que o agente lê no início da sessão	Archcore substitui um arquivo de instrução crescente por documentos tipados, relacionados e consultáveis

Escolha uma ferramenta de metodologia para um fluxo de desenvolvimento opinativo. Escolha uma ferramenta de memória para continuidade de sessão. Escolha Archcore quando quiser verdade do projeto tipada e consultável — as decisões, regras e arquitetura deste repositório — que seu agente de codificação respeita em cada solicitação.

Links e licença

Documentação: docs.archcore.ai
Website: archcore.ai
Plugin (Claude Code, Cursor): github.com/archcore-ai/archcore-plugin
Issues: github.com/archcore-ai/cli/issues
Licença: Apache 2.0