Atlas / MCP servers / sylweriusz / Neo4j Memory

Neo4j MemorySAFE

Name: Neo4j Memory
Author: sylweriusz

mcp/sylweriusz/neo4j-memory

MCP server by sylweriusz · Audited 2026-10-08

⚑ Report / re-scan Source ↗

Verdict

SAFE

Grade

Trust score

89 /100

Exposed tools

32 29r · 3w · 0d

Transport

stdio · streamable-http

License

MIT

Stars

Overview

From the repository's own README, as read at the audited commit. Badges and raw HTML are left out.

A Model Context Protocol (MCP) server that provides AI assistants with persistent, intelligent memory capabilities using Neo4j's graph database with unified architecture

What it does

This server enables AI assistants to:

Remember - Store memories as interconnected knowledge nodes with observations and metadata
Search - Find relevant memories using semantic vector search, exact matching, and graph traversal
Connect - Create meaningful relationships between memories with batch operations and cross-references
Organize - Separate memories by project using different databases
Evolve - Track how knowledge develops over time with temporal metadata and relationship networks

Features

Core Capabilities

🧠 Graph Memory - Memories as nodes, relationships as edges, observations as content
🔍 Unified Search - Semantic vectors, exact matching, wildcards, and graph traversal in one tool
🔗 Smart Relations - Typed connections with strength, source tracking, and temporal metadata
📊 Multi-Database - Isolated project contexts with instant switching

Advanced Operations

⚡ Batch Operations - Create multiple memories with relationships in single request using localId
🎯 Context Control - Response detail levels: minimal (lists), full (complete data), relations-only
📅 Time Queries - Filter by relative ("7d", "30d") or absolute dates on any temporal field
🌐 Graph Traversal - Navigate networks in any direction with depth control

Architecture

🚀 MCP Native - Seamless integration with Claude Desktop and MCP clients
💾 Persistent Storage - Neo4j graph database with GDS plugin for vector operations
⚠️ Zero-Fallback - Explicit errors for reliable debugging, no silent failures

Technical Highlights

Built on Neo4j for scalable graph operations
Vector embeddings using sentence transformers (384 dimensions)
Clean architecture with domain-driven design
Su

Read from source at commit e300e5e4299aOBSERVED · 2026-10-08

Connect

Built from this server's own package name, version and transport as found in its source — not copied from anyone's documentation, so it cannot drift against a page we do not control. Replace the environment placeholders with a token scoped to the least it needs.

claude-code

claude mcp add mcp-neo4j-memory-server --env NEO4J_PASSWORD=${NEO4J_PASSWORD} -- npx -y @sylweriusz/[email protected]

claude-desktop

{
  "mcpServers": {
    "mcp-neo4j-memory-server": {
      "command": "npx",
      "args": [
        "-y",
        "@sylweriusz/[email protected]"
      ],
      "env": {
        "NEO4J_PASSWORD": "${NEO4J_PASSWORD}"
      }
    }
  }
}

Exposed tools (32)

29 read · 3 write · 0 destructive.

Tool	Risk	Description
`analyze-memory-quality`	read	Assess observation quality and relationship density. Identifies improvement opportunities in knowledge capture and organization.
`area`	read	Technical area (database, api, frontend, infrastructure)
`constraints`	read	What must NOT change (APIs, interfaces, behavior)
`create-project-knowledge`	write	Structured project documentation workflow. Ensures comprehensive memory creation with proper relationships for maintainable knowledge graphs.
`current_state`	read	Brief description of current architecture
`database_switch`	read
`debug-orphaned-memories`	read	Find and fix disconnected memories. Identifies isolation patterns and suggests meaningful connections to improve knowledge graph density.
`decision_title`	read	Brief title of the decision
`depth`	read	How many relationship levels to explore (1-5)
`desired_outcome`	read	Where you want the architecture to go
`document-decision`	read	Capture architectural/technical decisions with full context. Ensures alternatives and rationale are recorded for future reference.
`domain`	read	Project domain (web, mobile, data, infrastructure)
`evolve-architecture`	read	Gradually evolve system architecture with memory-tracked decisions. Each step documented, relationships mapped, alternatives recorded.
`explore-memory-graph`	read	Systematic exploration of memory connections. Guides through graph traversal patterns to discover knowledge relationships and insights.
`granularity`	read	Detail level:
`iteration_size`	read	How big each step should be:
`memory_find`	read
`memory_modify`	write
`memory_store`	read
`memory_types`	read	Types to check for orphans (comma-separated)
`pain_points`	read	What problems you
`project_description`	read	What you
`project_name`	read	Name of the project to document
`refactor-with-rationale`	read	Refactor code while documenting every decision. Creates memory trail of what changed and why, perfect for team handoffs.
`scope`	read	Analysis scope:
`session_type`	read	Type of session:
`starting_point`	write	Memory name or type to start exploration from
`target_code`	read	File/module/function to refactor
`text-to-knowledge-graph`	read	Transform narrative text (books, documents, conversations) into structured knowledge graph with entities and relationships.
`text_source`	read	Source type:
`vibe-code-with-memory`	read	Memory-assisted vibe coding workflow. Captures design decisions, tracks implementation evolution, and maintains context across sessions.
`vibe_level`	read	How much to embrace the vibe:

Trust audit

SAFEgrade B · trust 89/100 Nothing in the source contradicts what it says it does. Grade A is reserved for packages that have also passed the behavioural sandbox.

Layer	What it checks	Result
L0	Provenance & inventory	PASS
L1	Static analysis of the code	PASS
L2	Instruction surface (what it tells the agent)	PASS
L3	Class-specific surface	PASS
L4	Behavioural (sandbox)	SKIPPED