Provides structured logging integration with Datadog for monitoring and debugging.
Allows syncing memories and capturing decisions from GitHub Actions workflows.
Enables importing memories from Notion exports.
Enables importing memories from Obsidian exports.
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., "@Velixar MCP Server get my current identity profile"
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.
The first cognitive memory server for AI assistants. Not a vector database wrapper — a full reasoning layer that gives your AI persistent memory, a knowledge graph, identity awareness, contradiction detection, and belief tracking across every session.
Works with any Model Context Protocol client: Claude Desktop, Kiro, Cursor, Windsurf, Continue.dev, or custom hosts.
Every AI assistant starts from zero every conversation. Velixar fixes that — but not by just storing and retrieving text. The MCP server gives your assistant the ability to:
Orient itself in a workspace with a single call — no manual context assembly
Track how beliefs evolve over time and surface when they contradict
Build and traverse a knowledge graph of entities and relationships it discovers
Maintain a persistent identity model of who you are, what you prefer, and how you work
Distill sessions into durable memories automatically, with deduplication
Import and export your entire memory corpus for backup or migration
40 tools. 5 live resources. 19 workflow prompts. One npm install.
Related MCP server: dbrain
npm install -g velixar-mcp-serverGet an API key at velixarai.com/settings/api-keys, then add to your MCP client:
{
"mcpServers": {
"velixar": {
"command": "velixar-mcp-server",
"env": {
"VELIXAR_API_KEY": "vlx_your_key_here"
}
}
}
}Restart your assistant. Done.
Tool | What it does |
| Store a memory with tags, tier, and type |
| Semantic search across all memories |
| Browse with pagination and filtering |
| Edit content or tags on an existing memory |
| Remove a memory |
Tool | What it does |
| Synthesized workspace briefing — orientation in one call |
| Get, store, or update the user's profile, preferences, and expertise |
| Surface conflicting facts or beliefs with resolution guidance |
| How a topic or belief evolved over time |
| Recurring problem/solution motifs across your history |
| Deep inspection of a specific memory with full provenance chain |
| Walk entity relationships — "what connects to X?" |
| Extract durable memories from session content with deduplication |
Tool | What it does |
| Save a session summary for later recall |
| Restore context from a previous session |
| Store up to 20 memories in one call |
| Run up to 10 search queries simultaneously |
| Merge related memories into a single durable memory |
| Bulk update tags across memories |
| Export memories as JSON or Markdown, optionally with graph data |
| Bulk import from JSON, Markdown, Notion, or Obsidian exports |
Tool | What it does |
| Backend connectivity, latency, workspace status |
| Cache state, circuit breaker, API timings |
| Feature list, tool inventory, resource URIs |
| Get or set content scanning mode |
Resources are injected into your assistant's context automatically — no tool call needed.
Resource | What it provides |
| Behavioral rules and cognitive modes for the assistant |
| Your persistent user profile |
| Most recent memories (compact) |
| Contextually relevant memories based on current activity |
| Knowledge graph view for a specific domain |
16 built-in prompts that guide multi-step reasoning workflows:
Orientation — recall prior reasoning, build project context, profile an entity, orient-then-narrow
Conflict — resolve contradictions, identify knowledge gaps
Continuity — trace belief evolution, resume sessions, reconstruct decision paths
Lifecycle — distill sessions, consolidate topic memory, retag recent memories
Identity — summarize user identity, detect preference shifts, align response style
Enterprise — evaluate enterprise fit for a domain
Memories are scoped to workspaces. Your personal project never bleeds into work.
Priority | Source | How |
1 |
| Explicit |
2 |
|
|
3 | Git root directory name | Automatic |
Host | Tools | Resources | Prompts |
Kiro CLI | ✅ | ✅ | ✅ |
Claude Desktop | ✅ | ✅ | ✅ |
Cursor | ✅ | ⚠️ | — |
Windsurf | ✅ | ⚠️ | — |
Continue.dev | ✅ | ✅ | ✅ |
When a host doesn't support resources or prompts, the server degrades gracefully — all tools still work independently.
Variable | Required | Description |
| Yes | Your API key (starts with |
| No | Explicit workspace scope |
| No | Custom API endpoint |
| No | Explicit end-user identity. Leave unset (recommended): the API derives scope from your key — you see your own memories, same as the dashboard. Set it only when one key serves multiple named end users |
| No |
|
| No |
|
| No | Port for HTTP health check endpoint |
Automatic retry with exponential backoff (3 attempts)
Circuit breaker — opens after sustained failures, auto-recovers
Cache fallback — serves stale data during outages rather than failing
Structured logging compatible with Datadog and CloudWatch
Use Velixar directly from code:
GitHub Actions: velixar-memory-sync — distill PR merges into memories
GitHub Actions: velixar-decision-capture — store issue resolutions as decisions
Webhook: POST /webhook/ci — generic CI event ingestion
MIT
Query recent tool calls made by THIS MCP session (in-process diagnostics, volatile, completed calls only). For the durable, hash-chained provenance trail pass durable:true — that queries the backend audit chain.
Inputs: after, limit, before, durable, +1 more.
Store multiple memories in one call. Returns per-item status. Use for bulk imports or multi-fact storage. Max 20 items per call.
Inputs: items (required).
List all available Velixar tools, resources, prompts, and features. Use to discover what cognitive capabilities are currently enabled.
Inputs: no named parameters.
Merge related episodic memories into a single semantic memory. Preserves originals as provenance. Use when multiple episodic memories cover the same topic and should be unified. Provide memory IDs to consolidate, or a topic to auto-find candidates. Set preview=true to see what would be merged without executing.
Inputs: topic, preview, summary, memory_ids.
Synthesize the best working brief for the current workspace. Recommended first tool for any new task. Returns summary, relevant facts, open issues, contradiction flags, and pattern hints.
Inputs: topic, compact.
Surface conflicting beliefs, preferences, or facts. Supports resolve action to mark contradictions as resolved. Returns pairs of contradicting statements with severity and linked memory IDs.
Inputs: topic, action, status, resolution, +2 more.
Check how well retrieved memories cover a topic. Returns coverage ratio, gaps, and suggested follow-up queries. Anti-hallucination guardrail — use before synthesizing an answer to verify completeness.
Inputs: topic (required), memory_ids, auto_retrieve.
Get debug information about the current Velixar MCP server state. Returns workspace config, cache state, API timings, retry counts, circuit breaker state.
Inputs: verbose.
Delete or archive memories. Use archive: true for soft-delete (recoverable).
Inputs: id, ids, archive, memory_id.
Find which data sources contain information about a topic via knowledge graph. Returns source names, tables, and related insights.
Inputs: topic (required), depth, include_schema.
Extract durable memories from session content. Use at natural memory-worthy breakpoints: task complete, decision made, bug solved, preference clarified. Detects duplicates (skips near-identical content) and flags active contradictions. Use preview: true to see extractions without storing.
Inputs: content (required), tags, preview, source_ids, +1 more.
Export memories as structured data (JSON or Markdown). Supports filtering by tags, tier, date range, and search query.
Inputs: all, tags, tier, after, +5 more.
Fuzzy entity search by name or type. Use to find entities without knowing exact names.
Inputs: query (required), limit, entity_type.
KG overview — entity count, relationship count, top entity types. Workspace-scoped.
Inputs: no named parameters.
Walk relationships from an entity — "what connects to X?" Supports fuzzy entity matching, relationship and entity type filtering.
Inputs: entity (required), depth, entity_type, relationship_type.
Check Velixar backend connectivity and health. Returns connection state, workspace, and latency.
Inputs: no named parameters.
User profile — preferences, expertise, communication style, recurring goals, stable constraints. Supports get (default), store, update, delete, list, and history actions. Workspace-scoped.
Inputs: field, value, action.
Bulk import memories from structured data (JSON or Markdown). Max 50 items per call. Supports conflict detection: skip duplicates, overwrite, or merge.
Inputs: data (required), format, source, default_tags, +2 more.
Deep inspection of a specific memory — raw content, provenance, relations, chain links.
Inputs: memory_id (required).
Trace the DERIVATION lineage of a memory — the knowledge-building graph, NOT similarity. Every edge was declared at store time via source_ids ("this memory was reasoned/built FROM those"). This answers "what understanding did this come from, and what was built on it" — fundamentally different from velixar_search_neighborhood, which finds memories that merely resemble one another in vector space. Upstream = ancestors (what it was built on); downstream = descendants (what was built on it). A memory with no ancestors is an origin (learned fresh). Returns nodes (each with hop distance and is_origin) and directed child→parent edges.
Inputs: memory_id (required), depth, direction.
List recent memories with pagination. Returns full metadata including IDs, tags, and timestamps. Supports filtering by tags, date range, tier, and memory type.
Inputs: sort, tags, tier, after, +5 more.
List all connected data sources for the current customer. Supports filtering by type and status.
Inputs: type, status.
Search from multiple angles simultaneously with deduplication and temporal awareness. Returns merged results by default. Set merge: false for per-query results (replaces velixar_batch_search).
Inputs: queries (required), limit, merge, strategy, +2 more.
Surface recurring problem/solution motifs from memory. Omit topic to return all detected patterns. Supports dismiss action.
Inputs: limit, topic, action, evidence, +2 more.
Assemble a token-budgeted, task-aware context package with explicit gap declaration. Runs multi-angle search, coverage check, and temporal analysis internally.
Inputs: intent (required), queries, strategy, context_ttl, +3 more.
Query a live data source through Marco Polo. Returns real-time data (ground truth). Natural language query is translated to SQL/API call. Always tag results as [LIVE DATA].
Inputs: query (required), datasource (required), limit, cursor, +1 more.
Expand a section, fill a gap, or add a topic to an existing context package. Accepts a single action or an array of actions for batch refinement.
Inputs: context_id (required), action, target, actions, +1 more.
Update tags on one or more memories. Use for organizing, correcting, or enriching memory metadata. Supports add, remove, or replace operations.
Inputs: memory_ids (required), add_tags, remove_tags, replace_tags.
Search stored memories by semantic similarity. Returns ranked results with relevance scores. Supports filtering by tags, date range, tier, and memory type.
Inputs: query (required), tags, tier, after, +4 more.
Find memories near a known memory in vector space. Classifies results as forward (newer chain links), backward (older), or lateral (related but independent).
Inputs: memory_id (required), limit, direction, exclude_ids, +1 more.
Get or set the security scanning mode for memory content. Modes: "standard" (default), "strict" (PII redaction), "off" (no scanning).
Inputs: mode.
Recall memories from a previous session by session ID, date, or topic. Use when resuming work to restore prior context. Supports chunk_id for drill-down into specific time segments (from session_resume manifest). Use order="chronological" for full narrative reconstruction (oldest-first).
Inputs: limit, order, topic, chunk_id, +3 more.
Reconstruct full session context in a single call — the recommended way to resume work. Returns narrative summary, key decisions, open threads, and last state.
Inputs: focus, topic, intent, max_tokens, +3 more.
Save a session summary for later recall. Auto-generates session_id if not provided. Returns the session_id for later recall.
Inputs: summary (required), tags, session_id.
Store a memory for later retrieval. Use for important facts, decisions, user preferences, project context, or anything worth remembering long-term. Memories are workspace-scoped and persist across sessions. Long content is automatically chunked; max 50,000 characters (larger is rejected with a 400 before embedding — split it or chunk client-side). DEDUP (before you call): exact byte-identical duplicates are always blocked server-side. If this content may overlap semantically with existing memories, either velixar_search first or pass check_duplicate:true to run a near-duplicate check.
Inputs: content (required), tags, tier, atomic, +5 more.
Show how a topic, entity, or belief evolved over time. Supports date range filtering and summary mode for long histories.
Inputs: after, limit, topic, before, +1 more.
Update an existing memory's content or tags.
Inputs: id, tags, content, memory_id.
Upload a file into Velixar memory with full source provenance. Supports PDF, Markdown, text, CSV, JSON, DOCX, and code files. Parsed, chunked, and tagged with source metadata.
Inputs: file_path (required), tags, quarantine_zone.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Scored across 38 tools
Most tools have clearly distinct purposes, with detailed descriptions aiding differentiation. However, there is slight overlap between context-building tools (velixar_context vs velixar_prepare_context) and session recall tools (velixar_session_recall vs velixar_session_resume), which could cause minor confusion.
All tools consistently use the 'velixar_' prefix and snake_case. However, the naming pattern is not uniformly verb_noun; some are nouns (e.g., velixar_capabilities, velixar_contradictions) while most are verb phrases, creating a minor inconsistency.
With 38 tools, the count is well above the typical well-scoped range of 3–15. While each tool serves a specific purpose, the sheer number is likely to overwhelm agents and hinder efficient selection, suggesting over-fragmentation.
The tool set comprehensively covers the memory management lifecycle (store, search, update, delete, archive), advanced features (contradiction detection, lineage, context synthesis, data source integration), and utility operations. No essential gaps are apparent for the stated domain.
Persistent memory for AI assistants: store, search, and connect knowledge across conversations.
Persistent, portable memory for AI assistants — your private memory graph, from any MCP client.
Persistent memory and knowledge graph for AI assistants — keyword + vector + graph search.
Persistent memory for AI agents. EU-hosted, privacy-first, hybrid recall, contradiction detection.
