Memsearch

https://github.com/zilliztech/memsearch
Admin
Memsearch is a semantic memory search engine for markdown knowledge bases that enables AI agents to...
Tokens:183,031
Snippets:1,387
Trust Score:8.4
License:MIT
Update:17 hours ago
Show doc for...
Tokens:
Raw
### Zero-config quick start: setup commands

Source: https://github.com/zilliztech/memsearch/blob/main/docs/getting-started.md

Creates a notes directory with a sample MEMORY.md file and installs the local embedding extra. This setup runs entirely on your machine and does not require an API key.

```bash
$ mkdir -p quickstart-notes
```

```bash
$ printf '# Notes\n\n- Redis TTL is 15 minutes\n- Staging URL is https://staging.example.com\n' > quickstart-notes/MEMORY.md
```

```bash
$ pip install "memsearch[local]"
```

--------------------------------

### Install memsearch extras for additional embedding providers

Source: https://github.com/zilliztech/memsearch/blob/main/docs/getting-started.md

Each optional extra installs the provider SDK needed for that embedding provider. The 'all' extra installs everything above.

```bash
$ pip install "memsearch[onnx]"        # ONNX Runtime — bge-m3 int8, CPU, no API key
```

```bash
$ pip install "memsearch[google]"      # Google Gemini embeddings
```

```bash
$ pip install "memsearch[voyage]"      # Voyage AI embeddings
```

```bash
$ pip install "memsearch[jina]"        # Jina AI embeddings
```

```bash
$ pip install "memsearch[mistral]"     # Mistral AI embeddings
```

```bash
$ pip install "memsearch[ollama]"      # Ollama (local, no API key)
```

```bash
$ pip install "memsearch[local]"       # sentence-transformers (local, no API key)
```

```bash
$ pip install "memsearch[anthropic]"   # Anthropic (for compact/summarization LLM)
```

```bash
$ pip install "memsearch[all]"         # Everything above
```

--------------------------------

### Example global config.toml

Source: https://github.com/zilliztech/memsearch/blob/main/docs/getting-started.md

Example TOML configuration for ~/.memsearch/config.toml. Shows settings for Milvus, embedding, chunking, watch, compact (deprecated), LLM, plugin summarization, and custom prompt templates. The [compact] section is deprecated; use [llm] and [prompts] instead.

```toml
# Example ~/.memsearch/config.toml

[milvus]
uri = "http://localhost:19530"
token = "root:Milvus"
collection = "memsearch_chunks"

[embedding]
provider = "openai"
model = ""
base_url = ""
api_key = ""

[chunking]
max_chunk_size = 1500
overlap_lines = 2

[watch]
debounce_ms = 1500

[compact]                    # deprecated — use [llm] + [prompts] instead
llm_provider = "openai"
llm_model = ""
prompt_file = ""

[llm]                        # LLM settings for memsearch compact
provider = ""                # empty = compact defaults to openai
model = ""

[llm.providers.openai]        # optional named providers for plugin summarization
type = "openai"               # openai/openai-compatible/anthropic/gemini
model = "gpt-5-mini"
base_url = ""
api_key = "env:OPENAI_API_KEY"

[plugins.claude-code.summarize] # optional plugin-specific summarize routing
provider = ""                 # empty/native = Claude Code native summarizer
model = ""                    # native model override, or API provider model override

[plugins.codex.summarize]
provider = ""                 # empty/native = Codex native summarizer
model = ""                    # empty = Codex plugin default

[plugins.opencode.summarize]
provider = ""                 # empty/native = OpenCode native summarizer
model = ""                    # native: empty = title-agent model, then host default

[plugins.openclaw.summarize]
provider = ""                 # empty/native = OpenClaw native summarizer
model = ""                    # empty = OpenClaw default agent model

[prompts]                    # custom prompt template files
compact = ""                 # for memsearch compact
summarize = ""               # for plugin session summarization
project_review = ""          # for plugin PROJECT.md maintenance
user_profile = ""            # for plugin USER.md maintenance
```

--------------------------------

### Install memsearch with pip

Source: https://github.com/zilliztech/memsearch/blob/main/docs/getting-started.md

Installs the memsearch package with default OpenAI embeddings support.

```bash
$ pip install memsearch
```

--------------------------------

### Zero-config quick start: Python usage

Source: https://github.com/zilliztech/memsearch/blob/main/docs/getting-started.md

