Archcore MCP

oficial

Servidor MCP stdio local que permite a los agentes de codificación de IA leer y mantener arquitectura estructurada, reglas y decisiones directamente desde tu repositorio.

¿Qué puedes hacer con Archcore MCP?

Archcore mantiene especificaciones, decisiones y reglas como Markdown tipado en .archcore/, servido a tu agente a través de herramientas MCP.

  • Buscar contexto del proyecto — Pide al asistente que encuentre ADRs, reglas o especificaciones aplicables antes de editar, mediante search_documents.
  • Registrar una decisión — Haz que el asistente cree un documento ADR o de reglas estructurado con create_document.
  • Actualizar contexto existente — Pide al asistente que revise una especificación o plan usando update_document.
  • Listar todos los documentos — Enumera cada documento de contexto en .archcore/ con list_documents.
  • Obtener un documento — Recupera el contenido completo de un solo documento con get_document.
  • Enlazar documentos relacionados — Conecta documentos con add_relation e inspecciónalos mediante list_relations.

Documentación

Archcore CLI — Contexto nativo de Git para agentes de codificación de IA

License Go Release Platform

Archcore es una capa de contexto nativa de Git para agentes de codificación de IA.

La CLI mantiene especificaciones, decisiones de arquitectura, reglas, planes y conocimiento del proyecto en .archcore/, versionados con tu código, y sirve el contexto relevante a los agentes de codificación a través de MCP y hooks de sesión.

Se distribuye como CLI y como servidor MCP stdio local, de modo que cualquier agente de codificación compatible con MCP puede leer y escribir el contexto de tu proyecto mediante herramientas estándar. Úsalo para contexto de proyecto persistente en Claude Code, Cursor, Codex CLI, GitHub Copilot, Gemini CLI, OpenCode, Roo Code y Cline.

Míralo funcionar

Ese contexto proviene de .archcore/: documentos Markdown tipados versionados en Git, servidos a cualquier agente mediante herramientas MCP y hooks de sesión.

archcore demo

Qué cambia

❌ Sin Archcore

Cada sesión empieza desde cero. El agente:

  • adivina tu arquitectura y rompe tus convenciones
  • duplica lógica que ya existe
  • vuelve a cuestionar decisiones que tu equipo ya tomó
  • necesita que le vuelvan a explicar el mismo contexto en cada chat

✅ Con Archcore

Tus decisiones, reglas y convenciones viven en Git como contexto estructurado. El agente:

  • carga las decisiones y reglas aplicables al inicio de la sesión
  • coloca el código donde tu arquitectura dice que corresponde
  • respeta los ADR, especificaciones y reglas ya presentes en el repositorio
  • registra nuevas decisiones como contexto duradero: revisable en PRs, portable entre agentes

El agente deja de adivinar y empieza a seguir el sistema.

Empieza en 60 segundos

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

archcore init inicializa .archcore/, detecta tus agentes de codificación y configura hooks y MCP para ellos.

Luego abre tu agente y di:

"Estamos usando PostgreSQL para el almacenamiento principal. Registra esta decisión."

Listo: ahora hay un ADR estructurado en .archcore/ que toda sesión futura, en cualquier agente, verá.

En Windows: irm https://archcore.ai/install.ps1 | iex. Para WSL, go install y compilar desde el código fuente, consulta Métodos de instalación más abajo o la guía de instalación completa.

Funciona con tu agente

La CLI es en sí misma un servidor MCP stdio local: una única superficie de integración para cada agente compatible con MCP. Los hooks añaden contexto de inicio de sesión donde el agente los soporta.

AgenteHooksMCP
Claude Code
Cursor
Gemini CLI
GitHub Copilot
OpenCode
Codex CLI
Roo Code
Clinemanual

archcore init configura automáticamente los agentes detectados. Para configurar uno 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

Cómo funciona

  1. Inicializararchcore init crea .archcore/ e instala las integraciones de agentes.
  2. Capturar — las decisiones, reglas, planes y guías se almacenan como documentos Markdown tipados con frontmatter YAML.
  3. Reutilizar — los agentes leen, crean, actualizan y enlazan documentos mediante herramientas MCP mientras trabajan; los hooks cargan contexto al inicio de la sesión.
  4. Mantenerlo en Git — revisa los cambios de contexto como código, hazlos evolucionar con el tiempo y mantenlos portables entre herramientas.
.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

