TradeMemory Protocol is an MIT-licensed Python memory and decision-audit layer for AI trading agents, giving them persistent outcome-weighted recall of past trades plus a tamper-evident SHA-256 audit trail with RFC 3161 timestamp anchoring — built for traders and developers running agentic trading systems who need an agent to remember what happened and to be able to prove it.

What it is

TradeMemory Protocol is a memory and audit layer that plugs into AI trading agents through the Model Context Protocol. It lives in the agentic-trading and MCP ecosystem, alongside the execution-focused MCP servers that place orders, fetch prices and read charts. What it replaces is not a named product but a missing layer: the ephemeral context-window memory that an agent loses the moment a session ends. The project describes the situation directly — an agent can buy 100 shares of AAPL but cannot answer "What happened last time I bought AAPL in this condition?" TradeMemory exists to answer that question and to keep the record that answers it.

The concrete problem is twofold. Operationally, an agent makes the same mistakes every session, cannot explain why it traded, and forgets everything when the context window closes. TradeMemory records every trade, outcome and mistake across five memory layers that update automatically from a single call, and recalls them, weighted by outcome, before the next decision. Regulatorily, MiFID II Article 17 raises the bar for algorithmic decision documentation and the EU AI Act Article 14 demands systematic logging of AI actions; the SHA-256 chain provides a tamper-evident record for that purpose. The tool records and recalls only — it does not execute trades and does not touch funds.

Key capabilities

• Exposes 20 MCP tools through an MCP server, listed on Smithery, for recording trades and querying memory from an agent session.
• Maintains a tamper-evident SHA-256 hash chain with RFC 3161 anchoring for the audit trail.
• Applies outcome-weighted recall (the OWM framework, documented in docs/OWM_FRAMEWORK.md) so past results shape what the agent retrieves.
• Updates five distinct memory layers automatically from one recording call.
• Provides safety rails: confidence tracking, drawdown alerts and losing streak detection, so the system signals when to stop.
• Supports a pre-trade recall query that asks what happened last time in the current market condition and how it ended.
• Ships a replay harness — tradememory demo --fast replays 30 trades and shows the recall and parameter adjustment derived from them.

Who uses it and how

• An independent trader runs a pre-flight checklist against memory before every position.
• A first-party deployment against an MT5 account logs blocked signals as well as executed ones, not only the trades that filled.
• It works across any market (stocks, forex, crypto, futures), any broker and any AI platform, since it records rather than executes.
• It integrates into Claude Desktop through claude_desktop_config.json, or into Claude Code with claude mcp add tradememory -- uvx tradememory-protocol.
• It can be self-hosted as a service with docker compose up -d for teams that keep trading data in their own environment.

Getting started

Install the Python package with pip install tradememory-protocol, then either register it as an MCP server (uvx tradememory-protocol) or run it from source with python -m tradememory; a Docker path is available through docker compose up -d. Full walkthroughs for both a Trader Track and a Developer Track are in docs/GETTING_STARTED.md.

How it compares

No comparable tool is named in the facts provided, so on the evidence available this project stands alone in this registry. The relevant contrast is structural rather than against a rival product: the surrounding MCP servers in the trading stack handle execution, and this is the layer that handles memory and audit.

When to use it — and when not to

This suits a self-hoster who is comfortable running a Python package or a Docker Compose stack and who wants decision history to stay in their own environment under an MIT licence. It is a poor fit for anyone wanting a hosted service or an actively developed feature roadmap: the project is feature-complete and in maintenance mode as of August 2026, with bug and security reports still reviewed but no new features or hosted service planned, and paid work routed to a separate Trading Record Analysis offering.

Note that the public dashboard runs on an illustrative synthetic dataset and is an interface preview, not a track record — the trades and figures on it are labelled as such. Prospective users should read docs/USE_CASES.md to see which of the two documented deployments each use case describes, and LIMITATIONS.md before depending on the audit trail for a compliance obligation.

pip install tradememory-protocol

{
  "mcpServers": {
    "tradememory": {
      "command": "uvx",
      "args": ["tradememory-protocol"]
    }
  }
}

# Claude Code
claude mcp add tradememory -- uvx tradememory-protocol

# From source
git clone https://github.com/mnemox-ai/tradememory-protocol.git
cd tradememory-protocol && pip install -e . && python -m tradememory

# Docker
docker compose up -d

## Verify a single record hasn't been tampered with
verify_audit_hash(trade_)
## → {"verified": true, "chain_entry": {"sequence_num": 42, ...}}

## Walk the entir