Plug into your
existing stack
Recall Racoon connects memory to working agents and applications. Use MCP for compatible clients. Use REST for custom workflows. Keep the right context in the right scope.
Memory tools for
connected agents.
Connect a compatible MCP client to Recall Racoon. Configure its access and project scope, then use the available memory tools in the agent’s workflow.
| Capability | Purpose |
|---|---|
| Create memory | Save useful knowledge with metadata and project context. |
| Read memory | Retrieve stored information for inspection or reuse. |
| Update memory | Revise stored content as the work changes. |
| Delete memory | Move a memory out of active use through the supported deletion workflow. |
| Search memory | Find relevant stored knowledge within the intended scope. |
Client Connection
Configure the supported MCP connection for your client and deployment. Every connection is authenticated and logged by key fingerprint — you can see who connected and audit failed attempts.
Project Context
Keep each agent’s memory operations attached to the intended project scope.
Workflow Continuity
Save and retrieve useful context across connected sessions.
Memory in your
application workflow.
Use REST interfaces to create, retrieve, update, and delete memory. Include metadata and scope with the workflow so stored knowledge can be found and managed later.
| Workflow | Purpose |
|---|---|
| Memory management | Create, read, update, and delete stored memories. |
| Semantic search | Retrieve relevant information by meaning. |
| Session state | Retain namespaced working context with configured expiry. |
| Export | Retrieve memories and sessions in JSON format. |
Input Validation
Validate incoming content before it enters the memory workflow.
Rate Limiting
Control request activity through the configured limits.
Key-Based Access
Every memory endpoint requires an API key. Logs record key fingerprints, never the keys themselves.
Operation Records
Keep memory activity available for review through the audit trail.
One memory layer,
many entry points.
Recall Racoon accepts information through connected agents, MCP, REST, or supported imports. A compatible MCP client connects directly to the memory tools in its workflow, while applications use REST to create, read, update, and delete memories through HTTP interfaces. Both paths land in the same governed Stash, so agents and applications share one source of persistent memory.
Whatever the entry point, incoming content is validated and enriched before it is stored. Rummage organizes the incoming information, and Rumi works through the stream to understand, summarize, categorize, and connect related knowledge. This turns raw inputs into retrievable, reusable memory rather than an undifferentiated pile of text.
Ingest, enrich,
and organize.
Persistent ingestion brings agent outputs and supported imports into memory, with enrichment preparing stored content for later recall. Memories are organized with project scope, categories, tags, source details, and agent metadata, so search stays within the context you intend. Mission Control provides a place to manage imports and inspect stored information.
Retrieval combines meaning and keywords. Hybrid semantic search finds stored knowledge by both, and returns relevant memories with the source context needed to use them. This keeps recall from being limited to exact word matches while still honoring the scope an agent was configured for.
Validated. Limited.
Traceable.
Incoming content is validated before it enters the memory workflow, and rate limiting controls request activity through configured limits. Content hashing supports duplicate detection and integrity checks, so repeated content is recognized and stored content can be verified.
Every operation leaves a record. Memory activity stays available for review through the audit trail, giving operators a trace of what changed and when. Deleted memories move to Trash rather than vanishing, and memories and sessions can be exported as JSON for portability and inspection.
Pick up where
you left off.
Session state retains namespaced working context with configured expiry, while durable knowledge lives in the Stash. When a connected agent starts a new session, persistent memory and session state let it pick up saved context rather than beginning from scratch. This is what turns an integration from a one-off write into an ongoing memory relationship.
Custom agent workflows can connect through the supported interfaces, with the integration requirements discussed for your environment. Whether you are wiring memory into an existing agent framework or building application workflows around REST, the goal is the same: keep the right context available in the right scope, every time work resumes.
Secrets caught
at the write path.
The integration path includes a guardrail for sensitive values. On memory writes, supported secret patterns are detected, including API keys and access tokens, passwords and credential-bearing connection strings, private keys, and supported card-number patterns with validation. Detected values follow the credential-handling path instead of entering ordinary memory.
When the encrypted credential vault is available, detected values are stored encrypted and replaced with references in memory. When the vault is unavailable, detected values are redacted and the remaining nonsecret content is preserved. This keeps sensitive information out of the knowledge your agents recall, regardless of which interface wrote it.
Configure the scope.
Start the flow.
Connecting is a matter of configuration and scope. A compatible MCP client is configured with its access and project scope, then uses the available memory tools in the agent's workflow. Applications reach the same memory through REST, creating, retrieving, updating, and deleting memories with metadata and scope attached.
For custom agent frameworks, the integration requirements are discussed for your environment before the connection is established. Once connected, memory flows both ways: agents and applications write useful knowledge, and retrieval brings the right context back into the workflow when it is needed.
With the connection in place, the memory relationship compounds over time. Each session adds to the Stash, retrieval returns relevant context with its source, and the claim lifecycle keeps that knowledge governed as it changes. The result is an integration that improves as it is used rather than one that simply accumulates a growing log of text.