{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"github_mcp-mibayy-token-savior","slug":"mcp-mibayy-token-savior","name":"token-savior","type":"mcp","url":"https://github.com/Mibayy/token-savior","page_url":"https://unfragile.ai/mcp-mibayy-token-savior","categories":["mcp-servers"],"tags":[],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"github_mcp-mibayy-token-savior__cap_0","uri":"capability://data.processing.analysis.structural.codebase.indexing.with.language.aware.parsing","name":"structural codebase indexing with language-aware parsing","description":"Builds a persistent ProjectIndex by dispatching files to language-specific annotators (high-fidelity for Python, TypeScript, Go, Rust, C#; fallback for Markdown, JSON, text). Uses AST-based parsing to extract entities (functions, classes, imports) and their relationships rather than treating code as raw text. The index persists across sessions, enabling zero-cost reuse of structural knowledge.","intents":["Index a multi-language codebase once and reuse the structural knowledge across multiple AI sessions without re-parsing","Enable AI agents to query code by symbol rather than file path, reducing context overhead","Build a dependency graph that tracks call chains and transitive relationships for impact analysis"],"best_for":["teams using Claude Code, Cursor, or Windsurf with large multi-language codebases","developers building AI agents that need surgical code navigation without full-file reads","projects where token efficiency is critical (e.g., long-running coding sessions with limited context windows)"],"limitations":["High-fidelity parsing only supports 5 languages (Python, TypeScript, Go, Rust, C#); other languages fall back to generic text/Markdown parsing with reduced structural awareness","Initial indexing latency depends on codebase size; no incremental indexing mentioned in architecture","Requires Python 3.11+ and MCP-compatible client; not compatible with REST-only LLM APIs"],"requires":["Python 3.11 or higher","MCP-compatible client (Claude Code, Cursor, Windsurf, or equivalent)","Workspace root(s) configured in environment or config file","File system read access to target codebase"],"input_types":["source code files (Python, TypeScript, Go, Rust, C#, Markdown, JSON, plain text)","directory paths (workspace roots)"],"output_types":["ProjectIndex (persistent data structure)","entity metadata (function signatures, class definitions, import statements)","dependency graph (call chains, transitive relationships)"],"categories":["data-processing-analysis","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-mibayy-token-savior__cap_1","uri":"capability://search.retrieval.surgical.symbol.level.code.retrieval.with.line.range.precision","name":"surgical symbol-level code retrieval with line-range precision","description":"Exposes 34+ specialized query tools that retrieve only the relevant source lines for a specific symbol (function, class, method) without including the entire file. Uses the structural index to map symbol names to exact line ranges, then returns only those lines. Supports nested symbol queries (e.g., method within class) and handles language-specific scoping rules.","intents":["Get the source code for a specific function or class without loading the entire file","Retrieve method definitions within a class without reading unrelated class members","Query symbols across the codebase by name without knowing their file paths"],"best_for":["AI agents building context windows with strict token budgets","developers navigating large files where only a few symbols are relevant","code review and impact analysis workflows where precision matters"],"limitations":["Requires the codebase to be indexed first; no on-demand parsing of unindexed files","Symbol resolution depends on language-specific scoping rules; ambiguous symbol names may require disambiguation","Does not return comments or docstrings unless they are part of the parsed entity definition"],"requires":["Codebase must be indexed via ProjectIndexer","Symbol name must exist in the index","MCP client must support tool calling"],"input_types":["symbol name (string)","optional: file path or module name for disambiguation","optional: scope context (class name for method queries)"],"output_types":["source code snippet (text)","line range metadata (start_line, end_line)","symbol metadata (type, signature, language)"],"categories":["search-retrieval","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-mibayy-token-savior__cap_10","uri":"capability://automation.workflow.checkpoint.and.rollback.system.for.safe.code.modifications","name":"checkpoint and rollback system for safe code modifications","description":"Creates checkpoints before editing operations and enables rollback to previous states if validation fails. Stores checkpoint metadata (timestamp, symbol, change description) and allows reverting to any checkpoint within a session. Uses file-based or version-control-aware storage to persist checkpoints.","intents":["Rollback a failed edit without manual git operations","Create savepoints before risky refactoring operations","Explore multiple code changes and revert to a known-good state"],"best_for":["AI agents performing autonomous refactoring with safety guarantees","developers experimenting with code changes who want easy undo","teams building self-healing systems that can recover from failed modifications"],"limitations":["Checkpoints are session-local; no persistence across server restarts unless explicitly saved","Rollback only works for changes made within the current session","No conflict detection if multiple agents modify the same symbol between checkpoints","Checkpoint storage grows with number of edits; no automatic cleanup or compression"],"requires":["Write access to codebase files","Local storage for checkpoint metadata","Session must be active (checkpoints are lost on server restart)"],"input_types":["checkpoint identifier (string or timestamp)","optional: checkpoint description"],"output_types":["checkpoint metadata (timestamp, symbol, change description)","rollback status (success/failure)","restored file state"],"categories":["automation-workflow","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-mibayy-token-savior__cap_11","uri":"capability://automation.workflow.workflow.orchestration.for.complex.multi.step.code.operations","name":"workflow orchestration for complex multi-step code operations","description":"Provides high-level workflow tools (workflow_ops) that combine multiple low-level operations (edit, re-index, test, validate) into single atomic workflows. Workflows are defined as sequences of operations with error handling and rollback logic. Enables AI agents to perform complex refactoring tasks without manual orchestration.","intents":["Perform a multi-step refactoring (rename function, update callers, run tests) in a single operation","Execute a code generation workflow (create class, add methods, run tests) atomically","Build custom workflows for domain-specific code modifications"],"best_for":["AI agents performing complex autonomous refactoring","teams building custom code modification workflows","developers automating repetitive multi-step code changes"],"limitations":["Workflow definitions are static; no dynamic workflow generation based on code analysis","Error handling is basic (rollback on failure); no retry logic or partial success handling","Workflows are synchronous; no support for parallel operations or async steps","No workflow persistence; workflows are lost on server restart"],"requires":["Workflow definitions (built-in or custom)","All prerequisite operations (edit, test, validate) must be available","Codebase must be indexed"],"input_types":["workflow name (string)","workflow parameters (symbol name, new code, etc.)","optional: workflow configuration (error handling, rollback strategy)"],"output_types":["workflow execution result (success/failure)","step-by-step execution log","final codebase state"],"categories":["automation-workflow","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-mibayy-token-savior__cap_12","uri":"capability://tool.use.integration.mcp.tool.registry.with.106.specialized.tools.and.zero.external.dependencies","name":"mcp tool registry with 106 specialized tools and zero external dependencies","description":"Exposes 106+ specialized tools via the Model Context Protocol (MCP) standard, covering code navigation, editing, analysis, and workflow operations. Tools are registered in a schema-based function registry that supports MCP-compatible clients (Claude Code, Cursor, Windsurf). Implements all tools with zero external dependencies beyond Python standard library.","intents":["Access a comprehensive toolkit for code analysis and modification via MCP","Integrate token-savior with any MCP-compatible LLM client","Build custom tools on top of the token-savior infrastructure"],"best_for":["developers using Claude Code, Cursor, Windsurf, or other MCP-compatible clients","teams building custom LLM agents that need code analysis capabilities","organizations deploying token-savior in air-gapped environments (no external dependencies)"],"limitations":["Tool discovery depends on MCP client support; not all clients expose all tools equally","Tool parameters are schema-based; complex or dynamic parameters may not be well-supported","No built-in rate limiting or quota management for tool usage","Tool versioning is implicit; breaking changes to tool signatures may break client integrations"],"requires":["MCP-compatible client (Claude Code, Cursor, Windsurf, etc.)","MCP server running with tools registered","Python 3.11+"],"input_types":["tool name (string)","tool parameters (schema-based, varies by tool)"],"output_types":["tool result (varies by tool)","error messages (if tool fails)"],"categories":["tool-use-integration","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-mibayy-token-savior__cap_13","uri":"capability://automation.workflow.incremental.codebase.re.indexing.with.file.watch.integration","name":"incremental codebase re-indexing with file-watch integration","description":"Monitors the file system for changes and incrementally re-indexes affected files rather than rebuilding the entire ProjectIndex. Uses file-watch events (or polling) to detect modifications and updates only the changed symbols in the index. Maintains index consistency across concurrent edits.","intents":["Keep the index up-to-date as code changes without manual refresh","Detect when external tools modify the codebase and update the index automatically","Maintain index consistency when multiple agents modify the codebase simultaneously"],"best_for":["long-running MCP servers that need to stay in sync with the codebase","teams using multiple AI agents on the same codebase","developers working with external tools (formatters, linters) that modify code"],"limitations":["File-watch integration is optional and may not be enabled by default","Incremental re-indexing adds complexity and potential for index inconsistency","No built-in conflict resolution for concurrent modifications","File-watch performance depends on OS and file system; may be slow on large codebases"],"requires":["File-watch capability (OS-dependent; may require polling on some systems)","Write access to index storage","Codebase must be indexed initially"],"input_types":["file path (detected via file-watch)","change type (created, modified, deleted)"],"output_types":["updated ProjectIndex","list of affected symbols","re-indexing status"],"categories":["automation-workflow","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-mibayy-token-savior__cap_2","uri":"capability://planning.reasoning.transitive.dependency.graph.traversal.for.impact.analysis","name":"transitive dependency graph traversal for impact analysis","description":"Builds and traverses a dependency graph that maps call chains and transitive relationships between symbols. When a symbol is modified, the system can identify all downstream dependents (what might break) and upstream dependencies (what this symbol depends on). Uses graph traversal algorithms to compute impact scope without re-scanning the codebase.","intents":["Determine what code might break if I modify a specific function or class","Identify all callers of a function to understand its usage patterns","Trace the dependency chain from a symbol to its leaf dependencies"],"best_for":["AI agents performing safe refactoring with regression awareness","developers analyzing the blast radius of a code change before committing","teams building automated test selection based on code changes"],"limitations":["Dependency graph is static (built at index time); dynamic calls (reflection, eval, plugin systems) are not captured","Cross-language dependencies (e.g., Python calling TypeScript via subprocess) are not tracked","Transitive closure computation may be expensive for highly connected graphs; no memoization strategy mentioned"],"requires":["Codebase must be indexed","Symbols must have resolvable dependencies within the indexed codebase","Graph must be built during indexing (no lazy evaluation)"],"input_types":["symbol name (string)","direction flag (upstream, downstream, or bidirectional)"],"output_types":["list of dependent symbols","call chain metadata (caller, callee, line number)","impact scope (count of affected symbols)"],"categories":["planning-reasoning","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-mibayy-token-savior__cap_3","uri":"capability://code.generation.editing.atomic.symbol.editing.with.automatic.re.indexing.and.validation","name":"atomic symbol editing with automatic re-indexing and validation","description":"Provides safe editing operations (edit_ops, compact_ops) that replace symbol source code without manual line-range calculations. After editing, automatically re-indexes the affected file and validates the change by running impacted tests. Uses checkpoints and rollback capabilities to ensure codebase integrity if validation fails.","intents":["Edit a function or class definition and automatically re-index the file without manual line tracking","Replace a symbol's source and immediately validate the change by running affected tests","Rollback a failed edit to the previous checkpoint without manual git operations"],"best_for":["AI agents performing autonomous code modifications with safety guarantees","developers using AI-assisted refactoring who want automatic regression detection","teams building self-healing code systems that can validate and rollback changes"],"limitations":["Requires test infrastructure to be present and discoverable; no tests means no validation","Rollback only works within a session; no persistent undo across server restarts","Editing nested symbols (methods within classes) requires precise scope specification; ambiguous edits may fail","Re-indexing latency adds ~100-500ms per edit depending on file size"],"requires":["Codebase must be indexed","Symbol must exist in the index","Test framework must be discoverable (pytest, Jest, etc.)","Write access to the codebase files"],"input_types":["symbol name (string)","new source code (string)","optional: scope context for nested symbols"],"output_types":["edit result (success/failure)","re-indexed metadata","test execution results (passed/failed tests)","rollback status if validation fails"],"categories":["code-generation-editing","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-mibayy-token-savior__cap_4","uri":"capability://data.processing.analysis.symbol.level.git.change.summarization.and.diff.analysis","name":"symbol-level git change summarization and diff analysis","description":"Integrates with git to summarize changes at the symbol level rather than raw line diffs. When a file is modified, the system maps changed lines back to symbols and reports what symbols were added, removed, or modified. Provides a high-level view of code changes that is more meaningful to AI agents than raw diffs.","intents":["Understand what symbols changed in a commit without reading raw git diffs","Generate commit messages based on symbol-level changes","Identify which symbols were affected by a pull request"],"best_for":["AI agents generating commit messages or PR descriptions","developers reviewing changes at a semantic level rather than line-by-line","teams building automated changelog generation based on code changes"],"limitations":["Requires git repository to be initialized and accessible","Symbol mapping depends on accurate indexing; if index is stale, diff analysis may be inaccurate","Does not track symbol renames (appears as deletion + addition rather than rename)"],"requires":["Git repository initialized in workspace","Codebase indexed and up-to-date","Git binary accessible in PATH"],"input_types":["git commit range (e.g., HEAD~1..HEAD)","optional: file path filter"],"output_types":["list of changed symbols","change type (added, removed, modified)","symbol metadata (type, language, scope)"],"categories":["data-processing-analysis","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-mibayy-token-savior__cap_5","uri":"capability://automation.workflow.impacted.test.selection.and.execution.based.on.dependency.analysis","name":"impacted test selection and execution based on dependency analysis","description":"Uses the dependency graph to automatically identify which tests are affected by a code change, then executes only those tests. Avoids running the full test suite by computing the transitive closure of changed symbols and finding tests that depend on them. Integrates with common test frameworks (pytest, Jest, etc.).","intents":["Run only the tests affected by my code change instead of the full test suite","Validate a refactoring by running tests that depend on the modified symbols","Get fast feedback on code changes without waiting for full CI/CD pipelines"],"best_for":["developers working on large codebases with slow test suites","AI agents performing autonomous refactoring who need fast validation","teams building fast feedback loops for code changes"],"limitations":["Test discovery depends on framework conventions; custom test runners may not be detected","Impacted test selection is conservative (may include tests that don't actually depend on the change) to avoid false negatives","Does not track indirect dependencies through configuration files or environment variables","Requires test framework to be installed and configured"],"requires":["Codebase indexed with dependency graph built","Test framework installed (pytest, Jest, etc.)","Tests must be discoverable via framework conventions"],"input_types":["list of changed symbols","optional: test framework hint"],"output_types":["list of impacted tests","test execution results (passed/failed)","execution time and coverage metrics"],"categories":["automation-workflow","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-mibayy-token-savior__cap_6","uri":"capability://memory.knowledge.persistent.session.memory.with.cross.session.context.retention","name":"persistent session memory with cross-session context retention","description":"Maintains a persistent memory engine that stores context and query results across MCP sessions. When an AI agent reconnects, it can access previously indexed data, query results, and session state without re-indexing or re-querying. Uses local storage (file-based or database) to persist the ProjectIndex and query cache.","intents":["Resume a coding session without re-indexing the codebase","Reuse query results from previous sessions to avoid redundant computation","Maintain conversation context across multiple AI agent invocations"],"best_for":["long-running coding sessions where re-indexing would be expensive","teams using multiple AI agents on the same codebase who want to share indexed knowledge","developers working on large codebases where indexing takes minutes"],"limitations":["Persistent memory is not automatically invalidated when code changes; requires manual refresh or file-watch integration","No built-in conflict resolution if multiple agents modify the codebase simultaneously","Memory footprint grows with codebase size; no automatic cleanup or garbage collection mentioned","Session state is local to the MCP server instance; no distributed session sharing"],"requires":["Local file system write access for persistence","MCP server must be running continuously or restarted to load persisted state","Sufficient disk space for ProjectIndex and query cache"],"input_types":["session identifier (string)","optional: memory scope (global, per-project, per-session)"],"output_types":["persisted ProjectIndex","query cache","session metadata (timestamp, agent ID, context)"],"categories":["memory-knowledge","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-mibayy-token-savior__cap_7","uri":"capability://data.processing.analysis.multi.language.entity.extraction.with.language.specific.semantics","name":"multi-language entity extraction with language-specific semantics","description":"Dispatches files to language-specific annotators that extract entities (functions, classes, methods, imports, exports) with language-specific semantics. High-fidelity annotators for Python, TypeScript, Go, Rust, and C# use AST parsing to understand scoping rules, decorators, type annotations, and module systems. Fallback annotators for Markdown, JSON, and text use pattern matching.","intents":["Extract all functions and classes from a Python file with their signatures and decorators","Identify exported symbols from a TypeScript module","Parse Go interfaces and their implementations","Extract Rust trait definitions and implementations"],"best_for":["developers building code analysis tools that need language-aware parsing","teams with multi-language codebases who want unified entity extraction","AI agents that need to understand code structure beyond simple text matching"],"limitations":["High-fidelity parsing only supports 5 languages; other languages use generic fallback with reduced accuracy","Fallback annotators may miss nested or complex structures (e.g., closures, anonymous classes)","Language-specific features (decorators, type annotations) are extracted but not deeply analyzed","No support for language-specific build systems (macros, generics, templates) beyond basic parsing"],"requires":["File extension must match a supported language","Source code must be syntactically valid for high-fidelity parsing","Language-specific parser/AST library must be available (tree-sitter, ast module, etc.)"],"input_types":["source code file (Python, TypeScript, Go, Rust, C#, Markdown, JSON, text)","file path (used to determine language)"],"output_types":["list of entities (functions, classes, methods, imports)","entity metadata (name, type, signature, line range, scope)","language-specific attributes (decorators, type annotations, visibility)"],"categories":["data-processing-analysis","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-mibayy-token-savior__cap_8","uri":"capability://tool.use.integration.workspace.aware.code.navigation.with.multi.root.support","name":"workspace-aware code navigation with multi-root support","description":"Supports indexing multiple workspace roots simultaneously, enabling navigation across monorepos and multi-project setups. Maintains separate ProjectIndex instances for each root but allows cross-root queries and dependency tracking. Handles workspace configuration via environment variables or config files.","intents":["Index a monorepo with multiple projects and navigate across them","Track dependencies between projects in a multi-root workspace","Query symbols across multiple projects without knowing which project they belong to"],"best_for":["teams using monorepos (Nx, Lerna, Bazel, etc.)","developers working on multi-project setups with shared dependencies","AI agents that need to understand cross-project dependencies"],"limitations":["Cross-root dependency tracking depends on import/export statements; implicit dependencies (via shared packages) may not be captured","Workspace configuration must be explicitly provided; no automatic detection of monorepo structure","Indexing multiple roots increases memory footprint and initial indexing time","No built-in support for workspace-level build systems (Nx, Bazel) beyond file-based indexing"],"requires":["WORKSPACE_ROOTS environment variable or config file with root paths","All roots must be accessible via file system","Each root should have consistent language/framework setup"],"input_types":["workspace root paths (list of strings)","optional: workspace configuration (project metadata, dependencies)"],"output_types":["multi-root ProjectIndex","cross-root dependency graph","workspace metadata (projects, shared dependencies)"],"categories":["tool-use-integration","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-mibayy-token-savior__cap_9","uri":"capability://data.processing.analysis.token.usage.tracking.and.savings.metrics.dashboard","name":"token usage tracking and savings metrics dashboard","description":"Tracks every character returned to the AI via token-savior tools versus what would have been returned by naive approaches (e.g., cat, full-file reads). Persists metrics to a local database and exposes them via a web dashboard. Calculates token savings percentage and provides usage statistics per tool, per session, and per codebase.","intents":["Measure how much token overhead is saved by using token-savior vs. naive approaches","Track token usage trends across sessions to optimize context window allocation","Demonstrate ROI of structural indexing to stakeholders"],"best_for":["teams optimizing token usage for cost-sensitive LLM deployments","developers evaluating token-savior's effectiveness on their codebase","organizations building internal dashboards for LLM usage monitoring"],"limitations":["Metrics are approximate (based on character counts, not actual token counts); actual token savings may vary by tokenizer","Dashboard requires web server to be running; no static export option mentioned","Metrics are local to the MCP server instance; no aggregation across multiple servers","No privacy controls; metrics may expose sensitive information about codebase structure"],"requires":["MCP server running with metrics collection enabled","Local database or file storage for metrics","Web server for dashboard (built-in or external)"],"input_types":["tool invocation logs (tool name, input, output size)","session metadata (timestamp, agent ID)"],"output_types":["metrics database (characters used, characters naive, savings %)","dashboard visualizations (charts, tables, trends)","export formats (JSON, CSV)"],"categories":["data-processing-analysis","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":42,"verified":false,"data_access_risk":"high","permissions":["Python 3.11 or higher","MCP-compatible client (Claude Code, Cursor, Windsurf, or equivalent)","Workspace root(s) configured in environment or config file","File system read access to target codebase","Codebase must be indexed via ProjectIndexer","Symbol name must exist in the index","MCP client must support tool calling","Write access to codebase files","Local storage for checkpoint metadata","Session must be active (checkpoints are lost on server restart)"],"failure_modes":["High-fidelity parsing only supports 5 languages (Python, TypeScript, Go, Rust, C#); other languages fall back to generic text/Markdown parsing with reduced structural awareness","Initial indexing latency depends on codebase size; no incremental indexing mentioned in architecture","Requires Python 3.11+ and MCP-compatible client; not compatible with REST-only LLM APIs","Requires the codebase to be indexed first; no on-demand parsing of unindexed files","Symbol resolution depends on language-specific scoping rules; ambiguous symbol names may require disambiguation","Does not return comments or docstrings unless they are part of the parsed entity definition","Checkpoints are session-local; no persistence across server restarts unless explicitly saved","Rollback only works for changes made within the current session","No conflict detection if multiple agents modify the same symbol between checkpoints","Checkpoint storage grows with number of edits; no automatic cleanup or compression","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.36224945488829974,"quality":0.5,"ecosystem":0.39999999999999997,"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-04-22T08:08:46.027Z","last_commit":"2026-04-21T15:01:41Z"},"community":{"stars":611,"forks":45,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=mcp-mibayy-token-savior","compare_url":"https://unfragile.ai/compare?artifact=mcp-mibayy-token-savior"}},"signature":"ys07xWd029Li9qKcszmsR7QvLXXyZE04TXfKHJ4g8KXHWoL+2BAk+Ufh1PR/5yaR7WnaEpxLLCpM9+6eyqlRBA==","signedAt":"2026-06-20T13:29:45.275Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/mcp-mibayy-token-savior","artifact":"https://unfragile.ai/mcp-mibayy-token-savior","verify":"https://unfragile.ai/api/v1/verify?slug=mcp-mibayy-token-savior","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"}}