Generated banner for memU
Generated logo for memU

memU

Memory framework

First committed by evan-ak

Published in NevaMind-AI/memU. Publisher page

14,613 GitHub stars

What it is

Personal memory across agents
— the description by evan-ak

AutoGineer overview, from the brain’s own files

memU is an agent-driven memory system designed to provide persistent knowledge across different AI agents, sessions, and devices. It functions as a sidecar to desktop coding agents, automatically mining session logs to extract reusable skills and workflows. These skills are stored as Markdown files, which the agent can then retrieve and apply to future tasks. The system is designed to be storage-agnostic, supporting local SQLite databases for single-device use or Postgres for concurrent access, and it integrates with various coding agents through dedicated host adapters.

How it works

Memory model: LLM wiki

AutoGineer overview, from the brain’s own files

memU operates by installing a scheduled background task that monitors agent session logs. It slices these logs into jobs, which the agent then processes to create or update Markdown-based skill files. These skills are indexed and stored in a configured backend. When an agent performs a task, it uses a standing instruction to trigger a retrieval process, which fetches relevant skills from the memory store and injects them into the agent's context.

Folders
FolderRoleFiles
.githubagent-config10
assetsattachments24
docsdocs25
scriptsscripts1
srcsource-code190
teststests69
npmfolder3

The agent reads

The agent writes

Requirements

Runtimes: Python >=3.11

Databases: PostgreSQL, SQLite

API keys (by name): MEMU_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: 4 scripts. Review Makefile, src/memu/hosts/claude_code/install.py, src/memu/hosts/codex/install.py, src/memu/hosts/pi/install.py before opening the folder in Claude Code. No step below turns a hook on for you.

    • Makefile: echo "🚀 Creating virtual environment using uv"; uv sync; uv run pre-commit install
    • src/memu/hosts/claude_code/install.py: python src/memu/hosts/claude_code/install.py
    • src/memu/hosts/codex/install.py: python src/memu/hosts/codex/install.py
    • src/memu/hosts/pi/install.py: python src/memu/hosts/pi/install.py
  2. 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/memu-cli/
  3. First committed by evan-ak. Published in NevaMind-AI/memU. Licence: Apache License 2.0.

Usage

AutoGineer overview, from the brain’s own files

  • Install memU via the provided CLI or agent-specific instructions.
  • Configure the memory backend using a local SQLite file or a Postgres DSN.
  • Allow the background task to automatically distill agent history into Markdown skills.
  • Use the agent's integrated retrieval mechanism to access relevant past skills during new tasks.
  • Manage memory settings and storage via the memU CLI or environment variables.
  • Use the doctor command to verify the configuration and retrieval path.
“memu-codex retrieve "What should I remember about this project?"”
The system returns relevant memory hits containing text, descriptions, and paths from previous sessions.
“memu-agent detect”
The system probes the machine to identify the agent and reports if memorization and retrieval are supported.

Documentation by evan-ak

Image: memU Banner

<div align="center">

memU

Personal memory, stored as Wiki

Across Sessions. Across Agents. Across Devices.

Image: PyPI version Image: License: Apache 2.0 Image: Python 3.11+ Image: Discord Image: Twitter

<a href="https://trendshift.io/repositories/17374" target="_blank"><img src="https://trendshift.io/api/badge/repositories/17374" alt="NevaMind-AI%2FmemU | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/></a>

</div>


memU is a lightweight, agent-driven memory system that gives users a shared LLM wiki across sessions, agents, and devices. It automatically distills your own reusable skills from your agent history. Its core memory logic is only 500 lines — compact enough to inspect, understand, and adapt.

Quick start

memU works with Codex, Claude Code, Cursor, OpenClaw, Hermes, WorkBuddy, Cola, pi, and more. See Host adapters.

Cross-device · Free · Unlimited · View online

Get your API key from memu.so, then send this message to your agent:

Read https://memu.pro/SKILL.md, follow its instructions to install and configure memU, API Key is memu_•••••••••(get Api Key from memu.so).

Agent support

This matrix lists the currently tested memU integrations by operating system.

  • Memorize — capture useful session knowledge through a scheduled background task and turn it into reusable memory.

  • Retrieve — bring relevant memory into a future task.

  • ⚠️ — supported with an important limitation; see the user note.