La estructura es libre: organízala por dominio, funcionalidad o equipo. El tipo de un documento vive en su nombre de archivo (slug.type.md): 19 tipos en tres capas: conocimiento (ADR, reglas, especificaciones, guías), visión (PRD, planes, ideas, tracks de requisitos) y experiencia (patrones de incidentes, tareas recurrentes). El propio .archcore/ de este repositorio es un ejemplo funcional.

Pregunta a tu agente

"Antes de tocar el módulo de autenticación, ¿qué decisiones y reglas aplican aquí?"

Carga los ADR y las reglas vinculadas a esa área antes de que el agente edite una sola línea.

"Tenemos una convención: envolver siempre los errores con fmt.Errorf y %w. Convierte esto en una regla."

Crea backend/error-wrapping.rule.md con guía imperativa, justificación y ejemplos buenos/malos.

"La semana pasada tuvimos un incidente de agotamiento del pool de conexiones. Documéntalo para que no se repita."

Crea incidents/connection-pool-exhaustion.cpat.md con análisis de causa raíz y pasos de prevención.

Cómo se compara

Si dependes de…La brechaQué hace Archcore en su lugar
NadaEl agente reaprende tu repositorio en cada sesión y vuelve a cuestionar decisiones ya resueltasCarga decisiones, reglas y convenciones al inicio de la sesión, en cualquier agente
Archivos de instrucciones planos (CLAUDE.md, .cursorrules)Un muro de texto creciente: sin tipos, sin enlaces, sin ciclo de vida, copiado y pegado por herramientaDocumentos tipados, un grafo de relaciones, un ciclo de vida borrador → aceptado, una única configuración para cada agente
Herramientas de memoria (claude-mem, Mem0)Recuerdan lo que hiciste: volátil, opaco, ligado al proveedorAlmacena cómo está construido el sistema y qué se decidió: versionado en Git, tuyo
Kits de metodología (BMAD, Spec Kit, Agent OS)Prescriben un proceso, a menudo como una entrega de una sola vezAlmacena los artefactos: un grafo de contexto vivo que evoluciona con el código base
RAG / una ventana de contexto más grandeRecupera lo que el código dice, no lo que se decidió y por quéMantiene las decisiones y la justificación explícitas y selectivas: el agente carga lo que aplica, no todo

No es para — memoria de chat, una biblioteca de prompts o un generador de especificación a código de una sola vez. Archcore es una capa de verdad del repositorio para agentes de codificación, no un kit de metodología.

Referencia

Lo que incluye: 19 tipos de documento, 4 tipos de relación, 10 herramientas MCP, integraciones de hooks para 4 agentes e integraciones MCP para 8.

Tipos de documento — 19 tipos entre visión, conocimiento y experiencia

Conocimiento

TipoNombre completoDescripción
adrRegistro de Decisión de ArquitecturaCaptura una decisión técnica finalizada con contexto, alternativas y consecuencias
rfcSolicitud de ComentariosPropone un cambio significativo abierto a revisión y comentarios del equipo
ruleReglaEstándar de codificación o proceso con guía imperativa y ejemplos
guideGuíaInstrucciones paso a paso para completar una tarea específica
docDocumentoDocumentación de referencia, registros y material descriptivo
specEspecificaciónContrato normativo de comportamiento para un límite o funcionalidad/subsistema del que otros dependen

Visión

TipoNombre completoDescripción
prdDocumento de Requisitos de ProductoObjetivos, historias de usuario, criterios de aceptación y métricas de éxito
ideaIdeaCaptura ligera de una idea de producto o técnica para exploración futura
planPlanLista de tareas por fases con criterios de aceptación y dependencias
rndInvestigaciónInvestigación con tiempo limitado que responde una pregunta que bloquea una decisión

Dos tracks de requisitos adicionales para equipos que necesitan descubrimiento estructurado o descomposición formal:

Track de fuentes (MRD → BRD → URD) — captura de dónde provienen los requisitos:

TipoNombre completoDescripción
mrdDocumento de Requisitos de MercadoPanorama del mercado, TAM/SAM/SOM, análisis competitivo y necesidades del mercado
brdDocumento de Requisitos de NegocioObjetivos de negocio, stakeholders, ROI y reglas de negocio
urdDocumento de Requisitos de UsuarioPersonas de usuario, journeys, requisitos de usabilidad y criterios de aceptación

Track ISO/IEC/IEEE 29148:2018 (BRS → StRS → SyRS → SRS) — captura cómo se descomponen los requisitos:

