{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"github_mcp-dataojitori-nocturne_memory","slug":"mcp-dataojitori-nocturne_memory","name":"nocturne_memory","type":"mcp","url":"https://github.com/Dataojitori/nocturne_memory","page_url":"https://unfragile.ai/mcp-dataojitori-nocturne_memory","categories":["mcp-servers","rag-knowledge"],"tags":["agentic-ai","ai-identity","ai-memory","artificial-intelligence","claude","claude-code","digital-soul","gemini-cli","llm","long-term-memory","mcp","mcp-server","postgresql","python","rag","second-brain","sqlite"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"github_mcp-dataojitori-nocturne_memory__cap_0","uri":"capability://memory.knowledge.graph.based.persistent.memory.storage.with.uri.hierarchical.addressing","name":"graph-based persistent memory storage with uri-hierarchical addressing","description":"Stores AI agent memories as a four-layer graph model (Node-Memory-Edge-Path) with URI-based hierarchical addressing (e.g., core://agent/identity, user://preferences/language) instead of flat vector embeddings. Each memory is a first-class entity with metadata, relationships, and structural context preserved across sessions. The system uses SQLite or PostgreSQL as the backing store with domain-scoped URI routing enabling semantic organization without semantic shredding.","intents":["I need my AI agent to remember facts, relationships, and context across multiple conversations without losing structural relationships","I want to organize agent memories hierarchically by domain (core, user, task, knowledge) so they can be queried by path, not just similarity","I need memories to be queryable by URI pattern matching, not just cosine similarity, so I can retrieve specific memory types reliably"],"best_for":["AI agent developers building multi-turn, stateful systems","Teams implementing agentic AI with persistent identity requirements","Builders needing structured knowledge graphs instead of vector RAG"],"limitations":["Graph traversal performance degrades with very large memory graphs (100k+ nodes) without proper indexing strategy","URI path design requires upfront schema planning — poor domain structure leads to inefficient queries","No built-in distributed graph partitioning — single-instance bottleneck for high-concurrency agent fleets"],"requires":["Python 3.9+","SQLite (included) or PostgreSQL 12+ for production","MCP client compatible with Model Context Protocol (Claude, Gemini, or custom LLM)"],"input_types":["structured memory objects (node, edge, path definitions)","URI strings (domain://path/to/memory)","JSON metadata and content payloads"],"output_types":["graph traversal results (nodes with relationships)","memory objects with version history","URI-matched memory subgraphs"],"categories":["memory-knowledge","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-dataojitori-nocturne_memory__cap_1","uri":"capability://memory.knowledge.version.controlled.memory.mutations.with.rollback.capability","name":"version-controlled memory mutations with rollback capability","description":"Implements dual version control: Memory version chains track the evolution of individual memory objects (create → update → update), while ChangesetStore records all mutations as atomic transactions with timestamps and metadata. Each change is immutable and reversible, enabling agents to modify their own memories while humans can audit, review, and rollback to any prior state. Uses SQLite/PostgreSQL transaction logs to maintain consistency.","intents":["I want my agent to update its own memories but have a complete audit trail of what changed and when","I need to rollback agent memory to a prior state if it learned something incorrect or harmful","I want to see exactly what mutations an agent made during a session and approve/reject them before they persist"],"best_for":["Teams requiring memory auditability and compliance (financial AI, healthcare agents)","Developers debugging agent behavior by replaying memory state at different points in time","Systems where human oversight of agent learning is mandatory"],"limitations":["Rollback is point-in-time only — cannot selectively revert individual mutations within a changeset","Version chains grow linearly with mutation count — no automatic pruning, requires manual maintenance","Rollback latency increases with memory graph size; reverting large graphs can take seconds"],"requires":["Python 3.9+","SQLite or PostgreSQL with transaction support","MCP server running with change recording enabled"],"input_types":["mutation operations (create_memory, update_memory, delete_memory)","changeset metadata (timestamp, agent_id, reason)","rollback target (version_id or timestamp)"],"output_types":["changeset records with full before/after state","version history timeline","rollback confirmation with affected memory count"],"categories":["memory-knowledge","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-dataojitori-nocturne_memory__cap_10","uri":"capability://safety.moderation.change.review.and.approval.workflow.for.memory.mutations","name":"change review and approval workflow for memory mutations","description":"Implements an optional review workflow where memory mutations (create, update, delete) are staged as pending changesets that require human approval before persisting to the main memory graph. Reviewers can inspect the changeset (before/after state), add comments, and approve or reject. Rejected changes are discarded; approved changes are committed atomically. This enables human-in-the-loop learning for agents.","intents":["I want to review what my agent learned before it becomes permanent memory","I need to reject incorrect or harmful memories the agent tried to create","I want to add comments to memory changes explaining why they were approved or rejected"],"best_for":["Regulated environments (healthcare, finance) where agent learning must be audited","Teams implementing human-in-the-loop AI where oversight is mandatory","Developers building agents that learn from user feedback and need to validate learning"],"limitations":["Review workflow adds latency — agents must wait for human approval before memory persists","No automatic approval rules; all changes require manual review (no whitelist/blacklist)","Rejected changes are discarded; no mechanism to suggest corrections or modifications"],"requires":["Nocturne Memory server with review workflow enabled","Human reviewers with dashboard access","Authentication/authorization for reviewer roles"],"input_types":["pending changeset (mutation operation with metadata)","reviewer decision (approve/reject)","review comments (optional)"],"output_types":["changeset status (pending, approved, rejected)","review audit trail (who reviewed, when, comments)","committed memory state (after approval)"],"categories":["safety-moderation","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-dataojitori-nocturne_memory__cap_11","uri":"capability://memory.knowledge.memory.content.versioning.and.diff.visualization","name":"memory content versioning and diff visualization","description":"Tracks versions of individual memory content (not just mutations) and generates diffs showing what changed between versions. The diff system highlights additions, deletions, and modifications at the character or line level. Humans can browse version history and compare any two versions side-by-side. This enables understanding how a memory evolved and identifying when incorrect information was introduced.","intents":["I want to see how a memory's content changed over time and understand what the agent learned at each step","I need to identify when incorrect information was added to a memory so I can rollback to the correct version","I want to compare two versions of a memory side-by-side to understand the difference"],"best_for":["Developers debugging agent learning by inspecting memory evolution","Teams auditing agent knowledge for correctness and consistency","Systems where memory accuracy is critical (knowledge bases, decision support)"],"limitations":["Diff generation is character-level; no semantic diff (e.g., detecting that a number changed from 5 to 6)","Version history grows linearly with mutations; no automatic compression or deduplication","Diff visualization is text-based; no support for structured data diffs (JSON, XML)"],"requires":["Nocturne Memory server with versioning enabled","Memory content stored as text or JSON","Dashboard access for visualization"],"input_types":["memory URI","version IDs to compare (optional; defaults to consecutive versions)"],"output_types":["version history timeline","diff output (additions/deletions/modifications highlighted)","side-by-side comparison view"],"categories":["memory-knowledge","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-dataojitori-nocturne_memory__cap_12","uri":"capability://memory.knowledge.cross.session.memory.persistence.and.agent.identity.continuity","name":"cross-session memory persistence and agent identity continuity","description":"Ensures memories created in one session persist and are accessible in subsequent sessions, enabling agents to maintain continuous identity and knowledge across disconnected conversations. The system stores memories with session metadata (session_id, timestamp) but retrieves them without session filtering, so an agent can access all its memories regardless of which session created them. This solves the stateless agent problem where each conversation starts fresh.","intents":["I want my agent to remember facts and relationships from previous conversations without re-learning them","I need my agent to maintain a consistent identity across multiple sessions (same personality, preferences, knowledge)","I want to build long-running agents that accumulate knowledge over weeks or months of interactions"],"best_for":["Long-running agent systems (chatbots, assistants, autonomous agents)","Applications requiring agent continuity (personal AI assistants, customer service bots)","Systems where agent identity and knowledge are valuable assets"],"limitations":["No automatic session cleanup; old sessions and their metadata accumulate indefinitely","Memory retrieval is session-agnostic; no mechanism to isolate memories by session or time window","Cross-session memory can cause interference if agents learn conflicting information in different sessions"],"requires":["Nocturne Memory server running persistently","Durable storage (SQLite or PostgreSQL)","Agent client that provides session_id with each memory operation"],"input_types":["session_id (provided by agent client)","memory operations (create, read, update, delete)","agent_id (to identify which agent owns the memories)"],"output_types":["persisted memories accessible in future sessions","agent identity maintained across sessions","session history and metadata"],"categories":["memory-knowledge","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-dataojitori-nocturne_memory__cap_2","uri":"capability://tool.use.integration.mcp.native.tool.interface.for.agent.memory.operations","name":"mcp-native tool interface for agent memory operations","description":"Exposes memory operations as MCP tools (create_memory, read_memory, update_memory, delete_memory, query_memory_by_uri, traverse_graph) that agents can call directly via the Model Context Protocol. Each tool validates inputs against the URI schema, enforces domain constraints, and returns structured responses. The MCP server acts as the AI-facing interface, translating agent intents into graph operations while maintaining consistency and access control.","intents":["I want my Claude or Gemini agent to autonomously create and update its own memories without human intervention","I need the agent to query its memory graph by URI pattern (e.g., 'retrieve all memories under user://preferences/*') and get structured results","I want to integrate Nocturne Memory into my existing MCP-based agent framework without rewriting the agent logic"],"best_for":["Developers building Claude agents or Gemini agents that need persistent memory","Teams using MCP as their agent communication standard","Solo developers prototyping agentic AI without complex infrastructure"],"limitations":["Tool calling latency adds ~50-200ms per memory operation due to MCP serialization and network round-trips","No built-in rate limiting — agents can spam memory operations, requiring external throttling","Tool schema validation is strict; agents must format URIs and payloads exactly or calls fail silently"],"requires":["MCP client (Claude API, Gemini API, or custom MCP implementation)","Nocturne Memory MCP server running (Python 3.9+)","Network connectivity between agent and MCP server"],"input_types":["MCP tool call requests with JSON parameters","URI strings and domain specifications","memory content (text, structured data)"],"output_types":["MCP tool results (success/failure with structured data)","memory objects with metadata","query results (arrays of matching memories)"],"categories":["tool-use-integration","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-dataojitori-nocturne_memory__cap_3","uri":"capability://search.retrieval.uri.based.memory.querying.with.domain.scoping.and.path.pattern.matching","name":"uri-based memory querying with domain scoping and path pattern matching","description":"Enables agents and humans to query memories using URI patterns (e.g., 'core://agent/*', 'user://preferences/language') with wildcard matching, prefix filtering, and domain-scoped isolation. The URI system acts as a semantic namespace where domain (core, user, task, knowledge) determines memory category and path determines hierarchical location. Queries return all memories matching the pattern with their full graph context (edges, relationships, metadata).","intents":["I want to retrieve all memories related to a specific user without doing semantic similarity search","I need to query memories by their structural location (e.g., 'all task memories for project X') using deterministic path patterns","I want to isolate memories by domain (core agent identity vs user-specific vs task-specific) so they don't interfere with each other"],"best_for":["Agents needing deterministic, debuggable memory retrieval instead of probabilistic similarity","Systems with clear semantic hierarchies (user → preferences → language, task → subtasks → status)","Developers building multi-tenant agent systems where domain isolation is critical"],"limitations":["Query performance depends on URI path depth and wildcard specificity — overly broad patterns (e.g., '*') scan entire graph","No full-text search within memory content — only URI path matching; requires separate indexing for content search","Requires upfront schema design; poor URI structure leads to inefficient queries and difficult refactoring"],"requires":["Nocturne Memory server with URI routing configured","Understanding of domain structure (core, user, task, knowledge)","MCP client or HTTP API access"],"input_types":["URI pattern strings (domain://path/to/memory, with * wildcards)","domain filter (optional)","depth limit (optional)"],"output_types":["array of memory objects matching pattern","graph subgraph with relationships preserved","metadata including version history"],"categories":["search-retrieval","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-dataojitori-nocturne_memory__cap_4","uri":"capability://memory.knowledge.graph.traversal.and.relationship.navigation.across.memory.nodes","name":"graph traversal and relationship navigation across memory nodes","description":"Implements graph traversal algorithms (BFS, DFS, path-finding) to navigate relationships between memory nodes (edges) and discover connected memories. The four-layer model (Node-Memory-Edge-Path) enables rich relationship types: memories can reference other memories, form hierarchies, or represent temporal sequences. Traversal respects domain boundaries and returns full context including intermediate nodes and relationship metadata.","intents":["I want my agent to discover related memories by following relationship edges (e.g., 'find all users who interacted with this task')","I need to reconstruct the reasoning chain that led to a decision by traversing memory relationships backward","I want to find all memories connected to a concept through multiple hops (e.g., 'all knowledge related to user preferences through task history')"],"best_for":["Agents performing reasoning that requires understanding memory relationships and context","Systems modeling complex domains with interconnected entities (knowledge graphs, social networks)","Developers debugging agent decision-making by visualizing memory relationship chains"],"limitations":["Traversal performance degrades exponentially with graph depth and branching factor — deep graphs require query optimization","No built-in cycle detection; circular relationships can cause infinite traversal without explicit depth limits","Relationship metadata is not indexed — filtering by relationship type during traversal requires scanning all edges"],"requires":["Nocturne Memory server with graph model initialized","Memories with established relationships (edges)","Traversal depth limit to prevent runaway queries"],"input_types":["starting memory URI","traversal direction (forward, backward, bidirectional)","relationship type filter (optional)","max depth limit"],"output_types":["path objects (sequences of connected nodes)","relationship graph (nodes + edges)","traversal metadata (distance, relationship types)"],"categories":["memory-knowledge","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-dataojitori-nocturne_memory__cap_5","uri":"capability://memory.knowledge.human.facing.memory.browser.and.audit.dashboard","name":"human-facing memory browser and audit dashboard","description":"Provides a web-based frontend (FastAPI backend + HTML/JS frontend) for humans to browse agent memories, visualize the memory graph, review changes, and approve/reject mutations. The dashboard displays memories organized by URI domain, shows version history with before/after diffs, and enables point-in-time rollback. Authentication is required; the interface is read-only for auditors and read-write for administrators.","intents":["I want to see what memories my agent has created and how they've evolved over time","I need to review changes the agent made and rollback any incorrect or harmful memories","I want to visualize the agent's memory graph to understand its knowledge structure and relationships"],"best_for":["Teams with compliance requirements (auditing agent behavior)","Developers debugging agent memory issues by inspecting state visually","Non-technical stakeholders who need visibility into agent knowledge without reading code"],"limitations":["Graph visualization becomes cluttered with >1000 nodes; requires filtering or clustering for large graphs","Real-time updates require WebSocket support; current implementation uses polling which adds latency","No bulk operations — reviewing/approving changes is one-at-a-time, slow for high-mutation agents"],"requires":["FastAPI backend running (Python 3.9+)","Web browser with JavaScript support","Authentication credentials (username/password or API key)","Network access to Nocturne Memory server"],"input_types":["user authentication (credentials)","filter parameters (domain, date range, agent_id)","rollback target (version_id)"],"output_types":["HTML dashboard with interactive graph visualization","changeset diffs (before/after memory state)","version timeline with metadata"],"categories":["memory-knowledge","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-dataojitori-nocturne_memory__cap_6","uri":"capability://memory.knowledge.memory.domain.isolation.and.access.control","name":"memory domain isolation and access control","description":"Enforces domain-based memory isolation where memories are scoped to domains (core, user, task, knowledge) with separate access control rules. Each domain can have different retention policies, visibility rules, and mutation permissions. The URI system ensures memories in one domain cannot accidentally interfere with another (e.g., user preferences cannot overwrite core agent identity). Domain configuration is defined at deployment time and enforced at the database layer.","intents":["I want to ensure agent identity memories (core domain) cannot be modified by user-specific operations","I need different retention policies for different memory types (e.g., task memories expire after 30 days, core memories persist forever)","I want to isolate memories by tenant in a multi-tenant agent system so agents don't see each other's memories"],"best_for":["Multi-tenant agent systems where isolation is critical","Regulated environments requiring memory segregation by type or sensitivity","Teams implementing role-based access control for agent memory"],"limitations":["Domain structure is static at deployment time — cannot dynamically add new domains without redeployment","Cross-domain queries require explicit permission; no implicit relationship traversal across domains","Access control is coarse-grained (domain-level); no fine-grained row-level security within a domain"],"requires":["Nocturne Memory server with domain configuration","Environment variables or config file defining domain rules","Authentication/authorization system for access control"],"input_types":["domain specification (core, user, task, knowledge)","access control rules (read, write, delete permissions)","retention policies (TTL, archival rules)"],"output_types":["domain-scoped memory queries","access control enforcement (allow/deny)","audit logs of cross-domain access attempts"],"categories":["memory-knowledge","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-dataojitori-nocturne_memory__cap_7","uri":"capability://memory.knowledge.glossary.and.keyword.indexing.for.memory.discovery","name":"glossary and keyword indexing for memory discovery","description":"Maintains a glossary of keywords and concepts extracted from memory content, enabling agents and humans to discover memories by topic without full-text search. Keywords are indexed and linked to their source memories, creating a lightweight semantic index. The glossary is automatically updated as memories are created/modified and can be manually curated to add domain-specific terminology.","intents":["I want my agent to discover memories about a topic (e.g., 'Python') without doing expensive full-text search","I need to see what topics the agent has learned about and which memories are associated with each topic","I want to add domain-specific terminology to the glossary so the agent can reason about specialized concepts"],"best_for":["Agents in specialized domains (medicine, law, engineering) where terminology matters","Systems needing lightweight semantic indexing without embedding overhead","Developers building knowledge-intensive agents that need topic-based memory organization"],"limitations":["Glossary is keyword-based, not semantic — synonyms and related terms must be manually added","Keyword extraction is simple (substring matching or NLP); no sophisticated entity recognition","No automatic deduplication of similar keywords; glossary can become cluttered with near-duplicates"],"requires":["Nocturne Memory server with glossary module enabled","Memory content with extractable keywords","Optional: NLP library for keyword extraction (spaCy, NLTK)"],"input_types":["memory content (text)","manual keyword additions (strings)","keyword extraction configuration"],"output_types":["glossary entries (keyword → memory URIs)","topic-based memory clusters","keyword frequency statistics"],"categories":["memory-knowledge","search-retrieval"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-dataojitori-nocturne_memory__cap_8","uri":"capability://data.processing.analysis.sqlite.and.postgresql.backend.abstraction.with.migration.system","name":"sqlite and postgresql backend abstraction with migration system","description":"Abstracts database operations behind a unified client interface (SQLiteClient) that supports both SQLite (for development/single-instance) and PostgreSQL (for production/multi-instance). Includes a migration system for schema versioning, enabling safe upgrades and rollbacks of the database schema. The abstraction layer handles connection pooling, transaction management, and query optimization for both databases.","intents":["I want to start with SQLite for prototyping and migrate to PostgreSQL for production without rewriting code","I need to upgrade my Nocturne Memory schema safely without losing data or downtime","I want to run multiple Nocturne Memory instances sharing a PostgreSQL database for high availability"],"best_for":["Teams scaling from prototype to production","Developers who want database flexibility without vendor lock-in","Operations teams managing Nocturne Memory deployments across environments"],"limitations":["SQLite has poor concurrency — not suitable for high-traffic agent fleets; PostgreSQL required for production","Migration system is manual — no automatic schema inference; migrations must be written by hand","Cross-database compatibility is not guaranteed; some PostgreSQL features (JSON operators, window functions) may not work in SQLite"],"requires":["Python 3.9+","SQLite (included) or PostgreSQL 12+ with network access","Database credentials and connection string"],"input_types":["database connection configuration (URL, credentials)","migration files (SQL scripts)","schema version target"],"output_types":["database connection object","migration status (applied, pending, failed)","schema version metadata"],"categories":["data-processing-analysis","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-dataojitori-nocturne_memory__cap_9","uri":"capability://automation.workflow.docker.compose.deployment.with.nginx.reverse.proxy","name":"docker compose deployment with nginx reverse proxy","description":"Provides a Docker Compose configuration that orchestrates Nocturne Memory (FastAPI backend), PostgreSQL database, and Nginx reverse proxy in a single deployment. Nginx handles SSL termination, request routing, and load balancing. The configuration includes environment variable injection, volume management for persistence, and health checks. Suitable for single-server deployments or as a base for Kubernetes migration.","intents":["I want to deploy Nocturne Memory to production with a single command without managing infrastructure","I need SSL/TLS encryption for my Nocturne Memory API and dashboard","I want to run Nocturne Memory alongside other services (agents, databases) in a containerized environment"],"best_for":["Teams using Docker/Compose for infrastructure","Developers deploying Nocturne Memory to cloud VMs (AWS EC2, DigitalOcean, etc.)","Small-to-medium deployments (single server or small cluster)"],"limitations":["Docker Compose is not suitable for large-scale deployments; Kubernetes required for multi-node clusters","Nginx configuration is basic; advanced routing, rate limiting, or WAF rules require manual customization","No built-in backup or disaster recovery; requires external tooling for data persistence"],"requires":["Docker and Docker Compose installed","Linux server (Ubuntu 20.04+ recommended)","Ports 80, 443 available (or custom ports)","Environment variables configured (.env file)"],"input_types":["docker-compose.yml configuration",".env file with secrets and settings","SSL certificates (optional, can use self-signed)"],"output_types":["running containers (nocturne-api, postgres, nginx)","health check status","logs from all services"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":49,"verified":false,"data_access_risk":"high","permissions":["Python 3.9+","SQLite (included) or PostgreSQL 12+ for production","MCP client compatible with Model Context Protocol (Claude, Gemini, or custom LLM)","SQLite or PostgreSQL with transaction support","MCP server running with change recording enabled","Nocturne Memory server with review workflow enabled","Human reviewers with dashboard access","Authentication/authorization for reviewer roles","Nocturne Memory server with versioning enabled","Memory content stored as text or JSON"],"failure_modes":["Graph traversal performance degrades with very large memory graphs (100k+ nodes) without proper indexing strategy","URI path design requires upfront schema planning — poor domain structure leads to inefficient queries","No built-in distributed graph partitioning — single-instance bottleneck for high-concurrency agent fleets","Rollback is point-in-time only — cannot selectively revert individual mutations within a changeset","Version chains grow linearly with mutation count — no automatic pruning, requires manual maintenance","Rollback latency increases with memory graph size; reverting large graphs can take seconds","Review workflow adds latency — agents must wait for human approval before memory persists","No automatic approval rules; all changes require manual review (no whitelist/blacklist)","Rejected changes are discarded; no mechanism to suggest corrections or modifications","Diff generation is character-level; no semantic diff (e.g., detecting that a number changed from 5 to 6)","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.432422718873418,"quality":0.5,"ecosystem":0.7000000000000001,"match_graph":0.25,"freshness":0.75,"weights":{"adoption":0.25,"quality":0.25,"ecosystem":0.15,"match_graph":0.23,"freshness":0.12}},"observed_outcomes":{"matches":0,"success_rate":0,"avg_confidence":0,"top_intents":[],"last_matched_at":null},"maintenance":{"status":"active","updated_at":"2026-05-24T12:16:22.065Z","last_scraped_at":"2026-05-03T14:23:44.761Z","last_commit":"2026-04-23T02:53:33Z"},"community":{"stars":1026,"forks":126,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=mcp-dataojitori-nocturne_memory","compare_url":"https://unfragile.ai/compare?artifact=mcp-dataojitori-nocturne_memory"}},"signature":"8FY1ttvDr5T6mGTStq8WTyP+BGWvnSvM0v9WaP01as6mOoXKl7/y54ygD3ysB1qUNCD4rDoGG3QzazIUVBRWBQ==","signedAt":"2026-06-20T23:50:45.111Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/mcp-dataojitori-nocturne_memory","artifact":"https://unfragile.ai/mcp-dataojitori-nocturne_memory","verify":"https://unfragile.ai/api/v1/verify?slug=mcp-dataojitori-nocturne_memory","publicKey":"https://unfragile.ai/api/v1/trust-passport-public-key","spec":"https://unfragile.ai/trust","schema":"https://unfragile.ai/schema.json","docs":"https://unfragile.ai/docs"}}