AutoGineer
Generated banner for Memoir
Generated logo for Memoir

Memoir

Memory server

First committed by zhangfengcdt

Published in zhangfengcdt/memoir. Publisher page

629 GitHub stars

What it is

Hierarchical Agent Memory with Git-Like Version Control
— the description by zhangfengcdt

AutoGineer overview, from the brain’s own files

Memoir is a memory system designed to replace opaque vector databases with a transparent, versioned, and cryptographically secure storage layer. By utilizing ProllyTrees, it enables hierarchical semantic paths instead of UUIDs, allowing for efficient O(log n) lookups. It addresses common AI memory issues like context contamination and token waste by providing branch, commit, merge, and rollback capabilities. Memoir integrates with various agents through plugins and an MCP server, supporting both keyword-based and LLM-powered semantic search.

How it works

Memory model: Not stated

AutoGineer overview, from the brain’s own files

Memoir organizes memory into a hierarchical structure using semantic paths, such as profile.professional.skills.python. It uses a ProllyTree-based store to manage data, allowing for Git-like operations such as branching and versioning. The system includes a classifier to categorize memories and a search engine for retrieval. It provides a CLI for manual interaction, hooks for automatic memory capture in supported agents, and an MCP server for integration with various AI development tools.

Folders
FolderRoleFiles
.githubagent-config10
docsdocs41
scriptsscripts9
srcsource-code216
teststests53
.agentsfolder1
.claude-pluginfolder1
benchmarksfolder10
packagingfolder3
pluginsfolder187
staticfolder2

The agent writes

Requirements

Runtimes: Python >=3.10

API keys (by name): ANTHROPIC_API_KEY, OPENAI_API_KEY

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Google Antigravity, Kiro, OpenCode, Amp, Roo Code, Cline, JetBrains Junie, Devin (ex-Windsurf)

Set it up

  1. This brain runs code automatically: 7 hooks (claude-code, codex), 2 scripts. Review Makefile, README.md, plugins/claude-code/hooks/hooks.json, plugins/codex/hooks/hooks.json before opening the folder in Claude Code. No step below turns a hook on for you.

    • Makefile: pip install -e .
    • README.md: curl -LsSf https://astral.sh/uv/install.sh | sh
    • plugins/claude-code/hooks/hooks.json: bash ${CLAUDE_PLUGIN_ROOT}/hooks/session-start.sh
    • plugins/claude-code/hooks/hooks.json: bash ${CLAUDE_PLUGIN_ROOT}/hooks/user-prompt-submit.sh
    • plugins/claude-code/hooks/hooks.json: bash ${CLAUDE_PLUGIN_ROOT}/hooks/stop.sh
    • plugins/claude-code/hooks/hooks.json: bash ${CLAUDE_PLUGIN_ROOT}/hooks/session-end.sh
    • plugins/codex/hooks/hooks.json: bash "${PLUGIN_ROOT}/hooks/session-start.sh"
    • plugins/codex/hooks/hooks.json: bash "${PLUGIN_ROOT}/hooks/user-prompt-submit.sh"
    • plugins/codex/hooks/hooks.json: bash "${PLUGIN_ROOT}/hooks/stop.sh"
  2. Not scanned by AutoGineerThe author’s README also describes installing it as a Claude Code plugin marketplace. Read its install section: AutoGineer did not scan that path. https://github.com/zhangfengcdt/memoir/blob/7fd1b3ef704fc554596571d5b9c8b73d7f2b0c5d/README.md#install-a-plugin-for-your-agent
  3. Not scanned by AutoGineerIts dependencies are installed by pip or uv when you run it and were not scanned by AutoGineer (7 declared). https://pypi.org/project/memoir-ai/

  4. First committed by zhangfengcdt. Published in zhangfengcdt/memoir. Licence: Apache License 2.0.

Usage

AutoGineer overview, from the brain’s own files

  • CLI-based memory management
  • Automatic context injection for coding agents
  • Version-controlled memory branching
  • Semantic search across stored facts
  • Cross-machine memory synchronization
“memoir remember "I prefer using Python for data analysis" -p preferences.coding.languages”
Stores the fact under the specified semantic path for later retrieval.
“memoir recall "what are my coding preferences?"”
Performs a semantic search to retrieve the relevant stored memory.

Documentation by zhangfengcdt

Memoir

<div align="center"> <picture> <source media="(prefers-color-scheme: dark)" srcset="https://www.memoir-ai.dev/images/memoir.png"> <source media="(prefers-color-scheme: light)" srcset="https://www.memoir-ai.dev/images/memoir-light.png"> <img src="https://www.memoir-ai.dev/images/memoir.png" alt="Memoir Logo" width="200" height="200"> </picture>

Git for AI Memory

Hierarchical Memory with Git-Like Version Control

</div>

Image: Python Image: License Image: Status Image: Website Image: Docs

<p align="center"> <img src="docs/_static/memoir-demo.gif" alt="Memoir demo" width="900"> </p>

Memoir is a high-performance semantic memory system for AI agents that brings Git-like version control to AI memory management. It replaces opaque vector databases with transparent, versioned, cryptographically secure memory storage using hierarchical semantic paths.

Project page: memoir-ai.dev — full overview, demos, and roadmap.

Why agents need versioned memory

AI memory is a Global Variable anti-pattern. Every production agent hits the same three walls: context contamination, token rent, and memory drift. Memoir brings version control to your agent's mind.

Your agent doesn't respect your git state. Context contamination happens every time you git checkout. Without branch-aware memory, your agent tries to apply experimental refactor patterns to stable production hotfixes.

You're paying "token rent" on a flat file. Using CLAUDE.md or MEMORY.md as a global store is a cache-killer. Every minor memory update invalidates your entire prefix cache, forcing you to pay full price to re-process your entire conversation.

Your agent's memory is code without version control. Today's AI memory — CLAUDE.md, vector stores, scratchpads — is treated like an append-only blob. One bad session poisons every future retrieval. Without memoir blame or memoir checkout, there's no way to audit who taught the agent a rule or revert a hallucination without wiping the whole store.

Key Features

  • Git-like Versioning — Branch, commit, merge, and rollback memories with cryptographic integrity.

  • Semantic Paths — Replace UUID keys with meaningful paths like profile.professional.skills.python.

  • O(log n) Lookups — Fast hierarchical search instead of expensive vector operations.

  • Memory Aggregation — Automatic consolidation of related memories at semantic locations.

  • Clean Architecture — Proper separation of storage, classification, and search layers.

  • Multiple Search Engines — Choose between fast keyword-based or intelligent LLM-powered search.

