{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"github_mcp-gannonh-memento-mcp","slug":"mcp-gannonh-memento-mcp","name":"memento-mcp","type":"mcp","url":"https://github.com/gannonh/memento-mcp","page_url":"https://unfragile.ai/mcp-gannonh-memento-mcp","categories":["mcp-servers"],"tags":["claude-desktop","cursor","knowledge-graph","modelcontextprotocol","neo4j","vector-database"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"github_mcp-gannonh-memento-mcp__cap_0","uri":"capability://memory.knowledge.entity.centric.knowledge.graph.construction.with.temporal.versioning","name":"entity-centric knowledge graph construction with temporal versioning","description":"Constructs and maintains a Neo4j-backed knowledge graph where entities (persons, organizations, concepts) serve as primary nodes with complete version history and temporal audit trails. Each entity stores name, type classification, observational statements, and vector embeddings. The system automatically tracks all mutations through Neo4jStorageProvider, enabling point-in-time reconstruction of entity state at any historical timestamp and supporting confidence decay calculations over time.","intents":["Build a persistent memory system that tracks how entity information evolves across conversations","Query what an LLM knew about a specific entity at a particular point in time","Maintain an immutable audit trail of all entity modifications for compliance and debugging","Enable LLMs to reason about confidence in stored facts based on recency and update frequency"],"best_for":["AI agents requiring long-term memory across multi-turn conversations","Teams building knowledge management systems for LLM applications","Developers implementing temporal reasoning in AI systems"],"limitations":["Version history storage grows linearly with entity mutations — no automatic pruning or archival","Temporal queries require full graph traversal; no built-in time-series optimization","Entity embedding updates are asynchronous via EmbeddingJobManager — stale embeddings possible during high-volume updates"],"requires":["Neo4j 4.4+ database instance with vector index support","OpenAI API key for text-embedding-3-small model","TypeScript/Node.js 18+ runtime","MCP client integration (Claude Desktop, Cursor, or compatible)"],"input_types":["entity name (string)","entity type (enum: person, organization, concept, event, location)","observations (array of descriptive statements)","metadata (key-value pairs)"],"output_types":["entity object with embedding vector","version history array with timestamps","temporal state snapshots"],"categories":["memory-knowledge","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-gannonh-memento-mcp__cap_1","uri":"capability://memory.knowledge.semantic.relationship.management.with.strength.and.confidence.scoring","name":"semantic relationship management with strength and confidence scoring","description":"Manages directed relationships between entities with multi-dimensional scoring: strength (0.0-1.0 importance indicator) and confidence (0.0-1.0 certainty level). Relationships are stored as Neo4j edges with relationType classification, metadata fields, and automatic timestamp tracking. The system supports relationship creation, updates, and queries that filter by strength/confidence thresholds, enabling LLMs to reason about relationship reliability and importance.","intents":["Define and update relationships between entities with explicit confidence and importance metrics","Query only high-confidence relationships to avoid propagating uncertain information","Track when relationships were established or modified for temporal reasoning","Filter relationship queries by strength to surface the most important connections"],"best_for":["Knowledge graph applications requiring nuanced relationship semantics","Systems where relationship certainty varies (e.g., inferred vs. directly stated facts)","Multi-agent systems needing to communicate relationship reliability"],"limitations":["Confidence decay is applied uniformly across all relationship types — no per-type decay curves","Strength and confidence are independent dimensions; no built-in correlation analysis","Relationship metadata is unstructured key-value pairs — no schema validation"],"requires":["Neo4j 4.4+ with graph write permissions","Two existing entities (from/to nodes) in the knowledge graph","MCP client with tool-calling capability"],"input_types":["source entity name (string)","target entity name (string)","relationship type (string)","strength (float 0.0-1.0)","confidence (float 0.0-1.0)","metadata (optional key-value object)"],"output_types":["relationship object with all properties","confirmation of creation/update with timestamp","relationship query results (filtered by threshold)"],"categories":["memory-knowledge","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-gannonh-memento-mcp__cap_10","uri":"capability://data.processing.analysis.neo4j.storage.abstraction.with.pluggable.provider.pattern","name":"neo4j storage abstraction with pluggable provider pattern","description":"Abstracts Neo4j database operations through a Neo4jStorageProvider interface, enabling potential future storage backend swaps without changing business logic. The provider handles all graph mutations, queries, vector indexing, and temporal operations. This layered architecture separates storage concerns from knowledge graph management, improving testability and maintainability. The provider implements connection pooling, transaction management, and error handling for Neo4j operations.","intents":["Isolate Neo4j-specific code from business logic for easier testing and maintenance","Enable future migration to alternative storage backends without rewriting core logic","Centralize database connection management and error handling","Implement storage-specific optimizations (indexing, query planning) in one place"],"best_for":["Teams planning long-term storage backend flexibility","Projects requiring high test coverage of business logic","Deployments needing centralized database configuration management"],"limitations":["Provider abstraction adds indirection — slightly higher latency than direct Neo4j calls","Neo4j-specific features (Cypher syntax, vector indexes) are not abstracted — backend swap would require significant refactoring","No built-in connection pooling configuration — relies on Neo4j driver defaults","Error handling is Neo4j-specific — error types would need mapping for alternative backends"],"requires":["Neo4j 4.4+ instance","Neo4j driver connection string (bolt://host:port)","Neo4j credentials (username/password or auth token)"],"input_types":["Neo4j connection configuration (URI, credentials)","optional connection pool size (integer)","optional transaction timeout (milliseconds)"],"output_types":["storage provider instance","connection status","error handling responses"],"categories":["data-processing-analysis","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-gannonh-memento-mcp__cap_11","uri":"capability://memory.knowledge.relationship.metadata.and.custom.field.storage","name":"relationship metadata and custom field storage","description":"Stores arbitrary metadata as key-value pairs on relationships, enabling custom fields beyond standard properties (strength, confidence, relationType). Metadata is unstructured and flexible, allowing LLMs to attach domain-specific information to relationships without schema changes. Metadata is queryable and included in relationship results, supporting rich relationship semantics.","intents":["Attach domain-specific information to relationships without schema modifications","Store relationship context (e.g., source, evidence, notes) as metadata","Enable flexible relationship properties that vary by relationship type","Query relationships by custom metadata fields"],"best_for":["Knowledge graphs with domain-specific relationship properties","Systems requiring flexible relationship semantics","Applications where relationship context varies by type"],"limitations":["Metadata is unstructured — no schema validation or type checking","Metadata queries require Neo4j property matching — no full-text search on metadata values","No metadata versioning — updates overwrite previous values","Metadata size is unbounded — no built-in limits on field count or value size"],"requires":["Relationship object with metadata field","Key-value pairs (string keys, any JSON-serializable values)"],"input_types":["metadata object (key-value pairs)","optional metadata query filters (object)"],"output_types":["relationship with metadata fields","metadata query results"],"categories":["memory-knowledge","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-gannonh-memento-mcp__cap_12","uri":"capability://tool.use.integration.cli.interface.for.local.knowledge.graph.management","name":"cli interface for local knowledge graph management","description":"Provides a command-line interface for managing knowledge graphs locally without requiring MCP client integration. The CLI enables entity creation, relationship management, search, and temporal queries through terminal commands, supporting scripted workflows and local testing. The CLI uses the same underlying KnowledgeGraphManager as the MCP server, ensuring consistent behavior across interfaces.","intents":["Manage knowledge graphs locally for testing and development","Script bulk entity/relationship creation from command line","Query knowledge graphs without MCP client setup","Debug knowledge graph state through CLI inspection commands"],"best_for":["Developers testing knowledge graph operations locally","Teams running batch import scripts","Debugging and inspection workflows"],"limitations":["CLI is synchronous — long-running operations block terminal","No interactive REPL mode — each command requires separate invocation","Output formatting is basic — no rich terminal UI or visualization","CLI argument parsing is custom — no standard CLI framework (e.g., yargs, commander)"],"requires":["Node.js 18+ runtime","Memento MCP package installed locally","Neo4j database connection configured"],"input_types":["CLI command (string)","command arguments (strings)","optional JSON input file"],"output_types":["command result (JSON or text)","error messages","operation status"],"categories":["tool-use-integration","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-gannonh-memento-mcp__cap_13","uri":"capability://automation.workflow.configuration.management.with.environment.variables.and.config.files","name":"configuration management with environment variables and config files","description":"Manages system configuration through environment variables and optional config files, enabling deployment flexibility without code changes. Configuration includes Neo4j connection details, OpenAI API keys, embedding batch sizes, decay half-life parameters, and MCP server settings. The system loads configuration at startup with environment variable precedence over file-based config, supporting both development and production deployments.","intents":["Configure Neo4j connection details for different deployment environments","Set OpenAI API keys and embedding parameters without code changes","Tune performance parameters (batch size, timeouts) per deployment","Enable production deployments with secure credential management"],"best_for":["Teams deploying Memento MCP across multiple environments","Production deployments requiring secure credential management","Operators needing to tune performance parameters"],"limitations":["Configuration validation is minimal — invalid values may cause runtime errors","No hot-reload — configuration changes require server restart","Config file format is not documented — unclear which formats are supported","No built-in secrets management — API keys stored in environment variables or files"],"requires":["Environment variables or config file with required settings","Neo4j connection string","OpenAI API key"],"input_types":["environment variables (string key-value pairs)","config file (format TBD)"],"output_types":["loaded configuration object","validation errors (if any)"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-gannonh-memento-mcp__cap_2","uri":"capability://memory.knowledge.vector.embedding.generation.and.caching.with.async.job.management","name":"vector embedding generation and caching with async job management","description":"Generates and caches vector embeddings for entities using OpenAI's text-embedding-3-small model through an EmbeddingJobManager that batches requests and implements exponential backoff retry logic. Embeddings are cached in Neo4j's vector index to enable semantic similarity search. The system queues embedding jobs asynchronously, allowing entity creation to proceed without blocking on embedding generation, while maintaining eventual consistency through background job processing.","intents":["Enable semantic search across entity observations without waiting for embedding generation","Batch embedding requests to reduce API costs and improve throughput","Cache embeddings in the graph database to avoid re-computing identical entity descriptions","Handle embedding API failures gracefully with automatic retry and exponential backoff"],"best_for":["Large-scale knowledge graphs with thousands of entities requiring semantic search","Cost-sensitive deployments needing embedding request batching","Systems where embedding latency must not block entity creation workflows"],"limitations":["Embeddings are generated asynchronously — newly created entities are not immediately searchable semantically","Embedding cache is tied to entity observations; changes to observations require re-embedding","OpenAI API rate limits apply; batch size and retry logic must be tuned per deployment","No support for alternative embedding models — hardcoded to text-embedding-3-small"],"requires":["OpenAI API key with text-embedding-3-small access","Neo4j 4.4+ with vector index support","Network connectivity to OpenAI API endpoints"],"input_types":["entity observations (array of strings)","batch size configuration (integer)","retry policy parameters (max attempts, backoff multiplier)"],"output_types":["embedding vector (1536-dimensional for text-embedding-3-small)","job status (queued, processing, completed, failed)","cache hit/miss metrics"],"categories":["memory-knowledge","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-gannonh-memento-mcp__cap_3","uri":"capability://search.retrieval.hybrid.semantic.and.keyword.search.with.adaptive.strategy.selection","name":"hybrid semantic and keyword search with adaptive strategy selection","description":"Implements hybrid search combining vector similarity (via Neo4j vector index) and keyword matching, with an adaptive strategy selector that automatically chooses the optimal search method based on query characteristics. Semantic search uses entity embeddings to find conceptually similar entities; keyword search uses Neo4j full-text indexes for exact term matching. The system evaluates query properties (length, specificity, entity type) to route to the most effective search path.","intents":["Search for entities by semantic meaning when exact keywords are unknown","Find entities using precise keyword matching for structured queries","Automatically select the best search strategy without requiring LLM configuration","Combine semantic and keyword results for comprehensive entity discovery"],"best_for":["Knowledge graphs with diverse entity types requiring flexible search","Systems where query intent varies (sometimes semantic, sometimes keyword-based)","Applications needing to balance recall (semantic) with precision (keyword)"],"limitations":["Adaptive strategy selection heuristics are not tunable — fixed logic in codebase","Hybrid results require manual ranking/deduplication — no built-in result fusion algorithm","Keyword search depends on Neo4j full-text index configuration — requires index maintenance","Semantic search limited to entities with generated embeddings — newly created entities not immediately searchable"],"requires":["Neo4j 4.4+ with vector index and full-text index support","Entities with generated embeddings for semantic search","Query string (minimum 3 characters recommended)"],"input_types":["query string (text)","optional entity type filter (string)","optional result limit (integer)","optional similarity threshold (float 0.0-1.0)"],"output_types":["ranked entity results array","similarity scores for semantic matches","match type indicator (semantic vs. keyword)","entity metadata and observations"],"categories":["search-retrieval","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-gannonh-memento-mcp__cap_4","uri":"capability://memory.knowledge.point.in.time.graph.reconstruction.with.temporal.queries","name":"point-in-time graph reconstruction with temporal queries","description":"Enables querying the knowledge graph state at any historical timestamp through getGraphAtTime() and related temporal query methods. The system uses Neo4j's timestamp metadata on all mutations to reconstruct the graph as it existed at a specific moment, filtering out entities and relationships created after the target timestamp and excluding relationships whose confidence has decayed below a threshold. This enables LLMs to reason about what was known at a particular point in time.","intents":["Reconstruct the knowledge graph state as it existed at a specific past date","Analyze how the LLM's understanding of a topic evolved over time","Validate that information used in a decision was current at the time of decision","Debug knowledge graph mutations by examining historical states"],"best_for":["Compliance-heavy applications requiring audit trails of knowledge state","Systems analyzing how LLM reasoning evolved across conversations","Temporal reasoning applications (e.g., 'what did we know before event X?')"],"limitations":["Temporal queries require full graph traversal — no time-series optimization for large graphs","Point-in-time reconstruction does not include deleted entities — only tracks mutations of existing entities","Confidence decay calculations are applied at query time, not stored — recalculation required for each temporal query","No built-in temporal indexing — performance degrades with large version histories"],"requires":["Neo4j 4.4+ with timestamp tracking on all mutations","Valid ISO 8601 timestamp or Unix epoch milliseconds","Entities with complete version history (no pruned records)"],"input_types":["target timestamp (ISO 8601 string or milliseconds)","optional entity filter (name or type)","optional confidence threshold (float 0.0-1.0)"],"output_types":["graph snapshot object with entities and relationships as of timestamp","entity version history up to timestamp","relationship confidence values decayed to timestamp"],"categories":["memory-knowledge","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-gannonh-memento-mcp__cap_5","uri":"capability://memory.knowledge.confidence.decay.with.configurable.half.life.parameters","name":"confidence decay with configurable half-life parameters","description":"Automatically reduces relationship confidence scores over time using an exponential decay model with configurable half-life parameters. The system applies decay calculations at query time based on the relationship's creation timestamp and current time, allowing older relationships to gradually lose confidence. This models the real-world phenomenon that information becomes less certain as time passes without reinforcement, enabling LLMs to deprioritize stale information.","intents":["Automatically reduce confidence in old relationships without manual updates","Prevent LLMs from relying on outdated information in long-running conversations","Model information decay as a continuous process rather than binary fresh/stale","Configure decay rates per relationship type or globally"],"best_for":["Knowledge graphs tracking information that becomes less reliable over time","Systems requiring automatic information freshness management","Applications modeling uncertainty in temporal reasoning"],"limitations":["Decay is applied uniformly across all relationship types — no per-type decay curves","Decay calculations happen at query time, not stored — adds latency to every query","No mechanism to 'refresh' confidence by re-observing relationships — only creation timestamp matters","Half-life parameters are global configuration — no per-relationship customization"],"requires":["Relationship creation timestamp in Neo4j","Configured half-life parameter (in milliseconds or configurable units)","Query execution to trigger decay calculation"],"input_types":["half-life duration (milliseconds)","relationship confidence at creation (float 0.0-1.0)","current timestamp (auto-calculated)"],"output_types":["decayed confidence score (float 0.0-1.0)","decay factor applied (float)","time elapsed since creation"],"categories":["memory-knowledge","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-gannonh-memento-mcp__cap_6","uri":"capability://tool.use.integration.mcp.tool.exposure.with.schema.based.function.calling","name":"mcp tool exposure with schema-based function calling","description":"Exposes all knowledge graph operations through the Model Context Protocol as MCP tools with JSON schema definitions. The system implements a tool registry that maps natural language requests to underlying KnowledgeGraphManager methods, with automatic schema generation for input validation and type safety. LLM clients invoke tools via standard MCP function-calling protocol, receiving structured responses with embedded metadata for error handling and result interpretation.","intents":["Enable Claude, Cursor, and other MCP clients to invoke knowledge graph operations naturally","Provide type-safe tool interfaces with JSON schema validation","Expose entity/relationship management, search, and temporal queries as callable tools","Integrate knowledge graph operations into LLM agent workflows"],"best_for":["Teams building LLM agents with persistent memory requirements","Claude Desktop and Cursor users needing knowledge graph integration","Developers implementing multi-turn conversations with memory"],"limitations":["Tool invocation is synchronous — long-running operations (large batch updates) may timeout","Schema validation is JSON schema only — no custom validation logic per tool","Error responses are passed through MCP protocol — debugging requires MCP client logs","Tool discovery is static — requires server restart to add new tools"],"requires":["MCP-compatible client (Claude Desktop, Cursor, or custom implementation)","Memento MCP server running and accessible via stdio transport","Proper MCP configuration in client (e.g., Claude Desktop config.json)"],"input_types":["tool name (string)","tool arguments (JSON object matching schema)","optional context metadata"],"output_types":["tool result (JSON object)","error message (if applicable)","execution metadata (timestamp, duration)"],"categories":["tool-use-integration","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-gannonh-memento-mcp__cap_7","uri":"capability://data.processing.analysis.batch.entity.and.relationship.operations.with.transactional.consistency","name":"batch entity and relationship operations with transactional consistency","description":"Supports batch creation and updates of multiple entities and relationships in a single transaction, ensuring all-or-nothing semantics. The system queues batch operations through the KnowledgeGraphManager, which coordinates Neo4j transactions to maintain consistency. Batch operations are more efficient than individual mutations, reducing network round-trips and enabling atomic multi-entity updates (e.g., creating an entity and all its relationships simultaneously).","intents":["Create multiple related entities and their relationships in a single atomic operation","Bulk update entity observations or relationship properties without intermediate inconsistency","Reduce latency for operations involving multiple graph mutations","Ensure consistency when entities and relationships must be created together"],"best_for":["Knowledge graph initialization with large entity/relationship sets","Bulk import workflows from external data sources","Multi-entity updates requiring transactional consistency"],"limitations":["Batch size limits are not documented — may fail silently on very large batches","Transaction timeout is Neo4j default — long-running batches may be killed","Embedding generation for batch entities is still asynchronous — semantic search latency remains","No built-in progress tracking or partial failure recovery — entire batch fails if any operation fails"],"requires":["Neo4j 4.4+ with transaction support","Array of entity objects or relationship objects","Valid entity references for relationship operations"],"input_types":["entities array (array of entity objects)","relationships array (array of relationship objects)","optional transaction timeout (milliseconds)"],"output_types":["batch operation result (success/failure)","created entity IDs","created relationship IDs","error details if any operation failed"],"categories":["data-processing-analysis","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-gannonh-memento-mcp__cap_8","uri":"capability://memory.knowledge.entity.observation.management.with.incremental.updates","name":"entity observation management with incremental updates","description":"Manages entity observations (descriptive statements about entities) with support for adding, updating, and removing individual observations without replacing the entire observation set. Each observation is tracked independently with timestamps, enabling LLMs to add new facts about entities incrementally. The system maintains observation history and supports querying observations by creation date or content, allowing temporal reasoning about when facts were learned.","intents":["Add new observations about an entity without overwriting existing ones","Track when specific facts about an entity were learned","Remove or update individual observations that become outdated","Query observations by creation date for temporal reasoning"],"best_for":["Knowledge graphs where entity information accumulates over time","Systems tracking the evolution of facts about entities","Multi-turn conversations where new observations are added incrementally"],"limitations":["Observations are unstructured text — no schema validation or semantic deduplication","No automatic conflict resolution when contradictory observations are added","Observation history is immutable — updates create new observations rather than modifying existing ones","No built-in observation ranking or importance scoring"],"requires":["Existing entity in the knowledge graph","Observation text (string)","Optional metadata (key-value pairs)"],"input_types":["entity name (string)","observation text (string)","optional metadata (object)","optional timestamp (ISO 8601)"],"output_types":["updated entity object with new observation","observation ID","observation timestamp","updated embedding (if applicable)"],"categories":["memory-knowledge","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-gannonh-memento-mcp__cap_9","uri":"capability://memory.knowledge.entity.type.classification.and.filtering","name":"entity type classification and filtering","description":"Classifies entities into predefined types (person, organization, concept, event, location) and enables filtering queries by entity type. The system uses entityType as a first-class property on entities, allowing queries to constrain results to specific categories. Type classification enables domain-specific reasoning (e.g., 'find all people related to this organization') and improves search precision by filtering irrelevant entity types.","intents":["Classify entities into semantic categories for domain-specific reasoning","Filter search results to specific entity types","Enable type-aware relationship queries (e.g., 'people in this organization')","Organize knowledge graph by entity category for better navigation"],"best_for":["Knowledge graphs with diverse entity types requiring categorization","Domain-specific applications where entity type is semantically important","Search systems needing to filter by entity category"],"limitations":["Entity types are hardcoded to predefined set — no custom type definitions","No type hierarchy or inheritance — types are flat categories","Type changes require entity updates — no type versioning or history","No automatic type inference — types must be explicitly specified at entity creation"],"requires":["Entity type from predefined set: person, organization, concept, event, location","Valid entity name"],"input_types":["entity type (enum: person, organization, concept, event, location)","optional type filter in queries (string)"],"output_types":["entities filtered by type","type-specific relationship queries","entity type metadata"],"categories":["memory-knowledge","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":39,"verified":false,"data_access_risk":"high","permissions":["Neo4j 4.4+ database instance with vector index support","OpenAI API key for text-embedding-3-small model","TypeScript/Node.js 18+ runtime","MCP client integration (Claude Desktop, Cursor, or compatible)","Neo4j 4.4+ with graph write permissions","Two existing entities (from/to nodes) in the knowledge graph","MCP client with tool-calling capability","Neo4j 4.4+ instance","Neo4j driver connection string (bolt://host:port)","Neo4j credentials (username/password or auth token)"],"failure_modes":["Version history storage grows linearly with entity mutations — no automatic pruning or archival","Temporal queries require full graph traversal; no built-in time-series optimization","Entity embedding updates are asynchronous via EmbeddingJobManager — stale embeddings possible during high-volume updates","Confidence decay is applied uniformly across all relationship types — no per-type decay curves","Strength and confidence are independent dimensions; no built-in correlation analysis","Relationship metadata is unstructured key-value pairs — no schema validation","Provider abstraction adds indirection — slightly higher latency than direct Neo4j calls","Neo4j-specific features (Cypher syntax, vector indexes) are not abstracted — backend swap would require significant refactoring","No built-in connection pooling configuration — relies on Neo4j driver defaults","Error handling is Neo4j-specific — error types would need mapping for alternative backends","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.34637700802170734,"quality":0.35,"ecosystem":0.5800000000000001,"match_graph":0.25,"freshness":0.6,"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:38.364Z","last_commit":"2025-10-27T15:04:50Z"},"community":{"stars":418,"forks":63,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=mcp-gannonh-memento-mcp","compare_url":"https://unfragile.ai/compare?artifact=mcp-gannonh-memento-mcp"}},"signature":"zt3yb4Xu7bV4fo/c/Cc5J+W11km4Qq+YNhA/Eao97lXvxtoOrggTK8AM77LgZrVilrkUUSB7DbNgnCbfHX87AQ==","signedAt":"2026-06-20T02:45:14.430Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/mcp-gannonh-memento-mcp","artifact":"https://unfragile.ai/mcp-gannonh-memento-mcp","verify":"https://unfragile.ai/api/v1/verify?slug=mcp-gannonh-memento-mcp","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"}}