This server is a lightweight MCP decision log that lets you record architectural choices, attach measurable predictions, and track whether they turned out to be accurate.
Record decisions with the problem, chosen solution, rejected alternatives, technologies, domain, status, ADR reference, and optional initial predictions.
Add predictions to existing decisions for outcomes like latency, cost, scalability, data quality, reliability, maintainability, or business impact.
Record outcomes for predictions by supplying the observed value, measurement source, and an accuracy score (0ā100).
Query decisions by keyword, technology, domain, or result limit to review past choices and their histories.
Receive outcome-gate reminders that show how many predictions still lack validation.
Build a portable, append-only JSONL log that requires no database and is easy to back up or inspect.
Support MCP-native use via JSON-RPC over stdio from MCP-compatible clients and AI agents.
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@mcp-server-decisions Record a decision to use DuckDB for query caching."
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
An open-source MCP server that helps teams record architectural decisions, connect them to testable predictions, and validate outcomes over time. It gives AI agents and developers a lightweight, auditable memory for technical choices.
Outcome-linked decisions ā connect each technical choice to measurable predictions and observed results.
In-band outcome gates ā tool responses identify predictions that still need validation before the work is considered complete.
Portable storage ā append-only JSONL keeps the log inspectable, easy to back up, and free from database setup.
Zero runtime dependencies ā Python's standard library is enough to run the server.
MCP-native interface ā expose decision tracking through JSON-RPC over stdio to MCP-compatible clients.
Technology feedback ā aggregate validated outcomes to inform future technology choices.
Related MCP server: Axiom-hub
Layer | Technology |
Protocol | Model Context Protocol over JSON-RPC 2.0 |
Runtime | Python 3.10+ |
Storage | Append-only JSONL file |
Packaging | PyPI / Hatchling |
Testing | Built-in self-test command |
License | MIT |
flowchart TD
A[MCP client or AI agent] --> B[JSON-RPC over stdio]
B --> C[mcp-server-decisions]
C --> D[Record decision]
C --> E[Attach prediction]
C --> F[Record outcome]
C --> G[Query decisions and technology history]
D --> H[(Append-only JSONL log)]
E --> H
F --> H
G --> H
F --> I[Validation status and accuracy]
I --> J[Future technical decisions]The server exposes four tools:
Tool | Purpose |
| Store the problem, chosen solution, alternatives, technologies, and predictions. |
| Add a measurable prediction to an existing decision. |
| Record the observed result and classify the prediction as success, partial success, or failure. |
| Search decisions by keyword, technology, domain, or result limit. |
Decide ā Predict ā Implement ā Measure ā Validate ā LearnA decision can produce an outcome-gate reminder such as:
{
"decision_id": "DEC-2026-0001",
"status": "OK",
"OUTCOME_GATE": "2 prediction(s) still lack outcomes."
}The reminder is a workflow signal, not a claim about adoption or measured impact. See the Outcome Gate Pattern for the design and trade-offs.
Area | Status |
Decision, prediction, and outcome tracking | Available |
Outcome-gate reminders | Available |
Technology performance report | Available |
PyPI package | Published as |
External adoption metrics | Not collected yet |
Web UI and notifications | Roadmap |
The project is early-stage. Contributions, examples from real projects, and feedback are welcome.
Python 3.10 or newer
An MCP-compatible client
python3 -m pip install mcp-server-decisionspython3 -m pip install -e .
python3 server.py --selftest{
"mcpServers": {
"mcp-server-decisions": {
"command": "mcp-server-decisions"
}
}
}For client-specific configuration and troubleshooting, see Client Integrations. For a guided first run, see Quick Start.
By default, the server writes to ~/.local/share/mcp-decisions/decisions_log.json. Set MCP_DECISIONS_LOG_PATH to use another file:
MCP_DECISIONS_LOG_PATH=/path/to/decisions.json mcp-server-decisions.
āāā server.py # MCP server and tool implementations
āāā scripts/ # Reports derived from the decision log
āāā docs/ # Architecture, examples, and integrations
āāā .github/ISSUE_TEMPLATE/ # Reusable bug and feature templates
āāā CONTRIBUTING.md # Development and contribution workflow
āāā QUICKSTART.md # Guided setup and first decision
āāā server.json # MCP Registry metadata
āāā pyproject.toml # PyPI package metadata
āāā LICENSE # MIT licenseQuick Start ā install and record a first decision.
Client Integrations ā configure MCP clients.
Detailed Examples ā JSON-RPC requests and responses.
Architecture & Design ā storage, IDs, scoring, and trade-offs.
Outcome Gate Pattern ā the reusable feedback-loop pattern.
Contributing ā propose fixes, features, and documentation.
Core decision, prediction, and outcome tracking
Outcome-gate reminders
Technology performance reporting
Web UI for browsing and searching decisions
Notifications for low prediction accuracy
Reusable decision templates and domain patterns
Issues and pull requests are welcome. Start with CONTRIBUTING.md, run the self-test, and explain the problem or use case in the pull request.
MIT Ā© 2026 Roberto Nascimento
Search prior decisions by keyword, technology, or domain
| Name | Required | Description | Default |
|---|---|---|---|
| domain | No | Partial domain filter | |
| keyword | No | Search in problem + solution + alternatives (case-insensitive) | |
| technology | No | Exact technology filter (e.g., 'duckdb') | |
| max_results | No | Maximum results to return |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description bears full responsibility. It only states 'search' without disclosing behavioral traits like read-only, pagination, or authentication requirements.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence with zero waste, efficiently conveying the tool's purpose and core dimensions.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite 4 parameters and no output schema, the description lacks details about return format, filter interaction, or sorting. More context is needed for a search tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the input schema already fully describes each parameter. The description adds no additional semantic meaning beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'search' and the resource 'prior decisions', listing the search dimensions (keyword, technology, domain). This distinguishes it from sibling tools that record decisions, predictions, and outcomes.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for searching past decisions, contrasting with recording siblings. However, it does not explicitly state when not to use or mention alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Register a technical decision with problem, solution, alternatives, and technologies
| Name | Required | Description | Default |
|---|---|---|---|
| domain | No | Technical domain (e.g., 'data-engineering', 'backend', 'ai') | |
| status | No | Decision status | ACTIVE |
| adr_ref | No | Reference to an associated ADR, if any (e.g., 'docs/adr/adr-012-duckdb.md') | |
| problem | Yes | The problem or technical opportunity identified | |
| predictions | No | Initial predictions known at decision time (optional) | |
| technologies | Yes | Technologies involved in this decision (e.g., ['duckdb', 'parquet']) | |
| chosen_solution | Yes | The solution that was chosen | |
| rejected_alternatives | Yes | Alternatives considered and rejected |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so the description must carry the full burden. It states 'Register' (implying creation) but does not disclose side effects (e.g., whether it overwrites, requires special permissions, or has constraints). A mutation tool with no annotation coverage should offer more behavioral context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence with no wasted words, front-loaded with the verb 'Register', and covers the essential aspects efficiently.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With 8 parameters, no output schema, and no annotations, the description is too brief. It doesn't explain return values, behavior on conflicts, prerequisites, or post-conditions. The tool's complexity merits a more comprehensive description.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all parameters. The description lists only four of eight parameters (problem, solution, alternatives, technologies) but adds no new meaning beyond what the schema provides. Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb 'Register' and noun 'technical decision', and lists key components (problem, solution, alternatives, technologies), clearly distinguishing it from query-decisions (retrieval) and record-prediction/outcome (related but different actions).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use (when registering a decision) but provides no explicit guidance on when not to use, nor mentions sibling tools like query-decisions as alternatives for retrieval. Usage context is implied but not clarified.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Close the prediction loop: record actual results and calculate accuracy
| Name | Required | Description | Default |
|---|---|---|---|
| actual_value | Yes | Observed result (e.g., 'latency p99 = 180ms') | |
| prediction_id | Yes | Prediction ID (e.g., 'PRD-2026-0001') | |
| accuracy_score | Yes | Accuracy of prediction (0-100). >=90 excellent, 50-89 acceptable, <50 failed | |
| measurement_source | Yes | Where the measurement came from |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must carry full burden. It only mentions recording and calculating accuracy, but does not disclose side effects (e.g., whether a new record is created or existing data updated), required permissions, or other behavioral traits.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence that efficiently conveys the tool's purpose without wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 4 required parameters and no output schema or annotations, the description is minimal. It does not explain how accuracy is calculated, what the output structure is, or how the outcome record integrates with other tools, leaving gaps for an agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all parameters. The description adds no additional meaning beyond the schema, earning a baseline 3.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action (record actual results and calculate accuracy) and resource (prediction loop). It distinguishes from sibling tools (record-decision, record-prediction) by focusing on closing the loop with outcomes.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies it is used after making a prediction, but does not explicitly state when to use it versus alternatives, nor provides exclusions or prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Register a measurable prediction linked to a decision
| Name | Required | Description | Default |
|---|---|---|---|
| decision_id | Yes | Decision ID (e.g., 'DEC-2026-0001') | |
| predicted_value | Yes | Expected result (e.g., 'latency p99 < 200ms', 'cost < $100/month') | |
| prediction_type | Yes | Type of prediction |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must carry the full burden. It does not disclose behavioral traits such as idempotency, authorization needs, side effects, or what happens on duplicate entries. The minimal description adds little beyond the basic action.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with no wasted words. It is front-loaded and communicates the essential purpose immediately.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple 3-parameter tool with no output schema or annotations, the description is adequate but not rich. It does not explain what happens on success, whether updates are allowed, or any constraints related to the decision ID.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all parameters. The description adds context ('measurable', 'linked') but does not provide additional meaning beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Register a measurable prediction linked to a decision', using a specific verb and resource. It distinguishes from sibling tools like 'record-decision' and 'record-outcome' by focusing on predictions.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance on when to use this tool versus alternatives, but the sibling names imply it's for predictions. Usage context is implied rather than directly stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v1.0.2query-decisionsrecord-decisionrecord-outcomerecord-predictionEach tool has a clearly distinct purpose: querying decisions, recording a decision, recording a prediction for that decision, and recording the outcome. There is no overlap or ambiguity.
All tool names follow the same pattern: a verb followed by a noun, using lowercase and hyphens (e.g., record-decision). The naming is perfectly consistent.
Four tools cover the core workflow of managing decisions with predictions and outcomes. The count is appropriate for this focused domain, not too few or too many.
The tool set covers the main lifecycle: querying, recording decisions, adding predictions, and logging outcomes. Missing update or delete functionality, but the core workflow is complete.
Decision memory for AI agents: record, revisit, and resolve consequential choices.
Live trading-pipeline intelligence for AI agents: signal scoring, calibration, recorded outcomes.
Deterministic decision layer for autonomous agents. Reproducible PROCEED, REVIEW, SKIP verdicts.
Deterministic AI code review, with an audit record. Governance inside the agent loop.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/Roberton003/mcp-server-decisions'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