<!-- ## Multi-agent sessions <p align="center"> <img src="docs/_static/memoir-multi-agent.gif" alt="Multiple agent sessions working with Memoir" width="900"> <br> <em>Multiple agent sessions working with Memoir.</em> </p> -->

Install from PyPI

pip install memoir-ai

The distribution name on PyPI is memoir-ai. The Python import is import memoir and the CLI is memoir.

Install a plugin for your agent

Memoir ships as a plugin for several coding and personal-assistant agents. Expand the one you use:

<details> <summary><b>Claude Code</b></summary>

Inside a Claude Code session, run:

/plugin marketplace add zhangfengcdt/memoir
/plugin install memoir@memoir

No manual pip install needed if you have uv on PATH — the plugin auto-resolves to uvx --from memoir-ai memoir when the bare memoir binary isn't installed. Don't have uv? Install it once with the standard one-liner:

curl -LsSf https://astral.sh/uv/install.sh | sh

That's enough — the plugin handles the rest. It registers hooks for session start, user-prompt-submit, and stop, so your project gets automatic context injection and auto-captured memories. See the Claude Code plugin guide for the full slash-command and hook reference.

</details>

<details> <summary><b>Codex</b></summary>

Memoir's Codex plugin is distributed from this repository's Codex marketplace. In Codex, run /plugins, add the memoir marketplace from zhangfengcdt/memoir, restart Codex if prompted, then choose Memoir Plugins and install memoir.

You can also register the marketplace from the CLI:

codex plugin marketplace add zhangfengcdt/memoir

While developing from a local checkout, use codex plugin marketplace add /absolute/path/to/memoir instead. The repo marketplace lives at .agents/plugins/marketplace.json and points Codex at ./plugins/codex, relative to the repository root.

No manual pip install needed if you have uv on PATH — the Codex plugin resolves the Memoir CLI the same way the Claude Code plugin does: memoir on PATH first, then uvx --from memoir-ai==<pinned> memoir, then uv tool run --from memoir-ai==<pinned> memoir.

Enable Codex hooks with [features].hooks = true in ~/.codex/config.toml or pass --enable hooks for a smoke run. The Codex plugin ships lifecycle hooks; memory-recall, memoir-onboard, memoir-remember, memoir-status, and memoir-ui skills; Codex-specific transcript parsing; and local marketplace metadata. See the Codex plugin guide for setup, limitations, and the real Codex smoke-test flow.

</details>

<details> <summary><b>Hermes</b></summary>

Memoir is a memory provider for Hermes, the Nous Research personal-assistant agent. Install the plugin into your Hermes home and activate it:

hermes plugins install zhangfengcdt/memoir/plugins/hermes   # or: cp -r plugins/hermes ~/.hermes/plugins/memoir
hermes memory setup                                         # choose "memoir"

Hermes then auto-captures durable facts (people, schedule, preferences, standing instructions) each turn and exposes memoir_recall / memoir_remember / memoir_forget / memoir_sync / memoir_status tools. Capture/classification run on your host-selected model via direct provider APIs (never the claude CLI). See the Hermes plugin guide for install, configuration, model selection, and proxy routing.

</details>

<details> <summary><b>OpenClaw</b> (community)</summary>

Memoir is a memory plugin for OpenClaw, the personal-assistant gateway. It lives in its own repo, zhangfengcdt/openclaw-memoir. Install it into the memory slot, allow conversation access, and restart the gateway:

openclaw plugins install https://github.com/zhangfengcdt/openclaw-memoir   # or: --link /path/to/openclaw-memoir
openclaw config set plugins.entries.memory-memoir.hooks.allowConversationAccess true
systemctl --user restart openclaw-gateway

OpenClaw then auto-captures durable facts each turn (remembered across your sessions by default) and exposes memoir_recall / memoir_remember / memoir_forget / memoir_status tools plus an in-chat /memoir command. Set a capture model + provider key in config — plugins.entries.memory-memoir.config.{model,apiKey} (OpenClaw keeps its own keys in a secret store; use a temperature=0-capable model like anthropic/claude-haiku-4-5). See the OpenClaw plugin guide for configuration, scoping, model selection, and tool-profile notes.

</details>

<details> <summary><b>OpenCode</b> (community)</summary>

opencode-memoir is a community-maintained plugin that brings Memoir's long-term memory workflows to OpenCode through its native plugin system. Follow the install instructions in that repository.

</details>

<details> <summary><b>Any MCP host</b> (Claude Desktop, Cursor, Cline, Windsurf, VS Code, Zed, …)</summary>

Memoir ships an MCP server (memoir-mcp) on the official Model Context Protocol SDK, so any MCP-compatible host gets git-versioned memory — including the memoir_branches / memoir_checkout / memoir_commits versioning tools no other memory server has. No install needed if you have uv; add to your host's mcpServers config:

{
  "mcpServers": {
    "memoir": {
      "command": "uvx",
      "args": ["--from", "memoir-ai[mcp]", "memoir-mcp"],
      "env": { "MEMOIR_STORE": "~/.memoir/mcp" }
    }
  }
}

Recall is LLM-free by default (keyless), with opt-in single-call or multi-level tiered LLM modes; the store auto-creates on first use. See the MCP server guide for per-host config (VS Code/Zed/Continue/LibreChat differ slightly), recall modes + LLM setup, remote HTTP for ChatGPT/Claude.ai connectors, and the one-click Claude Desktop .mcpb.

</details>

Quick look

Memoir's CLI defaults to Anthropic claude-haiku-4-5 as of v0.1.6 — set your key first:

export ANTHROPIC_API_KEY="sk-..."

Note that if you do not set any model api keys, it will try to use the claude -p command to authenticate via claude code's subscription.

Then create a store and round-trip a memory:

# 1. Create a memoir store
memoir new my-memoir-store
cd my-memoir-store

# 2. Store with an explicit path (offline, no LLM call)
memoir remember "Sarah prefers tabs and 2-space indents" -p preferences.coding.style

# 3. Store with auto-classification (LLM picks the path; needs API key)
memoir remember "I work in Pacific time"

# 4. Read back by path (offline)
memoir get preferences.coding.style

# 5. Semantic search (LLM-backed)
memoir recall "what does Sarah prefer?"

# 6. Watch a file by indexing it on the fly
memoir watch add ~/papers/transformer.pdf -n research

# 7. Search the indexed content
memoir search "transformer attention mechanism"

# 8. Open the visual explorer (auto-opens in your browser)
memoir ui

Curious what the UI looks like before installing? Browse the UI Gallery.

