Skip to content
Back to search

memento-mcp

Memento MCP: A Knowledge Graph Memory System for LLMs

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/gannonh--memento-mcp/badge.svg)](/listings/gannonh--memento-mcp)

HTML

<a href="/listings/gannonh--memento-mcp"><img src="/api/listings/gannonh--memento-mcp/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Alternatively, you can use Docker Compose to run Neo4j:

# Start Neo4j container
docker-compose up -d neo4j

# Stop Neo4j container
docker-compose stop neo4j

# Remove Neo4j container (preserves data)
docker-compose rm neo4j

When using Docker, the Neo4j database will be available at:

- **Bolt URI**: `bolt://127.0.0.1:7687` (for driver connections) - **HTTP**: `http://127.0.0.1:7474` (for Neo4j Browser UI) - **Default credentials**: username: `neo4j`, password: `memento_password`

Data Persistence and Management

Neo4j data persists across container restarts and even version upgrades due to the Docker volume configuration in the `docker-compose.yml` file:

volumes:
  - ./neo4j-data:/data
  - ./neo4j-logs:/logs
  - ./neo4j-import:/import

These mappings ensure that:

- `/data` directory (contains all database files) persists on your host at `./neo4j-data` - `/logs` directory persists on your host at `./neo4j-logs` - `/import` directory (for importing data files) persists at `./neo4j-import`

You can modify these paths in your `docker-compose.yml` file to store data in different locations if needed.

Upgrading Neo4j Version

You can change Neo4j editions and versions without losing data:

1. Update the Neo4j image version in `docker-compose.yml` 2. Restart the container with `docker-compose down && docker-compose up -d neo4j` 3. Reinitialize the schema with `npm run neo4j:init`

The data will persist through this process as long as the volume mappings remain the same.

Complete Database Reset

If you need to completely reset your Neo4j database:

# Stop the container
docker-compose stop neo4j

# Remove the container
docker-compose rm -f neo4j