Indexes the quickstart-notes directory using local embeddings and searches for the Redis TTL. Uses the default Milvus Lite backend and requires no API key.

```python
import asyncio
from memsearch import MemSearch

async def main():
    mem = MemSearch(
        paths=["./quickstart-notes"],
        embedding_provider="local",
    )
    await mem.index()

    results = await mem.search("what is the Redis TTL?", top_k=3)
    for r in results:
        print(r["content"])

    mem.close()

asyncio.run(main())
```

--------------------------------

### Install Codex Plugin via Script

Source: https://github.com/zilliztech/memsearch/blob/main/docs/index.md

Install the memsearch plugin for Codex by running the provided install script, then start Codex with --yolo to enable the plugin.

```bash
bash memsearch/plugins/codex/scripts/install.sh
codex --yolo
```

--------------------------------

### Milvus Server Python, CLI, and Docker setup

Source: https://github.com/zilliztech/memsearch/blob/main/docs/getting-started.md

Connect to a self-hosted Milvus Server. Python and CLI use default credentials root:Milvus; Docker command runs standalone Milvus.

```python
mem = MemSearch(
    paths=["./memory/"],
    milvus_uri="http://localhost:19530",
    milvus_token="root:Milvus",    # default credentials
)
```

```bash
$ memsearch index ./memory/ --milvus-uri http://localhost:19530 --milvus-token root:Milvus
```

```bash
$ docker run -d --name milvus \
    -p 19530:19530 -p 9091:9091 \
    milvusdb/milvus:latest milvus run standalone
```

--------------------------------

### Run interactive config wizard

Source: https://github.com/zilliztech/memsearch/blob/main/docs/getting-started.md

Starts the interactive configuration wizard that writes to ~/.memsearch/config.toml. The wizard prompts for Milvus, embedding, and chunking settings. Use --project to write allowlisted local indexing overrides to .memsearch.toml in the current directory.

```bash
$ memsearch config init
memsearch configuration wizard
Writing to: /home/user/.memsearch/config.toml

── Milvus ──
  Milvus URI [~/.memsearch/milvus.db]:
  Milvus token (empty for none) []:
  Collection name [memsearch_chunks]:

── Embedding ──
  Provider (openai/google/voyage/jina/mistral/ollama/local/onnx) [openai]:
  Model (empty for provider default) []:

── Chunking ──
  Max chunk size (chars) [1500]:
  Overlap lines [2]:
...

Config saved to /home/user/.memsearch/config.toml
```

```bash
$ memsearch config init --project
```

--------------------------------

### Install MemSearch CLI with ONNX Embedding

Source: https://github.com/zilliztech/memsearch/blob/main/docs/index.md

Install the memsearch CLI using `uv` or `pip`. The `onnx` extra provides ONNX-based embedding, eliminating the need for an API key.

```bash
# Install the CLI (with ONNX embedding -- no API key needed)
uv tool install "memsearch[onnx]"

# Or with pip
pip install "memsearch[onnx]"
```

--------------------------------

### OpenAI example (default)

Source: https://github.com/zilliztech/memsearch/blob/main/docs/getting-started.md

Complete Python script for building an agent with persistent memory using OpenAI. It defines a save_memory function to append notes to a daily markdown log, an agent_chat function that recalls memories, calls the LLM with context, and saves the exchange, and a main function that seeds memories and tests the agent. Requires the openai and memsearch packages.

```python
import asyncio
from datetime import date
from pathlib import Path
from openai import OpenAI
from memsearch import MemSearch

MEMORY_DIR = "./memory"
llm = OpenAI()
mem = MemSearch(paths=[MEMORY_DIR])


def save_memory(content: str):
    """Append a note to today's memory log (OpenClaw-style daily markdown)."""
    p = Path(MEMORY_DIR) / f"{date.today()}.md"
    p.parent.mkdir(parents=True, exist_ok=True)
    with open(p, "a") as f:
        if p.stat().st_size == 0:
            f.write(f"# {date.today()}\n")
        f.write(f"\n{content}\n")


async def agent_chat(user_input: str) -> str:
    # 1. Recall — search past memories for relevant context
    memories = await mem.search(user_input, top_k=5)
    context = "\n".join(f"- {m['content'][:300]}" for m in memories)

    # 2. Think — call LLM with memory context
    resp = llm.chat.completions.create(
        model="gpt-5-mini",
        messages=[
            {
                "role": "system",
                "content": (
                    "You are a helpful assistant with access to the user's memory.\n"
                    f"Relevant memories:\n{context}"
                ),
            },
            {"role": "user", "content": user_input},
        ],
    )
    answer = resp.choices[0].message.content

    # 3. Remember — save this exchange and re-index
    save_memory(f"## User: {user_input}\n\n{answer}")
    await mem.index()

    return answer


async def main():
    # Seed some knowledge
    save_memory("## Team\n- Alice: frontend lead\n- Bob: backend lead")
    save_memory("## Decision\nWe chose Redis for caching over Memcached.")
    await mem.index()

    # Agent can now recall those memories
    print(await agent_chat("Who is our frontend lead?"))
    print(await agent_chat("What caching solution did we pick?"))


asyncio.run(main())
```

