Claude Desktop Extension (DXT)

Searches your full associative memory graph using cosine similarity across 384-dim vectors. Returns top-k memories ranked by relevance score. Claude calls this automatically at the start of conversations to retrieve prior context.

// Example: recall coding preferences
vektor_recall → query: "coding preferences and project setup"

// Returns scored results like:
[{ content: "User prefers TypeScript", score: 0.97, importance: 4 }]

Routes through the AUDN curation loop — automatically deduplicates, detects contradictions, and resolves conflicts before storing. Importance scores affect how long memories persist and how highly they're ranked in recall.

vektor_store → content: "Project deadline is April 15th — hard deadline", importance: 5
vektor_store → content: "User prefers dark mode in all tools", importance: 3

Traverses the MAGMA graph from a seed topic, returning connected nodes across all four graph types — semantic (similarity), causal (cause→effect), temporal (before→after), entity (co-occurrence). Reveals hidden connections between memories.

vektor_graph → topic: "authentication", depth: 2
// Returns: nodes connected to authentication — JWT decisions, past bugs,
// team preferences, and their further connections

Returns new nodes, updates, and resolved contradictions on a topic over a time window. Useful for morning briefings, project reviews, or understanding how knowledge evolved.

vektor_delta → topic: "project architecture", days: 14
// Shows decisions made, options rejected, changes in direction over 2 weeks

Produces a human-readable briefing of the last 24h of memory activity — new facts stored, important context recalled, and graph changes. Useful as a morning summary or context primer.

vektor_briefing
// Returns: "[SLIPSTREAM BRIEFING — last 24h — 12 memories]
// 1. Project deadline confirmed as April 15th (importance: 5)
// 2. Authentication migrated to JWT — session tokens deprecated ..."

Passes a conversation transcript or summary to an LLM, extracts key facts, decisions, and context, then stores each one via the AUDN deduplication pipeline. Supports multiple LLM providers with automatic fallback. Ideal for end-of-session memory consolidation.

// End-of-session ingestion with Groq (fast + free tier)
vektor_ingest → conversation: "We decided to migrate auth to JWT...", provider: "groq"

// Dry run to preview what would be stored
vektor_ingest → conversation: <transcript>, dry_run: true

// Returns:
// { extracted: 9, stored: 9, skipped: 0, provider: "groq", model: "llama-3.3-70b-versatile" }

Launches a stealth Playwright browser instance, loads the page with full JS/CSS execution, and returns clean compressed text. Bypasses basic bot detection. Results cached locally — force-refresh with force: true.

cloak_fetch → url: "https://example.com", force: true, limit: 12000

First checks if the site has an llms.txt file (a machine-readable content endpoint). If found, fetches it directly without spinning up a browser — faster and uses fewer tokens. Falls back to full stealth Playwright if not found.

cloak_fetch_smart → url: "https://vektormemory.com"
// Returns: { source: "llms.txt", tokensSaved: 2456, llmsFriendly: true }
// Much faster when llms.txt is available

Renders a page with full JS/CSS and returns a detailed layout audit: computed styles for CSS selectors, font load status, layout gap suspects, and asset errors (broken images, blocked scripts). Useful for QA and visual debugging.

cloak_render → url: "https://mysite.com", mobile: true, selectors: ["h1", ".nav", ".cta"]
// Returns: layout dimensions, visibility, font audit, console errors

Compares the current page content against the last cached version and returns a semantic diff — added terms, removed terms, and a summary. Great for monitoring pages for changes.

cloak_diff → url: "https://competitor.com/pricing"
// Returns: { added: ["new plan", "$49"], removed: ["$39"], summary: "+2 / -1" }

Diffs two strings or JSON objects directly — no browser needed. Returns added lines, removed lines, and unchanged status. Useful for comparing prompt versions, config files, or any text output.

cloak_diff_text → a: "Version 1.4.8 — 27 tools", b: "Version 1.4.9 — 34 tools"
// Returns: { added: ["Version 1.4.9..."], removed: ["Version 1.4.8..."] }

Generates a full browser fingerprint — User Agent, WebGL renderer, canvas hash, timezone, platform, fonts. Identities persist across sessions and accumulate visit history for higher trust scores on anti-bot systems.

cloak_identity_create → name: "research-agent-uk", seed: "my-project-2026"
// Returns: UA, platform, WebGL renderer, timezone profile

Launches the stealth browser with the specified identity's full fingerprint — UA, WebGL, timezone, cookies. Call cloak_identity_create first, then use this to browse as that persistent persona.

cloak_identity_use → name: "research-agent-uk", url: "https://example.com"

Returns all stored identities with age, visit count, last used timestamp, and fingerprint summary. Older identities with higher visit counts appear more trustworthy to anti-bot systems.

cloak_identity_list
// Returns: [{ name, ageDays, visitCount, lastUsed, ua, timezone }]

Replays recorded or synthetically generated human mouse/scroll patterns via Playwright CDP. Defeats reCAPTCHA v3, Cloudflare, and DataDome behavioural scoring by making the session look human. Use synthetic mode for quick testing.

cloak_inject_behaviour → url: "https://example.com", category: "reading", durationMs: 5000, synthetic: true
// Returns: { synthetic: true, durationMs: 5000, scrolled: 1316 }

Returns all built-in and custom patterns, their categories, and how they work. Useful to see what's available before calling cloak_inject_behaviour.

