Generated banner for memoria
Generated logo for memoria

memoria

Memory frameworkOfficial Matrix Origin project

Created by Matrix Origin

Published in matrixorigin/memoria. Publisher page

626 GitHub stars

What it is

Secure memory management for AI Agents • Ensures data integrity • Reduces hallucinations • Maintains consistent long-term context
— the description by Matrix Origin

AutoGineer overview, from the brain’s own files

Memoria is a persistent memory layer designed to give AI agents reliable, auditable, and version-controlled long-term memory. By leveraging a Git-inspired architecture powered by MatrixOne, it allows agents to snapshot, branch, merge, and rollback their memory state. This ensures that memory changes are tracked and reversible, reducing hallucinations and maintaining consistency across sessions. It supports semantic search through hybrid retrieval and includes self-governing features to detect contradictions and maintain audit trails, making it a robust solution for managing agent knowledge.

How it works

Memory model: Hybrid

AutoGineer overview, from the brain’s own files

Memoria functions as a memory service that agents interact with via MCP tools. It uses a hybrid memory model where facts, preferences, and decisions are stored and retrieved. The system supports branching for isolated experimentation, allowing agents to test new information or hypotheses without altering the main memory state. It includes specific steering rules for managing the lifecycle of memories, from initial retrieval at the start of a conversation to purging transient working memories upon task completion. Data is stored using a database-native engine that supports zero-copy branching and snapshots.

Folders
FolderRoleFiles
.claudeagent-config1
.cursoragent-config2
.geminiagent-config1
.githubagent-config16
.kiroagent-config7
assetsattachments7
docsdocs10
scriptsscripts2
skillsagent-instructions7
benchmarksfolder7
configfolder7
grafanafolder1
memoriafolder280
pluginsfolder69
sdkfolder36

Requirements

Apps: Docker

Databases: PostgreSQL, SQLite

API keys (by name): MEMORIA_API_KEY, MEMORIA_EMBEDDING_API_KEY, MEMORIA_LLM_API_KEY

Works with: Claude Code, Cursor, Gemini CLI, Kiro

Set it up

  1. This brain runs code automatically: 5 scripts. Review README.md, scripts/install.ps1, scripts/install.sh before opening the folder in Claude Code. No step below turns a hook on for you.

    • README.md: curl -sSL https://raw.githubusercontent.com/matrixorigin/Memoria/main/scripts/install.sh | bash
    • README.md: curl -sSL https://raw.githubusercontent.com/matrixorigin/Memoria/main/scripts/install.sh | bash
    • README.md: command -v memoria >/dev/null || curl -sSL https://raw.githubusercontent.com/matrixorigin/Memoria/main/scripts/install.sh | bash -s -- -y -d ~/.local/bin
    • scripts/install.ps1: pwsh scripts/install.ps1
    • scripts/install.sh: sh scripts/install.sh
  2. Not scanned by AutoGineerThe author’s README also describes installing it with Docker Compose. Read its install section: AutoGineer did not scan that path. https://github.com/matrixorigin/memoria/blob/93ccccf2ea8da4c205ac2d93c1a010c287bc742d/README.md#-quick-start
  3. Not scanned by AutoGineerThe author’s README also describes installing it from a clone of its repository. Read its install section: AutoGineer did not scan that path. https://github.com/matrixorigin/memoria/blob/93ccccf2ea8da4c205ac2d93c1a010c287bc742d/README.md#-quick-start
  4. Created by Matrix Origin. Published in matrixorigin/memoria. Licence: Apache License 2.0.

Usage

AutoGineer overview, from the brain’s own files

  • Persistent memory across agent sessions
  • Git-like version control for agent knowledge
  • Isolated experimentation via memory branching
  • Semantic and full-text hybrid retrieval
  • Automated contradiction detection and memory governance
“Let's try switching from PostgreSQL to SQLite.”
The agent creates a new memory branch 'eval_sqlite', performs experiments, and allows the user to diff and merge the results back to main.
“I want to add OAuth support to the API.”
The agent searches for existing goals, stores the new goal, and tracks progress as working memories across sessions.
“What are my deployment preferences?”
The agent retrieves relevant semantic memories to provide context-aware information based on previous sessions.

Documentation by Matrix Origin