# Delete the data directory contents
rm -rf ./neo4j-data/*

# Restart the container
docker-compose up -d neo4j

# Reinitialize the schema
npm run neo4j:init

Backing Up Data

To back up your Neo4j data, you can simply copy the data directory:

# Make a backup of the Neo4j data
cp -r ./neo4j-data ./neo4j-data-backup-$(date +%Y%m%d)

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 678 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # Memento MCP: A Knowledge Graph Memory System for LLMs
  2. ![Memento MCP Logo](assets/memento-logo-gray.svg)
  3. Scalable, high performance knowledge graph memory system with semantic retrieval, contextual recall, and temporal awareness. Provides any LLM client that supports the model context protocol (e.g., Claude Desktop, Cursor, Github Copilot) with resilient, adaptive, and persistent long-term ontological memory.
  4. [![Memento MCP Tests](https://github.com/gannonh/memento-mcp/actions/workflows/memento-mcp.yml/badge.svg)](https://github.com/gannonh/memento-mcp/actions/workflows/memento-mcp.yml)
  5. [![smithery badge](https://smithery.ai/badge/@gannonh/memento-mcp)](https://smithery.ai/server/@gannonh/memento-mcp)
  6. ## Core Concepts
  7. ### Entities
  8. Entities are the primary nodes in the knowledge graph. Each entity has:
  9. - A unique name (identifier)
  10. - An entity type (e.g., "person", "organization", "event")
  11. - A list of observations
  12. - Vector embeddings (for semantic search)
  13. - Complete version history
  14. Example:
  15. ```json
  16. {
  17. "name": "John_Smith",
  18. "entityType": "person",
  19. "observations": ["Speaks fluent Spanish"]
  20. }
  21. ```
  22. ### Relations
  23. Relations define directed connections between entities with enhanced properties:
  24. - Strength indicators (0.0-1.0)
  25. - Confidence levels (0.0-1.0)
  26. - Rich metadata (source, timestamps, tags)
  27. - Temporal awareness with version history
  28. - Time-based confidence decay
  29. Example:
  30. ```json
  31. {
  32. "from": "John_Smith",
  33. "to": "Anthropic",
  34. "relationType": "works_at",
  35. "strength": 0.9,
  36. "confidence": 0.95,
  37. "metadata": {
  38. "source": "linkedin_profile",
  39. "last_verified": "2025-03-21"
  40. }
  41. }
  42. ```
  43. ## Storage Backend
  44. Memento MCP uses Neo4j as its storage backend, providing a unified solution for both graph storage and vector search capabilities.
  45. ### Why Neo4j?
  46. - **Unified Storage**: Consolidates both graph and vector storage into a single database
  47. - **Native Graph Operations**: Built specifically for graph traversal and queries
  48. - **Integrated Vector Search**: Vector similarity search for embeddings built directly into Neo4j
  49. - **Scalability**: Better performance with large knowledge graphs
  50. - **Simplified Architecture**: Clean design with a single database for all operations
  51. ### Prerequisites
  52. - Neo4j 5.13+ (required for vector search capabilities)
  53. ### Neo4j Desktop Setup (Recommended)
  54. The easiest way to get started with Neo4j is to use [Neo4j Desktop](https://neo4j.com/download/):
  55. 1. Download and install Neo4j Desktop from <https://neo4j.com/download/>
  56. 2. Create a new project
  57. 3. Add a new database
  58. 4. Set password to `memento_password` (or your preferred password)
  59. 5. Start the database
  60. The Neo4j database will be available at:
  61. - **Bolt URI**: `bolt://127.0.0.1:7687` (for driver connections)
  62. - **HTTP**: `http://127.0.0.1:7474` (for Neo4j Browser UI)
  63. - **Default credentials**: username: `neo4j`, password: `memento_password` (or whatever you configured)
  64. ### Neo4j Setup with Docker (Alternative)
  65. Alternatively, you can use Docker Compose to run Neo4j:
  66. ```bash
  67. # Start Neo4j container
  68. docker-compose up -d neo4j
  69. # Stop Neo4j container
  70. docker-compose stop neo4j
  71. # Remove Neo4j container (preserves data)
  72. docker-compose rm neo4j
  73. ```
  74. When using Docker, the Neo4j database will be available at:
  75. - **Bolt URI**: `bolt://127.0.0.1:7687` (for driver connections)
  76. - **HTTP**: `http://127.0.0.1:7474` (for Neo4j Browser UI)
  77. - **Default credentials**: username: `neo4j`, password: `memento_password`
  78. #### Data Persistence and Management
  79. Neo4j data persists across container restarts and even version upgrades due to the Docker volume configuration in the `docker-compose.yml` file:
  80. ```yaml
  81. volumes:
  82. - ./neo4j-data:/data
  83. - ./neo4j-logs:/logs
  84. - ./neo4j-import:/import
  85. ```
  86. These mappings ensure that:
  87. - `/data` directory (contains all database files) persists on your host at `./neo4j-data`
  88. - `/logs` directory persists on your host at `./neo4j-logs`
  89. - `/import` directory (for importing data files) persists at `./neo4j-import`
  90. You can modify these paths in your `docker-compose.yml` file to store data in different locations if needed.
  91. ##### Upgrading Neo4j Version
  92. You can change Neo4j editions and versions without losing data:
  93. 1. Update the Neo4j image version in `docker-compose.yml`
  94. 2. Restart the container with `docker-compose down && docker-compose up -d neo4j`
  95. 3. Reinitialize the schema with `npm run neo4j:init`
  96. The data will persist through this process as long as the volume mappings remain the same.
  97. ##### Complete Database Reset
  98. If you need to completely reset your Neo4j database:
  99. ```bash
  100. # Stop the container
  101. docker-compose stop neo4j
  102. # Remove the container
  103. docker-compose rm -f neo4j
  104. # Delete the data directory contents
  105. rm -rf ./neo4j-data/*
  106. # Restart the container
  107. docker-compose up -d neo4j
  108. # Reinitialize the schema
  109. npm run neo4j:init
  110. ```
  111. ##### Backing Up Data
  112. To back up your Neo4j data, you can simply copy the data directory:
  113. ```bash
  114. # Make a backup of the Neo4j data
  115. cp -r ./neo4j-data ./neo4j-data-backup-$(date +%Y%m%d)
  116. ```
  117. ### Neo4j CLI Utilities
  118. Memento MCP includes command-line utilities for managing Neo4j operations:
  119. #### Testing Connection
  120. Test the connection to your Neo4j database:
  121. ```bash
  122. # Test with default settings
  123. npm run neo4j:test
  124. # Test with custom settings
  125. npm run neo4j:test -- --uri bolt://127.0.0.1:7687 --username myuser --password mypass --database neo4j
  126. ```
  127. #### Initializing Schema
  128. For normal operation, Neo4j schema initialization happens automatically when Memento MCP connects to the database. You don't need to run any manual commands for regular usage.
  129. The following commands are only necessary for development, testing, or advanced customization scenarios:
  130. ```bash
  131. # Initialize with default settings (only needed for development or troubleshooting)
  132. npm run neo4j:init
  133. # Initialize with custom vector dimensions
  134. npm run neo4j:init -- --dimensions 768 --similarity euclidean
  135. # Force recreation of all constraints and indexes
  136. npm run neo4j:init -- --recreate
  137. # Combine multiple options
  138. npm run neo4j:init -- --vector-index custom_index --dimensions 384 --recreate
  139. ```
  140. ## Advanced Features
  141. ### Semantic Search
  142. Find semantically related entities based on meaning rather than just keywords:
  143. - **Vector Embeddings**: Entities are automatically encoded into high-dimensional vector space using OpenAI's embedding models
  144. - **Cosine Similarity**: Find related concepts even when they use different terminology
  145. - **Configurable Thresholds**: Set minimum similarity scores to control result relevance
  146. - **Cross-Modal Search**: Query with text to find relevant entities regardless of how they were described
  147. - **Multi-Model Support**: Compatible with multiple embedding models (OpenAI text-embedding-3-small/large)
  148. - **Contextual Retrieval**: Retrieve information based on semantic meaning rather than exact keyword matches
  149. - **Optimized Defaults**: Tuned parameters for balance between precision and recall (0.6 similarity threshold, hybrid search enabled)
  150. - **Hybrid Search**: Combines semantic and keyword search for more comprehensive results
  151. - **Adaptive Search**: System intelligently chooses between vector-only, keyword-only, or hybrid search based on query characteristics and available data
  152. - **Performance Optimization**: Prioritizes vector search for semantic understanding while maintaining fallback mechanisms for resilience
  153. - **Query-Aware Processing**: Adjusts search strategy based on query complexity and available entity embeddings
  154. ### Temporal Awareness
  155. Track complete history of entities and relations with point-in-time graph retrieval:
  156. - **Full Version History**: Every change to an entity or relation is preserved with timestamps
  157. - **Point-in-Time Queries**: Retrieve the exact state of the knowledge graph at any moment in the past
  158. - **Change Tracking**: Automatically records createdAt, updatedAt, validFrom, and validTo timestamps
  159. - **Temporal Consistency**: Maintain a historically accurate view of how knowledge evolved
  160. - **Non-Destructive Updates**: Updates create new versions rather than overwriting existing data
  161. - **Time-Based Filtering**: Filter graph elements based on temporal criteria
  162. - **History Exploration**: Investigate how specific information changed over time
  163. ### Confidence Decay
  164. Relations automatically decay in confidence over time based on configurable half-life:
  165. - **Time-Based Decay**: Confidence in relations naturally decreases over time if not reinforced
  166. - **Configurable Half-Life**: Define how quickly information becomes less certain (default: 30 days)
  167. - **Minimum Confidence Floors**: Set thresholds to prevent over-decay of important information
  168. - **Decay Metadata**: Each relation includes detailed decay calculation information
  169. - **Non-Destructive**: Original confidence values are preserved alongside decayed values
  170. - **Reinforcement Learning**: Relations regain confidence when reinforced by new observations
  171. - **Reference Time Flexibility**: Calculate decay based on arbitrary reference times for historical analysis
  172. ### Advanced Metadata
  173. Rich metadata support for both entities and relations with custom fields:
  174. - **Source Tracking**: Record where information originated (user input, analysis, external sources)
  175. - **Confidence Levels**: Assign confidence scores (0.0-1.0) to relations based on certainty
  176. - **Relation Strength**: Indicate importance or strength of relationships (0.0-1.0)
  177. - **Temporal Metadata**: Track when information was added, modified, or verified
  178. - **Custom Tags**: Add arbitrary tags for classification and filtering
  179. - **Structured Data**: Store complex structured data within metadata fields
  180. - **Query Support**: Search and filter based on metadata properties
  181. - **Extensible Schema**: Add custom fields as needed without modifying the core data model
  182. ## MCP API Tools
  183. The following tools are available to LLM client hosts through the Model Context Protocol:
  184. ### Entity Management
  185. - **create_entities**
  186. - Create multiple new entities in the knowledge graph
  187. - Input: `entities` (array of objects)
  188. - Each object contains:
  189. - `name` (string): Entity identifier
  190. - `entityType` (string): Type classification
  191. - `observations` (string[]): Associated observations
  192. - **add_observations**
  193. - Add new observations to existing entities
  194. - Input: `observations` (array of objects)
  195. - Each object contains:
  196. - `entityName` (string): Target entity
  197. - `contents` (string[]): New observations to add
  198. - **delete_entities**
  199. - Remove entities and their relations
  200. - Input: `entityNames` (string[])
  201. - **delete_observations**
  202. - Remove specific observations from entities
  203. - Input: `deletions` (array of objects)
  204. - Each object contains:
  205. - `entityName` (string): Target entity
  206. - `observations` (string[]): Observations to remove
  207. ### Relation Management
  208. - **create_relations**
  209. - Create multiple new relations between entities with enhanced properties
  210. - Input: `relations` (array of objects)
  211. - Each object contains:
  212. - `from` (string): Source entity name
  213. - `to` (string): Target entity name
  214. - `relationType` (string): Relationship type
  215. - `strength` (number, optional): Relation strength (0.0-1.0)
  216. - `confidence` (number, optional): Confidence level (0.0-1.0)
  217. - `metadata` (object, optional): Custom metadata fields
  218. - **get_relation**
  219. - Get a specific relation with its enhanced properties
  220. - Input:
  221. - `from` (string): Source entity name
  222. - `to` (string): Target entity name
  223. - `relationType` (string): Relationship type
  224. - **update_relation**
  225. - Update an existing relation with enhanced properties
  226. - Input: `relation` (object):
  227. - Contains:
  228. - `from` (string): Source entity name
  229. - `to` (string): Target entity name
  230. - `relationType` (string): Relationship type
  231. - `strength` (number, optional): Relation strength (0.0-1.0)
  232. - `confidence` (number, optional): Confidence level (0.0-1.0)
  233. - `metadata` (object, optional): Custom metadata fields
  234. - **delete_relations**
  235. - Remove specific relations from the graph
  236. - Input: `relations` (array of objects)
  237. - Each object contains:
  238. - `from` (string): Source entity name
  239. - `to` (string): Target entity name
  240. - `relationType` (string): Relationship type
  241. ### Graph Operations
  242. - **read_graph**
  243. - Read the entire knowledge graph
  244. - No input required
  245. - **search_nodes**
  246. - Search for nodes based on query
  247. - Input: `query` (string)
  248. - **open_nodes**
  249. - Retrieve specific nodes by name
  250. - Input: `names` (string[])
  251. ### Semantic Search
  252. - **semantic_search**
  253. - Search for entities semantically using vector embeddings and similarity
  254. - Input:
  255. - `query` (string): The text query to search for semantically
  256. - `limit` (number, optional): Maximum results to return (default: 10)
  257. - `min_similarity` (number, optional): Minimum similarity threshold (0.0-1.0, default: 0.6)
  258. - `entity_types` (string[], optional): Filter results by entity types
  259. - `hybrid_search` (boolean, optional): Combine keyword and semantic search (default: true)
  260. - `semantic_weight` (number, optional): Weight of semantic results in hybrid search (0.0-1.0, default: 0.6)
  261. - Features:
  262. - Intelligently selects optimal search method (vector, keyword, or hybrid) based on query context
  263. - Gracefully handles queries with no semantic matches through fallback mechanisms
  264. - Maintains high performance with automatic optimization decisions
  265. - **get_entity_embedding**
  266. - Get the vector embedding for a specific entity
  267. - Input:
  268. - `entity_name` (string): The name of the entity to get the embedding for
  269. ### Temporal Features
  270. - **get_entity_history**
  271. - Get complete version history of an entity
  272. - Input: `entityName` (string)
  273. - **get_relation_history**
  274. - Get complete version history of a relation
  275. - Input:
  276. - `from` (string): Source entity name
  277. - `to` (string): Target entity name
  278. - `relationType` (string): Relationship type
  279. - **get_graph_at_time**
  280. - Get the state of the graph at a specific timestamp
  281. - Input: `timestamp` (number): Unix timestamp (milliseconds since epoch)
  282. - **get_decayed_graph**
  283. - Get graph with time-decayed confidence values
  284. - Input: `options` (object, optional):
  285. - `reference_time` (number): Reference timestamp for decay calculation (milliseconds since epoch)
  286. - `decay_factor` (number): Optional decay factor override
  287. ## Configuration
  288. ### Environment Variables
  289. Configure Memento MCP with these environment variables:
  290. ```bash
  291. # Neo4j Connection Settings
  292. NEO4J_URI=bolt://127.0.0.1:7687
  293. NEO4J_USERNAME=neo4j
  294. NEO4J_PASSWORD=memento_password
  295. NEO4J_DATABASE=neo4j
  296. # Vector Search Configuration
  297. NEO4J_VECTOR_INDEX=entity_embeddings
  298. NEO4J_VECTOR_DIMENSIONS=1536
  299. NEO4J_SIMILARITY_FUNCTION=cosine
  300. # Embedding Service Configuration
  301. MEMORY_STORAGE_TYPE=neo4j
  302. OPENAI_API_KEY=your-openai-api-key
  303. OPENAI_EMBEDDING_MODEL=text-embedding-3-small
  304. # Debug Settings
  305. DEBUG=true
  306. ```
  307. ### Command Line Options
  308. The Neo4j CLI tools support the following options:
  309. ```
  310. --uri <uri> Neo4j server URI (default: bolt://127.0.0.1:7687)
  311. --username <username> Neo4j username (default: neo4j)
  312. --password <password> Neo4j password (default: memento_password)
  313. --database <n> Neo4j database name (default: neo4j)
  314. --vector-index <n> Vector index name (default: entity_embeddings)
  315. --dimensions <number> Vector dimensions (default: 1536)
  316. --similarity <function> Similarity function (cosine|euclidean) (default: cosine)
  317. --recreate Force recreation of constraints and indexes
  318. --no-debug Disable detailed output (debug is ON by default)
  319. ```
  320. ### Embedding Models
  321. Available OpenAI embedding models:
  322. - `text-embedding-3-small`: Efficient, cost-effective (1536 dimensions)
  323. - `text-embedding-3-large`: Higher accuracy, more expensive (3072 dimensions)
  324. - `text-embedding-ada-002`: Legacy model (1536 dimensions)
  325. #### OpenAI API Configuration
  326. To use semantic search, you'll need to configure OpenAI API credentials:
  327. 1. Obtain an API key from [OpenAI](https://platform.openai.com/api-keys)
  328. 2. Configure your environment with:
  329. ```bash
  330. # OpenAI API Key for embeddings
  331. OPENAI_API_KEY=your-openai-api-key
  332. # Default embedding model
  333. OPENAI_EMBEDDING_MODEL=text-embedding-3-small
  334. ```
  335. > **Note**: For testing environments, the system will mock embedding generation if no API key is provided. However, using real embeddings is recommended for integration testing.
  336. ## Integration with Claude Desktop
  337. ### Configuration
  338. Add this to your `claude_desktop_config.json`:
  339. ```json
  340. {
  341. "mcpServers": {
  342. "memento": {
  343. "command": "npx",
  344. "args": ["-y", "@gannonh/memento-mcp"],
  345. "env": {
  346. "MEMORY_STORAGE_TYPE": "neo4j",
  347. "NEO4J_URI": "bolt://127.0.0.1:7687",
  348. "NEO4J_USERNAME": "neo4j",
  349. "NEO4J_PASSWORD": "memento_password",
  350. "NEO4J_DATABASE": "neo4j",
  351. "NEO4J_VECTOR_INDEX": "entity_embeddings",
  352. "NEO4J_VECTOR_DIMENSIONS": "1536",
  353. "NEO4J_SIMILARITY_FUNCTION": "cosine",
  354. "OPENAI_API_KEY": "your-openai-api-key",
  355. "OPENAI_EMBEDDING_MODEL": "text-embedding-3-small",
  356. "DEBUG": "true"
  357. }
  358. }
  359. }
  360. }
  361. ```
  362. Alternatively, for local development, you can use:
  363. ```json
  364. {
  365. "mcpServers": {
  366. "memento": {
  367. "command": "/path/to/node",
  368. "args": ["/path/to/memento-mcp/dist/index.js"],
  369. "env": {
  370. "MEMORY_STORAGE_TYPE": "neo4j",
  371. "NEO4J_URI": "bolt://127.0.0.1:7687",
  372. "NEO4J_USERNAME": "neo4j",
  373. "NEO4J_PASSWORD": "memento_password",
  374. "NEO4J_DATABASE": "neo4j",
  375. "NEO4J_VECTOR_INDEX": "entity_embeddings",
  376. "NEO4J_VECTOR_DIMENSIONS": "1536",
  377. "NEO4J_SIMILARITY_FUNCTION": "cosine",
  378. "OPENAI_API_KEY": "your-openai-api-key",
  379. "OPENAI_EMBEDDING_MODEL": "text-embedding-3-small",
  380. "DEBUG": "true"
  381. }
  382. }
  383. }
  384. }
  385. ```
  386. > **Important**: Always explicitly specify the embedding model in your Claude Desktop configuration to ensure consistent behavior.
  387. ### Recommended System Prompts
  388. For optimal integration with Claude, add these statements to your system prompt:
  389. ```
  390. You have access to the Memento MCP knowledge graph memory system, which provides you with persistent memory capabilities.
  391. Your memory tools are provided by Memento MCP, a sophisticated knowledge graph implementation.
  392. When asked about past conversations or user information, always check the Memento MCP knowledge graph first.
  393. You should use semantic_search to find relevant information in your memory when answering questions.
  394. ```
  395. ### Testing Semantic Search
  396. Once configured, Claude can access the semantic search capabilities through natural language:
  397. 1. To create entities with semantic embeddings:
  398. ```
  399. User: "Remember that Python is a high-level programming language known for its readability and JavaScript is primarily used for web development."
  400. ```
  401. 2. To search semantically:
  402. ```
  403. User: "What programming languages do you know about that are good for web development?"
  404. ```
  405. 3. To retrieve specific information:
  406. ```
  407. User: "Tell me everything you know about Python."
  408. ```
  409. The power of this approach is that users can interact naturally, while the LLM handles the complexity of selecting and using the appropriate memory tools.
  410. ### Real-World Applications
  411. Memento's adaptive search capabilities provide practical benefits:
  412. 1. **Query Versatility**: Users don't need to worry about how to phrase questions - the system adapts to different query types automatically
  413. 2. **Failure Resilience**: Even when semantic matches aren't available, the system can fall back to alternative methods without user intervention
  414. 3. **Performance Efficiency**: By intelligently selecting the optimal search method, the system balances performance and relevance for each query
  415. 4. **Improved Context Retrieval**: LLM conversations benefit from better context retrieval as the system can find relevant information across complex knowledge graphs
  416. For example, when a user asks "What do you know about machine learning?", the system can retrieve conceptually related entities even if they don't explicitly mention "machine learning" - perhaps entities about neural networks, data science, or specific algorithms. But if semantic search yields insufficient results, the system automatically adjusts its approach to ensure useful information is still returned.
  417. ## Troubleshooting
  418. ### Vector Search Diagnostics
  419. Memento MCP includes built-in diagnostic capabilities to help troubleshoot vector search issues:
  420. - **Embedding Verification**: The system checks if entities have valid embeddings and automatically generates them if missing
  421. - **Vector Index Status**: Verifies that the vector index exists and is in the ONLINE state
  422. - **Fallback Search**: If vector search fails, the system falls back to text-based search
  423. - **Detailed Logging**: Comprehensive logging of vector search operations for troubleshooting
  424. ### Debug Tools (when DEBUG=true)
  425. Additional diagnostic tools become available when debug mode is enabled:
  426. - **diagnose_vector_search**: Information about the Neo4j vector index, embedding counts, and search functionality
  427. - **force_generate_embedding**: Forces the generation of an embedding for a specific entity
  428. - **debug_embedding_config**: Information about the current embedding service configuration
  429. ### Developer Reset
  430. To completely reset your Neo4j database during development:
  431. ```bash
  432. # Stop the container (if using Docker)
  433. docker-compose stop neo4j
  434. # Remove the container (if using Docker)
  435. docker-compose rm -f neo4j
  436. # Delete the data directory (if using Docker)
  437. rm -rf ./neo4j-data/*
  438. # For Neo4j Desktop, right-click your database and select "Drop database"
  439. # Restart the database
  440. # For Docker:
  441. docker-compose up -d neo4j
  442. # For Neo4j Desktop:
  443. # Click the "Start" button for your database
  444. # Reinitialize the schema
  445. npm run neo4j:init
  446. ```
  447. ## Building and Development
  448. ```bash
  449. # Clone the repository
  450. git clone https://github.com/gannonh/memento-mcp.git
  451. cd memento-mcp
  452. # Install dependencies
  453. npm install
  454. # Build the project
  455. npm run build
  456. # Run tests
  457. npm test
  458. # Check test coverage
  459. npm run test:coverage
  460. ```
  461. ## Installation
  462. ### Installing via Smithery
  463. To install memento-mcp for Claude Desktop automatically via [Smithery](https://smithery.ai/server/@gannonh/memento-mcp):
  464. ```bash
  465. npx -y @smithery/cli install @gannonh/memento-mcp --client claude
  466. ```
  467. ### Global Installation with npx
  468. You can run Memento MCP directly using npx without installing it globally:
  469. ```bash
  470. npx -y @gannonh/memento-mcp
  471. ```
  472. This method is recommended for use with Claude Desktop and other MCP-compatible clients.
  473. ### Local Installation
  474. For development or contributing to the project:
  475. ```bash
  476. # Install locally
  477. npm install @gannonh/memento-mcp
  478. # Or clone the repository
  479. git clone https://github.com/gannonh/memento-mcp.git
  480. cd memento-mcp
  481. npm install
  482. ```
  483. ## License
  484. MIT

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.