Archcore MCP Server

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.

GitHub

Documentación

Archcore CLI

Tu agente de IA deja de adivinar y empieza a seguir tu arquitectura.

Git envía tu código. CI/CD envía tus entregas. Archcore envía tu comprensión.

Archcore almacena tus decisiones, reglas y convenciones en Git — para que tu agente de IA las siga automáticamente. Funciona con Claude Code, Cursor, Copilot, Gemini CLI, Codex, OpenCode, Roo Code y Cline.

Archcore se distribuye como una CLI y un servidor MCP stdio local — cualquier agente de codificación compatible con MCP puede leer y escribir el contexto de tu repositorio a través de herramientas estándar, mientras que el plugin de Claude Code / Cursor añade una capa de flujo de trabajo de nivel superior.

¿Usas Claude Code o Cursor? Combina la CLI con el Plugin de Archcore — mismo motor, además de habilidades, comandos de intención y barreras de protección listas para usar. Usar solo la CLI también es excelente — funciona con cualquier otro agente.

En 60 segundos

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

Luego abre tu agente de IA y dile:

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

Hecho. Ahora hay un ADR estructurado en .archcore/ que cada sesión futura — en cualquier agente — puede leer.

¿En Windows? Usa PowerShell: irm https://archcore.ai/install.ps1 | iex. Para WSL, go install, y otras opciones, consulta Métodos de instalación o la guía de instalación completa.

Pregúntale a tu IA cosas como

Una vez que tu repositorio tenga algunos documentos, tu agente puede usarlos. Prueba:

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

El agente carga las decisiones y reglas relevantes vinculadas a esa área antes de editar una sola línea.

"Añade un nuevo manejador de API y sigue las convenciones de este repositorio."

El agente muestra la regla correspondiente (ej. "los manejadores viven en src/api/handlers/") y coloca el código donde tu arquitectura dice que debe ir.

"¿Cuál es nuestra regla de manejo de errores?"

El agente lee error-wrapping.rule.md directamente de .archcore/ en lugar de adivinar a partir de unos pocos ejemplos en el código base.

Prueba esto primero

Estos prompts capturan contexto nuevo — decisiones, reglas, planes, incidentes. Cada uno crea un documento estructurado que el agente (o cualquier compañero de equipo) puede reutilizar más tarde.

¿Repositorio nuevo? archcore init crea .archcore/. El servidor MCP también funciona en un repositorio vacío y expone una herramienta init_project, para que el agente pueda iniciarlo por ti.

"Decidimos usar PostgreSQL en lugar de MongoDB para nuestra base de datos principal. Registra esta decisión."

Crea infrastructure/use-postgres.adr.md con contexto, decisión, alternativas consideradas y consecuencias.

"Tenemos una convención de equipo: siempre envolver errores con contexto usando fmt.Errorf y %w. Haz de esto una regla."

Crea backend/error-wrapping.rule.md con guía imperativa, justificación y ejemplos de código bueno/malo.

"La semana pasada tuvimos un incidente de agotamiento del pool de conexiones porque las conexiones inactivas no se estaban reciclando. Documenta esto para que no se repita."

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

"Necesito un PRD para la funcionalidad de notificaciones de usuario — push, resúmenes por correo y alertas en la aplicación."

Crea notifications/user-notifications.prd.md con objetivos, historias de usuario, requisitos y métricas de éxito.

"Crea un plan de implementación para el PRD de notificaciones y vincúlalos."

Crea notifications/notifications-implementation.plan.md, luego lo vincula al PRD con una relación implements.

Si algo de esto te resuena, el resto de Archcore es más de lo mismo — solo que estructurado.

Qué cambia después de la instalación

Sin Archcore, el agente:

ignora tu arquitectura
rompe tus convenciones
duplica lógica que ya existe
reabre decisiones que tu equipo ya tomó
necesita que se repitan las mismas convenciones en cada chat
pierde la verdad del proyecto en el momento en que termina la sesión

Con Archcore, las mismas solicitudes producen código que:

aterriza donde tu arquitectura dice que debe ir
respeta los ADRs, especificaciones y reglas que ya están en Git
sigue las convenciones del equipo cargadas automáticamente al inicio de la sesión
refleja nuevas decisiones como barreras de protección futuras, no como cementerios de markdown

La IA debería seguir tu sistema, no adivinarlo.

Usa Archcore cuando