<div align="center"> <img src="assets/memoria-logo.png" alt="Memoria Logo" width="300"/>

Memoria

The World's First Git for AI Agent Memory

Snapshot · Branch · Merge · Rollback — for memory, not code.

Git made code safe to change. Memoria makes memory safe to change.

Image: CI Image: Release Image: GitHub Stars Image: Downloads Image: License Image: MCP Image: MatrixOne Image: Paper

Quick Start · Memoria in Astra · Why Memoria · Research · See It in Action · API Reference · Architecture · Development · Citation

</div>


Overview

Memoria is a persistent memory layer for AI agents with Git-level version control. Every memory change is tracked, auditable, and reversible — snapshots, branches, merges, and time-travel rollback, all powered by MatrixOne's native Copy-on-Write engine.

A core memory component of MatrixOrigin's Astra.

Astra runs the agent. Memoria helps it remember across sessions. MatrixOne powers the data storage and search.

Using Astra? · Use Memoria with another agent

<table> <tr> <td align="center" width="33%">

🔀 Git for Memory

Zero-copy branching, instant snapshots, point-in-time rollback — version control for every memory mutation

</td> <td align="center" width="33%">

🔍 Semantic Search

Vector + full-text hybrid retrieval finds memories by meaning, not just keywords

</td> <td align="center" width="33%">

🛡️ Self-Governing

Auto-detects contradictions, quarantines low-confidence memories, maintains audit trails

</td> </tr> </table>

<table> <tr> <td align="center" width="33%">

🔒 Private by Default

Local embedding model option — no data leaves your machine

</td> <td align="center" width="33%">

🧠 Cross-Conversation

Preferences, facts, and decisions persist across sessions

</td> <td align="center" width="33%">

📋 Full Audit Trail

Every memory mutation has a snapshot + provenance chain

</td> </tr> </table>

Supported Agents

<p align="center"> <a href="https://kiro.dev"><img src="https://img.shields.io/badge/Kiro-00C853?style=for-the-badge&logo=data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNCAyNCI+PHRleHQgeD0iNCIgeT0iMTgiIGZvbnQtc2l6ZT0iMTYiIGZpbGw9IndoaXRlIj5LPC90ZXh0Pjwvc3ZnPg==&logoColor=white" alt="Kiro"/></a> <a href="https://cursor.sh"><img src="https://img.shields.io/badge/Cursor-000000?style=for-the-badge&logo=cursor&logoColor=white" alt="Cursor"/></a> <a href="https://docs.anthropic.com/en/docs/claude-code"><img src="https://img.shields.io/badge/Claude_Code-D97757?style=for-the-badge&logo=anthropic&logoColor=white" alt="Claude Code"/></a> <a href="https://openai.com/index/introducing-codex/"><img src="https://img.shields.io/badge/Codex-412991?style=for-the-badge&logo=openai&logoColor=white" alt="Codex"/></a> <a href="https://geminicli.com"><img src="https://img.shields.io/badge/Gemini_CLI-4285F4?style=for-the-badge&logo=google&logoColor=white" alt="Gemini CLI"/></a> <a href="plugins/openclaw/README.md"><img src="https://img.shields.io/badge/OpenClaw-FF6B6B?style=for-the-badge" alt="OpenClaw"/></a> <a href="plugins/hermes/README.md"><img src="https://img.shields.io/badge/Hermes-8B5CF6?style=for-the-badge" alt="Hermes"/></a> </p>

<p align="center"><i>Works with any MCP-compatible agent</i></p>


🧠 Memoria in Hermes

Memoria is available from the Hermes plugin catalog. Log in at Memoria and create/copy a memory-service API key, then run:

hermes plugins install memoria --yes-deps --enable
hermes memory setup
hermes memory status

In the interactive setup, select memoria, paste your API key at the masked prompt, and choose whether to enable automatic capture (off by default). Confirm that status reports memoria, installed and available, then exit any existing conversation and start a new one with hermes. Status checks local readiness; verify a live write using the complete Hermes guide. The free Memoria Cloud requires no local Memoria server or database. Self-hosting, fixed GitHub installation and named profiles are covered in the same guide.


🧩 Memoria in Astra

In Astra, Memoria stores and retrieves facts, preferences, decisions, and session summaries so agents can reuse knowledge across conversations. Memory changes can be reviewed and rolled back.

