convez.ai
MCP ServerProdutividadeIntermediário
codedaptive

MOOTx01 Community Edition

codedaptive/mootx01-ce

Memória persistente e local para suas IAs através do MCP

Ver no GitHub
BomPluginScore · de 0 a 100

MCP server que fornece memória de longo prazo persistente para IAs. Armazena decisões, conversas, fatos e relacionamentos em um repositório local que qualquer cliente compatível com Model Context Protocol pode acessar via ARIA. Permite que a IA mantenha contexto entre sessões e mude de ferramenta sem perder conhecimento acumulado.

Instalação

$npx convez-ai codedaptive/mootx01-ce

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
9
Forks
0
Acompanhando
0
Saúde
87%
Último commit
há 1 dia
Versão
v1.1.5
Issues abertas
1
Contribuidores
5

Casos de uso

  • Manter histórico de decisões de projeto entre conversas
  • Recuperar contexto e fatos importantes em novas sessões com diferentes IAs
  • Construir base de conhecimento pessoal vinculado a projetos específicos
  • Reduzir necessidade de re-explicar contexto ao trocar de ferramenta de IA

Veredito

Projeto ambicioso e bem arquitetado que resolve um problema real: perda de contexto entre sessões de IA. Ainda em beta e sem hardening de segurança, mas implementação clara e documentação sólida. Recomendado para early adopters que precisam de persistência de conhecimento em workflows de IA multi-ferramenta.

README

A tradução para o português deste README ainda está na fila.

MOOTx01

Long-term memory for AI.

Observe · Remember · Dream · Convene

The frontier intelligence is rented. The memory is yours.

status platforms ports interface license

What it is

MOOTx01 gives your AI a memory that lasts.

Every AI today has the same basic problem: when the chat ends, the useful context often disappears with it. You start over. You re-explain the same project rules. You re-introduce old decisions. You switch from one AI tool to another and the memory does not come with you.

MOOTx01 stores useful memory in a local estate your AI can read from later. It runs on your machine by default. Any AI client that speaks the Model Context Protocol can connect to it through ARIA, the MOOTx01 memory language.

The model can change. Your memory stays yours.

What it fixes

Your AI has a context window. That is what it can think with right now.

MOOTx01 gives it a memory estate. That is what it can remember from later.

Use MOOTx01 when you want your AI to:

  • remember project decisions,
  • recall prior conversations,
  • keep durable facts and notes,
  • link related ideas,
  • search across sessions,
  • stop asking you to rebuild the past every time.

MOOTx01 is not just a vector database. It stores memory as a substrate: memories, facts, links, journals, trust state, recall indexes, graph structure, reasoning lenses, and background consolidation signals.

In plain English: it keeps what happened, finds what matters, and helps your AI use that memory when it matters.

What it looks like

Install MOOTx01, wire it into your AI client, restart the client, and verify that the tools are visible.

mootx01 install

Then ask your AI to try memory:

Remember that this project ships the importer behind a flag.
Search my MOOT for what we decided about the importer.
Show me the current status of my MOOT estate.

Behind the scenes, the AI uses ARIA tools like these:

// store a memory
moot_file_memory {
  "content": "We ship the importer behind a flag.",
  "location": "project/alpha"
}

// retrieve memory
moot_memory_search {
  "query": "what did we decide about the importer?"
}

Where to go next


Quickstart (1.0.0-beta)

1.0.0-beta — early access. Installable now, not yet security-hardened. The full security sweep precedes the general-availability binary. For early adopters and builders.

1 · Install the binary

Prebuilt, no toolchain, no clone.

macOS / Linux

curl -fsSL https://raw.githubusercontent.com/codedaptive/mootx01-ce/stable/1.0.x/install.sh | sh

Windows (PowerShell)

[Net.ServicePointManager]::SecurityProtocol=[Net.SecurityProtocolType]::Tls12; iex "& { $(irm https://raw.githubusercontent.com/codedaptive/mootx01-ce/stable/1.0.x/install.ps1) }"

Installs to:

