Skip to main content
Glama
Kova Mind MCP Server

Kova Mind MCP Server

Official
by KovaMind

@kovamind/mcp-server

npm

MCP server for Kova Mind — use AI memory in Claude Desktop, Cursor, Windsurf, VS Code, and any MCP-compatible client.

Quick setup

npx @kovamind/mcp-server setup

The 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

KOVAMIND_API_KEY

Yes

—

Your Kova Mind API key

KOVAMIND_API_URL

No

https://api.kovamind.io

API base URL

KOVAMIND_USER_ID

No

—

Default user ID for all operations

Available tools

Memory

Tool

Description

memory_extract

Extract memory patterns from a conversation. Credential-guarded — refuses to store text containing API keys or secrets (see below)

memory_recall

Retrieve relevant memories for a context

memory_reinforce

Mark a pattern as confirmed, contradicted, or used

memory_surprise

Score how novel content is vs existing memory

memory_health

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

vault_setup

One-time vault setup. Returns 12 recovery words — store them safely

vault_unlock

Unlock the vault with your passphrase

vault_lock

Lock the vault and zero the key from memory

vault_store

Store a credential. Returns an opaque handle

vault_handles

List available handles (never the values)

vault_find

Search handles by natural-language query

vault_execute

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_id you pass (or the KOVAMIND_USER_ID env var) matches the identity the key was issued for.

  • Unbound keys are unaffected — they pass the client-supplied user_id through 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_id and always send the matching user_id.

Get an API key

Sign up at kovamind.io to get your API key.

License

MIT

Available Tools

12 tools
memory_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

    A3.7/5.0

    Scored across 12 tools

    Disambiguation4/5

    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.

    Naming Consistency5/5

    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.

    Tool Count5/5

    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.

    Completeness4/5

    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

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      Gives Claude Desktop, Cursor, Cline, and other MCP-compatible AI tools persistent memory, enabling them to store and recall information seamlessly across sessions.
      7 npm
      1
      Apache 2.0
    • A
      license
      Not graded
      quality
      B
      maintenance
      Enables 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
    • A
      license
      A
      quality
      C
      maintenance
      Enables 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.
      45
      288 npm
      MIT