MCP server de Agendum
✓ VerificadoProporciona a los agentes de IA memoria persistente de proyectos, seguimiento de tareas y paquetes de trabajo delimitados para mantener la continuidad entre sesiones.
También conocido como sralli/agendum
- Stars
- 6
- Herramientas
- 14
- Descargas, 30 días
- 103
- Última versión
- 0.3.4
- Último commit
- 13 abr 2026
- Licencia
- MIT
¿Qué es Agendum MCP?
Proporciona a los agentes de IA memoria persistente de proyectos, seguimiento de tareas y paquetes de trabajo delimitados para mantener la continuidad entre sesiones. Expone 14 herramientas, como pm_init, pm_project, pm_status.
Resumen generado a partir del README del proyecto
Acerca del MCP server de Agendum
Agendum permite mantener la continuidad de los agentes de codificación de IA durante ciclos de desarrollo complejos. Proporciona un motor de memoria persistente y de delimitación de alcance que evita que los agentes sin estado olviden decisiones o pierdan el contexto entre sesiones. Al usar este MCP server con clientes como Claude Code, Cursor, Windsurf o Cline, los desarrolladores pueden transformar un agente de una herramienta que modifica archivos al azar a uno que opera dentro de paquetes de trabajo delimitados que contienen criterios de aceptación y restricciones específicas.
El sistema gestiona un grafo de dependencias para ordenar las tareas y desbloquear elementos automáticamente a medida que se completa el trabajo. Utiliza diversas herramientas, incluyendo pm_ingest para importar planes en Markdown, pm_next para recuperar la siguiente tarea delimitada y pm_done para registrar decisiones y patrones. Todo el estado del proyecto se almacena en archivos Markdown y YAML legibles por humanos, lo que hace que la memoria sea comparable mediante diff y se pueda subir mediante Git. El servidor también cuenta con una capacidad de búsqueda híbrida que combina coincidencia de palabras clave, búsqueda vectorial y un grafo de entidades para extraer el conocimiento relevante del proyecto.
Escrito a partir del README del proyecto. Cada caso de uso se verifica con una cita del mismo.
Cómo instalar Agendum MCP
Formatos verificados el 10 nov 2026Añadir a CursorAñadir a GooseInstalar Agendum MCP en Claude Code
$ claude mcp add agendum -- uvx agendumInstalar Agendum MCP en Cursor
~/.cursor/mcp.json
{
"mcpServers": {
"agendum": {
"command": "uvx",
"args": [
"agendum"
]
}
}
}Instalar Agendum MCP en VS Code
.vscode/mcp.json
{
"servers": {
"agendum": {
"type": "stdio",
"command": "uvx",
"args": [
"agendum"
]
}
}
}Instalar Agendum MCP en VS Code CLI
$ code --add-mcp '{"name":"agendum","type":"stdio","command":"uvx","args":["agendum"]}'Instalar Agendum MCP en Claude Desktop
claude_desktop_config.json
{
"mcpServers": {
"agendum": {
"command": "uvx",
"args": [
"agendum"
]
}
}
}Instalar Agendum MCP en Codex
$ codex mcp add agendum -- uvx agendumInstalar Agendum MCP en Codex config.toml
~/.codex/config.toml
[mcp_servers.agendum] command = "uvx" args = ["agendum"]
Instalar Agendum MCP en Gemini CLI
$ gemini mcp add -s user agendum uvx -- agendumInstalar Agendum MCP en Gemini settings.json
~/.gemini/settings.json
{
"mcpServers": {
"agendum": {
"command": "uvx",
"args": [
"agendum"
]
}
}
}Herramientas de Agendum MCP 14
Detectado desde el READMEpm_initpm_projectpm_statuspm_addpm_boardpm_ingestpm_nextpm_donepm_blockpm_memorypm_learnpm_search
| pm_init | — | |
| pm_project | — | |
| pm_status | — | |
| pm_add | — | |
| pm_board | — | |
| pm_ingest | — | |
| pm_next | — | |
| pm_done | — | |
| pm_block | — | |
| pm_memory | — | |
| pm_learn | — | |
| pm_search | — |
Mostrar las 14 herramientasMostrar menos herramientas
pm_consolidatepm_supersede
| pm_consolidate | — | |
| pm_supersede | — |
Verificaciones automáticas
Ejecutado 14 nov 2026Informe completo →Pasó nuestras verificaciones automáticas. Esto no es una auditoría de seguridad: lee el código y dale al servidor el acceso más limitado que necesite. Cómo funcionan las verificaciones
- Repositorio de origen vinculado y accesiblesralli/agendum is public and reachablegithub.com/sralli/agendum ↗Aprobado
- El paquete indica este repositorio como su origenagendum names sralli/agendum as sourcepypi.org/project/agendum/ ↗Aprobado
- Procedencia de la compilación (atestación de Sigstore)No build attestation published for this releaseNo verificado
- Licencia de código abierto (OSI)MITspdx.org/licenses/MIT.html ↗Aprobado
- Commit o lanzamiento en el último añoLast commit or release 2026-04-13github.com/sralli/agendum ↗Aprobado
- OpenSSF ScorecardNo verificado
- El nombre del paquete no es similar a un paquete popularNo popular package one edit away from agendumAprobado
- No hay avisos críticos en el paquete ni en sus dependencias40 resolved dependencies checked; no critical advisoryosv.dev ↗Aprobado
- Sin instrucciones ocultas para el modelo14 tool descriptions and the README read; no override phrases, credential paths or hidden charactersAprobado
- Las herramientas destructivas están etiquetadasNo tool named like delete, drop or execAprobado
- El endpoint remoto responde al handshake de MCPNo verificado
README
Ver en GitHubagendum
Project memory and scoping engine for AI coding agents.
AI coding agents are stateless — they forget between sessions, lose decisions, and have no way to scope complex work. agendum is an MCP server that gives any agent (Claude Code, Cursor, Windsurf, Cline, and others) persistent project state, bounded work packages, and cross-session continuity.
| Without agendum | With agendum |
|---|---|
| Agent forgets everything between sessions | Picks up exactly where it left off |
| No scope — agent modifies random files | Bounded work packages with file lists, acceptance criteria, constraints |
| Decisions lost — same mistakes repeated | Decisions and patterns persist in searchable memory |
| No task ordering — agent picks randomly | Dependency graph with auto-unblocking and priority scoring |
| Learning locked inside one project | Cross-project learnings carry patterns forward |
Quick Start
pip install agendum # or: uvx agendum
claude mcp add agendum -- uvx agendum --home serve # add to Claude Code
# Done. pm_* tools are now available in your agent.
Works with any MCP client — see setup for Cursor, Windsurf, VS Code, and others.
How It Works
flowchart LR
A["PLAN\nwrite plan file"] --> B["pm_ingest\nboard items + deps"]
B --> C["pm_next\nwork package + context"]
C --> D["EXECUTE\nagent implements"]
D --> E["pm_done\ndecisions + patterns"]
E -->|next task| C
E -->|new session| F["pm_status\nresume context"]
F --> C
Each pm_done records decisions and patterns that enrich future pm_next calls — context compounds across sessions.
Example session:
You: I have a plan file for the API rewrite. Ingest it.
Agent:
→ pm_ingest(project="api-rewrite", plan_file="plan.md")
Ingested 4 board items from plan:
item-001: Schema design [high]
item-002: Resolver layer (depends on item-001)
item-003: Auth middleware (depends on item-001)
item-004: Integration tests (depends on item-002, item-003)
You: What should I work on?
Agent:
→ pm_next(project="api-rewrite")
Work package for item-001 "Schema design":
Context: project rules, memory from last session
Scope: Define GraphQL schema types
Acceptance criteria: Types for User, Product, Order
You: Done with the schema. Here's what I decided...
Agent:
→ pm_done(project="api-rewrite", item_id="item-001",
decisions="Using code-first with Strawberry",
patterns="N+1 queries need DataLoader",
verified=True)
Marked item-001 as done. Unblocked: item-002, item-003
> Next: pm_next("api-rewrite") to continue with newly unblocked tasks
14 MCP Tools
Setup & Orientation
| Tool | Purpose |
|---|---|
pm_init |
Initialize board directory (optional — auto-initializes on first use) |
pm_project |
Create, list, or get projects |
pm_status |
Dashboard — item counts, recent progress, memory health, suggested next task |
Planning & Backlog
| Tool | Purpose |
|---|---|
pm_add |
Add an item with type, priority, tags, dependencies, acceptance criteria |
pm_board |
View and filter the project board |
pm_ingest |
Import a Markdown plan file into bounded board items with dependencies |
Execution Loop
| Tool | Purpose |
|---|---|
pm_next |
Get the next scoped work package with complexity signal and enriched context |
pm_done |
Complete an item — record decisions, patterns, learnings; auto-extract from git; auto-unblock dependents |
pm_block |
Report a task as blocked with reason |
Knowledge & Search
| Tool | Purpose |
|---|---|
pm_memory |
Read, write, append, or search project memory (decisions, patterns, project knowledge) |
pm_learn |
Record global or project-scoped learnings with tags and topic entities |
pm_search |
Hybrid search across all knowledge — memory, learnings, completed items |
pm_consolidate |
Clean memory corruption, deduplicate learnings, detect contradictions |
pm_supersede |
Soft-invalidate a learning — excluded from all future searches |
Hybrid Search
pm_search combines three signals to find relevant knowledge across memory, learnings, and completed board items:
- FTS5 with Porter stemming —
authmatchesauthentication,configmatchesconfiguration. Always on, zero config. - Vector search (optional) — Install
agendum[vectors]to add semantic similarity viafastembed+sqlite-vec. Activates automatically alongside FTS5. - Entity graph — Topics and tags form a knowledge graph. Entries sharing 2+ entities are linked automatically. Graph expansion surfaces related knowledge that keyword search misses.
All three signals are fused via Reciprocal Rank Fusion (RRF), then reranked by recency and access frequency. The index rebuilds from Markdown files — no data loss if it gets corrupted.
Key Capabilities
- Adaptive context budget — enrichment scales with task complexity: 4K chars for trivial tasks, up to 10K for large ones
- Verification gate —
pm_done(verified=True)distinguishes tested from untested completions - Git auto-extract —
pm_donereadsgit diffandgit logautomatically when no files are specified - Pluggable enrichment pipeline — four context sources injected into every work package: project rules (CLAUDE.md/AGENTS.md), memory, dependency context, learnings
- Dependency resolution — topological ordering with cycle detection; dependents unblock automatically when upstream tasks complete
- Memory health —
pm_statuswarns about corrupted entries;pm_consolidatestrips XML fragments, deduplicates, and flags contradictions - Zero config — auto-initializes on first tool call, derives board name from git remote
- Git-native storage — all state is human-readable Markdown + YAML in
.agendum/, diffable and committable
Installation
All MCP clients except VS Code use the same config. Add to the appropriate file:
{
"mcpServers": {
"agendum": {
"command": "uvx",
"args": ["agendum", "--home", "serve"]
}
}
}
| Client | Config location |
|---|---|
| Claude Code | Run: claude mcp add agendum -- uvx agendum --home serve |
| Cursor | .cursor/mcp.json in project root |
| Windsurf | ~/.codeium/windsurf/mcp_config.json |
| Cline | Settings › MCP Servers › Edit |
| Roo Code | MCP settings file |
| Claude Desktop | claude_desktop_config.json |
VS Code (GitHub Copilot): Uses
"servers"instead of"mcpServers". Add to.vscode/mcp.json:{ "servers": { "agendum": { "command": "uvx", "args": ["agendum", "--home", "serve"] } } }
CLI (standalone)
pip install agendum
agendum project create my-app # Create a project
agendum status # Dashboard overview
agendum next my-app # Suggest next task
Storage Layout
All state lives in ~/.agendum/ (or .agendum/ in your project if you prefer local storage):
~/.agendum/
├── .cache/
│ └── search.db # FTS5 + vector search index (auto-rebuilt)
├── config.yaml
├── projects/
│ └── webapp/
│ ├── project.yaml # Project metadata
│ ├── board/
│ │ ├── item-001.md # Markdown + YAML frontmatter
│ │ └── item-002.md
│ └── learnings/ # Project-scoped learnings
│ └── learning-001.md
├── learnings/ # Cross-project learnings
│ └── learning-001.md
└── memory/
├── decisions.md # Key decisions + rationale
└── patterns.md # Discovered conventions
Architecture
src/agendum/
├── server.py # MCP server wiring (FastMCP)
├── tools.py # 14 MCP tools
├── models.py # Pydantic models (BoardItem, WorkPackage, SearchResult)
├── task_graph.py # Dependency resolution + topological levels
├── config.py # Shared configuration
├── env_context.py # Git diff/log auto-extraction
├── cli.py # CLI interface
├── enrichment/
│ ├── pipeline.py # ContextEnricher, budget allocation
│ └── sources.py # ProjectRules, Memory, Dependency, Learnings sources
└── store/
├── board_store.py # BoardItem CRUD
├── board_format.py # Markdown <-> BoardItem serialization
├── project_store.py # Project metadata
├── memory_store.py # Scoped memory storage
├── learnings_store.py # Global and project-scoped learnings
├── search_index.py # FTS5 + vector + entity graph + RRF
├── embedding.py # Lazy fastembed wrapper (optional)
└── locking.py # get_lock() + atomic_write()
Development
git clone https://github.com/sralli/agendum.git
cd agendum
uv sync
uv run pytest tests/ -v # all tests
uv run ruff check . # lint
uv run ruff format --check . # format check
License
MIT
Preguntas sobre Agendum MCP
¿Cómo agrego Agendum MCP a Claude Code?
Ejecuta claude mcp add agendum -- uvx agendum en tu terminal. Añade --scope user para que esté disponible en todos los proyectos.
¿Cómo agrego Agendum MCP a Cursor?
Abre ~/.cursor/mcp.json y añade el servidor en mcpServers, usando la configuración de Cursor que se muestra en la sección de instalación de arriba.
¿Qué herramientas proporciona Agendum MCP?
Expone 14 herramientas, incluidas pm_init, pm_project, pm_status, pm_add, pm_board.
¿Qué problema resuelve Agendum para los agentes de IA?
Resuelve la naturaleza sin estado de los agentes de codificación de IA al proporcionar un estado de proyecto persistente, paquetes de trabajo delimitados y continuidad entre sesiones.
¿Cómo gestiona Agendum las dependencias de las tareas?
Utiliza un grafo de dependencias con ordenamiento topológico y detección de ciclos, lo que permite que las tareas se desbloqueen automáticamente cuando se completan sus dependencias.
¿Dónde se almacenan los datos del proyecto?
Todo el estado se almacena en archivos Markdown y YAML legibles por humanos dentro de un directorio .agendum/, lo que lo hace nativo de Git y permite realizar diffs.
¿Puedo usar búsqueda semántica con Agendum?
Sí, al instalar la extensión vectorial opcional, puedes añadir búsqueda de similitud semántica usando fastembed y sqlite-vec.