~/.mootx01/bin

Re-run to upgrade.

2 · Wire it in

mootx01 install

The installer registers MOOTx01 with supported MCP clients and starts the local services when supported.

By default:

SurfaceAddress
MOOTx01 resident daemonhttp://127.0.0.1:4242
moot-mgr dashboardhttp://127.0.0.1:4200

Both are loopback addresses. They are meant for your own machine, not the public internet. For security they will reject connection from other devices.

3 · Verify it

mootx01 status

If the manager is installed:

moot-mgr status

Open the dashboard:

http://127.0.0.1:4200

If your AI client supports MCP tool discovery, confirm it can see MOOTx01 tools such as:

  • moot_estate_ping
  • moot_estate_status
  • moot_memory_search
  • moot_file_memory

4 · Make the AI use memory automatically

Installing the runtime gives the AI tools. The next step is installing the matching MOOTx01 adapter for your AI client so it knows when to reach for memory.

Adapters live in:

apps/moot-agent-skills/

Start with:

apps/moot-agent-skills/README.md

How it works

MOOTx01 is an SDK of composable kits. GeniusLocusKit composes them into a working estate, the Brain layer prepares memory, and ARIA is the one interface in front of all of it.

Observe / Remember -> LocusKit (spatial memory + knowledge graph)
                      VectorKit (on-device embeddings + ANN / hybrid search)
                      CorpusKit (content-plus-vector RAG bundles)

Dream             -> NeuronKit (hybrid recall, dreaming daemon, Bradley-Terry, SolverBandit)
                     CognitionKit (named, composable behaviour recipes)

Compose / Convene -> GeniusLocusKit (N estates, matrix layer, federation)

Speak             -> ARIA (MCP server + native app surfaces)

The readable map of the whole repository is docs/concepts/TOPOLOGY.md.

For developers

If you are building an application and you want it to have temporal knowledge — memory that survives sessions, links to AI, and participates in the user's life — you can embed MOOTx01 directly.

Most apps do not have a memory substrate because writing one is hard. The math debt is steep. The speed optimization is harder. MOOTx01 ships as a kit family, so your application can gain memory without rebuilding the substrate from scratch.

Your app can use MOOTx01 in three common ways:

  • Sidecar: the app keeps its own store, and a MOOT runs beside it.
  • Embedded: the app links the kits directly.
  • MCP surface: the app exposes or consumes memory through ARIA over MCP.

The interface is ARIA: consistent across implementations, surfaces, and languages. The same vocabulary works whether you embed MOOTx01 as a library, query it through an MCP server, or call it through a native API.

For builders: the kit stack

Behaviour:
    NeuronKit       AI algorithms: reasoning functions plus autonomic daemons
    CognitionKit    Behaviour layer: named, composable workflows

Composition:
    GeniusLocusKit  Unified substrate: LocusKit + CorpusKit + Brain layer; N estates

Standalone substrate:
    LocusKit        Spatial memory system plus knowledge graph
    VectorKit       On-device embeddings plus nearest-neighbour search
    CorpusKit       Content-plus-vector RAG bundles

Grounding:
    EideticLib      Deterministic text-to-anchor (FDC code + Wikidata Q-ID)
    LatticeLib      Frame Decimal Classification: assembler, canon, lookup

Typed math:
    EngramLib       Typed 256-bit Engram API

Foundation:
    SubstrateTypes  Pure substrate types
    SubstrateKernel Hot-path bit ops, write gate, clock
    SubstrateML     Learning + graph algorithms
    SubstrateLib    Orchestration: verbs + row-state automaton
    PersistenceKit  Storage backends: SQLite, PostgreSQL, InMemory
    ConvergenceKit  Sync implementations: CloudKit, Federation, None
    QueueKit        Fill-and-drain job queue
    IntellectusLib  Telemetry floor
    ObserverSink    Telemetry sink + SQLite stats store
    AriaLexiconLib  Reified ARIA grammar
    VaultKit        Encrypted, portable estate export/import

Build status