Prefer a different model? memoir recall "..." --model gpt-4o-mini (needs OPENAI_API_KEY), or set MEMOIR_LLM_MODEL in your shell. Resolution order: --model flag → MEMOIR_LLM_MODEL → claude-haiku-4-5.

See the full Quickstart for the Python API and version-control workflow.

Documentation

Full docs live at zhangfengcdt.github.io/memoir:

  • Quickstart — five-minute tour of the core loop.

  • CLI Reference — every command, flag, and exit code.

  • UI — the visual explorer (Tree / Graph / Timeline / Places + /stats).

  • Claude Code — plugin install, slash commands, hooks, lifecycle.

  • Codex — plugin install, hooks, skills, transcript parsing, smoke-test evidence.

  • Architecture — taxonomy, classifier, store, search.

  • API Reference — Python SDK.

  • Examples — context branching, memory debugging, reproducible testing.

Contributing

Memoir is alpha and contributions are very welcome — especially from people building coding agents, since that's the audience we're optimizing for. Good first paths in:

  • Pick an issue from the issue tracker or open one describing a gap.

  • Fork the repo, branch off main, and run make ci before opening a PR (lint, tests, docs build must be green).

  • Bug reports with a minimal reproducer and benchmark / taxonomy proposals for coding-agent use cases are particularly appreciated.

License

Apache License 2.0 — see LICENSE.

docs/faq.md

Frequently Asked Questions

This section answers common questions about Memoir's capabilities, use cases, and implementation details.

!!! note "About the code samples" Code snippets in this FAQ use the MemoryClient SDK surface — memory.remember(...), memory.recall(...), memory.forget(...) for content operations, and memory.branch.create/checkout/merge/delete(...) for git-style operations. Every example assumes memory = MemoryClient("/path/to/store") is in scope. Equivalent operations are available via the memoir CLI (memoir remember, memoir branch, memoir checkout, memoir merge, memoir time-travel).

AI Agent Development & Debugging

Q: With the branching and time-travel features for AI agent memory, would it help vibe coding tools (such as Claude Code) to debug and fix agent bugs or issues more efficiently?

A: Absolutely! Memoir's branching and time-travel features would be incredibly powerful for debugging Claude Code and other AI coding tools. Here's why:

Current AI Agent Debugging Problems:

Traditional AI agents (including coding tools) suffer from:

  • Opaque decision-making: No visibility into what memories influenced a bad code suggestion

  • Irreversible corruption: Once the agent "learns" something wrong, it's hard to undo

  • No historical context: Can't see how the agent's understanding evolved over time

  • Contaminated memory: Previous interactions pollute future ones

How Memoir Transforms AI Coding Tool Debugging:

  1. Time-Travel Debugging for Code Decisions

    # Agent makes a bad code suggestion
agent.suggest_code("implement authentication")  # Returns broken OAuth code

# Debug: Jump back to see what memories influenced this decision
memory.branch.checkout("before_oauth_confusion")
memories = await memory.recall("authentication patterns")
# See exactly which memories led to the bad suggestion

# Fix: Remove the corrupted memory and add correct one
memory.branch.checkout("main")
await memory.forget("oauth.broken_pattern")
await memory.remember("OAuth 2.0 requires proper state validation")

  2. Branch-Based Hypothesis Testing

    # User reports: "Claude Code keeps suggesting React instead of Vue"
# Create debugging branch to investigate without affecting main agent
memory.branch.create("debug_react_bias")

# Test hypothesis: Is there a React bias in the codebase memory?
react_memories = await memory.recall("frontend framework")
# Discover: Agent learned from React-heavy repositories

# Fix in isolation, then merge back
await memory.remember("User prefers Vue.js for this project")
memory.branch.checkout("main")
memory.branch.merge("debug_react_bias")

  3. Reproducible Bug Reports

    # User: "Claude Code suggested wrong import on line 42"
# Instead of: "Can you reproduce this?"
# You get: exact memory state snapshot (a branch acts as a named bookmark)
memory.branch.create("bug_report_line_42")

# Developer can instantly reproduce:
memory.branch.checkout("bug_report_line_42")
suggestion = agent.suggest_import("pandas")  # Gets same wrong result
# Fix and verify fix works

Benefits for Claude Code Development:

  • Faster Bug Resolution: Jump directly to problematic memory states

  • Better User Experience: Isolate user-specific learning without cross-contamination

  • Safer Experimentation: Test new features in branches before deployment

  • Detailed Analytics: Track exactly how agent behavior changes over time

  • Reproducible Issues: Users can share exact memory state snapshots

  • Quality Assurance: Compare agent performance across different memory configurations

Q: I've been using Claude Code to debug my text classification agent that relies on agent memory. When Claude Code finds an issue, I have to rebuild all memories from scratch (very time-consuming) or write specific test files. Would Memoir's time-travel help make this more efficient?

A: Absolutely YES! This is a perfect example of where Memoir's time-travel debugging would be transformative. Your current workflow pain points would be completely eliminated:

Current Pain Points (Without Memoir):

# Current workflow when Claude Code finds a classification bug:
1. Agent classifies "I love Python programming" → wrong path: "personal.hobbies.python"
2. Claude Code identifies the issue
3. Must rebuild ALL memories from scratch (hours of work)
4. Or write complex test cases that may miss edge cases
5. Hard to reproduce exact memory state that caused the bug
6. Risk breaking other correctly working classifications

With Memoir: Instant Time-Travel Debugging:

# Memoir-powered workflow:
1. Agent classifies incorrectly → bug detected
2. Claude Code: "Let me time-travel to debug this..."

# INSTANT time-travel - no rebuilding needed!
memory.branch.checkout("before_classification_bug")

# Claude Code can now:
# - See EXACT memory state when bug occurred
# - Test different classification approaches in branches
# - Compare memory states across timeline
# - Fix without affecting production memories

# Create debugging branch
memory.branch.create("debug_python_classification")

# Test fixes in isolation
await memory.remember(
    "Python programming is a professional skill",
    namespace="profile.professional.skills.python"
)

# Verify fix works, then merge back
if classification_test_passes():
    memory.branch.merge("debug_python_classification")

Specific Benefits for Classification Agent Debugging:

  1. Instant State Reproduction

    # Instead of rebuilding everything:
rebuild_all_memories()  # Hours of work
create_test_fixtures()  # May miss real-world complexity

# Memoir approach:
memory.branch.checkout("bug_occurrence_timestamp")  # <1ms
# Exact same memory state instantly available

  2. Safe Experimentation

    # Claude Code can test multiple hypotheses simultaneously:
memory.branch.create("hypothesis_1_context_window")
memory.branch.create("hypothesis_2_classification_threshold")
memory.branch.create("hypothesis_3_memory_aggregation")

