{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"github_mcp-mksglu-context-mode","slug":"mcp-mksglu-context-mode","name":"context-mode","type":"mcp","url":"https://github.com/mksglu/context-mode","page_url":"https://unfragile.ai/mcp-mksglu-context-mode","categories":["mcp-servers"],"tags":["antigravity","claude","claude-code","claude-code-hooks","claude-code-plugins","claude-code-skill","codex","codex-cli","context-mode","copilot","cursor-plugin","kiro","mcp","mcp-server","mcp-tools","openclaw","opencode","pi-agent","skills","zed-extension"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"github_mcp-mksglu-context-mode__cap_0","uri":"capability://code.generation.editing.polyglot.sandboxed.code.execution.with.context.isolation","name":"polyglot-sandboxed-code-execution-with-context-isolation","description":"Executes code in isolated subprocess sandboxes across 11 languages (Python, Node.js, Bash, Go, Rust, Java, C++, C#, Ruby, PHP, Kotlin) using runtime detection and language-specific execution pipelines. Only stdout is captured and returned to the context window, filtering stderr and side effects. The PolyglotExecutor spawns isolated processes, manages lifecycle, and enforces execution timeouts, reducing context bloat from 56 KB (raw output) to 299 B (filtered stdout).","intents":["Execute code snippets without polluting the AI context window with full output","Run multi-language scripts safely without exposing error traces or debug logs","Test code changes in isolation while keeping the conversation focused on intent"],"best_for":["AI coding agents working across polyglot codebases","Teams using Claude Code, Cursor, or VS Code Copilot who need context efficiency","Developers building long-running coding sessions (30+ minutes) where context window fills quickly"],"limitations":["Subprocess spawning adds ~50-200ms latency per execution depending on language startup time","No built-in inter-process communication for stateful execution chains — each call is isolated","Background processes and daemon spawning require explicit management via hook system","Execution timeout is fixed per platform adapter; no per-call timeout override"],"requires":["Node.js 18+ (MCP server runtime)","Language runtimes installed locally (Python 3.9+, Node.js 18+, Go 1.18+, Rust 1.70+, etc.)","Unix-like shell for process spawning (Linux, macOS; Windows requires WSL or native subprocess support)"],"input_types":["code (string, any language)","command (shell command string)","file path (for ctx_execute_file)"],"output_types":["stdout (filtered, max 4KB per execution)","exit code (integer)","execution metadata (duration, language detected)"],"categories":["code-generation-editing","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-mksglu-context-mode__cap_1","uri":"capability://memory.knowledge.fts5.full.text.search.knowledge.base.with.bm25.ranking","name":"fts5-full-text-search-knowledge-base-with-bm25-ranking","description":"Indexes code, documentation, and tool output into a SQLite FTS5 (Full-Text Search 5) database with BM25 ranking. The ContentStore abstracts indexing and retrieval, allowing agents to search indexed content via ctx_search and ctx_fetch_and_index tools. Search results are ranked by relevance and truncated to snippets, keeping retrieved data small (40 B vs. 60 KB raw). Supports incremental indexing and session-aware knowledge partitioning.","intents":["Search across indexed codebase or documentation without loading full files into context","Retrieve relevant code snippets by semantic intent (e.g., 'authentication middleware') without full-text scanning","Build persistent knowledge bases across sessions, indexed once and queried many times"],"best_for":["Long-running coding sessions where the same codebase is queried repeatedly","Teams with large codebases (10K+ files) where loading full context is infeasible","Agents building RAG-style workflows with local knowledge bases"],"limitations":["FTS5 is SQLite-only; no support for external vector databases or Elasticsearch","BM25 ranking is lexical, not semantic — does not understand code intent or similarity","Indexing is synchronous and blocks execution; large codebases (100K+ files) may cause noticeable latency","No built-in deduplication or versioning — duplicate content increases index size"],"requires":["SQLite 3.8.2+ (FTS5 module)","Disk space for index (typically 10-20% of source code size)","ctx_index tool call to populate the knowledge base before searching"],"input_types":["file path (for indexing)","directory path (for batch indexing)","query string (for search)"],"output_types":["search results (array of snippets with relevance scores)","indexed content metadata (file path, line numbers, timestamp)"],"categories":["memory-knowledge","search-retrieval"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-mksglu-context-mode__cap_10","uri":"capability://safety.moderation.policy.based.security.filtering.with.configurable.rules","name":"policy-based-security-filtering-with-configurable-rules","description":"The security architecture includes configurable policies that filter or block tool calls based on rules (e.g., block execution of certain commands, restrict file access to specific directories, limit execution timeout). Policies are defined in platform-specific configuration files and enforced by the PreToolUse hook. Policy evaluation is synchronous and happens before tool execution. Policies support allow-lists (whitelist commands), deny-lists (blacklist commands), and resource limits (timeout, memory, file size).","intents":["Prevent AI agents from executing dangerous commands (e.g., rm -rf /)","Restrict file access to specific directories (e.g., only allow reading from /src)","Enforce resource limits (execution timeout, memory usage) to prevent runaway processes"],"best_for":["Security-conscious teams deploying context-mode in shared or untrusted environments","Organizations with compliance requirements (e.g., no execution of certain commands)","Teams running AI agents on production systems where safety is critical"],"limitations":["Policy enforcement is heuristic-based; sophisticated attacks (e.g., obfuscated commands) may bypass rules","Policies are static; no dynamic policy updates without restarting the MCP server","No audit logging of blocked tool calls; security events are not recorded","Policy evaluation adds ~5-10ms overhead per tool call"],"requires":["Policy configuration in platform-specific config file","PreToolUse hook registered to enforce policies"],"input_types":["policy rules (allow-list, deny-list, resource limits)","tool call object (for evaluation)"],"output_types":["policy evaluation result (allow/deny)","denial reason (if blocked)"],"categories":["safety-moderation","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-mksglu-context-mode__cap_11","uri":"capability://data.processing.analysis.context.window.usage.analytics.and.optimization.reporting","name":"context-window-usage-analytics-and-optimization-reporting","description":"The system tracks context window usage across tool calls and sessions, reporting metrics like total tokens consumed, context reduction percentage (98% claimed), and per-tool overhead. Analytics are collected via the event system and aggregated by ctx_stats. Reports show which tools consume the most context (before filtering) and how much context is saved by sandboxing and knowledge base queries. Enables data-driven optimization of tool usage and context management strategies.","intents":["Understand which tools and operations consume the most context window","Measure the effectiveness of context reduction strategies (sandboxing, knowledge base queries)","Identify optimization opportunities (e.g., which tools should be refactored for smaller output)"],"best_for":["Teams optimizing AI coding workflows for context efficiency","Researchers studying context window usage patterns in AI agents","Operators monitoring context-mode deployments for performance"],"limitations":["Analytics are collected at the MCP server level; no visibility into AI platform's internal context accounting","Reported context reduction percentage (98%) is theoretical; actual reduction depends on agent behavior","No real-time alerting or anomaly detection; analytics are historical only","Analytics data is not persisted across MCP server restarts"],"requires":["Event system enabled (default)","ctx_stats tool call to retrieve analytics"],"input_types":["none (analytics are collected automatically)"],"output_types":["context usage report (tokens consumed, reduction percentage, per-tool breakdown)","optimization recommendations (optional)"],"categories":["data-processing-analysis","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-mksglu-context-mode__cap_2","uri":"capability://memory.knowledge.session.continuity.with.event.capture.and.snapshot.restoration","name":"session-continuity-with-event-capture-and-snapshot-restoration","description":"Captures AI agent actions (tool calls, code edits, decisions) into a SessionDB (persistent SQLite store) as events. When the context window fills and compaction occurs, the PreCompact hook builds a priority-tiered snapshot of critical state (active files, pending tasks, resolved errors, user intent). On session resume, SessionStart hook restores the snapshot, allowing the agent to continue work without re-explaining context. Event system tracks file modifications, tool invocations, and decision points across session boundaries.","intents":["Resume long-running coding tasks across multiple AI sessions without losing working memory","Preserve which files were being edited, what errors were resolved, and what the user last requested","Avoid re-explaining context when the AI agent's conversation is compacted due to context window limits"],"best_for":["Multi-hour coding sessions that span multiple AI conversations","Teams working on large refactors or feature implementations that require session continuity","Developers using Claude Code or Cursor who frequently hit context limits"],"limitations":["Snapshot restoration is heuristic-based; complex state (e.g., partially-applied patches) may not fully restore","Event capture adds ~10-20ms overhead per tool call for database writes","SessionDB grows unbounded; no automatic cleanup or archival of old sessions","Snapshots are text-based; binary state (e.g., compiled artifacts) is not captured"],"requires":["SQLite 3.8.2+ for SessionDB storage","Hook system integration (PreCompact, SessionStart hooks must be registered)","Persistent filesystem for .context-mode/sessions/ directory"],"input_types":["event objects (tool calls, file edits, decisions)","session metadata (session ID, timestamp, user intent)"],"output_types":["resume snapshot (text summary of critical state)","event log (structured event history)","session metadata (session ID, duration, file list)"],"categories":["memory-knowledge","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-mksglu-context-mode__cap_3","uri":"capability://tool.use.integration.hook.system.for.lifecycle.interception.and.custom.logic","name":"hook-system-for-lifecycle-interception-and-custom-logic","description":"Provides four lifecycle hooks (PreToolUse, PostToolUse, PreCompact, SessionStart) that intercept AI agent execution at key points. Hooks are registered as TypeScript functions in platform-specific configurations and execute synchronously before/after tool invocations or session events. PreToolUse can filter or modify tool inputs; PostToolUse extracts structured data from tool outputs; PreCompact builds snapshots; SessionStart restores state. Hooks enable custom filtering, logging, and state management without modifying core MCP tools.","intents":["Inject custom filtering or validation logic before tools execute (e.g., block dangerous commands)","Extract structured data from tool outputs for indexing or state tracking","Build custom snapshots during context compaction based on application-specific state","Restore application-specific state when sessions resume"],"best_for":["Teams building custom AI coding workflows with domain-specific logic","Security-conscious teams needing to filter or audit tool calls before execution","Developers extending context-mode with custom state management or logging"],"limitations":["Hooks are synchronous; long-running logic (e.g., external API calls) blocks tool execution","Hook registration is platform-specific; no unified hook registration API across all platforms","Hook errors are not gracefully handled; a failing hook can crash the MCP server","No built-in hook ordering or dependency management for multiple hooks"],"requires":["TypeScript knowledge for writing hook functions","Platform-specific configuration file (.claude-plugin/plugin.json, cursor.json, etc.)","Node.js 18+ for hook execution"],"input_types":["tool call object (tool name, arguments)","tool output (stdout, exit code)","session metadata (session ID, event history)"],"output_types":["modified tool call (for PreToolUse)","extracted data (for PostToolUse)","snapshot object (for PreCompact)","restored state (for SessionStart)"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-mksglu-context-mode__cap_4","uri":"capability://tool.use.integration.multi.platform.adapter.architecture.with.platform.detection","name":"multi-platform-adapter-architecture-with-platform-detection","description":"Abstracts platform-specific integration details (Claude Code, Gemini CLI, VS Code Copilot, Cursor, OpenCode, Codex CLI) behind a unified adapter interface. Each platform adapter handles hook registration, configuration file parsing, and MCP server lifecycle. Runtime platform detection identifies the active AI platform and loads the appropriate adapter. Adapters expose platform-specific features (e.g., Claude Code's plugin API, Cursor's native integration) while maintaining a consistent MCP tool interface across all platforms.","intents":["Deploy context-mode to multiple AI coding platforms without rewriting integration code","Automatically detect which AI platform is running and load the correct configuration","Leverage platform-specific features (e.g., Claude Code plugins, Cursor native bindings) when available"],"best_for":["Teams using multiple AI coding platforms (Claude Code + Cursor + VS Code Copilot)","Tool developers building cross-platform AI integrations","Organizations standardizing on context-mode across heterogeneous AI tooling"],"limitations":["Platform detection is heuristic-based (environment variables, process names); may fail in non-standard setups","Each platform adapter requires separate configuration and testing; adding a new platform requires code changes","Platform-specific features (e.g., Claude Code plugin API) are not available on all platforms","Adapter abstraction adds ~20-50ms overhead per tool call for platform routing"],"requires":["Platform-specific configuration file (.claude-plugin/plugin.json, cursor.json, .opencode/config.json, etc.)","Environment detection (process name, environment variables, or manual platform specification)"],"input_types":["platform identifier (auto-detected or manual)","platform-specific configuration (JSON or TOML)"],"output_types":["loaded adapter instance","platform-specific MCP server configuration","hook registration status"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-mksglu-context-mode__cap_5","uri":"capability://code.generation.editing.batch.code.execution.with.dependency.ordering","name":"batch-code-execution-with-dependency-ordering","description":"The ctx_batch_execute tool accepts a list of code snippets with optional dependency declarations and executes them in topologically-sorted order. Dependencies are resolved to ensure snippets that depend on earlier outputs execute after their dependencies complete. Execution is atomic per batch; if a dependency fails, dependent snippets are skipped. Output from each snippet is captured separately and returned as an array, allowing agents to run multi-step workflows (e.g., install dependencies, run tests, deploy) in a single tool call.","intents":["Execute multi-step workflows (install → build → test → deploy) in a single batch without intermediate context pollution","Ensure code snippets execute in the correct order based on dependencies","Capture output from each step separately for debugging and decision-making"],"best_for":["CI/CD-like workflows embedded in AI coding sessions","Multi-language build pipelines (e.g., npm install → cargo build → pytest)","Agents that need to execute dependent code snippets atomically"],"limitations":["Dependency resolution is declarative only; no automatic dependency inference from code analysis","Batch execution is sequential, not parallel; no concurrency optimization for independent snippets","If a dependency fails, dependent snippets are silently skipped; no rollback or cleanup logic","Output from each snippet is limited to 4KB; large outputs are truncated"],"requires":["Dependency declarations in batch input (optional; execution is sequential if no dependencies specified)","All required runtimes installed locally"],"input_types":["array of code snippets (string, any language)","dependency graph (optional, as adjacency list or edge list)"],"output_types":["array of execution results (stdout, exit code, duration per snippet)","dependency resolution order (for debugging)"],"categories":["code-generation-editing","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-mksglu-context-mode__cap_6","uri":"capability://code.generation.editing.file.aware.code.execution.with.working.directory.context","name":"file-aware-code-execution-with-working-directory-context","description":"The ctx_execute_file tool executes code from a file path with working directory context preserved. The executor resolves the file path relative to the session's working directory, executes the code in that context, and captures stdout. This enables agents to run scripts that depend on relative imports, environment variables, or file system state without manually setting up context. Supports shebang-based language detection (#!/usr/bin/env python) and explicit language specification.","intents":["Execute scripts from the codebase without copying code into the context window","Run code that depends on relative imports or working directory state","Test changes to existing files without re-uploading them to the context"],"best_for":["Agents working with existing codebases that have scripts and test files","Workflows where code is stored on disk and executed in place","Teams using relative imports or environment-dependent code"],"limitations":["File path resolution is relative to session working directory; absolute paths may not work as expected","Shebang detection is Unix-only; Windows batch files and PowerShell scripts require explicit language specification","File must be readable by the MCP server process; permission errors are not gracefully handled","Large files (>10 MB) may cause memory issues during execution"],"requires":["File path (relative or absolute)","File must be readable by the MCP server process","Language runtime installed locally (or shebang in file)"],"input_types":["file path (string, relative or absolute)","language (optional, inferred from shebang or file extension)"],"output_types":["stdout (filtered, max 4KB)","exit code (integer)","execution metadata (duration, language detected)"],"categories":["code-generation-editing","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-mksglu-context-mode__cap_7","uri":"capability://memory.knowledge.content.indexing.and.fetch.with.incremental.updates","name":"content-indexing-and-fetch-with-incremental-updates","description":"The ctx_index tool indexes files or directories into the FTS5 knowledge base, and ctx_fetch_and_index combines fetching remote content (e.g., GitHub issues, API responses) with indexing. Indexing is incremental; only new or modified files are re-indexed. The ContentStore tracks file modification times and skips unchanged files. Indexed content is partitioned by session, allowing multi-session knowledge reuse without context pollution. Supports batch indexing of large directories with progress tracking.","intents":["Index a codebase or documentation once, then search it many times without re-indexing","Fetch remote content (GitHub issues, API docs) and index it for later search","Build persistent knowledge bases that persist across AI sessions"],"best_for":["Long-running projects where the codebase is indexed once and queried repeatedly","Teams fetching and indexing external content (GitHub issues, API documentation)","Workflows where knowledge base updates are infrequent (daily or weekly)"],"limitations":["Incremental indexing relies on file modification times; files modified outside the MCP server may not be re-indexed","Batch indexing of large directories (100K+ files) is slow and may block other operations","No automatic cleanup of deleted files; the index grows unbounded","Session-partitioned knowledge is not shared across sessions by default; requires explicit cross-session queries"],"requires":["File path or directory path (for local indexing)","URL (for remote content fetching)","Disk space for index (typically 10-20% of source code size)"],"input_types":["file path (string, relative or absolute)","directory path (for batch indexing)","URL (for remote content)","content type (optional, for parsing hints)"],"output_types":["indexing status (number of files indexed, skipped, errors)","index metadata (total size, file count, last updated)"],"categories":["memory-knowledge","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-mksglu-context-mode__cap_8","uri":"capability://search.retrieval.semantic.search.with.relevance.ranking.and.snippet.truncation","name":"semantic-search-with-relevance-ranking-and-snippet-truncation","description":"The ctx_search tool queries the FTS5 knowledge base using BM25 ranking and returns the top-K results as truncated snippets. Search is lexical (keyword-based), not semantic; results are ranked by term frequency and inverse document frequency. Snippets are truncated to 200-500 characters to keep retrieved data small. Search results include file paths, line numbers, and relevance scores, enabling agents to navigate to relevant code without loading full files. Supports filtering by file type or directory.","intents":["Find relevant code snippets by keyword without loading full files into context","Locate where a function or class is defined across a large codebase","Search indexed documentation or comments for relevant information"],"best_for":["Large codebases (10K+ files) where full-file loading is infeasible","Agents that need to navigate code without context pollution","Workflows where the same codebase is searched repeatedly"],"limitations":["BM25 ranking is lexical, not semantic; searches for 'authentication' won't find 'login' without explicit indexing","Snippet truncation (200-500 chars) may cut off important context; agents may need to fetch full files","Search is case-insensitive and does not support regex or advanced query syntax","No support for semantic similarity or code-aware search (e.g., finding similar functions)"],"requires":["Content must be indexed first via ctx_index or ctx_fetch_and_index","Query string (keywords)"],"input_types":["query string (keywords, space-separated)","file type filter (optional, e.g., '*.py')","directory filter (optional)"],"output_types":["search results (array of snippets with file path, line number, relevance score)","result count (number of matches)"],"categories":["search-retrieval","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-mksglu-context-mode__cap_9","uri":"capability://automation.workflow.diagnostic.and.maintenance.tools.for.system.health","name":"diagnostic-and-maintenance-tools-for-system-health","description":"The ctx_doctor tool performs system diagnostics (checks MCP server health, hook registration, platform detection, file permissions, database integrity). The ctx_stats tool reports index size, session count, event count, and memory usage. The ctx_upgrade tool updates context-mode to the latest version and migrates database schemas. These tools enable operators to monitor system health, troubleshoot integration issues, and maintain the MCP server without manual inspection.","intents":["Diagnose why context-mode is not working (hooks not registered, platform not detected, permissions issues)","Monitor system health (index size, session count, memory usage)","Upgrade context-mode and migrate database schemas without manual intervention"],"best_for":["Operators managing context-mode deployments across multiple machines","Teams troubleshooting integration issues with AI platforms","DevOps workflows that need automated health checks and upgrades"],"limitations":["ctx_doctor is heuristic-based; it may not catch all integration issues","ctx_stats reports are point-in-time snapshots; no historical trending or alerting","ctx_upgrade requires network access to fetch the latest version; may fail in air-gapped environments","Database schema migrations are not reversible; downgrades require manual intervention"],"requires":["MCP server running (for ctx_doctor and ctx_stats)","Network access (for ctx_upgrade)"],"input_types":["none (for ctx_doctor and ctx_stats)","version specifier (optional, for ctx_upgrade)"],"output_types":["diagnostic report (JSON or text)","statistics (index size, session count, memory usage)","upgrade status (success/failure, changelog)"],"categories":["automation-workflow","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":49,"verified":false,"data_access_risk":"high","permissions":["Node.js 18+ (MCP server runtime)","Language runtimes installed locally (Python 3.9+, Node.js 18+, Go 1.18+, Rust 1.70+, etc.)","Unix-like shell for process spawning (Linux, macOS; Windows requires WSL or native subprocess support)","SQLite 3.8.2+ (FTS5 module)","Disk space for index (typically 10-20% of source code size)","ctx_index tool call to populate the knowledge base before searching","Policy configuration in platform-specific config file","PreToolUse hook registered to enforce policies","Event system enabled (default)","ctx_stats tool call to retrieve analytics"],"failure_modes":["Subprocess spawning adds ~50-200ms latency per execution depending on language startup time","No built-in inter-process communication for stateful execution chains — each call is isolated","Background processes and daemon spawning require explicit management via hook system","Execution timeout is fixed per platform adapter; no per-call timeout override","FTS5 is SQLite-only; no support for external vector databases or Elasticsearch","BM25 ranking is lexical, not semantic — does not understand code intent or similarity","Indexing is synchronous and blocks execution; large codebases (100K+ files) may cause noticeable latency","No built-in deduplication or versioning — duplicate content increases index size","Policy enforcement is heuristic-based; sophisticated attacks (e.g., obfuscated commands) may bypass rules","Policies are static; no dynamic policy updates without restarting the MCP server","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.669065505138823,"quality":0.34,"ecosystem":0.6000000000000001,"match_graph":0.25,"freshness":0.75,"weights":{"adoption":0.25,"quality":0.25,"ecosystem":0.15,"match_graph":0.23,"freshness":0.12}},"observed_outcomes":{"matches":0,"success_rate":0,"avg_confidence":0,"top_intents":[],"last_matched_at":null},"maintenance":{"status":"active","updated_at":"2026-05-24T12:16:22.065Z","last_scraped_at":"2026-05-03T14:23:31.492Z","last_commit":"2026-05-03T12:22:52Z"},"community":{"stars":12162,"forks":842,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=mcp-mksglu-context-mode","compare_url":"https://unfragile.ai/compare?artifact=mcp-mksglu-context-mode"}},"signature":"yrs74BV1UHhza8heHl/UKUA752llTGhUug/R13X967F/ctgF+qVQJ4GgADGjHRTY2bhTBsDUDBQdq0xH3DHADg==","signedAt":"2026-06-21T14:27:35.802Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/mcp-mksglu-context-mode","artifact":"https://unfragile.ai/mcp-mksglu-context-mode","verify":"https://unfragile.ai/api/v1/verify?slug=mcp-mksglu-context-mode","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"}}