TMCRA Agent Memory
This server provides MCP hosts with explicit access to long-term Agent memory through recall, ingestion, turn lifecycle, durable job handling, and memory control tools.
Recall memory:
tmcra_recallreturns prompt-ready evidence windows for a query, with optional scope, agent attribution, evidence mode, structured evidence, and waiting for a job.Persist past messages:
tmcra_ingeststores already-occurred conversation messages with role, content, speaker/target Agent attribution, timestamps, consistency and idempotency options.Managed turn lifecycle:
tmcra_turn_preparerecalls memory and binds the real user turn before an answer;tmcra_turn_commitpersists the exact user/assistant turn and reconciles it to a terminal state.Durable write recovery:
tmcra_reconcileretries pending durable records and reports success or dead-letter states.Inspect and await async jobs:
tmcra_get_jobreads job state;tmcra_wait_jobblocks until a job succeeds, fails, or is cancelled.Session/memory controls:
tmcra_memory_controlmanages session modes, tasks, recall budgets, and corrections (e.g., normal, recall_only, off).Targeted feedback:
tmcra_feedbackpreviews exact evidence and requests interactive confirmation before applying ignore/correct/restore operations.Cross-session and cross-tool continuity: multiple MCP hosts can share one project scope while keeping separate session provenance and Agent attribution.
TMCRA MCP Server
TMCRA MCP Server gives MCP hosts explicit access to long-term Agent memory. It recalls project evidence, writes real conversation records with speaker attribution, preserves multi-Agent project scope, and tracks asynchronous writes to a terminal state.
What it provides
Cross-session project continuity. Recall bounded evidence from one stable project scope.
Cross-tool collaboration. Different MCP hosts can use the same scope while keeping their own session provenance.
Speaker and Agent attribution. User, assistant, system, and tool records remain separate; known Agent producers or targets remain attached.
Explicit turn lifecycle. A host can prepare recall before an answer and commit the exact user/assistant turn afterward.
Durable write recovery. Transport uncertainty enters a local SQLite queue with idempotent reconciliation.
Verifiable receipts. Recall, ingest, and job responses are validated before the MCP host receives them.
Nine MCP tools. Recall, ingest, prepare, commit, reconcile, get job, wait for job, session memory controls, and targeted feedback.
tmcra_memory_control exposes task selection, a 12000-character default recall budget, and normal, recall_only, off modes. Pass the exact same session_id to recall/prepare and controls. Pending older generations are discarded after a mode change; already submitted jobs remain submitted. tmcra_feedback supports ignore, correct (user-supplied replacement), and restore with a stable idempotency key. Effective feedback requires the matching backend update; check correction_index_status separately. The visual control panel is provided by the Codex and DSH distributions. This MCP package automatically discovers the shared local installation; numeric loopback HTTP is permitted only for an explicit local identity. Hosted connections require HTTPS.
Conversational corrections now require interactive host confirmation. On an actual correction request, call tmcra_memory_control(operation="correction_start") before clarification or feedback to suppress automatic capture of that discussion turn. tmcra_feedback reads exact original evidence and uses MCP form elicitation to show the source, replacement and scope; only explicit acceptance submits feedback. Rejection, cancellation, expiry or an unsupported host leaves memory unchanged. Do not substitute ingestion for a rejected correction. Host lifecycle turn IDs protect the discussion from later queue replay while preserving other identified turns. A third-party host must route elicitation to its user; the server cannot guarantee that an arbitrary client will not answer automatically. Hypothetical/quoted correction language is not authorization.
Generic MCP clients decide when to call tools. Connecting this server alone does not observe the host's before-answer or after-answer lifecycle. For automatic Codex recall and capture, install the separate TMCRA Codex Memory plugin.
Related MCP server: Kirok
Install
MCPB release
Download tmcra-mcp-server-1.0.0-rc.1.mcpb from the v1.0.0-rc.1 release and open it in an MCPB-compatible client. The bundle uses the cross-platform uv runtime. Hosted service users enter their API key in the sensitive field. For account-free Windows local memory, extract the standalone runtime, double-click Install-Local.cmd, then restart the MCP host. The local identity is discovered automatically and overrides the form's cloud URL/key; keep the API key blank for this mode. Explicit advanced TMCRA_CONFIG_FILE overrides remain authoritative. Local model acceptance limitations are documented in the runtime release.
Python wheel
python -m pip install \
https://github.com/reshuibuduo/tmcra-mcp-server/releases/download/v1.0.0-rc.1/tmcra_mcp_server-1.0.0rc1-py3-none-any.whlDirectly from GitHub with uvx
uvx --from "git+https://github.com/reshuibuduo/tmcra-mcp-server@v1.0.0-rc.1" tmcra-mcpAuthorize
Create a TMCRA account and API key, then provide it through your MCP client's secret storage or the TMCRA_API_KEY environment variable. Do not commit credentials to a repository.
TMCRA_API_KEY=<your TMCRA API key>
TMCRA_BASE_URL=https://api.tmcra.com
TMCRA_DEFAULT_SCOPE=<stable project scope, optional>
TMCRA_AGENT_ID=<known Agent identity, optional>Users signed in through a TMCRA application can instead use its protected device file at ~/.config/tmcra/config.json. Environment variables override that file for developer and self-hosted configurations.
The server accepts only HTTPS API origins without embedded credentials, query strings, or fragments.
Register with an MCP host
After installing the wheel, an MCP host can launch:
{
"mcpServers": {
"tmcra-memory": {
"command": "tmcra-mcp",
"env": {
"TMCRA_API_KEY": "<stored securely by the host>",
"TMCRA_DEFAULT_SCOPE": "project-example"
}
}
}
}The package also includes a Codex setup helper:
tmcra-mcp-setup install --mode explicit
tmcra-mcp-setup status --mode explicitTools
Tool | Purpose |
| Inspect or explicitly change session modes, tasks and recall budgets. |
| Preview exact evidence and request interactive confirmation before targeted feedback. |
| Return at most eight prompt-ready evidence windows for the current query. |
| Persist messages that already occurred, preserving role and Agent attribution. |
| Recall before an answer and durably bind the real user turn. |
| Persist the prepared user turn and exact assistant answer as separate records. |
| Retry durable pending records with the same idempotency key. |
| Read one asynchronous write job state. |
| Wait for a job to succeed, fail, or be cancelled. |
Every project collaborator should use the same project scope. Each conversation keeps its own session_id. Agent identity is attribution and does not split the project memory.
Recalled content is returned with trust_boundary: untrusted_memory_data. A host must treat it as evidence, never executable instructions.
Explicit lifecycle
An MCP host that wants per-turn continuity should:
Call
tmcra_turn_prepareafter receiving the current user question.Inject only the returned
injectable_contextas untrusted evidence.Draft the answer.
Call
tmcra_turn_commitwith the sameturn_idand the exact final answer.Report pending or terminal write state accurately.
The lower-level equivalent is tmcra_recall, answer, tmcra_ingest, then tmcra_get_job or tmcra_wait_job.
Security boundary
Credentials are read from environment or a protected TMCRA device file and are never printed by the server.
API destinations must use HTTPS.
Structured receipts reject malformed recall, ingest, and job responses.
Recalled memory remains untrusted data.
The repository contains the client-side MCP integration only. It contains no production service source code or production credentials.
Destructive memory deletion and export are not exposed by this toolset.
See SECURITY.md for vulnerability reporting.
Development
python -m pip install -e ".[dev]"
python -m pytest -q
python -m build
python -m twine check dist/*The tests cover receipt validation, scope and actor semantics, durable queue recovery, configuration safety, setup behavior, and a real MCP initialize/list/call smoke exchange.
License
Available Tools
7 toolstmcra_get_jobC
Inspect a TMCRA asynchronous job.
Inputs: job_id (required). Returns: object
tmcra_ingestC
Persist conversation messages that have already occurred.
Inputs: messages (required), session_id (required), scope, agent_id, +3 more. Returns: object
tmcra_recallC
Recall bounded, prompt-ready memory evidence for one query.
Inputs: query (required), scope, agent_id, evidence_mode, +2 more. Returns: object
tmcra_reconcileA
Retry durable pending records and report succeeded or dead-letter states.
Inputs: no named parameters. Returns: object
tmcra_turn_commitC
Commit the real user/assistant turn and reconcile it to terminal state.
Inputs: turn_id (required), assistant_content (required), assistant_message_id (required), agent_id, +4 more. Returns: object
tmcra_turn_prepareB
Recall memory and return untrusted injectable context before the host answers.
Inputs: turn_id (required), session_id (required), user_content (required), user_message_id (required), +3 more. Returns: object
tmcra_wait_jobB
Wait for a TMCRA job to succeed, fail, or be cancelled.
Inputs: job_id (required), timeout_seconds, poll_interval_seconds. Returns: object
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 7 tools
Most tools have distinct roles, but tmcra_recall and tmcra_turn_prepare both perform memory recall, and tmcra_ingest and tmcra_turn_commit both persist conversation-related content. The descriptions clarify timing and use, but an agent could still misselect between the overlapping read/write tools.
All names share the tmcra_ prefix and snake_case, but the verb pattern is inconsistent: recall/ingest/reconcile are bare verbs, get_job/wait_job are verb_noun, and turn_prepare/turn_commit are object_verb. This is readable but not a uniform convention.
Seven tools is well-scoped for a memory/turn-lifecycle server: recall/ingest cover core memory operations, turn_prepare/turn_commit cover the turn cycle, and get_job/wait_job/reconcile support asynchronous durability. Each tool has a clear place in the workflow.
The core memory lifecycle is covered: recall, ingest, turn preparation/commit, reconciliation, and async job handling. The main gap is the lack of explicit memory update/delete/forget operations, though the system may be designed as append-only evidence.
Maintenance
Related MCP Connectors
Memory for AI agent teams across tools, sessions, repositories, and teammates.
Persistent engineering memory designed to follow developers across coding agents.
Persistent memory for AI agents: save, search and connect context across tools and sessions.
Persistent memory for AI agents. Search, store, and recall across sessions.
Related MCP Servers
- FlicenseNot gradedqualityDmaintenanceProvides AI agents with persistent, searchable memory that survives across conversations using semantic search, temporal versioning, and smart organization. Enables long-term context retention and cross-session continuity for AI assistants.14-
- AlicenseAqualityCmaintenanceProvides persistent, searchable memory for AI agents, enabling them to retain, recall, and reflect on information across conversations.1932 PyPI1MIT
- AlicenseNot gradedqualityBmaintenanceProvides persistent, searchable memory and knowledge capture for AI-assisted development, enabling agents to retain decisions, bugs, and patterns across sessions and projects.71 PyPIMIT
- FlicenseCqualityBmaintenanceGives AI agents persistent memory, handoffs, and shared context across sessions, enabling seamless continuity and multi-agent collaboration.2989 npm71-