Kova Mind MCP Server
OfficialThe Kova Mind MCP Server provides AI memory management and zero-exposure credential vault capabilities for MCP-compatible clients (Claude Desktop, Cursor, Windsurf, VS Code, etc.).
Memory Tools:
memory_extract: Parse conversation messages and store learned patterns about a user.memory_recall: Retrieve relevant memories for a given context, with configurable confidence thresholds.memory_reinforce: Confirm, deny, strengthen, or weaken stored memory patterns based on feedback.memory_surprise: Score how novel or contradictory new content is compared to existing memories.memory_health: Check the health status of the Kova Mind API.
Vault Tools (Zero-Exposure Credentials):
vault_setup: Initialize the secrets vault; returns 12 recovery words for safekeeping.vault_unlock/vault_lock: Unlock the vault with a passphrase, or lock it and zero the encryption key from memory.vault_store: Securely store credentials (API keys, passwords, SSH keys, OAuth tokens, etc.), returning an opaque handle — actual values are never exposed to the AI.vault_handles: List all credential handles (labels and types only, not values).vault_find: Search for credentials using a natural-language query, returning matching handles with relevance scores.vault_execute: Perform HTTP requests or browser form fills using a stored credential handle — credentials flow through a secure side channel and are never exposed to the AI.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Kova Mind MCP Server recall memories about my recent projects"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
@kovamind/mcp-server
MCP server for Kova Mind — use AI memory in Claude Desktop, Cursor, Windsurf, VS Code, and any MCP-compatible client.
Quick setup
Setup wizard (recommended)
npx @kovamind/mcp-server setupThe wizard health-checks the API, detects your installed MCP clients — Claude Code, Claude Desktop, Cursor, Windsurf, Cline, Antigravity, Gemini CLI — and writes the kovamind server entry into each one. Add --dry-run (or --print) to see exactly what would be written (API key masked) without touching any config.
Prefer manual configuration? Use the per-client snippets below.
Claude Desktop
Add to your claude_desktop_config.json:
{
"mcpServers": {
"kovamind": {
"command": "npx",
"args": ["-y", "@kovamind/mcp-server"],
"env": {
"KOVAMIND_API_KEY": "km_live_xxx",
"KOVAMIND_USER_ID": "my-user"
}
}
}
}Cursor
Add to your Cursor MCP settings:
{
"mcpServers": {
"kovamind": {
"command": "npx",
"args": ["-y", "@kovamind/mcp-server"],
"env": {
"KOVAMIND_API_KEY": "km_live_xxx",
"KOVAMIND_USER_ID": "my-user"
}
}
}
}VS Code
Add to .vscode/mcp.json:
{
"servers": {
"kovamind": {
"command": "npx",
"args": ["-y", "@kovamind/mcp-server"],
"env": {
"KOVAMIND_API_KEY": "km_live_xxx",
"KOVAMIND_USER_ID": "my-user"
}
}
}
}Windsurf
Add to your Windsurf MCP config:
{
"mcpServers": {
"kovamind": {
"command": "npx",
"args": ["-y", "@kovamind/mcp-server"],
"env": {
"KOVAMIND_API_KEY": "km_live_xxx",
"KOVAMIND_USER_ID": "my-user"
}
}
}
}Related MCP server: SharedMemory MCP Server
Environment variables
Variable | Required | Default | Description |
| Yes | — | Your Kova Mind API key |
| No |
| API base URL |
| No | — | Default user ID for all operations |
Available tools
Memory
Tool | Description |
| Extract memory patterns from a conversation. Credential-guarded — refuses to store text containing API keys or secrets (see below) |
| Retrieve relevant memories for a context |
| Mark a pattern as confirmed, contradicted, or used |
| Score how novel content is vs existing memory |
| Check API health status |
Vault (zero-exposure credentials)
Credential values never reach the AI. Store a credential once, get back an opaque handle, then ask the AI to act with that handle — the value flows through a secure side channel.
Tool | Description |
| One-time vault setup. Returns 12 recovery words — store them safely |
| Unlock the vault with your passphrase |
| Lock the vault and zero the key from memory |
| Store a credential. Returns an opaque handle |
| List available handles (never the values) |
| Search handles by natural-language query |
| Run an action (http request, browser fill) using a handle |
vault_execute output is additionally scrubbed: if the executed request's response echoes a credential (echo endpoints, request dumps), it comes back as [REDACTED <type>], never the raw value.
Credential guard
A memory product that silently stores a pasted API key is a security failure. memory_extract runs 17 client-side detection patterns (OpenAI, Anthropic, Stripe, GitHub, AWS, Slack, Google, npm, Kova Mind keys, Bearer tokens, private keys, SSNs, inline passwords, generic hex secrets) on the conversation before anything reaches the API. On a match, the tool refuses and points you at vault_store, which encrypts the secret and returns an opaque handle instead.
Troubleshooting
403 — API key is bound to a different agent identity
A Kova Mind API key can be bound server-side to a single user_id (agent identity). If a request's user_id does not match the identity the key is bound to, the API returns:
HTTP 403 {"detail":"API key is bound to a different agent identity"}This surfaces in any tool that takes a user_id (e.g. memory_extract, memory_recall, memory_surprise) as a ... failed: API error 403: ... message.
What to do:
Make sure the
user_idyou pass (or theKOVAMIND_USER_IDenv var) matches the identity the key was issued for.Unbound keys are unaffected — they pass the client-supplied
user_idthrough unchanged, so a single unbound key can serve multiple users.If you need one key per agent, bind the key to that agent's
user_idand always send the matchinguser_id.
Get an API key
Sign up at kovamind.io to get your API key.
License
MIT
Available Tools
12 toolsmemory_extractC
Extract memory patterns from a conversation. Parses messages and stores learned patterns about the user.
Inputs: conversation (required), user_id, session_id.
memory_healthA
Check if the Kova Mind API is healthy and responding.
Inputs: no named parameters.
memory_recallB
Retrieve relevant memory patterns for a given context. Use this to recall what you know about a user.
Inputs: context (required), user_id, max_patterns, min_confidence.
memory_reinforceA
Reinforce or deny a stored memory pattern. Use 'confirmed' when the user validates a memory, 'denied' when they contradict it.
Inputs: pattern_id (required), reinforcement_type (required), context.
memory_surpriseA
Score how surprising/novel new content is compared to existing memories. High scores indicate contradictions with stored knowledge.
Inputs: content (required), user_id.
vault_executeB
Execute an action using a credential. The credential is never exposed to you — it flows through a secure side channel.
Inputs: action (required), target (required), handle, mapping, +1 more.
vault_findA
Find credentials matching a search query. Returns matching handles with relevance scores. You will never see credential values.
Inputs: query (required).
vault_handlesA
List available credential handles. You will never see the credential values — only the handle, label, and type.
Inputs: no named parameters.
vault_lockA
Lock the secrets vault. Zeros the encryption key from memory.
Inputs: no named parameters.
vault_setupA
Set up the secrets vault for the first time. Returns 12 recovery words — store them safely. The vault stores credentials that agents can use without ever seeing the values.
Inputs: passphrase (required).
vault_storeA
Store a new credential in the vault. Returns an opaque handle — you will never see the credential values.
Inputs: label (required), schema_type (required), fields (required), tags.
vault_unlockA
Unlock the secrets vault with your passphrase. Required before storing or using credentials.
Inputs: passphrase (required).
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 12 tools
Tools are clearly grouped by domain (memory vs vault), and within each group, actions are distinct. However, memory_extract vs memory_recall could confuse agents about when to extract vs recall. Overall, most tools have well-defined boundaries.
All tool names follow a consistent verb_noun pattern with a domain prefix (memory_ or vault_). Snake_case is used uniformly, making the naming predictable and easy to navigate.
With 12 tools covering two distinct subsystems (memory and vault), the count is well-scoped. Each tool serves a clear purpose without unnecessary bloat or deficiency.
The memory subsystem covers extraction, recall, reinforcement, and novelty scoring but lacks explicit deletion or listing of all memories. The vault subsystem covers setup, unlock, store, find, handles, execute, and lock, but could benefit from a credential update or delete operation. Minor gaps exist but core workflows are covered.
Maintenance
Related MCP Connectors
Persistent memory for AI assistants — one shared, OAuth-secured vault for every MCP client.
Persistent memory for AI assistants. Save once; recall from Claude, ChatGPT, or any MCP client.
Persistent AI memory shared across Claude, ChatGPT, coding agents, and compatible MCP clients.
Persistent memory for AI agents across Claude, ChatGPT and any MCP client.
Related MCP Servers
AlicenseNot gradedqualityDmaintenanceGives Claude Desktop, Cursor, Cline, and other MCP-compatible AI tools persistent memory, enabling them to store and recall information seamlessly across sessions.7 npm1Apache 2.0- AlicenseAqualityDmaintenanceGives Claude Code, Claude Desktop, Cursor, VS Code Copilot, and other MCP-compatible tools persistent memory.1866 npm1MIT
- AlicenseNot gradedqualityBmaintenanceEnables agents to access a shared portable vault for memory, skills, and API credentials through MCP, so tools can store and retrieve memories, read versioned skill playbooks, and make server-side API calls without exposing secret keys.Apache 2.0
- AlicenseAqualityCmaintenanceEnables AI assistants to retain persistent, searchable memory and versioned vaults, spawn and recall named agents with state and audit history, run automations, monitors, and deep research, and execute on-chain and web tasks across sessions. It can be installed alongside Claude Code, Cursor, Windsurf, Zed, Hermes, and other MCP clients, with vault and memory optionally run entirely on the user's machine.45288 npmMIT