Bramble Labs Inc. Meet Burrow
grove.

GROVE / AGENT MEMORY

New session.
Same context.

Persistent memory for the agents you build with. Save decisions, search by meaning, and connect project knowledge through one private memory account.

Your stack. Your data. Context that survives the session.

Start remembering See it in action
$npm i -g @miniaxolotl/grove
Free & open source Your infrastructure Your memory
Your agent Persistent context
grove / MCPEXAMPLE

SESSION 01 · SAVE A DECISION

remember

{ "information": "Use Postgres for billing: we need ACID transactions.", "metadata": { "project": "billing-api" } }

Saved privately

SESSION 02 · RECALL THE CONTEXT

memory_search

{ "query": "Why this database?", "project": "billing-api" }

RELATED MEMORY

Use Postgres for billing: we need ACID transactions.

Illustrative tool calls · your agent decides what to save and recall

BUILT FOR YOUR STACK

MCP

HTTP & stdio transport

PostgreSQL

Private, searchable memory

ONNX

Local embeddings by default

OpenCode

Optional agent plugin

SOUND FAMILIAR?

You already explained this.
Let’s keep it that way.

The architecture decision. The coding convention. The bug that took all afternoon. Give your agent something to come back to.

Interactive example
01 / A PREVIOUS SESSION
Saved to Grove

“Use PostgreSQL for billing. We need reliable transactions, and the team already knows it.”

project: my-app#architecture

The chat ends. The memory stays.

02 / A FRESH START
You

Let’s build the billing service. Which database are we using?

memory_search “billing database”
Your agent, with context

PostgreSQL. You chose it for reliable transactions and the team’s familiarity. Let’s build on that decision.

Illustrative workflow, not a live agent. Your agent uses Grove’s tools to save and retrieve context.

Make it your workflow

THE MEMORY TOOLKIT

Useful context.
Ready to retrieve.

Keep the useful bits. Find the right context. Connect what matters. All through tools your agent can use.

Find the meaning.
Not just the keywords.

Ask about “the billing database” and find the decision about PostgreSQL. Semantic and full-text search work together to retrieve a small, relevant set of memories.

Why did we choose this database?↵
RELATED MEMORY#architecture

PostgreSQL gives our billing service the reliable transactions it needs.

Good context
travels with you.

One project identity across agents and worktrees. Keep personal preferences close and project decisions in their own scope. Start your next task with the context that belongs there.

OpenCode
recalls
My project
remembers
Claude Code

Your context.
Your account.

Private account ownership, authenticated connections, and PostgreSQL row security. Give each agent a named scope and revoke it whenever you need to.

Private by accountLocal embeddingsMIT licensed

Manage the lifecycle.
Keep the signal.

Browse, search, and correct your memories with revision history. Archive them reversibly or delete them permanently. Durable saves stay until you change them; task handoffs have a clear expiry.

Keep what matters

Four MCP tools. Remember, recall, memories, and forget. Ready for your agent.

Explore the tool reference

SIMPLE ARCHITECTURE

Your agent calls the tools.
Grove keeps the context.

A focused MCP server between your agent and a persistent store. Explicit tool calls. Local embeddings. Durable storage.

Your AI agentOpenCode, Claude, or Codex
MCP TOOLS
GroveAuthenticated private memory
PERSISTENT STORAGE
PostgreSQLAccount-owned rows + pgvector
01

Save the useful things.

Your agent calls remember to save a preference, confirmed decision, useful fact, verified solution, or short handoff. Choose personal or project scope.

02

Keep it private.

Grove saves the memory transactionally in PostgreSQL and indexes its current revision. Only your account and approved connections can access it.

03

Pick up where you left off.

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. One authenticated API for your website and agents.

QUICKSTART

Add memory
to your stack.

Create your Grove account, connect an agent, and save your first project decision.

Open the installation guide
  1. 01

    Give your memories a home.

    Sign in to your Grove deployment and install the client with npm. Self-hosting? Compose starts the API, worker, and private PostgreSQL.

    macOS, Linux, or Windows with Docker
    Docker setup
    git clone https://github.com/miniaxolotl/grove.git
cd grove
cp .env.example .env
# Set Grove Clerk keys and generated passwords in .env
docker compose up -d --build

    Requires Git, Docker Compose, and a configured Grove Clerk application. Set the keys and generated passwords before starting. The first run downloads the local embedding model.

    Check that Grove is ready
    Readiness check
    curl --fail http://localhost:26080/health/ready

    Wait for initialization to finish. The readiness endpoint returns HTTP 200 after the database and configured embedding model are ready.

  2. 02

    Make the connection.

    Give your agent access to Grove’s MCP tools. Use the OpenCode configuration, or connect your preferred MCP client.

    Client configuration reference
    opencode.json
    {
  "$schema": "https://opencode.ai/config.json",
  "plugins": ["@miniaxolotl/grove-opencode-plugin"]
}

    Grove init merges this entry into OpenCode V2 configuration. The plugin adds four memory tools and bounded context recall. Run grove project after approving project access to resolve the same repository identity across agents and worktrees.

  3. Plant your first memory.

    Ask your agent to save something worth keeping. Open a new session, search for it, and pick up the thread.

    Ask your agent to remember
    Use Grove to remember this confirmed decision in my current project: "We use PostgreSQL for billing because we need transactions."

    Then, in a new session

    Ask your agent to recall
    Recall our billing database decision from Grove for this project. 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 reference

A FEW GOOD QUESTIONS

Curious?
Dig a little deeper.

Everything you need to know before giving your agent a longer memory.

Ask a question on GitHub
What exactly is Grove?

Grove is private memory for everyday agent conversations and tasks. Keep preferences, confirmed decisions, useful facts, verified solutions, and short task handoffs. Four tools and a memory library help you pick up where you left off.

Which agents can use it?

Grove includes packages for OpenCode V2, Claude Code, and Codex. Each uses an authenticated API connection. Other MCP clients can use the remote endpoint or the packaged stdio bridge. Hook support depends on the client; explicit memory tools are always available.

Does it remember everything automatically?

Grove keeps concise, useful context through explicit tool calls. Optional hooks retrieve a small profile at task start; they never upload raw conversations or tool logs. Pause automatic memory locally or in Settings. You can inspect every saved memory in your library.

Where does my data go?

Memories are stored in private PostgreSQL behind Grove’s authenticated API. Account ownership and database row security keep users separated. Embeddings run on the Grove server by default. Your AI client receives the context you recall and follows its own data settings. Server-side search is not end-to-end encryption.

Is Grove free?

Grove is open source under the MIT license. Self-hosting uses your own compute, PostgreSQL storage, and Clerk configuration. Hosting and identity providers may have their own costs.

What do I need to get started?

Create an account on your Grove deployment, install the CLI with Node.js 22 or newer, and run grove init for your agent. Browser sign-in or a scoped API key connects the agent. Self-hosting uses Docker Compose, PostgreSQL with pgvector, and a dedicated Clerk application.

Can I organize or remove memories?

Yes. Browse personal and project memories, correct them with revision history, archive them reversibly, or delete them permanently. Durable memories stay until changed or deleted. Temporary handoffs leave recall after 30 days and are purged after 90 days. Each agent gets only its approved scope.

BUILT FOR DEVELOPERS. BY BRAMBLE LABS INC.

Keep the context.
Keep building.

Give your next session the decisions, preferences, and fixes you already worked out.

Install Grove Explore on GitHub OPEN SOURCE · SELF-HOSTED · MIT LICENSED