Integrations

1. Overview — three interfaces, one vault

Claspt exposes your vault through three complementary interfaces. All three operate on the same local vault, respect the same encryption boundaries, and require the vault to be unlocked.

2. MCP Server (AI tools)

Claspt includes a built-in Model Context Protocol (MCP) server that lets AI coding tools interact with your vault as a first-class data source. No plugins, no extensions — it's built into the app.

Supported AI tools

• Claude Code — Anthropic's CLI agent. Add Claspt as an MCP server in your project or global config.
• Claude Desktop — Configure in Claude Desktop settings.
• Cursor — Add to your Cursor MCP configuration.
• Windsurf — Add to Windsurf's MCP settings.
• Any MCP-compatible client — Claspt speaks the standard MCP protocol.

Setup

Add Claspt to your MCP configuration. The exact location depends on your tool:

{
  "mcpServers": {
    "claspt": {
      "command": "claspt",
      "args": ["mcp-server"]
    }
  }
}

{
  "mcpServers": {
    "claspt": {
      "command": "claspt",
      "args": ["mcp-server"]
    }
  }
}

Once configured, your AI tool can call Claspt operations directly. You'll see tool calls like mcp__claspt__search, mcp__claspt__create_page, and mcp__claspt__generate_password in your conversation.

What AI tools can do with your vault

• Search — Find pages by content, title, or tags
• Read & write pages — Create new pages, read existing ones, update content
• Organise — Create folders, list folder contents, move pages
• Generate passwords — 6 modes: random, passphrase, memorable, PIN, UUID, bulk
• Check password strength — Entropy analysis, crack time estimation
• AI memory — Persistent key-value store for cross-session context
• Vault status — Check lock state, vault info

For a detailed setup walkthrough with screenshots, see the blog post: How to Use Claude, Cursor, and Windsurf with Your Encrypted Vault.

3. CLI (command line)

Claspt ships a full command-line interface. Every operation available in the GUI and MCP server is also available from your terminal.

# List all pages
claspt list

# Search your vault
claspt search "AWS credentials"

# Read a specific page
claspt read "DevOps/AWS Production"

# Create a new page
claspt create --title "Deploy Keys" --folder "Infrastructure" --content "# Deploy Keys\n\nSSH keys for CI/CD..."

# Generate a password
claspt generate password --length 24

# Generate a passphrase
claspt generate passphrase --words 5 --separator "-"

# Check password strength
claspt check-strength "MyP@ssw0rd123"

# Vault status
claspt vault status

JSON output for scripting

Add --json to any command for machine-readable output. Pipe it into jq, feed it to another script, or use it in CI/CD.

# Get a password and copy to clipboard
claspt generate password --length 20 --json | jq -r '.value' | pbcopy

# List all pages in a folder as JSON
claspt list --folder "Credentials" --json

# Search and extract first result
claspt search "production database" --json | jq '.[0]'

# Bulk generate 10 passwords
claspt generate bulk --count 10 --length 16 --json

For comprehensive CLI documentation, see: Automate Your Vault — Local HTTP API and CLI.

4. REST API (HTTP)

Claspt runs a local HTTP server (default: http://localhost:9477) that exposes a RESTful JSON API. Use it from any language, any tool, any browser extension.

# List all pages
curl http://localhost:9477/api/pages

# Search the vault
curl http://localhost:9477/api/search?q=AWS

# Create a page
curl -X POST http://localhost:9477/api/pages \
  -H "Content-Type: application/json" \
  -d '{"title": "New Credentials", "folder": "Work", "content": "# My Page\n\nContent here"}'

# Read a specific page
curl http://localhost:9477/api/pages/PAGE_ID

# Generate a password
curl http://localhost:9477/api/generate/password?length=20

# Vault status
curl http://localhost:9477/api/vault/status

All responses are JSON. Errors include a message field with a human-readable description and an appropriate HTTP status code.

5. Storing data — secrets vs. plaintext

Claspt stores two kinds of data, and the distinction matters for integrations:

Creating a page via MCP / CLI / API

When you create a page through any interface, the content is stored as plaintext markdown. This is ideal for documentation, notes, and reference material that you want searchable and always accessible.

// AI tool calls:
mcp__claspt__create_page({
  title: "AWS Production Environment",
  folder: "Infrastructure",
  content: "# AWS Production\n\n## Region: ap-south-1\n\nEC2 instances: 3x t3.medium\nRDS: PostgreSQL 16\nS3 bucket: prod-assets-2026"
})

claspt create \
  --title "AWS Production Environment" \
  --folder "Infrastructure" \
  --content "# AWS Production\n\n## Region: ap-south-1..."

Organising with folders

Create pages in any folder — folders are created automatically if they don't exist. Use list_folders (MCP), claspt folders (CLI), or GET /api/folders (API) to see your folder structure.

6. Retrieving data

Three ways to find and read your vault content:

All three operations work across MCP, CLI, and REST API with identical results.

7. Password generation

Claspt's password generator is available across all three interfaces with 6 generation modes:

Every generated password includes an entropy score (bits), strength rating (0–4), and estimated crack time. You can also check the strength of any existing password with check_password_strength.

8. AI memory

Claspt provides a dedicated key-value memory store designed for AI agents. This lets AI tools remember context across sessions — preferences, project notes, recurring instructions — stored in your vault, not on someone else's server.

// Store a memory
mcp__claspt__memory_upsert({ key: "preferred_lang", value: "TypeScript" })

// Read a memory
mcp__claspt__memory_read({ key: "preferred_lang" })
// → "TypeScript"

// List all memories
mcp__claspt__memory_list()

// Bulk upsert multiple memories
mcp__claspt__memory_bulk_upsert({
  memories: [
    { key: "project", value: "claspt-website" },
    { key: "deploy_target", value: "cloudflare-pages" }
  ]
})

// Delete a memory
mcp__claspt__memory_delete({ key: "old_preference" })

Memories persist across conversations and AI tool sessions. They're stored locally in your vault — private, portable, and under your control.

9. Full operations reference

Every operation available across all three interfaces:

Next steps