MemoryNode

Inspiration

What it does## 1. Project Story

# MemoryNode

> Give AI a memory it can use, and people a memory they can govern.

## Inspiration

AI agents are becoming better at retaining context, but durable memory creates a trust problem: a model can misunderstand a conversation, preserve an outdated preference, or silently turn a temporary statement into a fact.

We wanted to make agent memory useful without making it unaccountable. MemoryNode is a local-first memory layer where an AI can propose what should be remembered, but a person decides whether it becomes durable memory.

## What it does

MemoryNode turns memory into a governed lifecycle:

```text
content -> pending proposal -> human review -> active memory
                                      |
                           reject / revoke / expire / supersede

A model extracts candidate memories into a pending review queue. The reviewer can inspect the proposed memory, source quote, rationale, confidence, and related-memory hints before approving or rejecting it.

Approved memories can then be searched and explained with their source and audit history. When a memory becomes wrong, stale, or replaced, it can be revoked, expired, or explicitly superseded. Default search excludes revoked, expired, and superseded memories.

This means an agent gets useful long-term context, while people retain the ability to answer: Why is this remembered? Where did it come from? Who approved it? What changed afterward?

How we built it

MemoryNode is a local-first Python package with a FastAPI /v1 lifecycle boundary. SQLite and FTS5 are the local source of truth for sources, proposals, memories, and audit events.

We built:

• A FastAPI API that owns all memory-state transitions
• A Chinese governance console for reviewing proposals and managing memory lifecycle
• Python SDK, CLI, and MCP transports for agent integration
• Qwen/OpenAI-compatible model extraction that creates pending proposals only
• Full auditability from source to proposal, review decision, and later lifecycle events
• CJK-aware search: Chinese partial phrases fall back safely to local content matching, while mixed Chinese-English queries retain FTS5 candidates and ranking

The key architectural rule is deliberate: SDK and MCP clients never write SQLite directly. They go through the same /v1 rules as the console.

Challenges

The hardest part was resisting the obvious shortcut: letting the model write memories directly. It feels convenient, but it makes errors durable and difficult to investigate.

We also had to make lifecycle states meaningful in search, preserve replacement links when memories are superseded, and improve Chinese partial-phrase retrieval without weakening normal FTS5 search behavior. Finally, we made local process management conservative: MemoryNode reuses a verified local API when possible and does not take over unknown processes.

What we learned

We learned that model confidence is evidence, not permission. Good AI memory is not only about retrieval quality; it is about preserving human authority, traceability, and the right to correct the record.

MemoryNode is intentionally not a hosted SaaS, vector database, automatic approval system, or automatic conflict arbiter. Its focus is a small, verifiable loop for trustworthy local agent memory.

## How we built it

## Challenges we ran into

## Accomplishments that we're proud of

## What we learned

## What's next for MemoryNode

Built With

• agent
• alibabacloud
• fastapi
• llm
• mcpserver
• python
• qwen
• react.js
• sqlite
• typescript