Mnemosyne MCP
The Mnemosyne MCP server provides AI-powered knowledge graph management through a FastAPI backend integration.
Core Capabilities:
Session Management - Create and manage MCP sessions for authenticated users with client name specification
Graph Management - List all accessible graphs with optional statistics/metadata, create new persistent or temporary graphs with custom configurations (size limits, descriptions), and delete graphs with safety confirmations and optional backups
Data Ingestion - Upload RDF files in multiple formats (Turtle, RDF/XML, N-Triples, JSON-LD) with configurable validation levels, namespace management, and options to replace or append data
Querying - Execute SPARQL queries against graphs with customizable result formats (JSON, CSV, XML) and timeout settings
Schema & Analysis - Retrieve comprehensive graph information including detailed statistics, metadata, schema previews, and structural analysis
Technical Features:
Real-time job streaming via WebSocket with HTTP polling fallback
Browser-based OAuth authentication with token management and dev mode bypass for local development
Support for multiple MCP clients (Claude Code, Codex, Goose)
Kubernetes-native with kubectl port-forwarding support
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., "@Mnemosyne MCP query my knowledge graph for all documents about machine learning"
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.
Mnemosyne MCP
THIS IS A WORK IN PROGRESS AND THE DOCUMENTATION IS AI-GENERATED AND WILL BE REWRITTEN BY HUMAN BEFORE PEOPLE ARE WIDELY ENCOURAGED TO READ IT AND USE THIS CODE. THANK YOU FOR YOUR ATTENTION TO THIS MATTER XOXO VERA
AI-powered knowledge graph integration for Claude Code, Goose & Codex
The Mnemosyne MCP (neem) historically exposed a full suite of graph management tools. We are currently rebuilding those tools from scratch against a new FastAPI backend that runs inside our local kubectl context.
Status: The MCP server provides 23+ tools for knowledge graph management, SPARQL queries, real-time document editing, and workspace organization via Hocuspocus/Y.js.
Features:
π Reliable connectivity to a local FastAPI backend (via env vars or kubectl port-forward)
π©Ί Automatic startup health probe so you know whether the backend is reachable
π Browser-based OAuth authentication (
neem init)π Full graph CRUD operations (create, list, delete)
π SPARQL query and update support
π Real-time document editing via Y.js CRDT
Related MCP server: mnemoth
Installation
uv tool install -e . While developing locally with uv:
uv sync
uv run neem --helpCommands
neem init # Authenticate (run browser-based OAuth)
neem status # Show token status and Claude Code config
neem logout # Remove saved token (optional: keep config)
neem config # Inspect config details (with optional --show-token)Quick Start
Step 1: Install and authenticate
# Install the package
uv tool install -e .
# Authenticate with Mnemosyne
neem init # Opens your browser to log in
neem inithandles authentication onlyβthe next steps show how to connect each MCP client manually.
Before registering the MCP server, expose the FastAPI backend from your kubectl context:
kubectl port-forward svc/mnemosyne-api 8080:80The MCP server defaults to http://127.0.0.1:8080 which matches this port-forward. Both HTTP and WebSocket connections go through port 8080.
Step 2: Add MCP server to your agent
Using Claude Code (local backend):
claude mcp add mnemosyne --scope user \
-- uv run neem-mcp-serverUsing Claude Code (hosted API):
When connecting to the hosted API (e.g. api.garden.sophia-labs.com) rather than a local port-forward, disable WebSocket streaming. The WS endpoint is internal to the cluster and not exposed externally β without this flag, job-based tools like list_graphs will hang for up to 60 seconds before falling back to HTTP polling.
claude mcp add mnemosyne --scope user \
--env MNEMOSYNE_FASTAPI_URL=https://api.garden.sophia-labs.com \
-- uv run neem-mcp-serverOr add directly to ~/.claude.json:
"mcpServers": {
"mnemosyne": {
"type": "stdio",
"command": "uv",
"args": ["run", "neem-mcp-server"],
"env": {
"MNEMOSYNE_FASTAPI_URL": "https://api.garden.sophia-labs.com",
}
}
}Authenticate first with neem init. Tokens are stored at ~/.mnemosyne/config.json and auto-refresh for ~30 days.
Using Codex
codex mcp add mnemosyne \
--env LOG_LEVEL=ERROR \
-- uv run neem-mcp-serverDev-mode shortcut: Append
--env MNEMOSYNE_DEV_TOKEN=<user>and--env MNEMOSYNE_DEV_USER_ID=<user>when the backend runs withMNEMOSYNE_AUTH__MODE=dev_no_auth. Both HTTP and WebSocket will impersonate that user without OAuth.Custom port? Add
--env MNEMOSYNE_FASTAPI_URL=http://127.0.0.1:XXXXif your port-forward differs from the default 8080.
Dev Mode (skip OAuth)
If the backend runs with MNEMOSYNE_AUTH__MODE=dev_no_auth, set both env vars before launching the MCP server to bypass the OAuth flow entirely:
export MNEMOSYNE_DEV_USER_ID=alice
export MNEMOSYNE_DEV_TOKEN=alice # many clusters treat the token string as the user id
uv run neem-mcp-serverBoth HTTP requests and the WebSocket handshake will send X-User-ID: alice plus Sec-WebSocket-Protocol: Bearer.alice, satisfying the backendβs dev-mode guards. Unset these envs when targeting production.
Usage Examples
After registering the server, ask your MCP client to run list_graphs. It submits a job, streams realtime events over /ws, and falls back to HTTP polling when the backend does not advertise push hints.
FastAPI Backend Configuration
The MCP server now assumes it should talk to the FastAPI backend that runs in your local kubectl context.
Point
kubectlat the desired cluster (kubectl config use-context ...).Port-forward the FastAPI service so it is reachable on your workstation (example:
kubectl port-forward svc/mnemosyne-fastapi 8001:8000).Start
neem-mcp-serverwith one of the supported backend configuration options:MNEMOSYNE_FASTAPI_URL(preferred) or the legacyMNEMOSYNE_API_URL.MNEMOSYNE_FASTAPI_HOST,MNEMOSYNE_FASTAPI_PORT, and optionalMNEMOSYNE_FASTAPI_SCHEMEif you want to supply host/port separately (handy for kubectl port-forward scripts).MNEMOSYNE_FASTAPI_HEALTH_PATHif the FastAPI app exposes a non-standard health endpoint (defaults to/health).
If none of these environment variables are set the server defaults to http://127.0.0.1:8001, which lines up with the sample port-forward above. On startup we issue a lightweight health probe so you immediately know whether the backend is reachable.
Token Management
Tokens are automatically refreshed in the background using OAuth refresh tokens. After initial authentication, you'll stay logged in for approximately 30 days without any manual intervention.
When the refresh token eventually expires, simply run neem init to re-authenticate.
Important: Set LOG_LEVEL=ERROR for Codex CLI to avoid any stderr interference with the stdio protocol.
Available MCP Tools
Graph Management
list_graphsβ List all knowledge graphs owned by the authenticated user (useinclude_deleted=trueto show soft-deleted graphs)create_graphβ Create a new knowledge graph with ID, title, and optional descriptiondelete_graphβ Delete a graph (soft delete by default, usehard=trueto permanently delete)
SPARQL Operations
sparql_queryβ Execute read-only SPARQL SELECT/CONSTRUCT queries against your graphssparql_updateβ Execute SPARQL INSERT/DELETE/UPDATE operations to modify graph data
Namespace Reference: When writing SPARQL queries, use these exact prefixes:
PREFIX doc: <http://mnemosyne.dev/doc#> PREFIX dcterms: <http://purl.org/dc/terms/> PREFIX nfo: <http://www.semanticdesktop.org/ontologies/2007/03/22/nfo#> PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#> PREFIX nie: <http://www.semanticdesktop.org/ontologies/2007/01/19/nie#> PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>WARNING: Do NOT use
urn:mnemosyne:schema:doc:as the doc namespace β it will match nothing.
Orientation
get_user_locationβ Get the graph and document the user is currently viewing (minimal tokens)get_workspaceβ Get the folder/file structure of a graph (primary exploration tool)get_session_stateβ Get full session state including tabs and preferences (large payload, rarely needed)
Folder Operations
create_folderβ Create a new folder in the workspacerename_folderβ Rename a foldermove_folderβ Move a folder to a different parentdelete_folderβ Delete a folder (with optional cascade to delete contents)
Document Operations (via Hocuspocus/Y.js)
read_documentβ Read document content as TipTap XMLwrite_documentβ Replace document content with TipTap XMLappend_to_documentβ Add a block to the end of a documentmove_documentβ Move a document to a different folderdelete_documentβ Remove a document from workspace navigation
Block-Level Operations
get_blockβ Read a specific block by its ID (includes text_length and formatting runs)query_blocksβ Search for blocks matching specific criteriaupdate_blockβ Update a block's attributes or replace entire contentedit_block_textβ Insert/delete text at character offsets within a block (CRDT-safe collaborative editing)insert_blockβ Insert a new block relative to an existing blockdelete_blockβ Delete a block (with optional cascade for children)batch_update_blocksβ Update multiple blocks in a single transaction
Artifact Operations
move_artifactβ Move an artifact to a different folderrename_artifactβ Rename an artifact
Wire Operations (Semantic Connections)
list_wire_predicatesβ List available semantic predicates organized by categorycreate_wireβ Create a semantic connection between documents or blocks (syncs via Y.js CRDT)get_wiresβ Get all wires connected to a document (filter by direction: outgoing/incoming/both)traverse_wiresβ BFS traversal of the wire graph from a starting document (up to depth 10)
TipTap XML Format
Documents use TipTap's XML representation with full formatting support:
Blocks: paragraph, heading (level="1-3"), bulletList, orderedList, blockquote, codeBlock (language="..."), taskList, taskItem (checked="true"), horizontalRule
Marks (nestable): strong, em, strike, code, mark (highlight), a (href="...")
Annotation Marks: Special inline marks that reference external content:
footnoteβ Self-contained annotation withdata-footnote-contentattributecommentMarkβ Reference annotation withdata-comment-idattribute
Example:
<paragraph>Text with <mark>highlight</mark> and a note<footnote data-footnote-content="This is a footnote"/></paragraph>Graph management and SPARQL tools submit jobs to the FastAPI backend, streaming realtime updates via WebSocket when available and falling back to HTTP polling otherwise. Document, block, folder, and wire operations use Y.js CRDT via Hocuspocus for real-time sync.
SPARQL Data Model
Documents, folders, and artifacts are materialized to RDF by two backend pipelines:
Workspace materializer β Syncs metadata (titles, folder structure, order) from the workspace Y.Doc
Document materializer β Syncs content (blocks, paragraphs, text nodes) from document Y.Docs
Common RDF types: doc:TipTapDocument, doc:Folder, doc:Artifact, doc:XmlFragment, doc:Paragraph, doc:Heading, doc:TextNode
Common predicates: dcterms:title, nfo:fileName, nfo:belongsToContainer, doc:order, doc:section, doc:content, doc:childNode, doc:siblingOrder, doc:createdAt, doc:updatedAt
Entity URI pattern: urn:mnemosyne:user:{user_id}:graph:{graph_id}:{type}:{entity_id}
Content fragments use # suffixes: ...doc:{id}#frag, ...doc:{id}#block-{block_id}, ...doc:{id}#node-{n}
Example query to list all documents with titles:
PREFIX doc: <http://mnemosyne.dev/doc#>
PREFIX dcterms: <http://purl.org/dc/terms/>
SELECT ?doc ?title WHERE {
?doc a doc:TipTapDocument .
?doc dcterms:title ?title .
} ORDER BY ?titleConfiguration
Tokens are stored at
~/.mnemosyne/config.json(override withMNEMOSYNE_CONFIG_DIR).
Architecture
This package contains two main components:
1. CLI Tool (neem)
Located in neem.cli:
OAuth PKCE authentication flow (
neem.utils.oauth)Secure token storage (
neem.utils.token_storage)Claude Code configuration management (
neem.utils.claude_config)
2. MCP Server (neem-mcp-server)
Located in neem.mcp.server:
Stdio transport β Communicates with Claude Code via stdin/stdout
Backend resolver β Determines the FastAPI base URL from env vars or kubectl service hosts
Health probe β Pings the FastAPI backend on startup so you know whether the port-forward/context is correct
Realtime job wiring β
neem.mcp.jobsships a websocket-friendly client that tools can use to subscribe to job progress once the backend emits hintsStructured logging β All logs go to stderr (stdio-safe) with optional file output
Key design principles for this reset:
Local-first loops β Assume developers are targeting a FastAPI pod through kubectl
Minimal surface area β Keep the server slim until the new tool contract is finalized
Explicit configuration β Prefer environment variables over hidden defaults so CLI harnesses can inject settings
Development
Local Development
# Install in development mode
uv sync
uv pip install -e .
# Run the CLI
uv run neem init
# Test the MCP server
uv run neem-mcp-serverProject Structure
src/neem/
βββ cli.py # CLI commands (init, status, logout, config)
βββ hocuspocus/ # Y.js CRDT client layer
β βββ client.py # WebSocket client for Hocuspocus
β βββ document.py # Document Y.Doc operations
β βββ protocol.py # Y.js sync protocol handler
β βββ workspace.py # Workspace Y.Doc operations
βββ mcp/
β βββ server/
β β βββ standalone_server.py # Backend resolver, health probe, tool registration
β β βββ standalone_server_stdio.py # Stdio transport wrapper
β βββ tools/
β β βββ basic.py # list_graphs + job helpers
β β βββ graph_ops.py # create/delete graph, SPARQL query/update
β β βββ hocuspocus.py # Document, block, folder, artifact operations
β β βββ wire_tools.py # Semantic connection tools
β βββ jobs/ # Job streaming (WebSocket + polling)
β βββ session.py # Session management
β βββ auth.py # MCP auth context
β βββ errors.py # MCP-specific errors
β βββ response_objects.py # Formatted MCP responses
βββ utils/
βββ oauth.py # OAuth PKCE flow
βββ token_storage.py # Token persistence
βββ claude_config.py # Claude Code config management
βββ logging.py # Structured logging
βββ deployment_context.py # Environment configuration
βββ errors.py # Base error classesEnvironment Variables
MNEMOSYNE_FASTAPI_URLβ Preferred FastAPI base URL (defaults tohttp://127.0.0.1:8001). The legacyMNEMOSYNE_API_URLis still honored if set.MNEMOSYNE_FASTAPI_HOST,MNEMOSYNE_FASTAPI_PORT,MNEMOSYNE_FASTAPI_SCHEMEβ Specify host/port separately (handy for scripted kubectl port-forwards).MNEMOSYNE_FASTAPI_HEALTH_PATHβ Alternate health-check path if your FastAPI app doesn't expose/health.MNEMOSYNE_FASTAPI_WS_URLβ Override the WebSocket gateway directly (defaults tows(s)://<host>/wsderived from the HTTP base).MNEMOSYNE_FASTAPI_WS_PATHβ Custom path appended to the derived WebSocket URL whenMNEMOSYNE_FASTAPI_WS_URLis unset.MNEMOSYNE_FASTAPI_WS_PORTβ Override just the WebSocket port while keeping the same host/path (useful when HTTP and WS are forwarded on different local ports).MNEMOSYNE_FASTAPI_WS_DISABLEβ Set totrueto opt out of WebSocket streaming (falls back to HTTP polling).MNEMOSYNE_CONFIG_DIRβ Token storage location (default:~/.mnemosyne)MNEMOSYNE_DEV_TOKENβ Optional dev-only override that skips the OAuth flow by injecting the provided bearer token directly (use only on trusted local stacks).CLAUDE_CODE_SETTINGS_PATHβ Claude settings file (default:~/.claude/settings.json)LOG_LEVELβ Logging verbosity (default:INFO)DEBUGβ Verbose logging for troubleshootingINFOβ Normal operational logging (default)WARNINGβ Quiet mode, only warnings and errorsERRORβ Silent mode, only errors (recommended for Codex CLI)CRITICALβ Minimal logging, critical errors only
Sessions are stored in-memory by default; no external cache service is required.
Troubleshooting
MCP Server Not Loading
For Claude Code:
Check configuration:
cat ~/.claude.json | grep mnemosyne-graphTest server directly:
echo '{"jsonrpc": "2.0", "method": "initialize", "id": 1}' | neem-mcp-serverCheck logs: Look for stderr output when Claude Code starts
Verify token:
neem statusshould show "Active" authenticationRestart Claude Code: Configuration changes require a complete restart
For Goose CLI:
Check configuration:
cat ~/.config/goose/config.yaml | grep mnemosyne-graphVerify extension is enabled:
enabled: truein the configCheck timeout: Increase to 600 seconds if server is slow to start
Test in session: Start a new Goose session and ask it to list available tools
Check environment: Ensure
MNEMOSYNE_FASTAPI_URL(or legacyMNEMOSYNE_API_URL) is set correctly
For Codex CLI:
Enable debug logging: Codex intentionally silences stderr, making debugging difficult
Set LOG_LEVEL: Use
LOG_LEVEL=ERRORin the environment to prevent stderr interferenceTest manually: Run
echo '{"jsonrpc":"2.0","method":"initialize","id":1}' | neem-mcp-serverto verify it worksCheck configuration: Ensure
codex.jsonor your config file has the correct command and environment variables
Authentication Issues
Token not refreshing: Tokens auto-refresh in the background. If you see auth errors, your refresh token may have expired (~30 days). Run
neem initto re-authenticate.Check token:
neem statusto see token details and expiryForce refresh:
neem init --forceto get completely fresh tokens
SPARQL Returns Empty Results
The most common cause is using the wrong namespace prefix. Use:
PREFIX doc: <http://mnemosyne.dev/doc#>Do NOT use urn:mnemosyne:schema:doc: β it will silently match nothing.
See the docs/ directory for end-user quick start and detailed guides that can
ship with the package or be published separately.
Available Tools
23 toolsappend_to_documentAppend Block to DocumentA
Appends a block to the end of a document. Accepts TipTap XML for any block type. Use this for incremental additions without replacing existing content. For plain text, wrap in text. For structured content, provide full XML like Title or ....
Inputs: graph_id (required), document_id (required), text (required).
batch_update_blocksBatch Update BlocksB
Update multiple blocks in a single transaction. More efficient than individual update_block calls. Each update can specify attributes to change and/or new XML content. Returns results for each update.
Inputs: graph_id (required), document_id (required), updates (required).
create_folderCreate FolderB
Create a new folder in the workspace. Use parent_id to nest inside another folder (null for root level). The section parameter determines which sidebar section the folder appears in.
Inputs: graph_id (required), folder_id (required), label (required), parent_id, +2 more.
create_graphCreate Knowledge GraphB
Creates a new knowledge graph with the given ID, title, and optional description. The graph_id should be a URL-safe identifier (e.g., 'my-project', 'research-notes').
Inputs: graph_id (required), title (required), description. Returns: result
delete_blockDelete BlockA
Delete a block by its ID. Use cascade=true to also delete all subsequent blocks with higher indent (indent-based children). Returns the list of deleted block IDs.
Inputs: graph_id (required), document_id (required), block_id (required), cascade.
delete_folderDelete FolderA
Delete a folder from the workspace. Set cascade=true to delete all contents (subfolders, documents, artifacts). Without cascade, deletion fails if the folder has children.
Inputs: graph_id (required), folder_id (required), cascade.
delete_graphDelete Knowledge GraphA
Permanently deletes a knowledge graph and all its contents. This action cannot be undone. Use with caution.
Inputs: graph_id (required). Returns: result
get_active_contextGet Active Graph and DocumentA
Returns the currently active graph ID and document ID from the user's session. Use this to understand what the user is currently working on in the Mnemosyne UI. The user_id is automatically derived from authentication if not provided.
Inputs: user_id.
get_blockGet Block by IDA
Read a specific block by its data-block-id. Returns detailed info including the block's XML content, attributes, text content, and context (prev/next block IDs). Use this for targeted reads without fetching the entire document.
Inputs: graph_id (required), document_id (required), block_id (required).
get_workspaceGet Workspace StructureB
Returns the folder and file structure of a graph's workspace. Use this to understand the organization of documents in a graph.
Inputs: graph_id (required).
insert_blockInsert BlockA
Insert a new block relative to an existing block. Use position='after' or 'before' to specify where to insert. Returns the new block's generated ID. For appending to the end, use append_to_document instead.
Inputs: graph_id (required), document_id (required), reference_block_id (required), xml_content (required), +1 more.
list_graphsList Mnemosyne GraphsA
Lists all knowledge graphs owned by the authenticated user. Returns graph metadata including IDs, titles, and timestamps.
Inputs: no named parameters. Returns: result
move_artifactMove ArtifactC
Move an artifact to a different folder. Set new_parent_id to null to move to root level.
Inputs: graph_id (required), artifact_id (required), new_parent_id, new_order.
move_documentMove DocumentA
Move a document to a folder. Set new_parent_id to null to move to root level (unfiled). Note: This updates the document's folder assignment in workspace navigation.
Inputs: graph_id (required), document_id (required), new_parent_id.
move_folderMove FolderA
Move a folder to a new parent folder. Set new_parent_id to null to move to root level. Optionally update the order for positioning among siblings.
Inputs: graph_id (required), folder_id (required), new_parent_id, new_order.
query_blocksQuery BlocksA
Search for blocks matching specific criteria. Filter by block type, indent level, list type, checked state, or text content. Returns a list of matching block summaries. Use this to find blocks without reading the entire document.
Inputs: graph_id (required), document_id (required), block_type, indent, +6 more.
read_documentRead Document ContentB
Reads document content as TipTap XML with full formatting.
Blocks: paragraph, heading (level="1-3"), bulletList, orderedList, blockquote, codeBlock (language="..."), taskList (taskItem checked="true"), horizontalRule Marks (nestable): strong, em, strike, code, mark (highlight), a (href="..."), footnote (data-footnote-content="..."), commentMark (data-comment-id="...") Lists: item
Inputs: graph_id (required), document_id (required).
rename_artifactRename ArtifactC
Rename an artifact's display label.
Inputs: graph_id (required), artifact_id (required), new_label (required).
rename_folderRename FolderC
Rename a folder's display label.
Inputs: graph_id (required), folder_id (required), new_label (required).
sparql_queryRun SPARQL QueryA
Executes a read-only SPARQL SELECT or CONSTRUCT query against the user's graphs. Returns query results as JSON. Use this for searching and retrieving data from graphs.
Inputs: sparql (required), result_format. Returns: result
sparql_updateRun SPARQL UpdateA
Executes a SPARQL INSERT, DELETE, or UPDATE operation to modify graph data. Use this for adding, modifying, or removing triples from graphs.
Inputs: sparql (required). Returns: result
update_blockUpdate BlockA
Update a block by its ID. Can update attributes (indent, checked, listType) without changing content, or replace the entire block content. This is the most surgical edit - only modifies what you specify.
Inputs: graph_id (required), document_id (required), block_id (required), attributes, +1 more.
write_documentWrite Document ContentA
Replaces document content with TipTap XML. Syncs to UI in real-time.
WARNING: This REPLACES all content. For collaborative editing, prefer append_to_document.
Blocks: paragraph, heading (level="1-3"), bulletList, orderedList, blockquote, codeBlock (language="..."), taskList (taskItem checked="true"), horizontalRule Marks (nestable): strong, em, strike, code, mark (highlight), a (href="..."), footnote (data-footnote-content="..."), commentMark (data-comment-id="...") Example: Text with highlight and a note
Comments: Pass a dict mapping comment IDs to metadata. Comment IDs must match data-comment-id attributes in the content. Example comments: {"comment-1": {"text": "Great point!", "author": "Claude"}}
Inputs: graph_id (required), document_id (required), content (required), comments.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelogβ¦
TDQS
Scored across 23 tools
Each tool has a clearly distinct purpose with no significant overlap. For example, append_to_document is for adding content without replacement, while write_document replaces entire documents; get_block retrieves a single block, query_blocks searches across blocks, and read_document fetches full documents. The separation between document operations, block operations, folder management, and graph queries is well-defined.
Tool names follow a highly consistent verb_noun pattern throughout, such as create_folder, delete_block, get_workspace, and move_document. All tools use snake_case without deviation, and verbs like create, delete, get, list, move, rename, query, and update are applied predictably across different resource types (e.g., graph, folder, block, document).
With 23 tools, the count is slightly high but reasonable for the server's broad scope covering document editing, block management, folder organization, and graph operations. Each tool appears purposeful, such as batch_update_blocks for efficiency or sparql_query for specialized queries, though some consolidation might be possible (e.g., move_artifact, move_document, and move_folder could be unified).
The toolset provides comprehensive coverage for the Mnemosyne domain, including full CRUD for documents, blocks, folders, and graphs, plus advanced operations like SPARQL queries, workspace navigation, and context retrieval. There are no obvious gaps; tools support creation, reading, updating, deletion, moving, renaming, querying, and batch operations, enabling agents to handle all typical workflows without dead ends.
Maintenance
Related MCP Connectors
Hosted memory for AI assistants: a knowledge graph over MCP with OAuth. Hosted in Germany.
Persistent memory, knowledge graph, task management and more for AI agents via MCP.
Knowledge base MCP for AI agents on iknow.dev. Search, read, and maintain via OAuth.
Persistent knowledge graph for AI agents. Remember, recall, and forget facts.
Related MCP Servers
- AlicenseAqualityDmaintenanceEnables AI agents to inspect ontology schemas, search typed objects, and execute read-only SPARQL queries against an RDF triple store.3MIT
- AlicenseBqualityBmaintenanceEnables coding agents to persist and retrieve a typed knowledge graph with ontology, hybrid search, contradiction tracking, and session memory through MCP tools and skills, all without an API key.2458Apache 2.0
- FlicenseNot gradedqualityCmaintenanceEnables AI agents to interact with ontology knowledge graphs via MCP SSE, supporting ontology and instance CRUD, relationship traversal, dynamic function registration, role-based tool permissions, and graph visualization.-
- AlicenseAqualityCmaintenanceEnables AI agents to connect to a LightRAG knowledge-graph server over HTTP, exposing 33 tools for querying, managing documents, and editing knowledge graph entities and relations with proper authentication and error handling.33MIT