macOS
AgentModeMemorizeRetrieveUser note
ChatGPTChatGPT(Work mode), codex and VS Code extension✅✅
ChatGPTChat❌❌Chat mode is not currently supported. Please use Work mode.
Claude CodeDesktop and CLI✅✅If the selected model declines the setup steps, retry with Opus or another model. Sonnet 5 can occasionally do this.
ClaudeChat and Cowork❌❌
Cursor—✅✅
OpenClaw—✅✅Retrieve support has not yet been verified.
Hermes Agent—✅✅
WorkBuddy—✅✅
Windows
AgentModeMemorizeRetrieveUser note
ChatGPTChatGPT(Work mode), codex and VS Code extension✅✅
ChatGPTChat❌❌Chat mode is not currently supported. Please use Work mode.
Claude CodeDesktop and CLI✅✅If the selected model declines the setup steps, retry with Opus or another model. Sonnet 5 can occasionally do this.
ClaudeChat and Cowork❌❌
Cursor—✅✅
OpenClaw—✅✅
Hermes Agent—✅⚠️Use a memU version with Windows HERMES_HOME support; older versions may retrieve from the wrong files.
WorkBuddy—✅✅With Hy3, retrieval may fail. Retry with another model if this happens.
Linux
AgentModeMemorizeRetrieveUser note
CodexVS Code extension❌✅
Claude CodeCLI✅✅
OpenClaw4.23 / 7.1✅✅

Support status reflects the current release and may change as host integrations evolve.

How it works

Image: memU memory system architecture

Automatic skill extraction

Once the scheduled bridging task is installed, memU can turn useful agent history into reusable Markdown skills automatically.

Image: How memU turns agent history into reusable skills

  1. Capture new sessions. The host adapter reads new session history, including messages and tool calls.

  2. Prepare self-evolve jobs. prepare slices each session into a self-contained job with the paths and context the agent needs.

  3. Let the agent decide. The agent reads related existing skills, then chooses to do nothing, patch an existing skill, or create a new one.

  4. Write readable skill Markdown. Each skill has a name, description, and reusable workflow, including useful branches, edge cases, and pitfalls.

  5. Commit and index. commit submits changed skill files through commit_results; memU embeds the skill name and description and stores it under the skill track.

  6. Retrieve it later. On a similar future task, memU returns the relevant skill so any connected agent can use the learned workflow.

The judgment and synthesis stay inside the agent. MemoryService makes no LLM or chat calls; it stores, embeds, and retrieves the skill Markdown the agent prepared.

Self-hosted

Private · Single-device · Embedding key required

To run memU locally with your own storage and embedding provider, send this message to your agent:

Read https://raw.githubusercontent.com/NevaMind-AI/MemU/main/SKILL.md and follow it to install memU.

Uninstall

To uninstall memU, send this message to your agent:

Read https://memu.pro/SKILL.md and follow its instructions to uninstall memU.

By default, uninstalling removes the host integration and tooling while keeping your memory store and ~/.memu/config.env, so a later reinstall can resume where you left off. Memory is erased only when you explicitly ask for it.

Host adapters: memory for desktop coding agents

memU runs as a sidecar to a desktop agent, one binary per host. Each binds two seams:

  • record — a scheduled bridging task slices new session logs into self-contained job files; the agent itself distills them into memory/skill Markdown; commit submits whatever the agent left on disk back through commit_results.

  • inject — a standing instruction in the host's instruction file tells the agent to run <binary> retrieve (→ progressive_retrieve) before answering.

