Get Started

Vibecoding

Give your coding assistant a memory that survives the session.

You build by prompting, Claude Code, Cursor, Windsurf. Korely gives them one hosted memory for the architecture you settled on, the library you rejected, the convention you agreed, reachable with the same key from every assistant and every machine. Its MCP server exposes your Korely agent store as MCP tools, so the assistant can recall what it learned and remember new decisions, and what it stores are typed, bi-temporal facts with a graph behind them, not a flat transcript it has to re-read.

Set it up

1. Get a key

One command mints a free hobby key and saves it locally, no signup form:

pip install 'korely-memory[mcp]'
korely init --agent --agent-caller claude-code

korely-mcp, the local MCP server, ships with the package and runs on Python 3.9 or later; the [mcp] extra is kept, empty, so the line above keeps working; korely init writes the key to ~/.korely/config.json. See Sign up as an agent for the full flow.

2. Add the MCP server to your assistant

In Claude Code, connect Korely's remote MCP server with one command, using the key from step 1 (saved in ~/.korely/config.json). It is the same setup as on the Claude Code page:

claude mcp add --transport http korely https://api.korely.ai/agent/mcp \
  --header "Authorization: Bearer kor_live_..."

To run the server on your machine instead, the package installs korely-mcp, a local stdio MCP server. Point any MCP-capable client at it. It reads the key from ~/.korely/config.json or the KORELY_API_KEY env var:

claude mcp add korely -- korely-mcp

{
  "mcpServers": {
    "korely": {
      "command": "korely-mcp",
      "env": { "KORELY_API_KEY": "kor_live_..." }
    }
  }
}

Restart the assistant and the four Korely tools appear. That's the whole setup, no rules engine, no separate dashboard.

To save every session without asking, run korely init --tool claude-code (or codex, or cursor) in the repository instead: it installs the MCP server and hooks that hand the assistant the repository's memory when a session starts and save the session to it. See Connect a coding assistant.

3. The tools your assistant now has

A starter prompt

Drop this into your assistant's system prompt or rules file so it uses the memory on its own:

You have persistent memory through the Korely MCP tools. Use it instead of asking
the user to repeat themselves:

- Before answering anything about this project, the user's preferences, or past
  decisions, call korely_get_context with a short query to recall what is known.
- After the user settles a durable decision, preference, convention, or fact,
  call korely_add with one clear sentence so it persists across sessions.
- Use korely_get_facts to check the current typed facts (as_of for what was
  true at a date, known_as_of for what the store knew then); use korely_search
  to pull up the underlying memories.

Memory persists across sessions and is shared with any other Korely surface
(SDK, CLI, REST). Treat it as the source of truth for what was decided.

What it looks like in practice

You tell the assistant "we're standardizing on Postgres and shipping on Fridays". It calls korely_add; Korely extracts you · uses · Postgres and you · ships_on · Fridays. Next week, in a fresh session, you ask it to scaffold a deploy script, it calls korely_get_context("deploy cadence and stack") first and already knows. If you later switch to a Tuesday cadence, the old fact is invalidated (not deleted) and as_of can still reconstruct what the plan was. That is the difference between a memory layer and a chat log.

Go deeper

• Build it into your own agent: the Quickstart and the SDK reference, the same memory, called from code.
• Understand the moat: temporal facts and the graph, why recall returns current truth, not the nearest paragraph.
• Use the CLI directly: the CLI reference, the same tools as korely context, korely add, for scripts and hooks.