How you use itWhere to start
Hosted AstraMemoria is already running for you. Follow the Astra quick start.
Self-hosted AstraAstra's deployment includes compatible Memoria and MatrixOne services. Follow Astra's Docker setup.
Memoria with other agentsUse Memoria independently via MCP. Follow the Memoria quick start below.

For example, search your memories from Astra:

astra memory search "deployment preferences"

🚀 Quick Start

<details open> <summary><b>☁️ Memoria Cloud (Recommended — no Docker, no database)</b></summary> <br/>

1. Sign up at thememoria.ai and get your token

2. Install & configure

curl -sSL https://raw.githubusercontent.com/matrixorigin/Memoria/main/scripts/install.sh | bash
cd your-project
memoria init -i   # Select "Remote" mode, paste your token

3. Restart & verify — restart your AI tool, then ask: "Do you have memory tools available?"

</details>

<details> <summary><b>🐳 Self-Hosted (Docker — full data control)</b></summary> <br/>

# 1. Start MatrixOne + API
git clone https://github.com/matrixorigin/Memoria.git
cd Memoria
docker compose up -d

# 2. Install CLI
curl -sSL https://raw.githubusercontent.com/matrixorigin/Memoria/main/scripts/install.sh | bash

# 3. Configure your AI tool
cd your-project
memoria init -i   # Select "Embedded" mode

Restart your AI tool, then ask: "Do you have memory tools available?"

</details>

<details> <summary><b>🦞 OpenClaw Plugin</b></summary> <br/>

Use the native OpenClaw plugin: OpenClaw Plugin Setup

# ensure memoria CLI exists
command -v memoria >/dev/null || curl -sSL https://raw.githubusercontent.com/matrixorigin/Memoria/main/scripts/install.sh | bash -s -- -y -d ~/.local/bin

# install & enable
openclaw plugins install @matrixorigin/memory-memoria
openclaw plugins enable memory-memoria

# cloud-first setup
openclaw memoria setup --mode cloud --api-url <MEMORIA_API_URL> --api-key <MEMORIA_API_KEY> --install-memoria
openclaw memoria health

</details>

Or download binaries directly from GitHub Releases. For detailed setup, see Setup Skill.


💡 Why Memoria?

CapabilityMemoriaLetta / Mem0 / Traditional RAG
Git-level version controlNative zero-copy snapshots & branchesFile-level or none
Isolated experimentationOne-click branch, merge after validationManual data duplication
Audit trailFull snapshot + provenance on every mutationLimited logging
Semantic retrievalVector + full-text hybrid searchVector only
Self-governanceAutomatic contradiction detection & quarantineManual cleanup

🔬 Research Foundation

Memoria's Git-for-Data layer is backed by Version Control System for Data with MatrixOne, our arXiv paper on bringing Git-like workflows directly into a cloud-native database.

The paper describes how MatrixOne's immutable storage and MVCC architecture make clone, branch / tag, diff, merge, and revert practical at terabyte scale without loading whole datasets into memory. Memoria applies the same foundation to AI-agent memory, so every memory change can be isolated, reviewed, merged, or rolled back with database-native consistency.


🎬 See Git for Data in Action

<p align="center"> <img src="assets/git4data-story-writing-demo.svg" alt="Animated Memoria Git-for-Data demo showing an author branching a story draft, merging a better plot direction into the main storyline, and rolling back the last two unsatisfying beats." width="100%"/> </p>

A story-writing scenario demonstrates the core concept: an author has accepted story beats on main, opens an experimental branch for a different plot direction, merges the stronger draft back, and rolls back when the newest beats don't work.

<details> <summary><b>What the demo shows</b></summary>

  • Main storyline — accepted story beats live on main

  • Experimental branch — the author tries a new plot turn without rewriting canon

  • Merge — the stronger draft is promoted back into the main storyline

  • Rollback — the last two bad turns are discarded, and writing resumes from a safe snapshot

</details>


📖 Steering Rules

Steering rules teach your AI agent when and how to use memory tools. Without them, the agent has tools but no guidance — like having a database without knowing the schema.

RulePurpose
memoryCore memory tools — when to store, retrieve, correct, purge
session-lifecycleBootstrap at conversation start, cleanup at end
memory-hygieneProactive governance, contradiction resolution, snapshot cleanup
memory-branching-patternsIsolated experiments with branches
goal-driven-evolutionTrack goals, plans, progress across conversations

