{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"github_mcp-alioshr-memory-bank-mcp","slug":"mcp-alioshr-memory-bank-mcp","name":"memory-bank-mcp","type":"mcp","url":"https://github.com/alioshr/memory-bank-mcp","page_url":"https://unfragile.ai/mcp-alioshr-memory-bank-mcp","categories":["mcp-servers"],"tags":["antrophic","claude","cline","cline-memory-bank","cursor","mcp-server","memory-bank","model-context-protocol","windsurf"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"github_mcp-alioshr-memory-bank-mcp__cap_0","uri":"capability://memory.knowledge.remote.memory.bank.file.reading.with.project.isolation","name":"remote memory bank file reading with project isolation","description":"Implements read-only access to memory bank files through MCP protocol with path traversal prevention and project-scoped file retrieval. Uses clean architecture layers (Presentation → Domain → Data Access → Infrastructure) to translate MCP read requests into filesystem operations, validating project and file paths against a root directory to prevent unauthorized access. Returns file contents as structured responses with error handling for missing or inaccessible files.","intents":["I want Claude or Cursor to read my project's memory bank files without direct filesystem access","I need to prevent AI tools from accessing memory files outside their assigned project directory","I want to serve memory bank contents to multiple MCP clients from a single centralized server"],"best_for":["teams using Claude, Cursor, or Cline with shared memory bank infrastructure","developers building multi-project AI agent systems requiring isolated context","organizations needing centralized memory management across multiple AI tools"],"limitations":["Read-only operation — no modification capability in this specific endpoint","File size not specified — potential performance impact with very large memory bank files","No built-in caching — each read request hits the filesystem directly"],"requires":["Node.js 18+ (TypeScript runtime)","MEMORY_BANK_ROOT environment variable pointing to valid filesystem directory","MCP client compatible with memory_bank_read tool definition","Read permissions on target project directory in filesystem"],"input_types":["project_id (string)","file_path (string, relative to project directory)"],"output_types":["file_contents (string)","error_response (structured error with code and message)"],"categories":["memory-knowledge","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-alioshr-memory-bank-mcp__cap_1","uri":"capability://memory.knowledge.memory.bank.file.creation.with.validation.and.path.safety","name":"memory bank file creation with validation and path safety","description":"Enables creation of new memory bank files through MCP protocol with comprehensive path validation, project isolation, and file structure enforcement. The Presentation layer validates input parameters, the Domain layer enforces business rules (e.g., valid project and file paths), and the Infrastructure layer performs actual filesystem write operations. Prevents path traversal attacks by validating that resolved paths remain within the target project directory.","intents":["I want to programmatically create new memory bank files from Claude or Cursor without manual filesystem access","I need to ensure new memory files follow project structure conventions and stay within project boundaries","I want to create memory bank entries from AI agents with guaranteed path safety"],"best_for":["AI agents that need to persist new memory entries during conversations","teams automating memory bank initialization across multiple projects","developers building MCP-based workflows that generate project-specific documentation"],"limitations":["No atomic multi-file creation — each file write is independent","No built-in versioning or rollback — overwrites are permanent","File permissions inherit from parent directory — no granular permission control per file","No transaction support — partial failures leave incomplete state"],"requires":["Node.js 18+ (TypeScript runtime)","MEMORY_BANK_ROOT environment variable configured","Write permissions on target project directory","Valid project_id that exists in the filesystem","MCP client with memory_bank_write tool support"],"input_types":["project_id (string)","file_path (string, relative to project)","file_contents (string)"],"output_types":["success_response (confirmation with file path)","error_response (validation or filesystem error)"],"categories":["memory-knowledge","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-alioshr-memory-bank-mcp__cap_10","uri":"capability://data.processing.analysis.data.access.layer.abstraction.with.filesystem.implementation","name":"data access layer abstraction with filesystem implementation","description":"Defines data access interfaces that abstract filesystem operations, allowing domain layer to request file operations without knowing implementation details. The Data Access layer specifies interfaces for read, write, update, and list operations, and the Infrastructure layer provides concrete filesystem implementations using Node.js fs module. This abstraction enables testing domain logic with mock implementations and potentially swapping filesystem for other storage backends (cloud storage, databases) without changing domain code.","intents":["I want to test domain logic without actual filesystem operations","I need to potentially swap filesystem storage for cloud storage or databases in the future","I want to mock file operations in unit tests"],"best_for":["developers building testable MCP servers with dependency injection","teams planning to support multiple storage backends","builders implementing repository pattern or data access abstraction"],"limitations":["Abstraction overhead — interface definitions add code without runtime benefit","Filesystem-specific optimizations hidden — abstraction may prevent performance tuning","No transaction support — abstraction doesn't enable ACID guarantees across operations","Mock implementations required for testing — adds test maintenance burden"],"requires":["Node.js 18+ (TypeScript runtime)","TypeScript knowledge for interface definitions","Understanding of dependency injection and repository pattern"],"input_types":["data access interface method calls (read, write, update, list)"],"output_types":["file contents, success/error responses"],"categories":["data-processing-analysis","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-alioshr-memory-bank-mcp__cap_11","uri":"capability://data.processing.analysis.infrastructure.layer.filesystem.operations.with.error.handling","name":"infrastructure layer filesystem operations with error handling","description":"Implements concrete filesystem operations using Node.js fs module to fulfill data access layer interfaces, handling file reads, writes, updates, and directory listings with proper error handling and path resolution. Performs actual filesystem I/O, manages file permissions, and translates filesystem errors into domain-level error responses. Includes path resolution to normalize paths and prevent directory traversal, and handles edge cases like missing files, permission errors, and invalid paths.","intents":["I want reliable filesystem operations with proper error handling","I need to handle filesystem errors gracefully and return meaningful error messages","I want to ensure filesystem operations respect project isolation boundaries"],"best_for":["developers implementing filesystem-based storage for MCP servers","teams needing robust file I/O with error handling","builders managing memory banks on local or network filesystems"],"limitations":["Synchronous vs asynchronous — implementation choice affects performance and concurrency","Filesystem-specific errors — error handling may differ across operating systems","No atomic operations — multi-file operations can partially fail","No built-in compression or encryption — files stored as-is on filesystem","Filesystem permissions — relies on OS-level permissions for access control"],"requires":["Node.js 18+ (TypeScript runtime)","Filesystem with read/write permissions on MEMORY_BANK_ROOT","Understanding of Node.js fs module (promises or callbacks)","Proper error handling for filesystem operations"],"input_types":["file paths (strings)","file contents (strings)","directory paths (strings)"],"output_types":["file contents (strings)","file lists (arrays of strings)","success/error responses"],"categories":["data-processing-analysis","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-alioshr-memory-bank-mcp__cap_12","uri":"capability://automation.workflow.environment.based.configuration.with.memory.bank.root","name":"environment-based configuration with memory_bank_root","description":"Configures memory bank root directory through MEMORY_BANK_ROOT environment variable, enabling deployment flexibility without code changes. The server reads this variable at startup to determine where all project directories are located, allowing different deployments (development, staging, production) to use different filesystem locations. Supports Docker deployment where the environment variable can be set via container environment or volume mounts.","intents":["I want to configure memory bank location without changing code","I need to deploy memory-bank-mcp to different environments with different storage paths","I want to use Docker with configurable memory bank location"],"best_for":["teams deploying memory-bank-mcp across multiple environments","developers using Docker or containerized deployments","builders implementing infrastructure-as-code with environment variables"],"limitations":["Single root directory — no support for multiple storage locations or sharding","No validation at startup — misconfigured MEMORY_BANK_ROOT fails at first operation","No hot-reload — changing MEMORY_BANK_ROOT requires server restart","No fallback — missing MEMORY_BANK_ROOT causes immediate failure"],"requires":["MEMORY_BANK_ROOT environment variable set before server startup","Target directory must exist and be readable/writable","Node.js 18+ (TypeScript runtime)"],"input_types":["environment variable: MEMORY_BANK_ROOT (string path)"],"output_types":["configured root directory path"],"categories":["automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-alioshr-memory-bank-mcp__cap_13","uri":"capability://tool.use.integration.type.safe.operation.definitions.with.input.validation","name":"type-safe operation definitions with input validation","description":"Defines type-safe operation schemas for each MCP tool with explicit input parameters, output types, and validation rules. Each operation specifies required parameters (project_id, file_path, contents), their types (string, etc.), and validation constraints. The Presentation layer validates incoming requests against these schemas before passing to domain logic, ensuring type safety and preventing invalid inputs from reaching business logic. Supports MCP tool definition format with parameter descriptions and types.","intents":["I want to validate MCP tool inputs before processing","I need type-safe operation definitions that prevent invalid parameters","I want to provide clear parameter documentation in MCP tool definitions"],"best_for":["developers building MCP servers with strict input validation","teams needing clear operation contracts and documentation","builders implementing schema-based validation"],"limitations":["Validation logic duplicated across tools — no shared validation framework","Schema changes require code updates — no dynamic schema registration","Limited validation rules — basic type checking, no complex constraints","Error messages generic — validation errors don't provide detailed guidance"],"requires":["Node.js 18+ (TypeScript runtime)","TypeScript knowledge for type definitions","Understanding of MCP tool definition format"],"input_types":["MCP tool parameters (project_id, file_path, contents, etc.)"],"output_types":["validation result (valid/invalid with error details)"],"categories":["tool-use-integration","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-alioshr-memory-bank-mcp__cap_2","uri":"capability://memory.knowledge.memory.bank.file.updating.with.content.replacement","name":"memory bank file updating with content replacement","description":"Provides in-place update capability for existing memory bank files through MCP protocol, replacing entire file contents while maintaining project isolation and path safety. Uses the same clean architecture pattern as file creation but targets existing files, with validation ensuring the file exists before update and the resolved path remains within project boundaries. Supports overwriting memory bank entries with new content from AI agents.","intents":["I want to update existing memory bank entries from Claude or Cursor during multi-turn conversations","I need to replace memory file contents while ensuring the file stays within its project directory","I want AI agents to modify memory banks without exposing filesystem paths"],"best_for":["long-running AI agent conversations that need to update context over time","teams maintaining shared memory banks that require programmatic updates","developers building memory-augmented AI workflows with persistent state"],"limitations":["Full content replacement only — no partial/patch updates or merge strategies","No conflict detection — concurrent updates from multiple clients will overwrite each other","No version history — previous content is lost after update","No pre-update validation — can replace valid memory with invalid content if client sends bad data"],"requires":["Node.js 18+ (TypeScript runtime)","MEMORY_BANK_ROOT environment variable configured","Write permissions on target project directory","Target file must already exist (no auto-creation)","Valid project_id","MCP client with memory_bank_update tool support"],"input_types":["project_id (string)","file_path (string, relative to project)","file_contents (string, new content)"],"output_types":["success_response (confirmation with updated file path)","error_response (file not found, validation, or filesystem error)"],"categories":["memory-knowledge","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-alioshr-memory-bank-mcp__cap_3","uri":"capability://memory.knowledge.project.enumeration.and.discovery.via.mcp","name":"project enumeration and discovery via mcp","description":"Lists all available projects in the memory bank root directory through MCP protocol, enabling clients to discover project structure without filesystem access. Implements read-only enumeration at the Presentation layer that queries the Infrastructure layer's filesystem operations to return project directories, with implicit filtering to exclude non-directory entries and hidden files. Supports multi-project management by allowing clients to discover which projects are available before accessing their files.","intents":["I want Claude or Cursor to discover which projects have memory banks available","I need to list all projects in my memory bank infrastructure for client initialization","I want to enable dynamic project selection in AI agent workflows"],"best_for":["multi-project AI systems that need dynamic project discovery","teams managing memory banks across many projects and needing visibility","developers building MCP clients that adapt behavior based on available projects"],"limitations":["No filtering or search — returns all projects regardless of client permissions","No metadata — returns only project names, not descriptions or creation dates","No sorting — order depends on filesystem enumeration (typically alphabetical but not guaranteed)","No pagination — all projects returned in single response (potential performance issue with thousands of projects)"],"requires":["Node.js 18+ (TypeScript runtime)","MEMORY_BANK_ROOT environment variable pointing to valid directory","Read permissions on MEMORY_BANK_ROOT directory","MCP client with list_projects tool support"],"input_types":["none (no parameters required)"],"output_types":["projects_array (array of project names as strings)","error_response (if MEMORY_BANK_ROOT is inaccessible)"],"categories":["memory-knowledge","search-retrieval"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-alioshr-memory-bank-mcp__cap_4","uri":"capability://memory.knowledge.project.scoped.file.enumeration.with.path.safety","name":"project-scoped file enumeration with path safety","description":"Lists all files within a specific project directory through MCP protocol, enabling clients to discover available memory bank files without direct filesystem access. Validates the project_id parameter to ensure it exists and resolves to a valid path within MEMORY_BANK_ROOT, then enumerates files in that project directory. Returns file names (not full paths) to maintain abstraction, with implicit filtering of directories and hidden files. Supports memory bank exploration by allowing clients to discover which files are available in a project.","intents":["I want to list all memory bank files in a specific project before reading them","I need to discover available memory entries in a project without knowing filenames in advance","I want AI agents to explore project structure and decide which memory files to access"],"best_for":["AI agents that need to discover available memory before deciding what to read","teams managing memory banks with many files per project","developers building MCP clients with dynamic file selection UI"],"limitations":["No recursive enumeration — only lists files in project root, not subdirectories","No file metadata — returns only names, not sizes, modification dates, or content previews","No filtering — returns all files regardless of type or naming convention","No sorting — order depends on filesystem enumeration","Project must exist — returns error if project_id doesn't correspond to a directory"],"requires":["Node.js 18+ (TypeScript runtime)","MEMORY_BANK_ROOT environment variable configured","Read permissions on target project directory","Valid project_id that exists in filesystem","MCP client with list_project_files tool support"],"input_types":["project_id (string, must exist in MEMORY_BANK_ROOT)"],"output_types":["files_array (array of file names as strings)","error_response (project not found or access denied)"],"categories":["memory-knowledge","search-retrieval"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-alioshr-memory-bank-mcp__cap_5","uri":"capability://tool.use.integration.clean.architecture.request.response.translation","name":"clean architecture request-response translation","description":"Implements the Presentation layer that translates incoming MCP protocol requests into domain operations and formats responses back to MCP format. Acts as an adapter between the MCP protocol's request/response structure and the internal domain layer's use cases, performing input validation, parameter extraction, and response formatting. Each MCP tool (memory_bank_read, memory_bank_write, etc.) maps to a corresponding use case through this translation layer, ensuring type safety and consistent error handling across all operations.","intents":["I want to add new MCP tools without modifying domain or infrastructure logic","I need consistent error handling and response formatting across all MCP operations","I want to validate MCP inputs before they reach domain logic"],"best_for":["developers extending memory-bank-mcp with new MCP tools","teams maintaining MCP server implementations with multiple tools","builders implementing clean architecture patterns in MCP servers"],"limitations":["Adds abstraction layer overhead — each request traverses Presentation → Domain → Data Access → Infrastructure","Validation logic duplicated across tools — no shared validation framework mentioned in architecture","MCP protocol changes require Presentation layer updates — tight coupling to MCP spec version","Error translation complexity — must map domain errors to MCP error format"],"requires":["Node.js 18+ (TypeScript runtime)","Understanding of MCP protocol tool definition format","TypeScript knowledge for implementing tool handlers","Familiarity with clean architecture patterns"],"input_types":["MCP tool request (JSON with tool name and parameters)"],"output_types":["MCP tool response (JSON with result or error)"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-alioshr-memory-bank-mcp__cap_6","uri":"capability://safety.moderation.path.traversal.prevention.with.resolved.path.validation","name":"path traversal prevention with resolved path validation","description":"Implements security validation across the architecture to prevent directory traversal attacks by resolving file paths to absolute paths and verifying they remain within the target project directory. The Presentation layer validates input format, the Domain layer enforces business rules, and the Infrastructure layer performs final resolved-path verification before filesystem operations. Uses filesystem path resolution (e.g., Node.js path.resolve) to normalize paths containing '..' or symbolic links, then validates the resolved path is within the project root using string prefix matching or path comparison.","intents":["I want to prevent MCP clients from accessing files outside their project directory","I need to block directory traversal attacks like '../../../etc/passwd' in file paths","I want to ensure symbolic links can't be used to escape project boundaries"],"best_for":["teams running memory-bank-mcp in multi-tenant or untrusted client environments","developers building security-sensitive MCP servers","organizations with compliance requirements for data isolation"],"limitations":["Symbolic link handling depends on filesystem — may not prevent all symlink attacks on all systems","No whitelist of allowed files — any file within project directory is accessible","Validation happens at multiple layers — potential for inconsistency if layers diverge","No audit logging — path traversal attempts are not logged for security monitoring"],"requires":["Node.js 18+ (TypeScript runtime)","Filesystem that supports path resolution (all major OSes)","Proper MEMORY_BANK_ROOT configuration pointing to intended root","Understanding of path traversal attack vectors"],"input_types":["project_id (string)","file_path (string, potentially containing '..' or symlinks)"],"output_types":["validation_result (boolean: path is safe)","error_response (path traversal detected)"],"categories":["safety-moderation","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-alioshr-memory-bank-mcp__cap_7","uri":"capability://safety.moderation.project.isolation.with.filesystem.based.access.control","name":"project isolation with filesystem-based access control","description":"Enforces project boundaries by organizing memory banks into separate project directories under MEMORY_BANK_ROOT and validating all file operations against the target project directory. Each project is a subdirectory containing its own memory bank files, and all read/write operations validate that the resolved file path remains within the project directory. This isolation is enforced at the Infrastructure layer through filesystem operations and validated at the Presentation and Domain layers, preventing clients from accessing files in other projects.","intents":["I want to ensure MCP clients can only access memory files in their assigned project","I need to prevent cross-project data leakage in multi-tenant memory bank infrastructure","I want to organize memory banks by project with guaranteed isolation"],"best_for":["multi-project organizations using shared memory bank infrastructure","teams with multiple AI agent systems that need isolated memory contexts","developers building multi-tenant MCP servers"],"limitations":["Isolation is filesystem-based — no cryptographic separation or encryption per project","No per-project access control lists — all projects are equally accessible to all clients","No project metadata or ownership tracking — projects are identified only by directory name","Isolation depends on correct MEMORY_BANK_ROOT configuration — misconfiguration breaks isolation"],"requires":["Node.js 18+ (TypeScript runtime)","MEMORY_BANK_ROOT environment variable pointing to valid directory","Filesystem with proper permission controls (Unix permissions or Windows ACLs)","Project directories pre-created under MEMORY_BANK_ROOT"],"input_types":["project_id (string, maps to subdirectory name)"],"output_types":["project_directory_path (validated, within MEMORY_BANK_ROOT)"],"categories":["safety-moderation","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-alioshr-memory-bank-mcp__cap_8","uri":"capability://tool.use.integration.mcp.protocol.server.implementation.with.tool.definitions","name":"mcp protocol server implementation with tool definitions","description":"Implements a complete MCP server that exposes five core tools (memory_bank_read, memory_bank_write, memory_bank_update, list_projects, list_project_files) through the Model Context Protocol, enabling MCP-compatible clients like Claude, Cursor, and Cline to interact with memory banks. The server defines tool schemas with input parameters and output types, handles MCP protocol messages, and routes requests to appropriate handlers. Provides type-safe operation definitions and proper error responses conforming to MCP specification.","intents":["I want to make my memory bank accessible to Claude, Cursor, or Cline via MCP","I need to expose memory bank operations as MCP tools that AI agents can call","I want to integrate memory bank management into MCP-based AI workflows"],"best_for":["developers building MCP servers for memory management","teams integrating memory banks with Claude, Cursor, or Cline","builders creating MCP-compatible AI agent infrastructure"],"limitations":["MCP protocol version locked to specific version — upgrading MCP spec requires server updates","Tool definitions are static — no dynamic tool registration at runtime","No built-in authentication — relies on transport-layer security (e.g., stdio, SSE)","Error handling limited to MCP error format — may lose implementation-specific error details"],"requires":["Node.js 18+ (TypeScript runtime)","MCP SDK for Node.js (included in package.json dependencies)","MCP-compatible client (Claude, Cursor, Cline, or custom MCP client)","Proper MCP server configuration (stdio or SSE transport)"],"input_types":["MCP protocol messages (JSON-RPC format)"],"output_types":["MCP protocol responses (JSON-RPC format with results or errors)"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-alioshr-memory-bank-mcp__cap_9","uri":"capability://planning.reasoning.domain.layer.use.case.orchestration","name":"domain layer use case orchestration","description":"Implements domain layer use cases that encapsulate business logic for each operation (read, write, update, list projects, list files) independent of MCP protocol or filesystem details. Each use case defines the business rules and constraints for its operation, receives validated inputs from the Presentation layer, and delegates to Data Access layer interfaces for actual operations. Use cases are protocol-agnostic and could be reused with different interfaces (REST, gRPC, CLI), enabling clean separation of concerns and testability.","intents":["I want to test memory bank business logic without MCP protocol or filesystem dependencies","I need to reuse memory bank operations in different interfaces (REST, CLI, etc.)","I want to add new business rules or constraints to memory operations"],"best_for":["developers building testable MCP servers with clean architecture","teams planning to expose memory bank operations through multiple interfaces","builders implementing domain-driven design patterns"],"limitations":["Additional abstraction layer adds complexity — more classes and interfaces to maintain","Use case orchestration adds latency — each operation traverses multiple layers","No cross-use-case transactions — each operation is independent","Business logic scattered across use cases — no centralized rule engine"],"requires":["Node.js 18+ (TypeScript runtime)","Understanding of use case pattern and clean architecture","TypeScript knowledge for implementing use case classes"],"input_types":["use case input objects (project_id, file_path, contents, etc.)"],"output_types":["use case output objects (file contents, project list, success/error)"],"categories":["planning-reasoning","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":45,"verified":false,"data_access_risk":"high","permissions":["Node.js 18+ (TypeScript runtime)","MEMORY_BANK_ROOT environment variable pointing to valid filesystem directory","MCP client compatible with memory_bank_read tool definition","Read permissions on target project directory in filesystem","MEMORY_BANK_ROOT environment variable configured","Write permissions on target project directory","Valid project_id that exists in the filesystem","MCP client with memory_bank_write tool support","TypeScript knowledge for interface definitions","Understanding of dependency injection and repository pattern"],"failure_modes":["Read-only operation — no modification capability in this specific endpoint","File size not specified — potential performance impact with very large memory bank files","No built-in caching — each read request hits the filesystem directly","No atomic multi-file creation — each file write is independent","No built-in versioning or rollback — overwrites are permanent","File permissions inherit from parent directory — no granular permission control per file","No transaction support — partial failures leave incomplete state","Abstraction overhead — interface definitions add code without runtime benefit","Filesystem-specific optimizations hidden — abstraction may prevent performance tuning","No transaction support — abstraction doesn't enable ACID guarantees across operations","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.4110189304870196,"quality":0.5,"ecosystem":0.6000000000000001,"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.064Z","last_scraped_at":"2026-05-03T14:23:34.856Z","last_commit":"2025-08-20T10:23:06Z"},"community":{"stars":899,"forks":87,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=mcp-alioshr-memory-bank-mcp","compare_url":"https://unfragile.ai/compare?artifact=mcp-alioshr-memory-bank-mcp"}},"signature":"EDrix3rwSGNFBq3H3Tovu0i5VThbgVn4bt0pDz2dlw8lA5XHWbUlSx6o7H3Pn1blq9ho4qbu7WCOcCrqXdvRDw==","signedAt":"2026-06-21T11:49:52.413Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/mcp-alioshr-memory-bank-mcp","artifact":"https://unfragile.ai/mcp-alioshr-memory-bank-mcp","verify":"https://unfragile.ai/api/v1/verify?slug=mcp-alioshr-memory-bank-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"}}