---
slug: "conare-pi"
source_type: "readme"
source_url: "https://cdn.jsdelivr.net/gh/FutureExcited/conare-pi@main/README.md"
repo: "https://github.com/FutureExcited/conare-pi"
source_file: "README.md"
branch: "main"
---
# Conare for Pi

Persistent, cross-session memory for the [Pi coding agent](https://pi.dev) — powered by [Conare](https://conare.ai).

Pi is deliberately minimal: four tools, a tiny system prompt, and **no built-in MCP** — you add capabilities as extensions. This is that extension. It gives Pi a memory that outlives any single session: past decisions, bug fixes, architecture, and your preferences, recalled automatically when you start work and on demand mid-task.

It's the same memory engine Conare already wires into Claude Code, Codex, Cursor, OpenCode, and Grok — so your history follows you across every agent, not just Pi.

## What you get

- **`recall`** — load relevant prior context for the task at hand.
- **`search`** — look up a specific past decision, bug, or conversation.
- **`save`** — persist a durable fact or preference for future sessions.
All three are registered as **native Pi tools** (no MCP proxy, no per-tool token tax) that the model calls when memory is relevant. There's **no automatic recall** — so nothing Conare does is ever on Pi's startup or first-message critical path. (Auto-injecting pre-prepared context is on the roadmap, once it's fast enough to be invisible.)

## Install

The easiest path is the Conare CLI, which sets up the extension (and indexes your existing Pi chats into memory) in one step:

```bash
bunx conare@latest
```

Pick **Pi** when it asks which agents to connect.

### Manual install

This is a [Pi package](https://pi.dev/docs/latest/packages) — install it with Pi's own package manager:

1. Get an API key at [conare.ai](https://conare.ai).
2. Install the package:

   ```bash
   pi install npm:@conare/pi
   ```

   (`pi install git:github.com/FutureExcited/conare-pi` and `pi install ./conare-pi` work too; `pi update --all` keeps it fresh.)
3. Make sure your key is available. The extension finds it automatically from
   `~/.conare/config.json` (written by the Conare CLI), or from `CONARE_API_KEY`
   in your environment — no per-file config needed.
4. Restart Pi (or run `/reload`).

## How it works

The extension talks to Conare's memory engine over its MCP HTTP endpoint (`https://conare.ai/mcp`) using your API key — built-in `fetch`, JSON-RPC `tools/call`, handles both JSON and SSE responses.

The `recall`/`search`/`save` tools call the corresponding memory operations when the model invokes them. There is **no background recall** on a lifecycle hook: any automatic recall today would put a live synthesis round-trip on the critical path and slow your first message. Tools-only keeps Pi fast and lets the model decide when memory is worth fetching. (A future version may auto-inject a *pre-prepared* context blob — fast enough to be invisible — but live synth on every session is the wrong tradeoff.)

It's one small file (its only runtime dependency is TypeBox, Pi's own schema library) — read it, fork it, audit it.

Failure handling follows Pi's contract: a genuine failure (network/HTTP/RPC error) throws, so Pi marks the tool call `isError` and the model can retry or proceed without memory. A missing key isn't an error — it returns a short "not configured, proceed without memory" note instead. Output is capped at 50KB (matching Pi's built-in tools) so a large recall never floods the context window.

## Configuration

| Env var | Default | Purpose |
| --- | --- | --- |
| `CONARE_API_KEY` | — | Your Conare key (required). |
| `CONARE_URL` | `https://conare.ai` | Override for self-hosted / staging. |

## License

MIT © Conare