MCP Memory LibSQL
The MCP Memory LibSQL server is a high-performance, persistent memory system that provides vector search and knowledge graph management capabilities. With this server, you can:
Create/Update Entities: Add entities with observations, embeddings for vector search, and optional relations
Search Entities: Perform text or vector similarity searches
Create Relations: Define relationships between entities to form a knowledge graph
Read Graph: Retrieve recent entities and their relations, with optional embeddings
Delete Entities: Remove entities and all associated data (observations and relations)
Delete Relations: Remove specific relations between entities
Store Data Persistently: Using local SQLite files or remote libSQL databases
Utilize Vector Operations: Leverage high-performance vector capabilities for similarity search
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., "@MCP Memory LibSQL search for 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.
mcp-memory-libsql
A high-performance, persistent memory system for the Model Context Protocol (MCP) powered by libSQL. This server provides vector search capabilities and efficient knowledge storage using libSQL as the backing store.
Features
🚀 High-performance vector search using libSQL
💾 Persistent storage of entities and relations
🔍 Semantic search capabilities
🔄 Knowledge graph management
🌐 Compatible with local and remote libSQL databases
🔒 Secure token-based authentication for remote databases
Related MCP server: MCP Memory LibSQL Go
Configuration
This server is designed to be used as part of an MCP configuration. Here are examples for different environments:
Cline Configuration
Add this to your Cline MCP settings:
{
"mcpServers": {
"mcp-memory-libsql": {
"command": "npx",
"args": ["-y", "mcp-memory-libsql"],
"env": {
"LIBSQL_URL": "file:/path/to/your/database.db"
}
}
}
}Claude Desktop with WSL Configuration
For a detailed guide on setting up this server with Claude Desktop in WSL, see Getting MCP Server Working with Claude Desktop in WSL.
Add this to your Claude Desktop configuration for WSL environments:
{
"mcpServers": {
"mcp-memory-libsql": {
"command": "wsl.exe",
"args": [
"bash",
"-c",
"source ~/.nvm/nvm.sh && LIBSQL_URL=file:/path/to/database.db /home/username/.nvm/versions/node/v20.12.1/bin/npx mcp-memory-libsql"
]
}
}
}Database Configuration
The server supports both local SQLite and remote libSQL databases through the LIBSQL_URL environment variable:
For local SQLite databases:
{
"env": {
"LIBSQL_URL": "file:/path/to/database.db"
}
}For remote libSQL databases (e.g., Turso):
{
"env": {
"LIBSQL_URL": "libsql://your-database.turso.io",
"LIBSQL_AUTH_TOKEN": "your-auth-token"
}
}Note: When using WSL, ensure the database path uses the Linux
filesystem format (e.g., /home/username/...) rather than Windows
format.
By default, if no URL is provided, it will use file:/memory-tool.db
in the current directory.
API
The server implements the standard MCP memory interface with additional vector search capabilities:
Entity Management
Create/Update entities with embeddings
Delete entities
Search entities by similarity
Relation Management
Create relations between entities
Delete relations
Query related entities
Architecture
The server uses a libSQL database with the following schema:
Entities table: Stores entity information and embeddings
Relations table: Stores relationships between entities
Vector search capabilities implemented using libSQL's built-in vector operations
Development
Publishing
Due to npm 2FA requirements, publishing needs to be done manually:
Create a changeset (documents your changes):
pnpm changesetVersion the package (updates version and CHANGELOG):
pnpm changeset versionPublish to npm (will prompt for 2FA code):
pnpm releaseContributing
Contributions are welcome! Please read our contributing guidelines before submitting pull requests.
License
MIT License - see the LICENSE file for details.
Acknowledgments
Built on the Model Context Protocol
Powered by libSQL
Available Tools
6 toolscreate_entitiesC
Create new entities with observations and optional embeddings
Inputs: entities (required).
create_relationsC
Create relations between entities
Inputs: relations (required).
delete_entityA
Delete an entity and all its associated data (observations and relations)
Inputs: name (required).
delete_relationC
Delete a specific relation between entities
Inputs: source (required), target (required), type (required).
read_graphC
Get recent entities and their relations
Inputs: includeEmbeddings.
search_nodesC
Search for entities and their relations using text or vector similarity
Inputs: query (required), includeEmbeddings.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 6 tools
Each tool has a clearly distinct purpose: create_entities and create_relations handle creation of different object types, delete_entity and delete_relation handle deletion of different object types, read_graph retrieves recent data, and search_nodes performs searches. No ambiguity exists between these operations.
All tools follow a consistent verb_noun pattern with snake_case naming: create_entities, create_relations, delete_entity, delete_relation, read_graph, and search_nodes. The naming is perfectly predictable and uniform throughout the set.
With 6 tools, this server is well-scoped for a memory/graph database system. Each tool earns its place by covering essential CRUD operations (create, delete, read/search) for both entities and relations, without being overly complex or insufficient.
The tool set provides strong coverage for core graph operations: creation and deletion of entities/relations, reading recent data, and searching. A minor gap exists in update operations (e.g., update_entity or update_relation), but agents can work around this by deleting and recreating as needed.
Related MCP Connectors
Persistent, inspectable memory for AI agents with lineage, correction, and a hosted MCP endpoint.
Persistent memory for AI agents to retain, retrieve, and recall conversation context through MCP.
Persistent memory for AI agents across Claude, ChatGPT and any MCP client.
Persistent memory, knowledge graph, task management and more for AI agents via MCP.
Related MCP Servers
- AlicenseBqualityDmaintenanceA high-performance MCP server utilizing libSQL for persistent memory and vector search capabilities, enabling efficient entity management and semantic knowledge storage.6103 npm87MIT
- AlicenseNot gradedqualityDmaintenance🧠 High-performance persistent memory system for Model Context Protocol (MCP) powered by libSQL. Features vector search, semantic knowledge storage, and efficient relationship management - perfect for AI agents and knowledge graph applications.7MIT
- AlicenseNot gradedqualityDmaintenanceA knowledge-graph-based persistent memory server for the Model Context Protocol, storing entities, observations, and relations in SQLite with semantic vector search and temporal versioning.34 npmMIT
- AlicenseNot gradedqualityDmaintenancePersistent memory for AI agents over the Model Context Protocol (MCP).MIT