Tu agente escribe código, pero no de la manera que este repositorio espera
Tu CLAUDE.md / .cursorrules / AGENTS.md sigue creciendo y desviándose
Trabajas con 2+ agentes o 2+ herramientas anfitrionas (Claude Code + Cursor + Copilot)
Quieres decisiones, reglas y especificaciones en Git — no en el historial del chat

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

¿Por qué no solo archivos de instrucciones?

CLAUDE.md, AGENTS.md y las instrucciones del repositorio son puntos de partida útiles, pero se quedan cortos cuando tu equipo necesita:

más de un archivo de memoria plano
tipos de documentos estructurados — ADRs, reglas, planes, incidentes
contexto reutilizable a través de múltiples herramientas de IA
conocimiento del proyecto versionado que crece con el código base
relaciones entre documentos (un plan que implementa un PRD, un RFC que extiende un ADR)
aprendizajes de incidentes y flujos de trabajo recurrentes que los agentes pueden retomar más tarde

Los archivos de instrucciones le dicen al agente lo que quieres. Archcore le dice al agente cómo funciona tu sistema — para que el agente pueda seguir tu sistema en lugar de adivinarlo.

Agentes soportados

La CLI de Archcore es en sí misma un servidor MCP stdio local — esa es la superficie de integración compartida para cada agente compatible con MCP en la tabla de abajo. Los hooks añaden contexto proactivo al inicio de la sesión donde el agente los soporta.

Agente	Hooks	MCP
Claude Code	sí	sí
Cursor	sí	sí
Gemini CLI	sí	sí
GitHub Copilot	sí	sí
OpenCode	—	sí
Codex CLI	—	sí
Roo Code	—	sí
Cline	—	manual

Cómo funciona

Inicializa tu repositorio archcore init crea .archcore/ e instala integraciones para los agentes soportados.
Captura contexto duradero Almacena decisiones de arquitectura, reglas, planes, documentos de producto y aprendizajes de incidentes como archivos Markdown estructurados.
Deja que los agentes lo reutilicen Los hooks y MCP permiten que tus agentes de codificación lean el contexto existente y creen o actualicen documentos durante el trabajo real.
Mantenlo en Git Revisa los cambios de contexto como código, evolucionalos con el tiempo y mantenlos portables entre herramientas.

Modelo mental

La CLI de Archcore es el compilador de contexto — convierte documentos dispersos en contexto estructurado y legible por máquinas. MCP y los hooks son el tiempo de ejecución — la superficie que los agentes usan para consumir ese contexto durante el trabajo real. El Plugin de Archcore para Claude Code y Cursor es un tiempo de ejecución de nivel superior construido encima.

implicit repo knowledge  →  structured context  →  AI-readable system