Two dimensions are tracked:

  • Build means functional with tests green.
  • Security Review means the security, quality-control, and hardening gate.

Security review has not run on any kit yet, so review is pending across the board. Build status reflects functionality only.

KitBuildSecurity Review
AriaLexiconLib · CognitionKit · ConvergenceKit · CorpusKit · EideticLib · EngramLib · GeniusLocusKit · IntellectusLib · LatticeLib · LocusKit · NeuronKit · ObserverSink · PersistenceKit · QueueKit · SubstrateKernel · SubstrateLib · SubstrateML · SubstrateTypes · VaultKit · VectorKitBuilt (Swift + Rust)Pending

Per-kit detail lives in packages/PACKAGES.md and the specs under docs/reference/.

Implementations

Every kit ships in two equal-status implementations, conformance-gated against shared test vectors:

  • Swift — Apple Silicon, macOS 26+, iOS 26+
  • Rust — PC/Linux x86_64 and Linux aarch64

Neither port leads. Both must agree bit for bit.

Roadmap

Intended sequence, not committed dates.

  1. Full security sweep — pending.
  2. Hardened GA binary — follows the security sweep.
  3. Sidecar and embedded examples — reference app patterns.
  4. Federation — bounded cross-estate sharing.
  5. Apple Intelligence integration — native capture and recall across Apple surfaces.

Repository structure

mootx01/
├── packages/
│   ├── libs/     SubstrateTypes · SubstrateKernel · SubstrateML · SubstrateLib · EngramLib
│   │             AriaLexiconLib · LatticeLib · EideticLib · IntellectusLib · ObserverSink · LoopbackHTTP
│   ├── kits/     LocusKit · VectorKit · PersistenceKit · ConvergenceKit · QueueKit
│   │             CorpusKit · GeniusLocusKit · NeuronKit · CognitionKit · VaultKit · AriaMcpKit
│   └── PACKAGES.md
├── apps/         aria-mcp-server (MCP server) · mootx01 (CLI) · moot-mgr (console)
│                 Mootx01-App (Apple app) · moot-math-benchmark · moot-agent-skills
├── examples/     SDK · SidecarDemo · MootNotepad · MootTodo · MootCalendarIngest
└── docs/         start-here · concepts · reference · decisions · engineering · validation · archive

Key documents

DocumentPurpose
ABOUT.mdWhat MOOTx01 is and why — the full story
AI_START_HERE.mdFor an AI assistant: explain MOOTx01 and install it for the user
docs/start-here/END_USER_EXPLAINER.mdPlain-language explainer for a non-technical user
docs/start-here/INSTALL_SURFACE.mdInstall fact sheet: addresses, flow, platform matrix, verification
docs/start-here/SDK_QUICKSTART.mdBuild on the substrate: open an estate, capture → recall (Swift + Rust)
docs/start-here/AI_INSTALL_MANIFEST.jsonMachine-readable install facts for AI agents (commands, ports, verification, adapters)
docs/concepts/TOPOLOGY.mdReadable front door: products, stack, surfaces, sidecar
docs/concepts/MOOTX01_AND_ARIA_CANON.mdDurable definitions of MOOTx01 and ARIA
docs/concepts/ARIA_LEXICON.mdThe ARIA grammar: one noun, nine verbs, four adjectives
docs/reference/GENIUSLOCUS_ARCHITECTURE_SPEC.mdAuthoritative substrate specification
EDITIONS.md · LICENSING.mdOpen core + commercial editions, in plain language

Standards

Swift 6 strict concurrency · zero external Swift dependencies in kits (except sqlite-vec in PersistenceKit-SQLite) · raw SQLite via PersistenceKit, no Core Data · dates as TEXT/ISO8601 · no Bool stored properties on entities (bitmap fields) · Metal for GPU compute on Apple Silicon · every computation deterministic.


MOOTx01 is a Codedaptive project. With thanks to Dennis E. Taylor, author of the Bobiverse — the replicants and their moots showed the shape of what we needed, and why.

Ver o original no GitHub

Bom para

Relacionados