--------------------------------

### Install MemSearch plugin for DeepSeek Harness

Source: https://github.com/zilliztech/memsearch/blob/main/README.md

Install the published MemSearch plugin into your DSH profile. After installation, restart the DSH profile or start a new session. Completed turns are captured automatically.

```bash
# Install the published plugin into your DSH profile
uv tool install "memsearch[onnx]"
dsh plugin --profile web add @zilliz/memsearch-dsh
# Restart that DSH profile, or start a new session
```

--------------------------------

### Create memory directory with mkdir and cd

Source: https://github.com/zilliztech/memsearch/blob/main/docs/getting-started.md

Sets up the memory directory following the OpenClaw memory layout: a MEMORY.md file for persistent facts plus daily logs in a memory/ subdirectory. Run from the project root.

```bash
$ mkdir -p my-project/memory
$ cd my-project
```

--------------------------------

### Set and get configuration values with memsearch config commands

Source: https://github.com/zilliztech/memsearch/blob/main/docs/getting-started.md

Use `memsearch config set` and `memsearch config get` to modify and retrieve individual configuration values. The `--project` flag writes to the project-level `.memsearch.toml` file; otherwise, changes are saved to the global `~/.memsearch/config.toml`. The output confirms the updated key and file path.

```bash
$ memsearch config set milvus.uri http://localhost:19530
Set milvus.uri = http://localhost:19530 in /home/user/.memsearch/config.toml

$ memsearch config get milvus.uri
http://localhost:19530

$ memsearch config set embedding.batch_size 32 --project
Set embedding.batch_size = 32 in .memsearch.toml
```

--------------------------------

### Run development checks for OpenCode plugin

Source: https://github.com/zilliztech/memsearch/blob/main/plugins/opencode/README.md

Run these commands from a source clone to verify the plugin. Includes dependency sync, typecheck, tests, and Python tests for specific test files.

```bash
uv sync --locked
npm --prefix plugins/opencode run typecheck
npm --prefix plugins/opencode test
uv run python -m pytest tests/test_opencode_turns.py tests/test_opencode_parse_transcript.py tests/test_maintenance_runner.py tests/test_skills_sync.py
```

--------------------------------

### Ollama setup commands

Source: https://github.com/zilliztech/memsearch/blob/main/README.md

Install memsearch with the ollama extra and pull the required models: nomic-embed-text for embeddings and llama3.2 for chat. This enables fully local operation without an API key.

```bash
pip install "memsearch[ollama]"
ollama pull nomic-embed-text          # embedding model
ollama pull llama3.2                  # chat model
```

--------------------------------

### CLI setup commands

Source: https://github.com/zilliztech/memsearch/blob/main/README.md

Initializes MemSearch with an interactive wizard, switches the embedding provider to onnx, and points the Milvus backend to a local URI.

```bash
memsearch config init                              # interactive setup wizard
memsearch config set embedding.provider onnx       # switch embedding provider
memsearch config set milvus.uri http://localhost:19530  # switch Milvus backend
```

--------------------------------

### Quick Setup: Interactive and Individual Config Commands

Source: https://github.com/zilliztech/memsearch/blob/main/docs/home/configuration.md

Use `memsearch config init` to launch the interactive configuration wizard, or set individual values with `memsearch config set`. The example sets the embedding provider to ONNX and the Milvus URI to a local instance.

```bash
# Interactive config wizard
memsearch config init

# Or set individual values
memsearch config set embedding.provider onnx
memsearch config set milvus.uri http://localhost:19530
```