cloak_behaviour_stats
// Returns: { builtInPatterns: ["reading","form","shopping","login","deep-scroll-read","idle-hover"] }

Register a custom recorded behaviour pattern for replay. Record patterns using the cloak-recorder browser snippet, then paste the JSON output here. Set save: true to persist across sessions.

Returns tier breakdown (elite / active / probation), win/loss rates, total sessions, and prune rules. The pattern store self-improves — patterns that beat bot detection get promoted, those that fail get demoted.

cloak_pattern_stats
// Returns: { total: 6, tiers: [{ tier: "active", avg_score: 1, total_wins: 0 }], caps: { elite: 10 } }

Returns every pattern with its tier, win/loss score, session count, and description. Filter by tier to see only elite or probation patterns.

cloak_pattern_list → tier: "elite"
// Returns highest-scoring patterns for use in injection

Removes stale (30+ days unused), low-scoring (below -3), aged (90+ days), and near-duplicate (>92% similar) patterns from the store. Runs automatically on schedule, but can be forced manually.

cloak_pattern_prune
// Returns: { removed: 2, remaining: 8 }

Populates the pattern store with the 6 built-in patterns (reading, form, shopping, login, deep-scroll-read, idle-hover). Only runs if the store is empty — safe to call at any time.

cloak_pattern_seed
// Returns: { seeded: 6 } on first run, { seeded: 0, reason: "store already has patterns" } if already seeded

Scans a page for hCaptcha, reCAPTCHA v2/v3, Cloudflare Turnstile, and audio challenges. Returns the CAPTCHA type and sitekey if found. Always run this before cloak_solve_captcha.

cloak_detect_captcha → url: "https://example.com/login"
// Returns: { type: "hcaptcha", sitekey: "abc123" } or null if no CAPTCHA

Attempts to solve the CAPTCHA using vision AI. Supports hCaptcha, reCAPTCHA v2/v3, Cloudflare Turnstile, and audio. Always run cloak_detect_captcha first to confirm the type.

// Typical workflow:
cloak_detect_captcha → url: "https://example.com/login"
// → { type: "hcaptcha" }
cloak_solve_captcha → url: "https://example.com/login", captchaType: "hcaptcha", provider: "claude"

Machine-bound AES-256 encrypted key-value store at ~/.vektor/vault.enc. Safe to store API keys, licence keys, passwords, and tokens. Credentials only decrypt on the machine they were stored on — cannot be read from another device.

// Store your licence key securely
cloak_passport → action: "set", key: "VEKTOR_LICENCE_KEY", value: "08C7D1F4-10FE-40E0-B84E-B583D3FA4E63"

// Retrieve it later
cloak_passport → action: "get", key: "VEKTOR_LICENCE_KEY"
// Returns: { value: "08C7D1F4-10FE-40E0-B84E-B583D3FA4E63" }

// Store other credentials
cloak_passport → action: "set", key: "OPENAI_API_KEY", value: "sk-..."
cloak_passport → action: "set", key: "GEMINI_API_KEY", value: "AIza..."

// Delete a key
cloak_passport → action: "delete", key: "OLD_API_KEY"

Calculates how many tokens VEKTOR saved versus sending raw context in every message. Tracks cost savings and ROI multiple based on your LLM provider's pricing.

tokens_saved → actual_tokens: 7552, raw_tokens: 750000, provider: "anthropic", cost_per_1m: 3.0
// Returns: "99% token reduction · $2.23 saved · 98x ROI"

Recursively scans a project directory, estimates token counts per file, and stores the anatomy in VEKTOR memory. Enables Claude to understand your entire codebase without loading every file into context. Set CLOAK_PROJECT_PATH in your config to avoid specifying it every time.

cloak_cortex → projectPath: "C:\\Users\\you\\my-project", force: true
// Returns: { scanned: 101, skipped: 0, written: 101, totalTokens: 7552991 }

// Or set CLOAK_PROJECT_PATH in config and just call:
cloak_cortex → force: true

Returns the cached file list and token estimates from the last cloak_cortex scan — sorted by token count descending. Fast read with no file I/O. Use this to navigate large codebases efficiently.

cloak_cortex_anatomy
// Returns: [{ path: "vektor.mjs", tokens: 27885 }, { path: "slipstream-core.js", tokens: 10258 }, ...]
// Files sorted largest to smallest — see at a glance what to load vs skip

Compresses all stored vector embeddings using TurboQuant PolarQuant — reducing storage by ~75% while maintaining ~0.998 cosine similarity. Runs automatically in the background but can be triggered manually. Safe to run at any time.

turbo_quant_compress
// Returns: { migrated: 1, skipped: 0, alreadyPolar: 10072, errors: 0 }

// If errors > 0: some DB rows have null/malformed embeddings
// Run: npx vektor fix-db in your vektor-slipstream directory

Returns three compression profiles for 384-dim vectors: legacy scalar (90% reduction, ~0.989 similarity), PolarQuant (75% reduction, ~0.998 similarity), and PolarQuant+QJL (71% reduction, ~0.9995 similarity). Higher similarity = more accurate recall.

turbo_quant_stats
// Returns:
// polarQuant: { bytes: 391, ratio: 3.93, savingPct: 75, cosineSim: "~0.998" }
// oldScalar:  { bytes: 156, ratio: 9.85, savingPct: 90, cosineSim: "~0.989" }