Qué vive en `.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

La estructura es libre — organiza los documentos por dominio, funcionalidad, equipo o lo que mejor se adapte a tu repositorio. Las categorías son virtuales y se infieren del tipo de documento en el nombre del archivo (slug.type.md).

Usa .archcore/ para:

decisiones de arquitectura
reglas y convenciones de codificación
planes de implementación
requisitos de producto
incidentes y autopsias
conocimiento de flujo de trabajo reutilizable

Mira el propio repositorio de la CLI de Archcore para un ejemplo funcional: .archcore/ en este repositorio

Qué incluye la caja

18 tipos de documentos a través de visión, conocimiento y experiencia
4 tipos de relación — related, implements, extends, depends_on
10 herramientas MCP — list_documents, get_document, create_document, update_document, remove_document, search_documents, init_project, más gestión de relaciones (add_relation, remove_relation, list_relations)
5 prompts multi-documento — seguimiento de cascadas invocables como comandos de barra desde agentes compatibles con MCP
Integraciones de hook para 4 agentes (Claude Code, Cursor, Gemini CLI, GitHub Copilot) e integraciones MCP para 8

Tipos de documentos

Archcore organiza el contexto en 3 capas de conocimiento: Visión, Conocimiento y Experiencia.

Visión

Tipo	Nombre Completo	Descripción
`prd`	Documento de Requisitos del Producto	Objetivos, historias de usuario, criterios de aceptación y métricas de éxito
`idea`	Idea	Captura ligera de una idea de producto o técnica para exploración futura
`plan`	Plan	Lista de tareas por fases con criterios de aceptación y dependencias

Archcore también soporta dos vías de requisitos adicionales para equipos que necesitan descubrimiento estructurado o descomposición formal:

Vía de fuentes (MRD → BRD → URD) — captura de dónde vienen los requisitos:

Tipo	Nombre Completo	Descripción
`mrd`	Documento de Requisitos de Mercado	Panorama del mercado, TAM/SAM/SOM, análisis competitivo y necesidades del mercado
`brd`	Documento de Requisitos de Negocio	Objetivos de negocio, partes interesadas, ROI y reglas de negocio
`urd`	Documento de Requisitos de Usuario	Personas de usuario, recorridos, requisitos de usabilidad y criterios de aceptación

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

Tipo	Nombre Completo	Descripción
`brs`	Especificación de Requisitos de Negocio	Misión, metas, objetivos y concepto operacional de negocio
`strs`	Especificación de Requisitos de Interesados	Necesidades de los interesados, concepto operacional y requisitos de usuario
`syrs`	Especificación de Requisitos del Sistema	Funciones del sistema, interfaces, rendimiento y restricciones de diseño
`srs`	Especificación de Requisitos de Software	Funciones del software, interfaces externas y especificaciones detalladas de comportamiento

Usa PRD para la mayoría de los proyectos. Añade la vía de fuentes cuando necesites un descubrimiento estructurado de requisitos. Añade ISO 29148 cuando necesites trazabilidad formal para sistemas regulados o complejos de múltiples equipos. Mezcla libremente — algunas funcionalidades pueden usar un PRD mientras otras usan la cascada completa.

Conocimiento

Tipo	Nombre Completo	Descripción
`adr`	Registro de Decisión de Arquitectura	Captura una decisión técnica finalizada con contexto, alternativas y consecuencias
`rfc`	Solicitud de Comentarios	Propone un cambio significativo abierto a revisión y retroalimentación del equipo
`rule`	Regla	Estándar de codificación o proceso con guía imperativa y ejemplos
`guide`	Guía	Instrucciones paso a paso para completar una tarea específica
`doc`	Documento	Documentación de referencia, registros y material descriptivo
`spec`	Especificación	Contrato normativo canónico para un sistema, componente, interfaz o protocolo

Experiencia

Tipo	Nombre completo	Descripción
`task-type`	Tipo de tarea	Lista de verificación y flujo de trabajo reutilizable para una tarea recurrente
`cpat`	Patrón de cambio de código	Análisis de causa raíz de un error 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 y rejected. Las etiquetas son opcionales y de formato libre; úsalas para marcar temas transversales (security, golang, frontend).

Relaciones entre documentos

Los documentos pueden vincularse con relaciones dirigidas hacia otros documentos:

related — asociación general
implements — el origen implementa lo que el destino especifica
extends — el origen se construye sobre el destino
depends_on — el origen requiere el destino para proceder

Las relaciones se almacenan en .sync-state.json y son gestionadas automáticamente por el agente de IA a través de las herramientas MCP.

Integración con agentes de IA

Archcore se integra con agentes de codificación de IA de tres maneras:

Hooks inyectan contexto al inicio de la sesión, para que el agente conozca tus documentos .archcore/ desde el primer mensaje.
Herramientas MCP otorgan al agente capacidades para listar, buscar, leer, crear, actualizar y vincular documentos en tiempo real. El servidor MCP también funciona en un repositorio vacío y expone una herramienta init_project, para que los agentes puedan iniciar .archcore/ por sí mismos.
Prompts MCP son flujos de trabajo multi-documento predefinidos que activas desde tu agente como comandos de barra.

Prompts

Los prompts orquestan cascadas completas de documentos en una sola llamada: el agente crea y vincula cada documento de la secuencia por ti. La mayoría de los agentes compatibles con MCP los muestran como comandos de barra (por ejemplo, /architecture_track); el prefijo exacto depende del cliente.

Prompt	Qué hace
`product_track`	idea → PRD → plan (flujo ligero de funcionalidad)
`architecture_track`	ADR → especificación → plan (diseño técnico + implementación)
`standard_track`	ADR → regla → guía (codificar un estándar del equipo)
`sources_track`	MRD → BRD → URD (descubrimiento de mercado / negocio / usuario)
`iso_track`	BRS → StRS → SyRS → SRS (cascada formal ISO 29148)

Ejemplo. En tu agente, ejecuta /product_track feature="user notifications". El agente redacta una idea, deriva un PRD, construye un plan de implementación y los vincula automáticamente.

Servidor MCP local

Archcore no requiere un servicio alojado. La CLI ejecuta un servidor MCP stdio local:

archcore mcp

Por defecto, archcore mcp sirve documentos desde el directorio actual. Pasa --project /path/to/repo (o establece ARCHCORE_PROJECT_ROOT) para apuntar a otra ubicación; útil cuando el servidor se lanza desde un directorio que no es tu espacio de trabajo (por ejemplo, mediante una integración de editor).

Conéctalo a Claude Code:

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

O instálalo automáticamente para un agente compatible:

archcore mcp install --agent cursor

Instalar integraciones

# 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	Descripción
`archcore init`	Inicializar el directorio `.archcore/` de forma interactiva
`archcore doctor`	Verificar tu configuración de archcore y solucionar problemas
`archcore status`	Verificar la estructura de .archcore/ y la salud de los documentos
`archcore config`	Ver o modificar configuraciones
`archcore hooks install`	Instalar hooks para los agentes de IA detectados
`archcore update`	Actualizar Archcore a la última versión
`archcore mcp`	Ejecutar el servidor MCP stdio
`archcore mcp install`	Instalar configuración MCP para los agentes detectados

Actualizar

archcore update

El comando busca una versión más reciente en GitHub Releases, la descarga, verifica la suma de comprobación SHA-256 y reemplaza atómicamente el binario actual.

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 para que el cambio en PATH se aplique.

Windows (WSL)

Instala WSL, luego ejecuta dentro de él:

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

Instalación con Go

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 completa de instalación en docs.archcore.ai.

Configuración

Los ajustes se almacenan en .archcore/settings.json y se crean durante archcore init.

Campo	Descripción	Valores
`sync`	Modo de sincronización. Nube y local próximamente.	`none` (solo local), `cloud`, `on-prem`
`language`	Idioma del documento. Ayuda al agente a generar documentación en el idioma correcto.	Cadena, por defecto `en`

archcore config                              # show all settings
archcore config get <key>                    # get a specific value
archcore config set <key> <value>            # set a value

Desarrollo

Prerrequisitos

Go 1.24+

Construir y probar

# 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

Estructura del proyecto

├── 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

¿Es Archcore como BMAD / Spec Kit / Memory Bank?

No — estos resuelven problemas diferentes. Mapa rápido:

Herramienta	Categoría	Qué es	En qué se diferencia Archcore
BMAD	Metodología	Metodología de SDLC agéntica — 12+ roles, 34+ flujos de trabajo	Archcore almacena artefactos; BMAD prescribe procesos
Spec Kit	Metodología	Flujo de trabajo guiado por especificaciones: `specify → plan → tasks → implement`, único	Spec Kit es una entrega única; Archcore mantiene un grafo vivo que evoluciona con el código
Agent OS	Metodología	Extracción de estándares del código + desarrollo guiado por especificaciones	Posicionamiento más cercano. Archcore añade documentos tipados, relaciones validadas y una cascada ISO opcional
claude-mem / Mem0	Memoria	Captura automática de memoria de sesión, recuerdo entre agentes	Las herramientas de memoria recuerdan lo que hiciste; Archcore almacena cómo está construido el sistema y qué se decidió
Cline Memory Bank	Documentos	Archivos markdown de esquema fijo (`projectbrief`, `activeContext`, `systemPatterns`…)	Mismo espíritu, menor formalidad. Archcore añade relaciones tipadas, validación MCP y cascadas de varios pasos
CLAUDE.md / .cursorrules	Instrucciones	Archivo plano único que el agente lee al inicio de la sesión	Archcore reemplaza un archivo de instrucciones creciente con documentos tipados, relacionados y consultables

Elige una herramienta de metodología para un flujo de desarrollo con opiniones definidas. Elige una herramienta de memoria para continuidad de sesión. Elige Archcore cuando quieras una verdad del proyecto tipada y consultable — las decisiones, reglas y arquitectura de este repositorio — que tu agente de codificación respete en cada solicitud.

Enlaces y licencia

Documentación: docs.archcore.ai
Sitio web: archcore.ai
Plugin (Claude Code, Cursor): github.com/archcore-ai/archcore-plugin
Incidencias: github.com/archcore-ai/cli/issues
Licencia: Apache 2.0