--------------------------------

### Install Anthropic extra

Source: https://github.com/zilliztech/memsearch/blob/main/docs/getting-started.md

Command to install the memsearch package with the Anthropic extra, enabling the Claude variant.

```bash
$ pip install "memsearch[anthropic]"
```

--------------------------------

### Quick Example: Index and search with MemSearch

Source: https://github.com/zilliztech/memsearch/blob/main/docs/home/for-developers.md

Initialize MemSearch with a path, index markdown files, and perform a semantic search. The search returns results with heading and score.

```python
from memsearch import MemSearch

mem = MemSearch(paths=["./memory"])

# Index markdown files
await mem.index()

# Search
results = await mem.search("Redis config", top_k=3)
for r in results:
    print(r["heading"], r["score"])
```

--------------------------------

### Resolve install paths and install a skill

Source: https://github.com/zilliztech/memsearch/blob/main/plugins/_shared/skills/memory-to-skill/SKILL.md

Resolve install targets from config first: if `paths` is a non-empty list, present those paths as proposed destinations and pass each entry as a `--path` after confirmation. If empty, ask the user where to install; do not silently fall back to a default path. Replace `<platform>` with your platform key prefix.

```bash
memsearch config get plugins.<platform>.memory_to_skill.paths 2>/dev/null || echo "[]"
memsearch skills install <name> --path <configured-or-user-approved-path>
```

--------------------------------

### Install Ollama extra and pull models

Source: https://github.com/zilliztech/memsearch/blob/main/docs/getting-started.md

Commands to install the memsearch package with the Ollama extra and pull the required embedding and chat models for fully local operation.

```bash
$ pip install "memsearch[ollama]"
$ ollama pull nomic-embed-text    # embedding model
$ ollama pull llama3.2            # chat model
```

--------------------------------

### Serve and build MkDocs documentation

Source: https://github.com/zilliztech/memsearch/blob/main/CONTRIBUTING.md

Use uv run mkdocs serve for a local preview at http://127.0.0.1:8000 and uv run mkdocs build to build the site to site/.

```bash
uv run mkdocs serve    # local preview at http://127.0.0.1:8000
uv run mkdocs build    # build to site/
```

--------------------------------

### Search with --json-output piped to python -m json.tool

Source: https://github.com/zilliztech/memsearch/blob/main/docs/getting-started.md

Use --json-output to get structured results for piping into other tools. The example pipes to python -m json.tool for pretty-printing.

```bash
$ memsearch search "inter-service communication" --json-output | python -m json.tool
```

--------------------------------

### Install memsearch with optional embedding providers

Source: https://github.com/zilliztech/memsearch/blob/main/README.md

Installation commands for optional embedding providers. The [onnx] extra is recommended for local ONNX without an API key. Other options include [openai], [google], [voyage], [jina], [mistral], [ollama], [local], and [all].

```bash
# As a CLI tool (recommended — local ONNX, no API key)
uv tool install "memsearch[onnx]"
pipx install "memsearch[onnx]"
pip install "memsearch[onnx]"

# As a project dependency
uv add "memsearch[onnx]"

# Other options: [openai], [google], [voyage], [jina], [mistral], [ollama], [local], [all]
```

--------------------------------

### Local vLLM endpoint configuration in ~/.memsearch/config.toml

Source: https://github.com/zilliztech/memsearch/blob/main/docs/getting-started.md

Configure a local vLLM server as an OpenAI-compatible embedding API using the `embedding.base_url` and `embedding.api_key` fields. This is a global configuration example stored in `~/.memsearch/config.toml`.

```toml
# ~/.memsearch/config.toml — local vLLM example
[embedding]
provider = "openai"
model = "BAAI/bge-small-en-v1.5"
base_url = "http://localhost:8000/v1"
api_key = "dummy"
```

--------------------------------

### Full configuration example (TOML)

Source: https://github.com/zilliztech/memsearch/blob/main/docs/architecture.md

Complete TOML configuration with all five sections: [milvus], [embedding], [compact] (deprecated), [llm], [llm.providers.openai], plugin summarize sections, [prompts], [chunking], and [watch]. API keys are read from environment variables by SDKs, not stored in config files.