# Test each hypothesis without affecting others
# Keep the one that works, discard the rest

  3. Pinpoint Root Cause Analysis

    # Binary search through memory timeline to find exact corruption point
memory.branch.checkout("1_hour_ago")      # Classifications working?
memory.branch.checkout("30_minutes_ago")  # Still working?
memory.branch.checkout("15_minutes_ago")  # Found the bug!

# Now Claude Code knows EXACTLY when/why classification broke

Real-World Example: Classification Bug Fix

# Scenario: Agent incorrectly classifies "I love Python programming"

# 1. Instant time-travel to bug occurrence
memory.branch.checkout("classification_bug_2024_01_15_14_30")

# 2. Claude Code analyzes: "I see the issue!"
bug_analysis = await memory.recall("programming AND personal")
# Finds conflicting memories:
# - "programming is hobby" (personal.hobbies.programming)
# - "Python for work" (profile.professional.skills.python)

# 3. Create fix branch and test solution
memory.branch.create("fix_programming_context")

# 4. Claude Code applies nuanced fix:
await memory.remember(
    "Context: 'I love X programming' indicates professional skill when discussing career",
    namespace="classification.rules.programming_context"
)

# 5. Test fix immediately on same memory state
test_result = agent.classify("I love Python programming")
assert test_result.path == "profile.professional.skills.python"  # Fixed!

# 6. Validate doesn't break other classifications
# 7. Merge fix to main - total time: minutes instead of hours!

Claude Code Enhanced Debugging Workflow:

class ClaudeCodeWithMemoir:
    async def debug_classification_issue(self, problematic_input: str):
        # 1. Bookmark current state before debugging (branches act as snapshots)
        checkpoint = f"debug_session_{int(time.time())}"
        self.memory.branch.create(checkpoint)

        # 2. Time-travel to find when classification first broke
        bug_timeline = await self._binary_search_bug_timeline(problematic_input)

        # 3. Create debugging branch for safe experimentation
        debug_branch = f"fix_{hash(problematic_input)}"
        self.memory.branch.create(debug_branch)

        # 4. Checkout the bug-era commit and analyze memory state
        self.memory.branch.checkout(bug_timeline.bug_commit)
        bug_memories = await self.memory.recall("classification patterns")

        # 5. Generate and test multiple fix hypotheses
        fix_candidates = await self._generate_fix_hypotheses(
            problematic_input, bug_memories
        )

        for fix in fix_candidates:
            # Test fix in isolated sub-branch
            fix_branch = f"{debug_branch}_fix_{fix.id}"
            self.memory.branch.create(fix_branch)

            # Apply fix
            await self._apply_classification_fix(fix)

            # Validate fix works and doesn't break existing
            if await self._validate_fix_comprehensive(fix):
                # Keep this fix
                self.memory.branch.merge(fix_branch)
                break
            else:
                # Discard this fix attempt
                self.memory.branch.delete(fix_branch)

        # 6. Deploy validated fix to main timeline
        self.memory.branch.checkout("main")
        self.memory.branch.merge(debug_branch)

        return f"Fixed classification bug in {len(fix_candidates)} attempts"

Efficiency Comparison:

Current ApproachWith Memoir Time-Travel
Rebuild all memories (hours)Instant state reproduction (<1ms)
Write complex test fixturesUse real memory state
Risk breaking working codeSafe branch experimentation
Hard to reproduce exact bugExact timeline reproduction
One-shot fix attemptsMultiple hypothesis testing
Manual memory inspectionAutomated timeline analysis

Result: Instead of hours of rebuilding memories and writing test cases, you get instant time-travel debugging with safe experimentation - perfect for complex memory-dependent agent classification issues!

Performance & Scalability

Q: How does Memoir compare to traditional vector databases in terms of performance?

A: Memoir provides significant performance improvements:

Performance Comparison:

OperationTraditional Vector DBMemoir (Git-like)Improvement
Search 100 memories150-750ms0.1-1ms150-750x faster
Store memory200-600ms20-30ms7-30x faster
Time-travel debugNot supported<1msImpossible → Instant
Branch explorationNot supported<1msImpossible → Instant

The key advantages come from:

  • O(log n) hierarchical lookups instead of O(n) vector similarity searches

  • Semantic paths that enable direct access instead of expensive embeddings

  • Structural sharing in the underlying ProllyTree for efficient storage

  • No vector computations during retrieval operations

Q: Can Memoir handle large-scale production deployments with thousands of users?

A: Yes! Memoir is designed for production scale:

  • Isolated Namespaces: Each user gets their own memory namespace with no cross-contamination

  • Git-like Efficiency: Structural sharing means similar memories don't duplicate storage

  • Configurable Cache: Adjustable cache sizes (default 10,000 items) for memory/performance trade-offs

  • Concurrent Access: Multiple agents can read/write simultaneously with proper locking

  • Horizontal Scaling: Deploy multiple Memoir instances with different user shards

For very large deployments, consider:

  • Partitioning users across multiple Memoir instances

  • Using read replicas for search-heavy workloads

  • Implementing periodic cleanup of old memory versions

Memory Management & Classification

Q: How does automatic memory classification work, and can I customize it?

A: Memoir provides flexible classification through multiple strategies:

Built-in Classification Options:

  1. Fast Pattern Matching (1-5ms): Keyword-based classification using predefined patterns

  2. LLM Classification (500-2000ms): GPT-4 or Claude for intelligent content analysis

  3. Hybrid Approach: Fast patterns for common cases, LLM for complex content

Customization Options:

# Option 1: Custom taxonomy via markdown data sources
from memoir.taxonomy.loader import TaxonomyLoader
from memoir.taxonomy.markdown_source import MarkdownTaxonomyDataSource

loader = TaxonomyLoader(store=store)
loader.load_from_source(MarkdownTaxonomyDataSource("/path/to/medical_taxonomy.md"))

# Option 2: Custom classification thresholds
classifier = IntelligentClassifier(
    llm=llm,
    confidence_thresholds={
        "high": 0.9,    # Use LLM for uncertain cases
        "medium": 0.7,  # Use pattern matching
        "low": 0.0      # Accept any classification
    }
)

# Option 3: Manual classification (bypass the classifier by choosing the path yourself)
await memory.remember(
    "Patient has type 2 diabetes",
    namespace="medical.conditions.diabetes.type2",  # Manual path
)

Q: What happens when memory classification is wrong?

A: Memoir provides several correction mechanisms:

# 1. Time-travel to find the misclassification
memory.branch.checkout("before_wrong_classification")

