GROVE / AGENT MEMORY
Persistent memory for the agents you build with. Save decisions, search by meaning, and connect project knowledge through one self-hosted MCP server.
Your stack. Your data. Context that survives the session.
$npm i -g @miniaxolotl/groveSESSION 01 · SAVE A DECISION
memory_save
{ "information": "Use Postgres for billing: we need ACID transactions.",
"metadata": { "project": "billing-api" } }Stored in Qdrant
SESSION 02 · RECALL THE CONTEXT
memory_search
{ "query": "Why this database?",
"project": "billing-api" }RELATED MEMORY
Use Postgres for billing: we need ACID transactions.
BUILT FOR YOUR STACK
MCP
HTTP & stdio transport
Qdrant
Persistent vector storage
ONNX
Local embeddings by default
OpenCode
Optional agent plugin
SOUND FAMILIAR?
The architecture decision. The coding convention. The bug that took all afternoon. Give your agent something to come back to.
“Use PostgreSQL for billing. We need reliable transactions, and the team already knows it.”
The chat ends. The memory stays.
Let’s build the billing service. Which database are we using?
PostgreSQL. You chose it for reliable transactions and the team’s familiarity. Let’s build on that decision.
“Keep tests beside the source files. Use Vitest and name test files *.test.ts.”
The chat ends. The memory stays.
Can you add tests for this new utility?
I’ll use Vitest and place a .test.ts file beside the utility, following your project’s testing convention.
“The auth callback failed behind the proxy. Forwarding the original host header fixed the redirect URL.”
The chat ends. The memory stays.
The auth redirect broke after the proxy change. Have we seen this?
Yes. Last time the proxy dropped the original host header. Forwarding it fixed the callback URL. Let’s check that first.
Illustrative workflow, not a live agent. Your agent uses Grove’s tools to save and retrieve context.
Make it your workflowTHE MEMORY TOOLKIT
Keep the useful bits. Find the right context. Connect what matters. All through tools your agent can use.
Ask about “the billing database” and find the decision about PostgreSQL. Semantic search retrieves related memories, with optional reranking for a sharper match.
PostgreSQL gives our billing service the reliable transactions it needs.
Build a knowledge graph of entities, observations, and relationships. Give your agent a way to explore how your projects, services, and decisions fit together.
Self-host Grove and Qdrant on your own infrastructure. Local ONNX embeddings are the default. No hosted memory subscription standing between you and your work.
Organize by project, session, and tags. Set importance, update what changes, and prune what no longer helps. Keep your memory store relevant as your codebase evolves.
21 MCP tools. Memory, entities, and relationships. Ready for your agent.
Explore the tool referenceSIMPLE ARCHITECTURE
A focused MCP server between your agent and a persistent store. Explicit tool calls. Local embeddings. Durable storage.
Your agent calls memory_save or memory_note to store a decision, a preference, or a finding. Add a project and tags to keep it organized.
Grove embeds the text and stores it in Qdrant. Create entities and relationships when you want to connect the bigger picture.
In a later session, your agent searches by meaning and uses the relevant memories as context. Less repetition. More forward motion.
Local embeddings by default. Remote embeddings and reranking when you want them.
QUICKSTART
Start Grove and Qdrant, connect your MCP client, and save your first project decision.
Open the installation guideStart Grove and its Qdrant store. Docker Compose brings them up together; npm fits an existing setup.
macOS, Linux, or Windows with Dockergit clone https://github.com/miniaxolotl/grove.git
cd grove
cp .env.example .env
docker compose up -dRequires Git and Docker with Compose. Builds Grove and starts Qdrant with persistent storage. The first run downloads the local embedding model.
# Start a persistent local Qdrant instance
docker run -d --name grove-qdrant \
-p 127.0.0.1:6333:6333 \
-v grove-qdrant:/qdrant/storage \
qdrant/qdrant:latest
npm install -g @miniaxolotl/grove
grove serveRequires Node.js 22+. The first command starts Qdrant with Docker; skip it if Qdrant is already running. Set QDRANT_URL if your instance is not at localhost:6333.
curl --fail http://localhost:26081/readyWait for initialization to finish. The readiness endpoint returns HTTP 200 when the collections are ready.
Give your agent access to Grove’s MCP tools. Use the OpenCode configuration, or connect your preferred MCP client.
Client configuration reference{
"$schema": "https://opencode.ai/config.json",
"plugin": ["@miniaxolotl/grove-opencode-plugin"],
"mcp": {
"grove": {
"type": "remote",
"url": "http://localhost:26080/mcp"
}
}
}Merge these entries into your existing configuration, then restart OpenCode. The companion plugin adds manual saves, error capture, and memory lifecycle hooks. Set GROVE_PROJECT in OpenCode’s environment to group plugin memories by project.
http://localhost:26080/mcpAdd a remote MCP server named grove with this URL and the Streamable HTTP transport. Configuration fields vary by client. Replace localhost with your server’s address if Grove runs elsewhere.
Prefer stdio? Install the npm package and configure your client to launch grove without arguments, with QDRANT_URL set to your Qdrant instance.
Ask your agent to save something worth keeping. Open a new session, search for it, and pick up the thread.
Use Grove to remember: "We use PostgreSQL for billing because we need transactions." Save it under the project "my-app".Then, in a new session
Search Grove for "billing database" in project "my-app". What did we decide, and why?Grove makes memory available through tools. Ask your agent to use them, or add saving and recall instructions to your agent’s workflow.
No Grove account or memory subscription. Run the server and storage on infrastructure you control.
Deployment referenceA FEW GOOD QUESTIONS
Everything you need to know before giving your agent a longer memory.
Ask a question on GitHubGrove is a persistent memory layer for AI agents, delivered as a Model Context Protocol (MCP) server. Your agent can save useful information, search it by meaning, and connect entities in a knowledge graph. Memories live in Qdrant, so they can outlast a single chat or context window.
Grove exposes MCP tools over HTTP or stdio, so you can connect a client that supports either transport. OpenCode has a ready-to-copy configuration and an optional companion plugin for manual saves, error capture, staleness checks, and memory compaction. Other clients may use different configuration formats.
Your agent saves and retrieves memories by calling Grove’s tools. Ask it to remember a decision or search previous context, or add memory instructions to your agent’s workflow. The OpenCode plugin adds error capture and lifecycle hooks; it does not record every conversation or automatically inject all your memories.
Memories are stored in the Qdrant instance you configure. By default, Grove runs embeddings locally with ONNX; the first run downloads the embedding model. Remote embedding and reranking services are optional. Your AI client still follows its own model and data settings.
Grove is open source under the MIT license. There is no Grove subscription or per-memory fee. You provide the compute and storage, and any optional external services have their own costs.
Use Docker with Compose and Git for the all-in-one setup. For npm, you need Node.js 22 or newer and a running Qdrant instance. Then connect an MCP-compatible agent. The installation guide includes the commands, client configuration, and a first-memory example.
Yes. Tag memories, attach a project or session, and set an importance score. Search can filter by project and tags. Use the memory tools to update or forget individual memories, compact low-importance entries, or prune by threshold. Project tags are organizational filters, not access-control boundaries.
BUILT FOR DEVELOPERS. BY BRAMBLE LABS INC.
Give your next session the decisions, preferences, and fixes you already worked out.