TipoNombre completoDescripción
brsEspecificación de Requisitos de NegocioMisión, metas, objetivos y concepto operativo del negocio
strsEspecificación de Requisitos de StakeholdersNecesidades de los stakeholders, concepto operativo y requisitos de usuario
syrsEspecificación de Requisitos del SistemaFunciones del sistema, interfaces, rendimiento y restricciones de diseño
srsEspecificación de Requisitos de SoftwareFunciones del software, interfaces externas y especificaciones de comportamiento detalladas

Usa PRD para la mayoría de los proyectos; añade el track de fuentes para descubrimiento estructurado de requisitos e ISO 29148 para trazabilidad formal en sistemas regulados o complejos con múltiples equipos. Mezcla libremente.

Experiencia

TipoNombre completoDescripción
task-typeTipo de TareaChecklist y flujo de trabajo reutilizables para una tarea recurrente
cpatPatrón de Cambio de CódigoAnálisis de causa raíz de un bug o incidente con pasos de prevención

Cada documento es un archivo Markdown con frontmatter YAML:

---
title: "Use PostgreSQL for Primary Storage"
status: draft
tags: [database, infrastructure]
---

## Context

...

Estados válidos: draft, accepted, rejected. Las etiquetas son opcionales y de formato libre.

Herramientas MCP y relaciones

Herramientas MCP

10 herramientas: init_project, list_documents, get_document, search_documents, create_document, update_document, remove_document, add_relation, remove_relation, list_relations. El servidor también funciona en un repositorio vacío: los agentes pueden inicializar .archcore/ ellos mismos mediante init_project.

Relaciones

Los documentos se enlazan con relaciones dirigidas: related (asociación general), implements (la fuente implementa lo que el destino especifica), extends (la fuente se basa en el destino), depends_on (la fuente requiere el destino). Gestionadas por el agente mediante herramientas MCP.

Servidor MCP local

archcore mcp sirve documentos del directorio actual a través de stdio. Pasa --project /path/to/repo (o establece ARCHCORE_PROJECT_ROOT) cuando el servidor se lanza desde un directorio que no es tu espacio de trabajo, por ejemplo, mediante una integración de editor.

Comandos | Comando | Descripción | | ------------------------ | ------------------------------------------------ | | `archcore init` | Inicializa el directorio `.archcore/` de forma interactiva | | `archcore doctor` | Verifica tu configuración de archcore y corrige problemas | | `archcore status` | Verifica la estructura de `.archcore/` y la salud de los documentos | | `archcore config` | Ver o modificar la configuración | | `archcore hooks install` | Instala hooks para agentes de IA detectados | | `archcore mcp` | Ejecuta el servidor MCP stdio | | `archcore mcp install` | Instala la configuración de MCP para agentes detectados | | `archcore update` | Actualiza Archcore a la última versión |

archcore update verifica los lanzamientos de GitHub, descarga la versión más reciente, verifica la suma de verificación SHA-256 y reemplaza el binario de forma atómica.

Métodos de instalación

macOS / Linux

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

Windows

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

Instala archcore.exe en %LOCALAPPDATA%\Programs\archcore y lo añade a tu PATH de usuario. Abre una nueva ventana de PowerShell después de la instalación.

Windows (WSL)

Instala WSL y luego ejecuta el script de macOS/Linux dentro de él.

Go install

go install github.com/archcore-ai/cli@latest

Desde el código fuente

git clone https://github.com/archcore-ai/cli.git
cd cli
go build -o archcore .

Plataformas compatibles: macOS, Linux, Windows — amd64 y arm64.

Para variables de entorno (ARCHCORE_VERSION, ARCHCORE_INSTALL_DIR, GITHUB_TOKEN) y solución de problemas de PATH, consulta la guía de instalación completa.

Configuración

La configuración se encuentra en .archcore/settings.json, creado por archcore init.

CampoDescripciónValores
syncModo de sincronización. Cloud y on-prem están próximamente.none (solo local), cloud, on-prem
languageIdioma de los documentos. Ayuda al agente a generar documentación en el idioma correcto.String, por defecto en
archcore config                    # show all settings
archcore config get <key>          # get a specific value
archcore config set <key> <value>  # set a value

Ecosistema

  • Archcore Plugin — ¿Usas Claude Code o Cursor? El plugin se combina con la CLI: el mismo motor, más habilidades, comandos de intención y protecciones. Un producto, dos puntos de entrada: la CLI por sí sola cubre cualquier otro agente.
  • docs.archcore.ai — documentación completa.
  • .archcore/ en este repositorio — un ejemplo vivo: la CLI está construida con su propia capa de contexto.

Desarrollo

Requiere Go 1.25+.

go build -o archcore .   # build
go test ./...            # run all tests

Enlaces y licencia