Kronvex Memory API

Step 1 — Get your API key

Get your free key and copy your kv- key and an agent UUID.

Step 2 — Edit the config file for your client

• Claude Desktop (Mac): ~/Library/Application Support/Claude/claude_desktop_config.json
• Claude Desktop (Windows): %APPDATA%\Claude\claude_desktop_config.json
• Claude Code CLI: ~/.claude/settings.json (under the mcpServers key)

Step 3 — Add the MCP server block

Merge this into your existing config (or create the file if it doesn't exist):

{
  "mcpServers": {
    "kronvex": {
      "command": "npx",
      "args": ["@kronvex/mcp"],
      "env": {
        "KRONVEX_API_KEY": "kv-your-key",
        "KRONVEX_AGENT_ID": "your-agent-uuid"
      }
    }
  }
}

Step 4 — Restart Claude Desktop, or run /mcp reload in Claude Code.

Step 1 — Get your API key

Get your free key to get your kv- key and an agent UUID.

Step 2 — Create or edit .cursor/mcp.json

Place this file in your project root (or the global Cursor config at ~/.cursor/mcp.json):

{
  "mcpServers": {
    "kronvex": {
      "command": "npx",
      "args": ["@kronvex/mcp"],
      "env": {
        "KRONVEX_API_KEY": "kv-your-key",
        "KRONVEX_AGENT_ID": "your-agent-uuid"
      }
    }
  }
}

Step 3 — Restart Cursor (Cmd/Ctrl+Shift+P → "Developer: Reload Window").

Step 1 — Get your API key

Get your free key and copy your kv- key and an agent UUID.

Step 2 — Add via Cline UI or config file

Option A — Cline UI: Open the Cline panel in VS Code → gear icon → MCP Servers → Add. Fill in:

Name:    kronvex
Command: npx
Args:    -y @kronvex/mcp
Env:     KRONVEX_API_KEY=kv-your-key
         KRONVEX_AGENT_ID=your-agent-uuid

Option B — JSON config (create or edit ~/.cline/mcp_settings.json):

{
  "mcpServers": {
    "kronvex": {
      "command": "npx",
      "args": ["-y", "@kronvex/mcp"],
      "env": {
        "KRONVEX_API_KEY": "kv-your-key",
        "KRONVEX_AGENT_ID": "your-agent-uuid"
      }
    }
  }
}

Step 3 — Reload the Cline extension or restart VS Code.

Step 1 — Get your API key

Get your free key to get your kv- key and an agent UUID.

Step 2 — Create or edit the config file

Edit ~/.codeium/windsurf/mcp_config.json:

{
  "mcpServers": {
    "kronvex": {
      "command": "npx",
      "args": ["-y", "@kronvex/mcp"],
      "env": {
        "KRONVEX_API_KEY": "kv-your-key",
        "KRONVEX_AGENT_ID": "your-agent-uuid"
      }
    }
  }
}

Step 3 — Restart Windsurf to apply the configuration.

Step 1 — Get your API key

Get your free key to get your kv- key and an agent UUID.

Step 2 — Edit ~/.gemini/settings.json

{
  "mcpServers": {
    "kronvex": {
      "command": "npx",
      "args": ["-y", "@kronvex/mcp"],
      "env": {
        "KRONVEX_API_KEY": "kv-your-key",
        "KRONVEX_AGENT_ID": "your-agent-uuid"
      }
    }
  }
}

Step 3 — Run any Gemini CLI command — the MCP server loads automatically.

Step 1 — Get your API key

Get your free key to get your key and an agent UUID.

Step 2 — Open VS Code Settings (JSON)

Press Cmd/Ctrl+Shift+P → "Open User Settings (JSON)" and add:

{
  "github.copilot.chat.mcp.servers": {
    "kronvex": {
      "command": "npx",
      "args": ["-y", "@kronvex/mcp"],
      "env": {
        "KRONVEX_API_KEY": "kv-your-key",
        "KRONVEX_AGENT_ID": "your-agent-uuid"
      }
    }
  }
}

Step 3 — Reload VS Code. The Kronvex tools will appear in Copilot Chat.

1. Get your free key.

2. Register the MCP server in your client's config with these parameters:

Command:  npx @kronvex/mcp
Env var:  KRONVEX_API_KEY=kv-your-key

3. The server exposes 3 MCP tools:

1. Open VS Code → Command Palette → Kilo Code: Open MCP Settings

2. Add the Kronvex MCP server:

{
  "mcpServers": {
    "kronvex": {
      "command": "npx",
      "args": ["-y", "@kronvex/mcp"],
      "env": {
        "KRONVEX_API_KEY": "kv-your-key"
      }
    }
  }
}

3. Reload VS Code. Kilo Code will show the Kronvex tools in the MCP panel.

1. Edit your OpenCode config file (~/.config/opencode/config.json):

{
  "mcp": {
    "servers": {
      "kronvex": {
        "command": "npx",
        "args": ["-y", "@kronvex/mcp"],
        "env": {
          "KRONVEX_API_KEY": "kv-your-key"
        }
      }
    }
  }
}

2. Restart OpenCode. The Kronvex tools will be available in the next session.

1. Open ChatGPT Desktop → Settings → MCP Servers.

2. Add a new server with these parameters:

Name:    kronvex
Command: npx -y @kronvex/mcp
Env:     KRONVEX_API_KEY=kv-your-key

3. Save and restart ChatGPT Desktop. The memory tools appear automatically.

Call Kronvex before and after each AutoGen conversation turn:

from kronvex import Kronvex

kv = Kronvex("kv-your-key")
agent = kv.agents("autogen-agent")

# Before the conversation — inject past context
context = agent.inject_context(query="user preferences and history")

# Run AutoGen with context in system message
import autogen
assistant = autogen.AssistantAgent(
    name="assistant",
    system_message=f"You are a helpful assistant.\n\n{context['prompt']}"
)

# After the conversation — store what happened
agent.remember("User asked about X, resolved with Y")

Recall relevant memories before generating a response:

Method: POST
URL:    https://api.kronvex.io/api/v1/agents/YOUR_AGENT_ID/inject-context
Headers:
  X-API-Key: kv-your-key
  Content-Type: application/json
Body:
  { "query": "{{ $json.question }}", "top_k": 5 }

→ Use response.prompt as system message in your LLM node.

Add an HTTP node before your LLM node to inject relevant context:

Method: POST
URL:    https://api.kronvex.io/api/v1/agents/YOUR_AGENT_ID/inject-context
Headers:
  X-API-Key: kv-your-key
  Content-Type: application/json
Body:
  { "query": "{{#sys.query#}}", "top_k": 5 }

→ Wire response.prompt into your LLM node's system prompt.

Async client

from kronvex.async_client import AsyncKronvex
import asyncio

async def main():
    kv = AsyncKronvex("kv-your-key")
    agent = kv.agents("my-agent")

    await agent.remember("User is based in Paris", memory_type="semantic")

    memories = await agent.recall("user location", top_k=3)
    for m in memories:
        print(m.content, m.confidence)

asyncio.run(main())

Full Express.js chatbot example

import express from 'express';
import { Kronvex } from 'kronvex';
import OpenAI from 'openai';

const app = express();
const kv = new Kronvex('kv-your-key');
const openai = new OpenAI();

app.post('/chat', async (req, res) => {
  const { userId, message } = req.body;
  const agent = kv.agents(userId);

  // 1. Load relevant memories
  const ctx = await agent.injectContext(message);

  // 2. Call LLM with memory context
  const response = await openai.chat.completions.create({
    model: 'gpt-4o',
    messages: [
      { role: 'system', content: ctx.contextBlock },
      { role: 'user', content: message }
    ]
  });

  const reply = response.choices[0].message.content;

  // 3. Store the interaction
  await agent.remember(`User said: ${message}. Bot replied: ${reply}`, {
    memoryType: 'episodic'
  });

  res.json({ reply });
});

1. Install the dependencies:

pip install kronvex langchain

2. Use the Kronvex memory integration:

from kronvex.integrations.langchain import KronvexMemory

memory = KronvexMemory(api_key="kv-your-key", agent_id="my-agent")
# Drop into any LangChain chain or LangGraph node

1. Install the SDK:

pip install kronvex crewai

2. Add the Kronvex tool to your CrewAI agent:

from kronvex.integrations.crewai import KronvexMemoryTool

tool = KronvexMemoryTool(api_key="kv-your-key", agent_id="my-agent")
# Pass as tool in CrewAI agent definition

1. In n8n, go to Settings → Community Nodes and install:

@kronvex/n8n-nodes-kronvex

2. In your workflow, add a Kronvex node.

3. Set credentials: click Add Credential → enter your API key:

API Key: kv-your-key

4. Select operation (Remember / Recall / Inject Context), connect to your workflow nodes, and save.

1. Install the dependencies:

pip install kronvex openai-agents

2. Register Kronvex as agent tools:

from agents import tool
from kronvex import Kronvex

kv = Kronvex(api_key="kv-your-key")

@tool
def remember(content: str) -> str:
    kv.remember("my-agent", content)
    return "Stored"

@tool
def recall(query: str) -> str:
    mems = kv.recall("my-agent", query)
    return "\n".join(m.content for m in mems)

1. Install dependencies:

pip install kronvex openai

2. Use Kronvex alongside Grok (xAI's OpenAI-compatible SDK):

from openai import OpenAI
from kronvex import Kronvex

grok = OpenAI(api_key="xai-your-key", base_url="https://api.x.ai/v1")
kv   = Kronvex(api_key="kv-your-key")

AGENT = "grok-agent"

def chat(user_msg: str) -> str:
    # Inject past memories into system prompt
    ctx = kv.inject_context(AGENT, user_msg)
    resp = grok.chat.completions.create(
        model="grok-3",
        messages=[
            {"role": "system", "content": ctx},
            {"role": "user",   "content": user_msg},
        ]
    )
    answer = resp.choices[0].message.content
    # Store the exchange
    kv.remember(AGENT, f"User: {user_msg}\nGrok: {answer}")
    return answer

1. Install dependencies:

pip install kronvex anthropic

2. Pass Kronvex memory into Claude's system prompt:

import anthropic
from kronvex import Kronvex

client = anthropic.Anthropic(api_key="sk-ant-...")
kv     = Kronvex(api_key="kv-your-key")

AGENT = "claude-agent"

def chat(user_msg: str) -> str:
    ctx = kv.inject_context(AGENT, user_msg)
    resp = client.messages.create(
        model="claude-opus-4-6",
        max_tokens=1024,
        system=ctx,
        messages=[{"role": "user", "content": user_msg}]
    )
    answer = resp.content[0].text
    kv.remember(AGENT, f"User: {user_msg}\nClaude: {answer}")
    return answer

1. Install dependencies:

pip install kronvex google-adk

2. Register Kronvex as ADK tools:

from google.adk.agents import Agent
from google.adk.tools import FunctionTool
from kronvex import Kronvex

kv = Kronvex(api_key="kv-your-key")
AGENT = "adk-agent"

def remember(content: str) -> str:
    kv.remember(AGENT, content)
    return "Stored"

def recall(query: str) -> str:
    mems = kv.recall(AGENT, query)
    return "\n".join(m.content for m in mems)

agent = Agent(
    model="gemini-2.0-flash",
    name="my_agent",
    tools=[FunctionTool(remember), FunctionTool(recall)],
)

1. Install dependencies:

npm install @kronvex/sdk ai

2. Use Kronvex as a tool in your Vercel AI agent:

import { generateText, tool } from 'ai'
import { openai } from '@ai-sdk/openai'
import { z } from 'zod'
import Kronvex from '@kronvex/sdk'

const kv = new Kronvex({ apiKey: 'kv-your-key' })
const AGENT = 'vercel-agent'

const { text } = await generateText({
  model: openai('gpt-4o'),
  system: await kv.injectContext(AGENT, userMessage),
  prompt: userMessage,
  tools: {
    remember: tool({
      description: 'Store a memory',
      parameters: z.object({ content: z.string() }),
      execute: async ({ content }) => {
        await kv.remember(AGENT, content)
        return 'Stored'
      },
    }),
    recall: tool({
      description: 'Search memories',
      parameters: z.object({ query: z.string() }),
      execute: async ({ query }) => {
        const mems = await kv.recall(AGENT, query)
        return mems.map(m => m.content).join('\n')
      },
    }),
  },
})

1. Get your free key.

2. Store a memory:

curl -X POST https://api.kronvex.io/api/v1/agents/AGENT_ID/remember \
  -H "X-API-Key: kv-your-key" \
  -H "Content-Type: application/json" \
  -d '{"content": "User prefers formal tone", "memory_type": "semantic"}'

3. Recall memories:

curl -X POST https://api.kronvex.io/api/v1/agents/AGENT_ID/recall \
  -H "X-API-Key: kv-your-key" \
  -H "Content-Type: application/json" \
  -d '{"query": "tone preference", "top_k": 5}'