HostBinarySession log it minesInstruction file it patches
Codexmemu-codex~/.codex/sessions/**/*.jsonl~/.codex/AGENTS.md
Claude Codememu-claude-code~/.claude/projects/<project>/<session>.jsonl~/.claude/CLAUDE.md
Cursor (Agent/CLI)memu-cursor~/.cursor/projects/<project>/agent-transcripts/**.jsonl./AGENTS.md (per project)
OpenClawmemu-openclaw~/.openclaw/agents/<agentId>/agent/openclaw-agent.sqlite (SQLite, read-only) + legacy <agentId>/sessions/*.jsonl~/.openclaw/workspace/AGENTS.md
Hermes Agentmemu-hermes~/.hermes/state.db (SQLite, read-only)~/.hermes/SOUL.md
WorkBuddymemu-workbuddy~/.workbuddy/projects/<project>/<session>.jsonl~/.workbuddy/SOUL.md
Colamemu-cola~/.cola/sessions/<scope>/<session>.jsonl~/.cola/memory-bank/MEMORY.md
pimemu-pi~/.pi/agent/sessions/<encoded-cwd>/<session>.jsonl~/.pi/agent/AGENTS.md
any other agentmemu-agentfound by memu-agent detect (JSONL dialect sniffed)found by detect (AGENTS.md / CLAUDE.md / SOUL.md / …)

For agents without a dedicated binary, memu-agent detect probes the machine and reports per agent whether memorization works (a recognizable session log exists) and whether retrieval works (an instruction file exists to patch) — then the same verbs run against what it found.

All hosts share one configured memory backend via ~/.memu/config.env — local or MemU Cloud. What one host's sessions taught memU, another host retrieves.

Installation is the one-message setup in Quick start or Self-hosted. SKILL.md is the routing skill it hands your agent: install the package, identify which host you are (falling back to memu-agent detect for anything without a dedicated adapter), print that host's packaged install guide (<binary> docs install), and follow it — configure the memory backend, register the scheduled bridging task, patch the instruction file, each step behind a verify gate — then report which seams (memorization / retrieval) are now active.

Afterwards <binary> doctor proves the whole loop resolves: config, selected mode, and a live retrieval.

Adding another host means implementing one TranscriptSource (where its session logs live, how its records are shaped) plus a HostSpec-sized CLI — the pipeline, verbs, and instruction text are shared.

Developer integration

Use memu memorize to turn application-owned conversations into memory and skills.

CLI

With memU Cloud, sign in at memu.so to view your memory files. With a local installation, memory lives in the shared store configured by MEMU_DB in ~/.memu/config.env — typically ~/.memu/memu.sqlite3 for local SQLite, or a Postgres DSN.

Once installed, your agent retrieves relevant memory automatically before answering. To retrieve manually, run the adapter for your host:

memu-codex retrieve "What should I remember about this project?"
# or: memu-claude-code / memu-cursor / memu-openclaw / memu-hermes / memu-workbuddy / memu-cola / memu-pi / memu-agent

For pi, run memu-pi install to configure the memory backend and install the extension, then run /reload or open a new session. Submitted prompts start retrieval in the background; results enter the model context and resume an idle agent. After the user turn and pending retrieval settle, a background worker processes the saved conversation into memory using the active session's model. Workers share a lock and a 30-minute cooldown. Long prompts use an isolated, tool-free pi request to extract a search query with the active provider/model; extraction has a 12-second timeout and falls back to the original prefix. The installer registers and verifies the extension. Run memu-pi uninstall and reload to remove it.

Host retrieval returns compact JSON with at most five self-contained hits plus independent resources. Each hit combines matched text with its source's description, track, and local mirror path (or inline content when no mirror is available). Its score describes the matched segment; created_at and updated_at describe the source file when available. Hits retain segment order, including excerpts whose source is missing; sources without matched excerpts remain source-only hits. Resources contain path, caption, and available scores/timestamps. Database IDs and scope metadata are omitted from the agent-facing output.

Install or invoke the CLI directly:

pip install memu-cli         # library + memu + memu-codex CLIs
npx memu-cli --help          # CLI via npm launcher (engine: PyPI package memu-cli)
uvx --from memu-cli memu     # CLI via uv, no install

Configuration

Values resolve in order: process env → ~/.memu/config.env → default. memU supports Local and Cloud memory backends, selected by MEMU_MEMORY_MODE; an unset mode remains Local for backward compatibility.

For Local / self-hosted installations, every CLI flag has a matching variable:

SettingEnv varDefault
StoreMEMU_DB./data/memu.sqlite3 (CLI); required for host adapters
Embedding providerMEMU_EMBED_PROVIDERopenai (also: jina, voyage, doubao, openrouter); legacy MEMU_LLM_PROVIDER still read
API keyMEMU_API_KEYthe provider's env var, e.g. OPENAI_API_KEY
Embedding modelMEMU_EMBED_MODELthe provider's default
Base URLMEMU_BASE_URLthe provider's default

Run <binary> doctor to display the resolved mode and verify the same retrieval path the host uses.

Storage backends
ProviderDSNVector searchUse for
inmemory—brute-force cosinetests, throwaway sessions
sqlitesqlite:///path.sqlite3brute-force cosinelocal/default, single writer
postgrespostgresql://...pgvectorconcurrent access, large stores (pip install "memu-cli[postgres]")
service = MemoryService(
    database_config={"metadata_store": {"provider": "postgres", "dsn": "postgresql://..."}},
    embedding_profiles={"default": {"provider": "jina"}},
)

Community contributions

Explore the community tasks (English / 简体中文) and claim a task in issue #790. Each task has a stable link, a difficulty rating, and acceptance criteria. See CONTRIBUTING.md for development and PR guidelines.

License

Apache-2.0

<sub>Partnership Community: <a href="https://linux.do">LINUX DO</a></sub>

LICENSE.txt

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 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
      (which shall not include communication that is conspicuously
      marked or otherwise designated in writing by the copyright owner
      as "Not a Contribution").

      "Derivative Works" shall mean any work, whether in Source or Object
      form, that is based upon (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 use, reproduce, modify, merge, publish,
      distribute, sublicense, and/or sell copies of the Work, and to
      permit persons to whom the Work is furnished to do so, subject to
      the following conditions:

      The above copyright notice and this permission notice shall be
      included in all copies or substantial portions of the Work.

   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, trademark, patent,
          attribution and other 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 notice 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 Support. You may choose to offer, and to
      charge a fee for, warranty, support, 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
      support.

   END OF TERMS AND CONDITIONS

   Copyright 2024 MemU Team

   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.
339 files · 329 not served here

Advantages

  • Automatically distills reusable skills from agent history without manual intervention. evidence: README.md
  • Supports multiple storage backends including SQLite and Postgres for different deployment needs. evidence: README.md

Limitations

  • Some agents require specific modes (e.g., Work mode) and do not support memory features in standard chat modes. evidence: README.md
  • Certain models may decline setup steps, requiring a retry with a different model like Opus. evidence: README.md

Security

Risk level: Medium risk

This brain runs

Git hooks (2)

  • .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/astral-sh/ruff-pre-commit at v0.14.3 (contributor tooling: runs only after pre-commit install) · uses the network

Agent instructions that run or fetch something (14)

  • AGENTS.md: Setup: `make install`
  • AGENTS.md: Run all tests: `make test`
  • AGENTS.md: Run focused tests: `uv run python -m pytest tests/<target_test>.py`
  • AGENTS.md: Full quality checks: `make check`
  • SKILL.md: Each supported host has its own adapter binary carrying its own install guide.
  • SKILL.md: Your job here is three steps: install the package, pick your binary, print and follow its guide.
  • SKILL.md: it installs helper interfaces only and is harmless to run on a personal machine.
  • SKILL.md: If you meet that error at any point, you are on a stale build: upgrade, then re-run the command that failed.
  • SKILL.md: With uv this means `uv tool install --upgrade memu-cli`, **not** `uv pip install`: however it is installed, `memu-cli` is a cross-session bridging tool and must be callable everywhere, not scoped to one project venv.
  • SKILL.md: Run:
  • SKILL.md: If the user does not mention an API key, or would rather keep memory on this device, run bare `<your-binary> init` and Step 3's guide will set up local memory.
  • SKILL.md: <your-binary> docs install
  • SKILL.md: **Install in one pass;
  • SKILL.md: Otherwise, after installation, run:

Install scripts (4)

  • Makefile (make install): echo "🚀 Creating virtual environment using uv"; uv sync; uv run pre-commit install
  • src/memu/hosts/claude_code/install.py: python src/memu/hosts/claude_code/install.py
  • src/memu/hosts/codex/install.py: python src/memu/hosts/codex/install.py
  • src/memu/hosts/pi/install.py: python src/memu/hosts/pi/install.py
  • Medium risk: runs-git-hook-remote-exec (.pre-commit-config.yaml:2)
  • Medium risk: runs-git-hook-remote-exec (.pre-commit-config.yaml:15)
  • Low risk: network-instructions (SKILL.md:33)
  • Low risk: scripts-present (src/memu/hosts/claude_code/install.py)
  • Low risk: scripts-present (src/memu/hosts/codex/install.py)
  • Low risk: scripts-present (src/memu/hosts/pi/install.py)

Attribution and licence

First committed by
GitHub avatar of evan-akevan-ak
Declared authors
  • MemU Team (declared in pyproject.toml)
Publisher
NevaMind AI (Community)
Source
NevaMind-AI/memU · commit fd86e38
Licence
Apache License 2.0 (files served here)
  • ATTRIBUTION.md (written by AutoGineer)
Synced
Contributors
sairin1202, xnne-bot, evan-ak, nevamind-agent, wutongyuonce

AutoGineer is not affiliated with or endorsed by evan-ak or NevaMind AI.

Install from source

329 of its files are not served here, so there is no ZIP. NevaMind-AI/memU at fd86e38