# 2. Move memory to correct location (delete + re-store under the right path)
await memory.forget("profile.hobbies.programming")
await memory.remember(
    "Python programming",
    namespace="profile.professional.skills.python",
)

# 3. Bookmark the fix as a branch for future reference
memory.branch.checkout("main")
memory.branch.create("classification_fix_v1")

Versioning & Git Integration

Q: How does Memoir's Git-like versioning actually work under the hood?

A: Memoir uses a combination of Git and ProllyTree for versioning:

Storage Layer:

  • ProllyTree: Provides content-addressed storage with structural sharing

  • Git Repository: Tracks commit history, branches, and metadata

  • Cryptographic Hashing: Ensures data integrity using SHA-256

Operations:

# Each memory operation can create a commit
store = ProllyTreeStore(auto_commit=True)  # Default behavior
store.put(namespace, key, value)  # Creates git commit automatically

# Or batch operations for cleaner history
store = ProllyTreeStore(auto_commit=False)
store.put(namespace, key1, value1)  # No commit
store.put(namespace, key2, value2)  # No commit
store.commit("Batch update with user preferences")  # Single commit

Branch Operations:

  • Branches: Git branches with ProllyTree state snapshots

  • Merging: Intelligent merging of memory states

  • Time-travel: Checkout any commit to see historical memory state

Q: Can I use standard Git tools to inspect Memoir's version history?

A: Yes! The underlying Git repository is fully compatible with standard Git tools:

# Navigate to your Memoir store directory
cd ./memory_store

# Use standard Git commands
git log --oneline                    # View commit history
git branch -a                        # List all branches
git diff HEAD~1                      # Compare with previous commit
git show <commit-hash>               # Inspect specific commit

# View memory evolution over time
git log --follow data/namespace_key  # Follow specific memory path

!!! warning While you can inspect with Git tools, avoid making direct Git commits or modifications. Always use Memoir's API to maintain data consistency.

Integration & Compatibility

Q: Can I migrate from an existing vector database to Memoir?

A: Yes — there is no built-in migration tool, but the pattern is straightforward: pull records out of the source store, then replay them through Memoir's remember() API so the classifier can place each record on a semantic path.

Migration pattern:

from memoir.sdk import MemoryClient

# 1. Extract records from the source vector DB with whatever client it exposes
records = source_client.query(top_k=10_000)  # e.g. Pinecone, Weaviate, Qdrant

# 2. Replay each record through Memoir — the classifier picks the semantic path
async with MemoryClient("./memoir_store") as memory:
    for rec in records:
        await memory.remember(
            rec["text"],
            namespace=f"user_{rec['metadata']['user_id']}",
        )

# 3. Spot-check by recalling a few known queries
result = await memory.recall("sample query", namespace="user_123")

Compatibility Notes:

  • Semantic paths replace vector embeddings for much faster retrieval

  • Memory aggregation may change how related memories are stored

  • Version history starts fresh (no historical versions from the source DB)

  • Performance improvement typically 10-100x faster after migration

Q: Can I use Memoir with frameworks other than LangGraph/LangChain?

A: Absolutely! Memoir is designed to be framework-agnostic:

Direct API Usage:

# Use Memoir with any Python framework
from memoir.store.prolly_adapter import ProllyTreeStore
from memoir.classifier.intelligent import IntelligentClassifier

# Initialize with your preferred LLM client
import openai  # or anthropic, cohere, etc.

# Custom LLM wrapper for your framework
class CustomLLMWrapper:
    def __init__(self, client):
        self.client = client

    async def ainvoke(self, prompt):
        response = await self.client.chat.completions.create(
            model="gpt-4",
            messages=[{"role": "user", "content": prompt}]
        )
        return response.choices[0].message.content

# Use with Memoir
llm = CustomLLMWrapper(openai.AsyncOpenAI())
classifier = IntelligentClassifier(llm=llm)

Framework Integrations:

  • AutoGen: Use Memoir as memory backend for multi-agent conversations

  • CrewAI: Store agent memories and learnings across missions

  • Semantic Kernel: Replace built-in memory with Memoir's versioned storage

  • Custom Agents: Direct integration with ProllyTreeStore interface

Q: Does Memoir work with local/offline LLMs?

A: Yes! Memoir supports any LLM that implements the LangChain BaseLanguageModel interface:

# Example with local Ollama
from langchain_community.llms import Ollama

local_llm = Ollama(model="llama3")
classifier = IntelligentClassifier(llm=local_llm)

# Example with Hugging Face Transformers
from langchain_community.llms import HuggingFacePipeline

hf_llm = HuggingFacePipeline.from_model_id(
    model_id="microsoft/DialoGPT-medium",
    task="text-generation",
)

Offline Benefits:

  • No API costs for classification

  • Data privacy - all processing happens locally

  • No network dependency for memory operations

Troubleshooting & Common Issues

Q: My agent's memory seems corrupted. How do I debug and fix it?

A: Use Memoir's time-travel debugging capabilities:

# 1. Identify the problem timeline
memory.branch.checkout("main")
current_memories = (await memory.recall("problematic topic")).memories

# 2. Binary search through history to find corruption point
memory.branch.checkout("yesterday")  # Known good commit / branch
yesterday_memories = (await memory.recall("problematic topic")).memories

# 3. Compare memory states
for current, past in zip(current_memories, yesterday_memories):
    if current.content != past.content:
        print(f"Memory changed: {current.key}")
        print(f"Before: {past.content}")
        print(f"After: {current.content}")

# 4. Fix by reverting or correcting
memory.branch.checkout("main")
await memory.forget("corrupted.memory.key")
await memory.remember("Corrected memory content", namespace="fixed.memory.key")

Q: Memoir is running slower than expected. How do I optimize performance?

A: Several optimization strategies:

1. Tune Cache Settings:

# Increase cache size for memory-rich environments
store = ProllyTreeStore(
    path="./memory_store",
    cache_size=50000,  # Default is 10,000
)

2. Use Batch Operations:

# Instead of many individual commits
store.auto_commit = False
for memory in batch_memories:
    store.put(namespace, memory.key, memory.data)
store.commit("Batch import of 100 memories")  # Single commit

3. Choose Right Search Engine:

# Use intelligent search for memory retrieval
from memoir.search.intelligent import IntelligentSearchEngine
search_engine = IntelligentSearchEngine(llm=llm, store=store)

4. Monitor Performance:

# Get performance metrics from the low-level manager
# (requires the `langmem` extra: pip install memoir-ai[langmem])
from memoir import ProllyTreeMemoryStoreManager