File locations: Kiro: .kiro/steering/*.md · Cursor: .cursor/rules/*.mdc · Claude: .claude/rules/*.md · Codex: AGENTS.md · Gemini CLI: GEMINI.md + .gemini/*.md

After upgrading: memoria rules --force

<details> <summary><b>Example: Conversation Lifecycle</b></summary>

┌─────────────────────────────────────────────────────────────────────────────┐
│  CONVERSATION START                                                         │
│  ┌─────────────────────────────────────────────────────────────────────┐   │
│  │ 1. memory_retrieve(query="<user's question>")  ← load context       │   │
│  │ 2. memory_search(query="GOAL ACTIVE")          ← check active goals │   │
│  └─────────────────────────────────────────────────────────────────────┘   │
├─────────────────────────────────────────────────────────────────────────────┤
│  MID-CONVERSATION                                                           │
│  ┌─────────────────────────────────────────────────────────────────────┐   │
│  │ • User states preference → memory_store(type="profile")             │   │
│  │ • User corrects a fact   → memory_correct(query="...", new="...")   │   │
│  │ • Topic shifts           → memory_retrieve(query="<new topic>")     │   │
│  └─────────────────────────────────────────────────────────────────────┘   │
├─────────────────────────────────────────────────────────────────────────────┤
│  CONVERSATION END                                                           │
│  ┌─────────────────────────────────────────────────────────────────────┐   │
│  │ 1. memory_purge(topic="<task>")  ← clean up working memories        │   │
│  │ 2. memory_store(type="episodic") ← save session summary             │   │
│  └─────────────────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────────────────┘

</details>

<details> <summary><b>Example: Goal-Driven Evolution</b></summary>

You: "I want to add OAuth support to the API"

AI:  → memory_search(query="GOAL OAuth")           ← check for existing goal
     → memory_store(content="🎯 GOAL: Add OAuth support\nStatus: ACTIVE", type="procedural")

     ... works on implementation, stores progress as working memories ...

     → memory_store(content="✅ STEP 1/3: Added OAuth routes", type="working")
     → memory_store(content="❌ STEP 2/3: Token refresh failed — need to fix expiry logic", type="working")

... next conversation ...

AI:  → memory_search(query="GOAL ACTIVE")          ← finds OAuth goal
     → memory_search(query="STEP for GOAL OAuth")  ← loads progress
     "Last time we were working on OAuth. Step 2 failed on token refresh. Want to continue?"

... goal completed ...

AI:  → memory_correct(query="GOAL OAuth", new_content="🎯 GOAL: OAuth — ✅ ACHIEVED")
     → memory_store(content="💡 LESSON: Token refresh needs 5min buffer before expiry", type="procedural")
     → memory_purge(topic="STEP for GOAL OAuth")   ← clean up working memories

</details>

<details> <summary><b>Example: Branch for Risky Experiments</b></summary>

You: "Let's try switching from PostgreSQL to SQLite"

AI:  → memory_branch(name="eval_sqlite")
     → memory_checkout(name="eval_sqlite")

     ... experiments on branch, stores findings ...

     → memory_diff(source="eval_sqlite")     ← preview changes
     → memory_checkout(name="main")
     → memory_merge(source="eval_sqlite")    ← or delete if failed

</details>


📚 API Reference

Core Tools
ToolDescription
memory_storeStore a new memory
memory_retrieveRetrieve relevant memories (call at conversation start)
memory_searchSemantic search across all memories
memory_correctUpdate an existing memory
memory_purgeDelete by ID or topic keyword
memory_listList active memories
memory_profileGet user's memory-derived profile
memory_feedbackRecord relevance feedback (useful/irrelevant/outdated/wrong)
memory_capabilitiesList available memory tools

<details> <summary><b>Snapshots & Branches</b></summary>

ToolDescription
memory_snapshotCreate named snapshot
memory_snapshotsList snapshots with pagination
memory_snapshot_deleteDelete snapshots by name, prefix, or age
memory_rollbackRestore to snapshot
memory_branchCreate isolated branch
memory_branchesList all branches
memory_checkoutSwitch branch
memory_mergeMerge branch back
memory_branch_deleteDelete a branch
memory_diffPreview merge changes

</details>

REST clients can use cached-count snapshot listing to avoid historical count queries and exclude automatic safety snapshots.

<details> <summary><b>Maintenance</b></summary>

ToolDescription
memory_governanceQuarantine low-confidence memories (1h cooldown)
memory_consolidateDetect contradictions (30min cooldown)
memory_reflectSynthesize insights (2h cooldown)

memory_rebuild_index, memory_observe, memory_get_retrieval_params, memory_tune_params, memory_extract_entities, and memory_link_entities are available via REST API but hidden from MCP tool listing — they are ops/debug tools not intended for agent use.

</details>

Memory Types
TypeUse forExample
semanticProject facts, decisions"Uses Go 1.22 with modules"
profileUser preferences"Prefers pytest over unittest"
proceduralWorkflows, how-to"Deploy: make build && kubectl apply"
workingTemporary task context"Currently debugging auth module"
episodicSession summaries"Session: optimized DB, added indexes"

Full API details: API Reference Skill

Retry-safe single-memory writes: Idempotent store protocol.

Trusted adapter content preservation: Content-filter policy.


🔧 Commands

CommandDescription
memoria init -iInteractive setup wizard
memoria statusShow config and rule versions
memoria rulesUpdate steering rules (auto-detect, --tool, or -i)
memoria mcpStart MCP server
memoria serveStart REST API server
memoria benchmarkRun benchmark suite

🤖 For AI Agents

If you're an AI agent helping a user set up Memoria:

  1. Load the Setup Skill — it has step-by-step instructions

  2. Ask before acting: which AI tool? · database mode? · embedding service? (Self-Hosted only)

  3. Run memoria init -i in the user's project directory

  4. Tell user to restart their AI tool, then verify with memory_retrieve("test")

Self-Hosted only: Configure embedding BEFORE first MCP server start — dimension is locked into schema.


🏗️ Architecture

Cloud / Remote Mode:

┌─────────────┐     MCP (stdio)     ┌──────────────────┐     HTTP/REST     ┌──────────────────┐
│  AI Agent   │ ◄─────────────────► │  Memoria CLI     │ ◄──────────────► │  Memoria Cloud   │
│             │   store / retrieve  │  (MCP bridge)    │   Bearer token   │  API Server      │
└─────────────┘                     └──────────────────┘                  └──────────────────┘

Self-Hosted / Embedded Mode:

┌─────────────┐     MCP (stdio)     ┌──────────────────────────────────────┐     SQL      ┌────────────┐
│  AI Agent   │ ◄─────────────────► │  Memoria MCP Server                  │ ◄──────────► │ MatrixOne  │
│             │   store / retrieve  │  ├── Canonical Storage               │  vector +    │  Database  │
│             │                     │  ├── Retrieval (vector / semantic)   │  fulltext    │            │
│             │                     │  └── Git-for-Data (snap/branch/merge)│              │            │
└─────────────┘                     └──────────────────────────────────────┘              └────────────┘

For codebase details, see Architecture Skill.


🛠️ Development

make up              # Start MatrixOne + API
make test            # Run all tests
make release VERSION=0.2.0   # Bump, tag, push

Developer documentation (for contributing to Memoria):

SkillDescription
ArchitectureCodebase layout, traits, tables
API ReferenceREST endpoints, request/response
DeploymentDocker, K8s, multi-instance
Plugin DevelopmentGovernance plugins
ReleaseVersion bump, CI/CD
Local EmbeddingOffline embedding build

📝 Citation

If you use Memoria in academic work, or refer to its Git-for-Data foundation for AI-agent memory, please cite the MatrixOne paper that describes the underlying data version control design:

@misc{gou2026versioncontrolsystemdata,
  title={Version Control System for Data with MatrixOne},
  author={Gou, Hongshen and Tian, Feng and Wang, Long and Deng, Nan and Xu, Peng},
  year={2026},
  eprint={2604.03927},
  archivePrefix={arXiv},
  primaryClass={cs.DB},
  doi={10.48550/arXiv.2604.03927},
  url={https://arxiv.org/abs/2604.03927}
}

🌟 Community

We'd love your support! If Memoria helps you, consider giving us a star.

Image: Star History Chart

Contributing — See the developer documentation above and check out our issue templates for bug reports, feature requests, and more.


License

Apache-2.0 © MatrixOrigin

memoria/vendor/sqlx-mysql/LICENSE-APACHE

Shown as plain text.

Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/

TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION

1. Definitions.

"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.

"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.

"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.

"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.

"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.

"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.

"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).

"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.

"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."

"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.

2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.

3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.

4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:

(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and

(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and

(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and

(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.

You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.

5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.

6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.

7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.

8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.

9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.

END OF TERMS AND CONDITIONS

APPENDIX: How to apply the Apache License to your work.

To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!)  The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.

Copyright 2020 LaunchBadge, LLC

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
467 files · 445 not served here

Advantages

Limitations

Security

Risk level: Medium risk

This brain runs

Agent instructions that run or fetch something (41)

  • .cursor/rules/memory.mdc: If ⚠️ health warnings appear → inform the user and offer to run `memory_governance`.
  • .cursor/rules/memory.mdc: | Type | Use for | Examples | |------|---------|---------| | `semantic` | Project facts, technical decisions (default) | "Uses MatrixOne as primary DB", "API follows REST conventions" | | `profile` | User/agent identity and preferences | "Prefers concise answers", "Works on mo-dev-agen …[+460 chars]
  • .kiro/steering/memory-hygiene.md: Run `memory_governance` (1h cooldown) when you notice ANY of these:
  • .kiro/steering/memory-hygiene.md: Run `memory_consolidate` (30min cooldown) when:
  • .kiro/steering/memory.md: | Type | Use for | Examples | |------|---------|---------| | `semantic` | Project facts, technical decisions (default) | "Uses MatrixOne as primary DB", "API follows REST conventions" | | `profile` | User/agent identity and preferences | "Prefers concise answers", "Works on mo-dev-agen …[+460 chars]
  • .kiro/steering/session-lifecycle.md: Before your first response, run a multi-query bootstrap to load full context:
  • .kiro/steering/skills.md: | Skill | When to use | |-------|-------------| | [Architecture](../../skills/architecture/SKILL.md) | Navigating or modifying Memoria code | | [API Reference](../../skills/api-reference/SKILL.md) | Calling or implementing REST endpoints | | [Deployment](../../skills/deployment/SKILL.m …[+385 chars]
  • plugins/clawhub/thememoria/SKILL.md: Install or verify the OpenClaw plugin: `references/setup.md`
  • skills/api-reference/SKILL.md: It does not generate embeddings or run vector, graph, hybrid, temporal, or confidence scoring and is intentionally not exposed as an MCP tool.
  • skills/architecture/SKILL.md: async fn execute(&self, store, task, plan) -> Result<GovernanceExecution>;
  • skills/architecture/SKILL.md: make check # cargo check + clippy -D warnings (MUST pass)
  • skills/architecture/SKILL.md: make test-unit # Unit tests (no DB): memoria-core, memoria-service, memoria-mcp
  • skills/architecture/SKILL.md: make test # All tests (needs MatrixOne, --test-threads=1)
  • skills/architecture/SKILL.md: make test-e2e # API e2e tests only
  • skills/deployment/SKILL.md: docker compose up -d
  • skills/deployment/SKILL.md: Verify: `curl http://localhost:8100/health` · uses the network
  • skills/deployment/SKILL.md: Run behind reverse proxy with TLS in production
  • skills/local-embedding/SKILL.md: make build-local
  • skills/local-embedding/SKILL.md: | Problem | Fix | |---------|-----| | "compiled without local-embedding" | Build from source: `make build-local` | | Model download fails | Set `HF_ENDPOINT` for mirror, or manually download to `~/.cache/fastembed/` | | High memory | Default ~100MB.
  • skills/plugin-development/SKILL.md: "capabilities": ["governance.plan", "governance.execute"],
  • skills/plugin-development/SKILL.md: `capabilities`: must include `governance.plan` and/or `governance.execute`
  • skills/plugin-development/SKILL.md: if ctx["phase"] == "execute" {
  • skills/release/SKILL.md: | Step | Who | How | |------|-----|-----| | Bump version, tag, push | You | `make release VERSION=x.y.z` | | Build binaries (4 platforms) | CI | `release-rust.yml` | | Build + push Docker image | CI | `release-docker.yml` | | Create GitHub Release | CI | `softprops/action-gh-release` |
  • skills/release/SKILL.md: git status # Must be clean
  • skills/release/SKILL.md: make release VERSION=0.2.0
  • skills/release/SKILL.md: make release-rc VERSION=0.2.0-rc1
  • skills/release/SKILL.md: make release-docker # :latest
  • skills/release/SKILL.md: make release-docker VERSION=0.2.0 # :0.2.0 + :latest
  • skills/release/SKILL.md: Both release workflows run full test suite before publishing.
  • skills/release/SKILL.md: [ ] `make release VERSION=x.y.z`
  • skills/setup/SKILL.md: Ask: "Use Memoria Cloud, or run your own instance?"
  • skills/setup/SKILL.md: **Memoria Cloud (recommended)** → sign up at [thememoria.ai](https://thememoria.ai/auth), get API URL + token, then proceed to Step 2 · uses the network
  • skills/setup/SKILL.md: No → run `docker compose up -d` in the Memoria repo root (wait 30-60s for first start)
  • skills/setup/SKILL.md: One-line install (recommended):
  • skills/setup/SKILL.md: Or download manually from [GitHub Releases](https://github.com/matrixorigin/Memoria/releases). · uses the network
  • skills/setup/SKILL.md: Platform-specific manual install:
  • skills/setup/SKILL.md: docker compose up -d # Start MatrixOne
  • skills/setup/SKILL.md: docker ps --filter name=matrixone # Verify (wait 30-60s)
  • skills/setup/SKILL.md: Or run: `memoria status`
  • skills/setup/SKILL.md: | Problem | Fix | |---------|-----| | MatrixOne won't start | `docker logs memoria-matrixone` | | Port 6001 in use | Change `MO_PORT` in `.env` | | Can't connect to DB | Wait 30-60s on first start | | Docker permission denied | `sudo usermod -aG docker $USER && newgrp docker` | | Docke …[+152 chars]
  • skills/setup/SKILL.md: Run `which memoria` to verify CLI installed 2.

Install scripts (5)

  • README.md: curl -sSL https://raw.githubusercontent.com/matrixorigin/Memoria/main/scripts/install.sh | bash · uses the network
  • README.md: curl -sSL https://raw.githubusercontent.com/matrixorigin/Memoria/main/scripts/install.sh | bash · uses the network
  • README.md: command -v memoria >/dev/null || curl -sSL https://raw.githubusercontent.com/matrixorigin/Memoria/main/scripts/install.sh | bash -s -- -y -d ~/.local/bin · uses the network
  • scripts/install.ps1: pwsh scripts/install.ps1 · uses the network
  • scripts/install.sh: sh scripts/install.sh · uses the network
  • Medium risk: runs-install-script-remote-exec (README.md:155)
  • Medium risk: runs-install-script-remote-exec (README.md:175)
  • Medium risk: runs-install-script-remote-exec (README.md:194)
  • Medium risk: runs-install-script-network-variable-host (scripts/install.ps1)
  • Medium risk: network-variable-host (scripts/install.ps1:119)
  • Medium risk: network-variable-host (scripts/install.ps1:125)
  • Medium risk: runs-install-script-network-variable-host (scripts/install.sh)
  • Medium risk: network-variable-host (scripts/install.sh:295)
  • Medium risk: runs-instruction-instruction-network (skills/setup/SKILL.md:14)
  • Medium risk: remote-exec-pipe (skills/setup/SKILL.md:58)
  • Medium risk: runs-instruction-instruction-network (skills/setup/SKILL.md:61)
  • Low risk: scripts-present (scripts/install.ps1)
  • Low risk: scripts-present (scripts/install.sh)
  • Low risk: network-instructions (skills/deployment/SKILL.md:14)
  • Low risk: network-instructions (skills/setup/SKILL.md:58)

Attribution and licence

Created by
Matrix Origin
Publisher
Matrix Origin (Official Matrix Origin project)
Source
matrixorigin/memoria · commit 93ccccf
Licence
Apache License 2.0 (files served here)
  • ATTRIBUTION.md (written by AutoGineer)
Synced

AutoGineer is not affiliated with or endorsed by Matrix Origin.

Install from source

445 of its files are not served here, so there is no ZIP. matrixorigin/memoria at 93ccccf