Connect your AI agent in one command.

Auto-detects Claude Desktop, Claude Code, Cursor, Windsurf, Cline and Gemini CLI. Prompts for your API key and configures everything in seconds.

Detects installed agents, writes the MCP config automatically. Or follow a manual guide below. Get your key at dashboard.kronvex.io.

npx @kronvex/setup --key kv-your-key --agent your-agent-id

Pass --key and --agent to skip the interactive prompts — useful for automated provisioning.

Agent Rules — teach Claude to use memory automatically

Add these instructions to your CLAUDE.md (or any project's .claude/skills/memory.md) so Claude automatically loads and saves context on every task — without being prompted:

## Memory Protocol (Kronvex)

BEFORE every task:
- Call `kronvex_recall` with the current task description as the query
- Inject any returned memories into your working context

AFTER every task:
- Call `kronvex_remember` to store:
  - Key decisions made
  - Patterns or preferences discovered
  - Architecture choices and their rationale
  - Anything that would help in future sessions

Memory types to use:
- `procedural` — how to do things (preferred approaches, commands, style rules)
- `semantic`   — facts about the project (stack, team, constraints)
- `episodic`   — what happened (bugs fixed, features shipped, blockers hit)

Ask Claude: "Use Kronvex to remember that I prefer TypeScript strict mode."
→ Claude calls kronvex_remember and confirms: "Memory stored."

Ask Claude: "What are my coding preferences?"
→ Claude calls kronvex_recall and returns the memory above.

Cursor Rules — automatic memory on every task

Add this rule to .cursor/rules/kronvex.mdc so Cursor's agent recalls and stores context automatically on each task:

---
description: Persistent memory via Kronvex MCP
globs: ["**/*"]
alwaysApply: true
---

## Kronvex Memory Protocol

BEFORE starting any task:
1. Call `kronvex_recall` with the task description as query
2. Read returned memories and incorporate them into your plan

AFTER completing any task:
1. Call `kronvex_remember` to store:
   - Architecture decisions made
   - Patterns and conventions established
   - Bugs fixed and their root causes
   - Preferences expressed by the user

Use memory_type: "procedural" for how-to knowledge, "semantic" for project facts.

In Cursor agent mode: "Remember that this project uses pnpm workspaces."
→ Cursor calls kronvex_remember → "Memory stored successfully."

Next session: "What's the package manager for this project?"
→ Cursor calls kronvex_recall → returns the memory above.

Cline Rules — automatic memory on every task

Create .clinerules/kronvex.md in your project root to teach Cline to automatically load and save memory:

## Memory Protocol (Kronvex)

BEFORE every task:
1. Call `kronvex_recall` with the current task description as query
2. Incorporate returned memories into your plan

AFTER every task:
1. Call `kronvex_remember` to store:
   - Architecture decisions made
   - Patterns and conventions discovered
   - Bugs fixed and their root causes
   - User preferences and constraints

Use memory_type: "procedural" for how-to knowledge, "semantic" for project facts,
"episodic" for events (bugs, deploys, decisions).

Ask Cline: "Use Kronvex to remember that this project uses ESLint with airbnb config."
→ Cline calls kronvex_remember → "Memory stored successfully."

Next session: "What linter config does this project use?"
→ Cline calls kronvex_recall → returns the memory above.

Windsurf Rules — automatic memory on every task

Create .windsurf/rules/kronvex.md in your project root to teach Cascade to recall and store memory automatically:

## Memory Protocol (Kronvex)

BEFORE every task:
1. Call `kronvex_recall` with the current task description as query
2. Incorporate returned memories into your plan

AFTER every task:
1. Call `kronvex_remember` to store:
   - Architecture and design decisions
   - Patterns and conventions established
   - Preferences expressed by the user
   - Bugs fixed and their root causes

Prefer memory_type "procedural" for workflows, "semantic" for project facts.

Ask Cascade: "Use Kronvex to remember that I prefer dark theme in all projects."
→ Cascade calls kronvex_remember → "Memory stored successfully."

Next session: "What are my UI preferences?"
→ Cascade calls kronvex_recall → returns the memory above.

GEMINI.md — automatic memory on every task

Add this block to GEMINI.md in your project root (or ~/.gemini/GEMINI.md globally) to teach Gemini CLI to use Kronvex automatically:

## Memory Protocol (Kronvex)

BEFORE every task:
1. Call `kronvex_recall` with the current task description as query
2. Incorporate returned memories into your plan

AFTER every task:
1. Call `kronvex_remember` to store:
   - Key decisions and their rationale
   - Patterns discovered in the codebase
   - User preferences and constraints
   - Bugs resolved and root causes

Use memory_type: "semantic" for facts, "procedural" for workflows.

gemini "Use Kronvex to remember that I prefer dark theme in all projects."
→ Gemini calls kronvex_remember → "Memory stored successfully."

Next session: "What are my UI preferences?"
→ Gemini calls kronvex_recall → returns the memory above.

Copilot Instructions — automatic memory on every task

Create .github/copilot-instructions.md in your project root to teach Copilot to use memory automatically:

## Memory Protocol (Kronvex)

BEFORE every task:
1. Call `kronvex_recall` with the current task description as query
2. Incorporate returned memories into your plan

AFTER every task:
1. Call `kronvex_remember` to store:
   - Architecture and design decisions
   - Coding standards and conventions
   - Personal preferences expressed
   - Bugs fixed and root causes found

Use memory_type: "procedural" for coding conventions, "semantic" for project facts.

In Copilot Chat: "Use Kronvex to remember that our API uses REST with JSON:API spec."
→ Copilot calls kronvex_remember → "Memory stored successfully."

Next session: "What API spec does this project use?"
→ Copilot calls kronvex_recall → returns the memory above.

Call tool: kronvex_recall  with  { "agent_id": "test-agent", "query": "test" }
→ Should return an empty list (no memories yet) — confirming the connection works.

In Kilo Code chat: "remember that this project uses TypeScript strict mode"
→ Kilo Code calls kronvex_remember → "Memory stored."

Next session: "what are the project conventions?"
→ Kilo Code calls kronvex_recall → returns the memory above.

Tell OpenCode: "remember that we use pnpm, not npm"
→ calls kronvex_remember → "Memory stored."

Later: "what package manager does this project use?"
→ calls kronvex_recall → returns the memory above.

In ChatGPT: "remember that I'm working on a SaaS product called Kronvex"
→ ChatGPT calls kronvex_remember → "Memory stored."

Next session: "what product am I working on?"
→ ChatGPT calls kronvex_recall → returns the memory above.

Works with your entire AI stack.

If it can make an HTTP POST, it already works with Kronvex. Native SDKs for Python and Node.js, framework adapters for LangChain, CrewAI and more, plus no-code nodes for n8n and Flowise.

Don't see your integration?

Kronvex is REST-first — if your tool can make an HTTP request, it works today. Missing a native SDK or tutorial? Let us know.

Run the snippet above.
→ Should print: "User prefers formal tone"

Run the snippet above with ts-node or tsx.
→ Should print: "User prefers formal tone"

memory.save_context({"input": "test"}, {"output": "hello"})
memories = memory.load_memory_variables({})
print(memories)
→ Should print stored context from Kronvex.

result = tool._run("remember: project uses Python 3.11")
print(result)
→ Should return a confirmation string from Kronvex.

Execute a "Remember" node with content: "test memory from n8n"
→ The node output should show { "id": "...", "content": "test memory from n8n" }

print(remember("Test memory from OpenAI Agents SDK"))
→ Should print: "Stored"
print(recall("test"))
→ Should print: "Test memory from OpenAI Agents SDK"

print(chat("My stack is FastAPI + PostgreSQL"))
# Second call — Grok now remembers your stack
print(chat("What database should I use for a new microservice?"))
→ Grok answers based on the stored context.

print(chat("I'm building a SaaS with Stripe and FastAPI"))
# Second message — Claude remembers your stack
print(chat("What auth approach fits my stack?"))
→ Claude answers with full context from memory.

result = agent.run("remember: our CI runs on GitHub Actions")
# Later:
result = agent.run("how does our CI work?")
→ Agent recalls the memory and answers correctly.

// First call
generateText({ prompt: "I prefer TypeScript with strict mode" })
→ Agent calls remember → "Stored"

// Next request — agent has full context
generateText({ prompt: "set up my tsconfig" })
→ Agent generates config with strictMode: true

Run the store command above.
→ Should return: { "id": "...", "content": "User prefers formal tone", "confidence": 1.0 }

What you can build with Kronvex

From customer support to legal research — any B2B AI agent that interacts with humans gets measurably better with persistent memory.

Support agents that know your users

Your AI support agent knows a user's full history — past tickets, preferences, account tier, prior resolutions. No more "can you repeat the issue?" — the agent already knows.

client.agents("support-bot").remember(
  "User John prefers email updates, on Pro plan since Jan, had billing issue in March"
)
ctx = client.agents("support-bot").inject_context("renewal question")

Sales agents with perfect deal memory

Every call, every objection, every buying signal — your AI sales agent remembers it all and opens the next conversation exactly where you left off.

# After each sales call, persist deal context
client.agents("sales-bot").remember(
  "Acme Corp: budget €50k, decision by Q3, main blocker is IT security review",
  memory_type="episodic"
)

Coding assistants with project memory

Your AI dev tool remembers architecture decisions, naming conventions, tech debt notes, and team preferences — producing code that fits your actual codebase.

Legal assistants with case memory

Your legal AI retains full case context — precedents cited, client instructions, document history — across every session. Never re-read the file. Just ask.

Personal assistants with long-term memory

Your AI assistant builds a persistent user profile — preferences, habits, history, goals — and carries that context across every conversation, indefinitely.

client.agents("personal-assistant").remember(
  "User prefers concise replies, morning briefings at 8am, based in Paris"
)
context = client.agents("personal-assistant").inject_context(user_message)