stats = memory_manager.get_performance_metrics()
print(f"Average search time: {stats['avg_search_ms']}ms")
print(f"Classification time: {stats['avg_classification_ms']}ms")

Q: How do I backup and restore Memoir data?

A: Multiple backup strategies available:

1. Git-based Backup:

# Memoir stores are Git repositories
cd /path/to/memory_store
git remote add backup user@backup-server:/memoir/backups/
git push backup --all    # Backup all branches
git push backup --tags   # Backup all snapshots

2. Export + replay:

# Export a specific namespace to JSON
store.export_namespace("user123", "/backup/user123_memories.json")

# Replay the export into a fresh store via the SDK (no import helper yet —
# iterate the exported records and re-remember each one).
import json
from memoir.sdk import MemoryClient

with open("/backup/user123_memories.json") as f:
    records = json.load(f)

async with MemoryClient("/new/location") as memory:
    for rec in records:
        await memory.remember(rec["content"], namespace=rec["namespace"])

3. File System Backup:

# Simple file copy (ensure store is not actively writing)
rsync -av /path/to/memory_store/ /backup/location/

Restore Process:

# Restore from Git backup
# git clone user@backup-server:/memoir/backups/memory_store ./restored_store

# Initialize Memoir with restored data
store = ProllyTreeStore("./restored_store")
# All branches, commits, and snapshots are preserved
512 files · 489 not served here

Advantages

  • Provides Git-like version control for AI memory, allowing for branching, merging, and rolling back. evidence: README.md
  • Uses hierarchical semantic paths for O(log n) lookups, offering better performance than traditional vector databases. evidence: README.md

Limitations

  • Requires an API key for LLM-powered features like intelligent classification and semantic search. evidence: README.md
  • Some advanced features like document watching require additional dependencies or manual configuration. evidence: pyproject.toml

Security

Risk level: Medium risk

This brain runs

Git hooks (5)

  • .pre-commit-config.yaml: pre-commit hooks from https://github.com/pre-commit/pre-commit-hooks at v6.0.0 (contributor tooling: runs only after pre-commit install) · uses the network
  • .pre-commit-config.yaml: pre-commit hooks from https://github.com/pycqa/isort at 6.0.1 (contributor tooling: runs only after pre-commit install) · uses the network
  • .pre-commit-config.yaml: pre-commit hooks from https://github.com/astral-sh/ruff-pre-commit at v0.12.9 (contributor tooling: runs only after pre-commit install) · uses the network
  • .pre-commit-config.yaml: pre-commit hooks from https://github.com/PyCQA/bandit at 1.8.6 (contributor tooling: runs only after pre-commit install) · uses the network
  • .pre-commit-config.yaml: pytest