```toml
[milvus]
uri = "~/.memsearch/milvus.db"
token = ""
collection = "memsearch_chunks"

[embedding]
provider = "openai"
model = ""                           # empty = provider default

[compact]                              # deprecated — use [llm] + [prompts]
llm_provider = "openai"
llm_model = ""
prompt_file = ""

[llm]                                  # LLM for memsearch compact
provider = ""                          # empty = compact defaults to openai
model = ""

[llm.providers.openai]                  # optional named providers for plugin summarization
type = "openai"                         # openai/openai-compatible/anthropic/gemini
model = "gpt-5-mini"
base_url = ""
api_key = "env:OPENAI_API_KEY"

[plugins.claude-code.summarize]        # optional plugin summarize routing
provider = ""                           # empty/native = plugin native summarizer
model = ""                              # native model override, or API provider model override

[plugins.codex.summarize]
provider = ""
model = ""

[plugins.opencode.summarize]
provider = ""
model = ""

[plugins.openclaw.summarize]
provider = ""
model = ""

[prompts]
compact = ""                           # custom compact prompt file
summarize = ""                         # custom summarize prompt file
project_review = ""                    # custom PROJECT.md maintenance prompt file
user_profile = ""                      # custom USER.md maintenance prompt file

[chunking]
max_chunk_size = 1500
overlap_lines = 2

[watch]
debounce_ms = 1500
```

--------------------------------

### Milvus Lite Python and CLI usage

Source: https://github.com/zilliztech/memsearch/blob/main/docs/getting-started.md

Initialize MemSearch with Milvus Lite default URI. Python example shows default milvus_uri can be omitted; CLI uses default path.

```python
mem = MemSearch(
    paths=["./memory/"],
    milvus_uri="~/.memsearch/milvus.db",  # default, can be omitted
)
```

```bash
$ memsearch index ./memory/
# Uses ~/.memsearch/milvus.db by default
```

--------------------------------

### Install memsearch as global CLI tool

Source: https://github.com/zilliztech/memsearch/blob/main/README.md

Installation commands for using memsearch as a global CLI tool, recommended when mainly using the memsearch command or agent plugins. Options include uv tool install, pipx install, and pip install.

```bash
# Install as a global CLI tool — recommended when you mainly use the
# `memsearch` command or any of the agent plugins (Claude Code, Codex,
# DSH, OpenClaw, OpenCode), which all shell out to the CLI.
uv tool install memsearch       # via uv
pipx install memsearch          # via pipx
pip install memsearch           # plain pip
```

--------------------------------

### Set API keys for embedding providers

Source: https://github.com/zilliztech/memsearch/blob/main/docs/getting-started.md

Export environment variables for various embedding providers. OpenAI is the default; others require additional installs. No API key needed for ONNX or local sentence-transformers.

```bash
$ export OPENAI_API_KEY="sk-..."         # OpenAI embeddings (default)
$ export GOOGLE_API_KEY="..."            # Google Gemini embeddings
$ export VOYAGE_API_KEY="..."            # Voyage AI embeddings
$ export JINA_API_KEY="jina_..."         # Jina AI embeddings
$ export MISTRAL_API_KEY="..."           # Mistral AI embeddings
$ export ANTHROPIC_API_KEY="..."         # Anthropic (for compact summarization)
```

--------------------------------

### CLI flag overrides for index and search commands

Source: https://github.com/zilliztech/memsearch/blob/main/docs/getting-started.md

Explicit CLI flags take the highest priority, except for `--default-collection` which is a fallback below global and project config. These examples show overriding provider and Milvus URI for indexing and searching.

```bash
$ memsearch index ./memory/ --provider google --milvus-uri http://localhost:19530
$ memsearch search "Redis config" --top-k 10 --milvus-uri http://10.0.0.5:19530
```

--------------------------------

### Install all optional providers

Source: https://github.com/zilliztech/memsearch/blob/main/docs/cli.md

Install all optional embedding providers at once using the 'all' extra.

```bash
$ pip install "memsearch[all]"
```

--------------------------------

### Azure OpenAI-compatible endpoint configuration in .memsearch.toml

Source: https://github.com/zilliztech/memsearch/blob/main/docs/getting-started.md

Configure a custom OpenAI-compatible embedding API (e.g., Azure OpenAI) using the `embedding.base_url` and `embedding.api_key` fields. The `api_key` uses the `env:` prefix to reference an environment variable. This is a project-level configuration example.