Agent instructions that run or fetch something (73)

  • CLAUDE.md: `make ci` runs the full pipeline (lint, test, security, docs).
  • CLAUDE.md: tests use the fake gateway in `tests/fake_cloud.py` (real `git http-backend`, no network).
  • CLAUDE.md: When touching the mod run `claude plugin validate plugins/claude-code` and `claude plugin test plugins/claude-code`;
  • CLAUDE.md: Run with `pytest`.
  • CLAUDE.md: Deep structural details (layouts, refactor history, per-file line counts) intentionally omitted — use `rg` / `git log` when you need them.
  • CLAUDE.md: flipping it later (`git init`, or `rm -rf .git`) surfaces a warning at SessionStart but does not block writes.
  • CLAUDE.md: When changing a prompt, **run the harness against haiku before merging**.
  • CLAUDE.md: The harness has two modes: **gate** (deterministic shell-hook tests, no LLM, sub-second per case — pins the recall-trigger gate in `hooks/user-prompt-submit.sh`) and **LLM mode** (`run` / `case` / `adhoc` against `claude -p` for prompt templates).
  • CLAUDE.md: # Gate mode — no LLM cost, run on every commit.
  • CLAUDE.md: plugins/claude-code/tests/prompt-harness/runner.py run --prompt stop_capture --model haiku
  • CLAUDE.md: plugins/claude-code/tests/prompt-harness/runner.py run --prompt stop_capture --model sonnet
  • CLAUDE.md: Every run drops `system.txt` (the assembled prompt actually sent), `input.txt`, `output.txt`, `command.sh` (replayable), and `result.json` per case under `/tmp/memoir-prompt-tests/<UTC-timestamp>/`.
  • CLAUDE.md: Skill prompts (`skills/<name>/SKILL.md`) are evaluated by the orchestrating Claude rather than dispatched as system prompts to a model, so they are *not* covered by this harness — to test those, run the slash command in a real session and inspect behavior.
  • CLAUDE.md: **Build the docs locally:** `make docs` (mkdocs) → `site/index.html`, or `make docs-live` for auto-reload.
  • plugins/claude-code/skills/memoir-onboard/SKILL.md: bash -c 'source "${CLAUDE_PLUGIN_ROOT}/hooks/common.sh" >/dev/null 2>&1; in_git_repo && echo codebase:onboard || echo project:onboard'
  • plugins/claude-code/skills/memoir-onboard/SKILL.md: Store: !`bash -c 'if [ -n "${MEMOIR_STORE:-}" ];
  • plugins/claude-code/skills/memoir-onboard/SKILL.md: `$MEMOIR` is a wrapper that resolves the right invocation for this machine — `memoir` on PATH if installed, otherwise `uvx --from memoir-ai==<pin> memoir`, otherwise `uv tool run --from memoir-ai==<pin> memoir` (pin lives in `scripts/resolve-memoir-cli.sh`).
  • plugins/claude-code/skills/memoir-onboard/SKILL.md: Wrap **every** memoir call — both branches A and B, both reads and writes — in a subshell that cd's into the store first, and use `"$MEMOIR"` (NOT bare `memoir`) so the call works on machines without a global memoir install:
  • plugins/claude-code/skills/memoir-onboard/SKILL.md: `test.strategy` — test layout, how to run tests, what coverage emphasizes.
  • plugins/claude-code/skills/memoir-onboard/SKILL.md: bash -c 'source "${CLAUDE_PLUGIN_ROOT}/hooks/common.sh" >/dev/null 2>&1; concurrent_session_warning'
  • plugins/claude-code/skills/memoir-onboard/SKILL.md: If the command prints anything, stop and report: "Concurrent session detected — run /memoir:onboard after the other session finishes, or set a distinct MEMOIR_STORE."
  • plugins/claude-code/skills/memoir-onboard/SKILL.md: `git log --oneline -20` and `git log --stat -5` for recent change patterns (informs lessons / rules).
  • plugins/claude-code/skills/memoir-onboard/SKILL.md: Run `git log --stat <last_sha>..HEAD` to enumerate changed paths since the last onboarding pass.
  • plugins/claude-code/skills/memoir-onboard/SKILL.md: Run the confirmation check (`memoir status` → path == `$STORE_PATH`) before doing any writes.
  • plugins/claude-code/skills/memoir-onboard/SKILL.md: `python3 ${CLAUDE_PLUGIN_ROOT}/skills/memoir-onboard/extractors.py walk <root>` — JSON list of `{path, size, mtime_ns, kind}` plus `snapshot_hash`.
  • plugins/claude-code/skills/memoir-onboard/SKILL.md: `python3 ${CLAUDE_PLUGIN_ROOT}/skills/memoir-onboard/extractors.py extract <path>` — `key=value` blob for one file (with `kind=` first, `extractor.stdlib.fields=[…]` for provenance).
  • plugins/claude-code/skills/memoir-onboard/SKILL.md: `python3 ${CLAUDE_PLUGIN_ROOT}/skills/memoir-onboard/extractors.py snapshot-hash <root>` — just the hash.
  • plugins/claude-code/skills/memoir-onboard/SKILL.md: `python3 ${CLAUDE_PLUGIN_ROOT}/skills/memoir-onboard/extractors.py tree <root>` — pruned tree.
  • plugins/claude-code/skills/memoir-onboard/SKILL.md: `python3 ${CLAUDE_PLUGIN_ROOT}/skills/memoir-onboard/extractors.py shape <root>` — `{shape, overview}` JSON.
  • plugins/claude-code/skills/memoir-onboard/SKILL.md: bash -c 'source "${CLAUDE_PLUGIN_ROOT}/hooks/common.sh" >/dev/null 2>&1; concurrent_session_warning'
  • plugins/claude-code/skills/memoir-onboard/SKILL.md: For each file in the walk result, run `extractors.py extract <path>` and capture the structured blob.
  • plugins/claude-code/skills/memoir-onboard/SKILL.md: python3 -c "import json,sys; print('\n'.join(e['path'] for e in json.loads(sys.argv[1])['files']))" "$WALK_JSON" \
  • plugins/claude-code/skills/memoir-onboard/SKILL.md: **added** (in walk, not in store) → run `extract <path>`, write `files.<san>.meta` and `files.<san>.summary`.
  • plugins/claude-code/skills/memoir-onboard/SKILL.md: **modified** (same path, different `(size, mtime_ns)`) → re-run `extract <path>`, write both keys.
  • plugins/claude-code/skills/memoir-onboard/SKILL.md: If a cold run fails partway through, the `_meta.*` keys act as commit markers.
  • plugins/claude-code/skills/memory-recall/SKILL.md: Run this preamble first and reuse `$STORE` and `$MEMOIR` for every memoir invocation below:
  • plugins/claude-code/skills/memory-recall/SKILL.md: `$MEMOIR` is a wrapper that resolves the right invocation for this machine — `memoir` on PATH if installed, otherwise `uvx --from memoir-ai==<pin> memoir`, otherwise `uv tool run --from memoir-ai==<pin> memoir` (pin lives in `scripts/resolve-memoir-cli.sh`).
  • plugins/claude-code/skills/memory-recall/SKILL.md: that way recall works on machines where memoir isn't `pip install`ed but `uv` is.
  • plugins/codex/skills/memoir-onboard/SKILL.md: bash -c 'source "${PLUGIN_ROOT}/hooks/common.sh" >/dev/null 2>&1; in_git_repo && echo codebase:onboard || echo project:onboard'
  • plugins/codex/skills/memoir-onboard/SKILL.md: Store: !`bash -c 'if [ -n "${MEMOIR_STORE:-}" ];
  • plugins/codex/skills/memoir-onboard/SKILL.md: python3 - "$manifest" <<'PY'
  • plugins/codex/skills/memoir-onboard/SKILL.md: `$MEMOIR` is a wrapper that resolves the right invocation for this machine — `memoir` on PATH if installed, otherwise `uvx --from memoir-ai==<pin> memoir`, otherwise `uv tool run --from memoir-ai==<pin> memoir` (pin lives in `scripts/resolve-memoir-cli.sh`).
  • plugins/codex/skills/memoir-onboard/SKILL.md: Wrap **every** memoir call — both branches A and B, both reads and writes — in a subshell that cd's into the store first, and use `"$MEMOIR"` (NOT bare `memoir`) so the call works on machines without a global memoir install:
  • plugins/codex/skills/memoir-onboard/SKILL.md: `test.strategy` — test layout, how to run tests, what coverage emphasizes.
  • plugins/codex/skills/memoir-onboard/SKILL.md: bash -c 'source "${PLUGIN_ROOT}/hooks/common.sh" >/dev/null 2>&1; concurrent_session_warning'
  • plugins/codex/skills/memoir-onboard/SKILL.md: If the command prints anything, stop and report: "Concurrent session detected - run memoir-onboard after the other session finishes, or set a distinct MEMOIR_STORE."
  • plugins/codex/skills/memoir-onboard/SKILL.md: `git log --oneline -20` and `git log --stat -5` for recent change patterns (informs lessons / rules).
  • plugins/codex/skills/memoir-onboard/SKILL.md: Run `git log --stat <last_sha>..HEAD` to enumerate changed paths since the last onboarding pass.
  • plugins/codex/skills/memoir-onboard/SKILL.md: Run the confirmation check (`memoir status` → path == `$STORE_PATH`) before doing any writes.
  • plugins/codex/skills/memoir-onboard/SKILL.md: `python3 ${PLUGIN_ROOT}/skills/memoir-onboard/extractors.py walk <root>` — JSON list of `{path, size, mtime_ns, kind}` plus `snapshot_hash`.
  • plugins/codex/skills/memoir-onboard/SKILL.md: `python3 ${PLUGIN_ROOT}/skills/memoir-onboard/extractors.py extract <path>` — `key=value` blob for one file (with `kind=` first, `extractor.stdlib.fields=[…]` for provenance).
  • plugins/codex/skills/memoir-onboard/SKILL.md: `python3 ${PLUGIN_ROOT}/skills/memoir-onboard/extractors.py snapshot-hash <root>` — just the hash.
  • plugins/codex/skills/memoir-onboard/SKILL.md: `python3 ${PLUGIN_ROOT}/skills/memoir-onboard/extractors.py tree <root>` — pruned tree.
  • plugins/codex/skills/memoir-onboard/SKILL.md: `python3 ${PLUGIN_ROOT}/skills/memoir-onboard/extractors.py shape <root>` — `{shape, overview}` JSON.
  • plugins/codex/skills/memoir-onboard/SKILL.md: bash -c 'source "${PLUGIN_ROOT}/hooks/common.sh" >/dev/null 2>&1; concurrent_session_warning'
  • plugins/codex/skills/memoir-onboard/SKILL.md: For each file in the walk result, run `extractors.py extract <path>` and capture the structured blob.
  • plugins/codex/skills/memoir-onboard/SKILL.md: python3 -c "import json,sys; print('\n'.join(e['path'] for e in json.loads(sys.argv[1])['files']))" "$WALK_JSON" \
  • plugins/codex/skills/memoir-onboard/SKILL.md: **added** (in walk, not in store) → run `extract <path>`, write `files.<san>.meta` and `files.<san>.summary`.
  • plugins/codex/skills/memoir-onboard/SKILL.md: **modified** (same path, different `(size, mtime_ns)`) → re-run `extract <path>`, write both keys.
  • plugins/codex/skills/memoir-onboard/SKILL.md: If a cold run fails partway through, the `_meta.*` keys act as commit markers.
  • plugins/codex/skills/memoir-onboard/SKILL.md: A subsequent forced memoir-onboard run will rewrite cleanly.
  • plugins/codex/skills/memoir-remember/SKILL.md: python3 - "$manifest" <<'PY'
  • plugins/codex/skills/memoir-remember/SKILL.md: bash "$PLUGIN_ROOT/scripts/ensure-store.sh" "$STORE" >/dev/null
  • plugins/codex/skills/memoir-status/SKILL.md: Run:
  • plugins/codex/skills/memoir-status/SKILL.md: python3 - "$manifest" <<'PY'
  • plugins/codex/skills/memoir-status/SKILL.md: bash "$PLUGIN_ROOT/scripts/status-cmd.sh"
  • plugins/codex/skills/memoir-ui/SKILL.md: Run:
  • plugins/codex/skills/memoir-ui/SKILL.md: python3 - "$manifest" <<'PY'
  • plugins/codex/skills/memoir-ui/SKILL.md: bash "$PLUGIN_ROOT/scripts/memoir-ui-ctl.sh" start "$STORE"
  • plugins/codex/skills/memory-recall/SKILL.md: Run this preamble first and reuse `$STORE` and `$MEMOIR` for every memoir invocation below:
  • plugins/codex/skills/memory-recall/SKILL.md: python3 - "$manifest" <<'PY'
  • plugins/codex/skills/memory-recall/SKILL.md: `$MEMOIR` is a wrapper that resolves the right invocation for this machine — `memoir` on PATH if installed, otherwise `uvx --from memoir-ai==<pin> memoir`, otherwise `uv tool run --from memoir-ai==<pin> memoir` (pin lives in `scripts/resolve-memoir-cli.sh`).
  • plugins/codex/skills/memory-recall/SKILL.md: that way recall works on machines where memoir isn't `pip install`ed but `uv` is.

Install scripts (2)

  • Makefile (make install): pip install -e .
  • README.md: curl -LsSf https://astral.sh/uv/install.sh | sh · uses the network

MCP servers (1)

  • README.md (memoir): uvx --from memoir-ai[mcp] memoir-mcp

Hooks (7)

  • plugins/claude-code/hooks/hooks.json (SessionStart): bash ${CLAUDE_PLUGIN_ROOT}/hooks/session-start.sh
  • plugins/claude-code/hooks/hooks.json (UserPromptSubmit): bash ${CLAUDE_PLUGIN_ROOT}/hooks/user-prompt-submit.sh
  • plugins/claude-code/hooks/hooks.json (Stop): bash ${CLAUDE_PLUGIN_ROOT}/hooks/stop.sh
  • plugins/claude-code/hooks/hooks.json (SessionEnd): bash ${CLAUDE_PLUGIN_ROOT}/hooks/session-end.sh
  • plugins/codex/hooks/hooks.json (SessionStart): bash "${PLUGIN_ROOT}/hooks/session-start.sh"
  • plugins/codex/hooks/hooks.json (UserPromptSubmit): bash "${PLUGIN_ROOT}/hooks/user-prompt-submit.sh"
  • plugins/codex/hooks/hooks.json (Stop): bash "${PLUGIN_ROOT}/hooks/stop.sh"
  • Medium risk: runs-git-hook-remote-exec (.pre-commit-config.yaml:2)
  • Medium risk: runs-git-hook-remote-exec (.pre-commit-config.yaml:23)
  • Medium risk: runs-git-hook-remote-exec (.pre-commit-config.yaml:30)
  • Medium risk: runs-git-hook-remote-exec (.pre-commit-config.yaml:40)
  • Medium risk: runs-install-script-remote-exec (README.md:86)
  • Medium risk: runs-mcp-server-unpinned-runner (README.md:153)
  • Low risk: network-instructions (Makefile:37)
  • Low risk: scripts-present (benchmarks/classifier.py)
  • Low risk: scripts-present (benchmarks/locomo/run.py)
  • Low risk: scripts-present (plugins/claude-code/hooks/session-end.sh)
  • Low risk: scripts-present (plugins/claude-code/hooks/session-start.sh)
  • Low risk: scripts-present (plugins/claude-code/hooks/stop.sh)
  • Low risk: scripts-present (plugins/claude-code/hooks/user-prompt-submit.sh)
  • Low risk: network-instructions (plugins/claude-code/skills/memory-recall/SKILL.md:20)
  • Low risk: scripts-present (plugins/codex/hooks/session-start.sh)
  • Low risk: scripts-present (plugins/codex/hooks/stop.sh)
  • Low risk: scripts-present (plugins/codex/hooks/user-prompt-submit.sh)
  • Low risk: network-instructions (plugins/codex/skills/memory-recall/SKILL.md:36)
  • Low risk: network-instructions (pyproject.toml:57)
  • Low risk: scripts-present (scripts/cc-smoke/run.sh)
  • Low risk: scripts-present (scripts/check_version_consistency.py)

Attribution and licence

First committed by
GitHub avatar of zhangfengcdtzhangfengcdt
Declared authors
  • zhangfengcdt (declared in pyproject.toml)
Publisher
Feng Zhang (Community)
Source
zhangfengcdt/memoir · commit 7fd1b3e
Licence
Apache License 2.0 (files served here)
  • ATTRIBUTION.md (written by AutoGineer)
Synced
Contributors
zhangfengcdt, rapidSpace, disafronov, KevFoxCodeCraft, Ottohere-Mourn

AutoGineer is not affiliated with or endorsed by zhangfengcdt.

Install from source

489 of its files are not served here, so there is no ZIP. zhangfengcdt/memoir at 7fd1b3e