```toml
# .memsearch.toml — Azure OpenAI example
[embedding]
provider = "openai"
model = "text-embedding-3-small"
base_url = "https://my-resource.openai.azure.com"
api_key = "env:AZURE_OPENAI_API_KEY"
```

--------------------------------

### Install MemSearch plugin for OpenCode

Source: https://github.com/zilliztech/memsearch/blob/main/README.md

Install the MemSearch plugin for OpenCode. Completed turns are summarized into `.memsearch/memory/` and indexed for recall.

```bash
opencode plugin add @zilliz/memsearch-opencode
```

--------------------------------

### Environment variable references in .memsearch.toml

Source: https://github.com/zilliztech/memsearch/blob/main/docs/getting-started.md

Example project config showing how to use the env: prefix to reference environment variables for API keys and tokens. If the referenced environment variable is not set, memsearch raises an error at startup. Plain string values without the env: prefix are used as-is.

```toml
# .memsearch.toml
[embedding]
provider = "openai"
base_url = "https://my-azure.openai.azure.com"
api_key = "env:AZURE_OPENAI_API_KEY"       # resolved from $AZURE_OPENAI_API_KEY at runtime

[milvus]
token = "env:MILVUS_TOKEN"                 # works for any string field
```

--------------------------------

### Install optional embedding providers

Source: https://github.com/zilliztech/memsearch/blob/main/docs/home/for-developers.md

Install optional embedding providers. The ONNX provider is recommended and requires no API key. Other options include [openai], [google], [voyage], [jina], [mistral], [ollama], [local], and [all].

```bash
pip install "memsearch[onnx]"    # Local ONNX (recommended, no API key)
# or: uv add "memsearch[onnx]"

# Other options: [openai], [google], [voyage], [jina], [mistral], [ollama], [local], [all]
```

--------------------------------

### Install memsearch with pip or uv

Source: https://github.com/zilliztech/memsearch/blob/main/docs/home/for-developers.md

Install the memsearch package using pip or uv. The uv command is recommended.

```bash
# pip
pip install memsearch

# or uv (recommended)
uv add memsearch
```

--------------------------------

### watch usage example

Source: https://github.com/zilliztech/memsearch/blob/main/docs/python-api.md

Example of starting a background file watcher after an initial index. The `on_event` callback prints event type and summary; `watcher.stop()` stops watching.

```python
mem = MemSearch(paths=["./memory"])
await mem.index()  # initial index

# Start watching for changes in the background
watcher = mem.watch(on_event=lambda t, s, p: print(f"[{t}] {s}"))

# ... your agent runs here ...

watcher.stop()
```

--------------------------------

### Install memsearch as project dependency

Source: https://github.com/zilliztech/memsearch/blob/main/README.md

Installation commands for adding memsearch as a project dependency, for importing memsearch from Python code (e.g., via the MemSearch class).

```bash
# Install as a project dependency — use this if you want to import
# `memsearch` from your own Python code (e.g. via the MemSearch class).
uv add memsearch                # via uv, adds to pyproject.toml
pip install memsearch           # into an activated venv
```

--------------------------------

### View current configuration with memsearch config list/get

Source: https://github.com/zilliztech/memsearch/blob/main/docs/home/configuration.md

Use `memsearch config list` to show all settings and `memsearch config get milvus.uri` to display a specific value.

```bash
memsearch config list          # show all settings
memsearch config get milvus.uri  # show specific value
```

--------------------------------

### Get Milvus URI (Milvus Lite default)

Source: https://github.com/zilliztech/memsearch/blob/main/README.md

Check the current Milvus URI. Milvus Lite is the default and requires no setup.

```bash
# Works out of the box, no setup needed
memsearch config get milvus.uri   # → ~/.memsearch/milvus.db
```

--------------------------------

### Start OpenClaw TUI session

Source: https://github.com/zilliztech/memsearch/blob/main/plugins/openclaw/README.md

Launches the OpenClaw TUI to begin a session with the memory plugin active.

```bash
openclaw tui
```

--------------------------------

### Update available hints for different install methods

Source: https://github.com/zilliztech/memsearch/blob/main/plugins/claude-code/README.md

Shows the upgrade command auto-detected from the installation method. The pip and uv tool commands preserve optional extras; uvx users get automatic upgrades.

```text
UPDATE: v0.1.15 available — run: pip install --upgrade memsearch
UPDATE: v0.1.15 available — run: uv tool upgrade memsearch
```
Tokens:
Raw