{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"github_mcp-jonigl-mcp-client-for-ollama","slug":"mcp-jonigl-mcp-client-for-ollama","name":"mcp-client-for-ollama","type":"cli","url":"https://github.com/jonigl/mcp-client-for-ollama","page_url":"https://unfragile.ai/mcp-jonigl-mcp-client-for-ollama","categories":["mcp-servers"],"tags":["agentic-ai","ai","command-line-tool","generative-ai","linux","llm","local-llm","macos","mcp","mcp-client","mcp-server","model-context-protocol","ollama","open-source","pypi-package","sse","stdio","streamable-http","tool-management","windows"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"github_mcp-jonigl-mcp-client-for-ollama__cap_0","uri":"capability://tool.use.integration.multi.transport.mcp.server.connection.with.auto.discovery","name":"multi-transport mcp server connection with auto-discovery","description":"Establishes and manages connections to MCP servers across three transport protocols (STDIO, SSE, Streamable HTTP) with automatic server discovery. The ServerConnector component handles protocol negotiation, session management, and transport-specific serialization/deserialization, enabling seamless integration with heterogeneous MCP server implementations without requiring manual transport configuration.","intents":["Connect to local MCP servers running as Python/JavaScript scripts via STDIO","Integrate with remote MCP servers exposing SSE endpoints for real-time streaming","Use modern HTTP-based MCP transports with improved performance characteristics","Automatically discover available MCP servers without manual configuration"],"best_for":["Developers building local LLM tool-use workflows with mixed server types","Teams deploying MCP servers across STDIO, SSE, and HTTP transports","Solo developers prototyping agentic systems without complex DevOps infrastructure"],"limitations":["STDIO transport limited to local process execution — no remote STDIO support","SSE connections require server-side event stream implementation — not all HTTP servers support this","Auto-discovery relies on configuration file scanning — no dynamic service registry support","Transport switching requires client restart — no hot-swapping between protocols"],"requires":["Python 3.9+","Ollama runtime installed and accessible","MCP servers configured in ~/.mcp/servers.json or custom config path","Network access to remote servers if using SSE or HTTP transports"],"input_types":["MCP server configuration (JSON)","Transport protocol specification (stdio|sse|streamable-http)","Server endpoint URLs or script paths"],"output_types":["Established MCP session handle","Server capability manifest (tools, resources, prompts)","Streaming response streams from MCP servers"],"categories":["tool-use-integration","mcp-protocol"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-jonigl-mcp-client-for-ollama__cap_1","uri":"capability://tool.use.integration.agentic.tool.execution.with.human.in.the.loop.approval","name":"agentic tool execution with human-in-the-loop approval","description":"Orchestrates tool invocation through a ToolManager that enables/disables tools, formats tool calls from LLM responses, executes them against MCP servers, and presents results to the user with optional approval gates. The system parses LLM-generated tool calls, validates them against available tool schemas, executes them via MCP protocol, and streams results back into the conversation context with human-in-the-loop checkpoints for safety-critical operations.","intents":["Enable LLMs to call external tools while maintaining user control over execution","Approve or reject tool calls before execution to prevent unintended side effects","Manage which tools are available to the LLM at any given time","Stream tool execution results back into the conversation for multi-step reasoning"],"best_for":["Developers building agentic systems with local LLMs requiring safety controls","Teams deploying autonomous workflows where human oversight is mandatory","Non-technical users running AI agents who need visibility into tool execution"],"limitations":["Tool execution is synchronous — no parallel tool invocation across multiple servers","Approval gates add latency — each tool call requires user interaction unless auto-approved","Tool schema validation is strict — malformed tool calls from LLM are rejected without fallback","No built-in tool result caching — repeated tool calls execute fresh each time"],"requires":["Python 3.9+","Active MCP server connections with tool definitions","LLM model capable of generating tool calls in expected format","User interaction capability (terminal for approval prompts)"],"input_types":["LLM response text containing tool call syntax","Tool schema definitions from MCP servers","Tool arguments as JSON or structured data"],"output_types":["Tool execution results (JSON, text, structured data)","Execution status and error messages","Formatted results for LLM context injection"],"categories":["tool-use-integration","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-jonigl-mcp-client-for-ollama__cap_10","uri":"capability://tool.use.integration.server.capability.discovery.and.tool.schema.introspection","name":"server capability discovery and tool schema introspection","description":"Automatically discovers and introspects MCP server capabilities including available tools, resources, and prompts with their full schema definitions. When connecting to an MCP server, the client queries the server's capabilities, parses tool schemas (including parameters, descriptions, and constraints), and makes this information available for tool selection, validation, and autocomplete. The system maintains an index of all discovered tools and their schemas for runtime validation.","intents":["Discover what tools are available from connected MCP servers","Understand tool parameters and constraints before calling them","Validate tool calls against server schemas before execution","Build autocomplete and tool discovery features from server metadata"],"best_for":["Developers integrating with multiple MCP servers with different tool sets","Teams deploying MCP servers and needing to understand available capabilities","Solo developers building tool-using LLM applications"],"limitations":["Schema discovery is one-time at connection — dynamic tool registration not supported","Tool schema validation is strict — servers with malformed schemas cause errors","No schema caching — tool discovery requires server round-trip each session","Schema evolution not handled — server schema changes require client reconnection"],"requires":["Python 3.9+","Connected MCP servers that implement capability discovery","Servers must return valid tool schema definitions"],"input_types":["MCP server connection","Capability query requests"],"output_types":["Tool schema definitions (name, description, parameters)","Resource definitions from servers","Prompt definitions from servers","Capability manifest"],"categories":["tool-use-integration","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-jonigl-mcp-client-for-ollama__cap_11","uri":"capability://memory.knowledge.conversation.context.management.with.tool.result.injection","name":"conversation context management with tool result injection","description":"Maintains conversation history and intelligently injects tool execution results back into the context for the LLM to process. The system tracks all user messages, LLM responses, and tool calls/results in a structured conversation object, formats tool results appropriately for LLM consumption, and includes relevant context in subsequent requests. This enables multi-turn conversations where the LLM can reason about tool results and take follow-up actions.","intents":["Maintain conversation history across multiple turns","Feed tool execution results back to the LLM for continued reasoning","Provide context about previous tool calls and results","Enable multi-turn workflows where LLM refines results based on feedback"],"best_for":["Developers building multi-turn LLM applications with tool use","Teams deploying conversational agents that learn from tool results","Solo developers building interactive LLM workflows"],"limitations":["Context window is limited by model — long conversations may exceed token limits","No automatic context pruning — developers must manage conversation length","Tool results are included verbatim — no summarization or filtering","Context is in-memory only — no persistence of conversation history by default"],"requires":["Python 3.9+","LLM model with sufficient context window for conversation history","Tool execution results in appropriate format for LLM consumption"],"input_types":["User messages (text)","LLM responses (text with tool calls)","Tool execution results (JSON, text, structured data)"],"output_types":["Formatted conversation history","Context-injected LLM requests","Conversation metadata (turn count, token usage)"],"categories":["memory-knowledge","text-generation-language"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-jonigl-mcp-client-for-ollama__cap_12","uri":"capability://automation.workflow.local.first.execution.with.no.cloud.dependencies","name":"local-first execution with no cloud dependencies","description":"Runs entirely locally using Ollama for LLM inference and local MCP servers, with no requirement for cloud API calls or external services. All model inference, tool execution, and data processing happens on the user's machine, providing privacy, offline capability, and cost savings. The system is designed for air-gapped environments and provides full functionality without internet connectivity.","intents":["Run LLM applications without sending data to cloud services","Deploy in air-gapped or offline environments","Avoid cloud API costs for LLM inference and tool execution","Maintain full data privacy and control"],"best_for":["Enterprises with data privacy requirements or air-gapped networks","Developers building offline-capable LLM applications","Teams avoiding cloud API costs for high-volume inference","Solo developers who value privacy and offline capability"],"limitations":["Model quality is limited to open-source models available for Ollama","Hardware requirements are high — GPU recommended for reasonable performance","No access to proprietary models (GPT-4, Claude, etc.)","Scaling is limited to single machine — no distributed inference"],"requires":["Python 3.9+","Ollama runtime installed locally","At least one Ollama model downloaded","Sufficient hardware (GPU recommended, 8GB+ RAM minimum)","Local MCP servers or ability to run them locally"],"input_types":["User queries and commands","Local model and tool configurations"],"output_types":["LLM responses from local models","Tool execution results from local servers","No external API calls or data transmission"],"categories":["automation-workflow","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-jonigl-mcp-client-for-ollama__cap_2","uri":"capability://automation.workflow.streaming.response.processing.with.real.time.token.output","name":"streaming response processing with real-time token output","description":"The StreamingManager processes MCP server responses and Ollama model outputs in real-time, handling token-by-token streaming from both sources with metrics collection and formatted output. It manages SSE streams from MCP servers, processes Ollama's streaming API responses, buffers partial tokens, and renders them to the terminal with latency tracking and throughput metrics.","intents":["Display LLM responses token-by-token as they generate for real-time feedback","Stream tool execution results from MCP servers without buffering entire responses","Monitor response generation latency and token throughput metrics","Handle partial tokens and multi-byte UTF-8 sequences correctly in terminal output"],"best_for":["Developers building interactive LLM applications requiring real-time feedback","Teams monitoring LLM performance and response latency in production","Users on slow network connections who benefit from progressive response display"],"limitations":["Streaming adds complexity to error handling — partial responses may be incomplete if stream breaks","Token-by-token output prevents batching optimizations — slightly higher CPU usage than buffered responses","Metrics collection adds ~5-10ms overhead per response batch","Terminal rendering is single-threaded — high token throughput may cause UI lag"],"requires":["Python 3.9+","Terminal with ANSI escape sequence support for formatting","Ollama API with streaming endpoint enabled","MCP servers supporting SSE or streaming HTTP responses"],"input_types":["Streaming response chunks from Ollama API","SSE event streams from MCP servers","Raw token data with metadata"],"output_types":["Formatted terminal output with real-time token display","Metrics data (latency, throughput, token count)","Structured response objects for downstream processing"],"categories":["automation-workflow","text-generation-language"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-jonigl-mcp-client-for-ollama__cap_3","uri":"capability://automation.workflow.model.parameter.configuration.and.request.formatting","name":"model parameter configuration and request formatting","description":"The ModelManager abstracts Ollama model selection, parameter configuration (temperature, top_p, top_k, etc.), and request formatting. It maintains model state, validates parameter ranges, constructs properly-formatted Ollama API requests, and handles model switching without losing conversation context. The manager translates user-friendly parameter names to Ollama API fields and enforces model-specific constraints.","intents":["Switch between different Ollama models without restarting the client","Configure model parameters like temperature and top_p for different response styles","Validate parameter values against model constraints before sending requests","Format requests correctly for Ollama API with all required fields"],"best_for":["Developers experimenting with different models and parameter combinations","Teams tuning model behavior for specific use cases (creative vs deterministic)","Solo developers building local LLM applications with parameter exploration"],"limitations":["Parameter validation is client-side only — invalid parameters may still fail at Ollama API","Model switching requires Ollama to have the model downloaded — no automatic model pulling","Parameter ranges are hardcoded — no dynamic discovery of model-specific constraints","No parameter presets or templates — users must manually configure each session"],"requires":["Python 3.9+","Ollama runtime with at least one model downloaded","Ollama API accessible at configured endpoint (default: http://localhost:11434)"],"input_types":["Model name (string)","Parameter values (temperature: 0.0-2.0, top_p: 0.0-1.0, etc.)","Conversation context and system prompts"],"output_types":["Formatted Ollama API request JSON","Model metadata and capabilities","Parameter validation results"],"categories":["automation-workflow","text-generation-language"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-jonigl-mcp-client-for-ollama__cap_4","uri":"capability://automation.workflow.configuration.persistence.with.profile.management","name":"configuration persistence with profile management","description":"The ConfigManager handles saving and loading client configurations including server definitions, model preferences, tool selections, and custom system prompts. It persists state to ~/.mcp/config.json and supports multiple configuration profiles, enabling users to save different setups (e.g., 'creative-writing', 'code-generation') and switch between them. The manager handles defaults, migration, and validation of configuration files.","intents":["Save current session configuration to reuse in future sessions","Create multiple configuration profiles for different workflows","Switch between profiles without manual reconfiguration","Persist custom system prompts and tool selections across sessions"],"best_for":["Developers with multiple LLM workflows requiring different configurations","Teams standardizing on shared MCP server configurations","Solo developers who want to quickly switch between different setups"],"limitations":["Configuration files are JSON — no encryption for sensitive API keys or credentials","Profile switching requires client restart — no hot-swapping between profiles","Configuration migration is manual — no automatic schema upgrades between versions","No conflict resolution — last-write-wins if multiple clients modify config simultaneously"],"requires":["Python 3.9+","Write access to ~/.mcp/ directory","Valid JSON configuration files"],"input_types":["Configuration dictionary with server, model, tool, and prompt settings","Profile name (string)","Configuration file path"],"output_types":["Persisted configuration JSON file","Loaded configuration dictionary","Configuration validation results"],"categories":["automation-workflow","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-jonigl-mcp-client-for-ollama__cap_5","uri":"capability://search.retrieval.fuzzy.autocomplete.for.commands.and.tool.discovery","name":"fuzzy autocomplete for commands and tool discovery","description":"Implements FZF-style fuzzy autocomplete in the TUI that enables users to search and select from available commands, tools, and server options with real-time filtering. The system maintains searchable indices of available tools from connected MCP servers, command names, and model options, allowing users to type partial strings and see matching results ranked by relevance.","intents":["Quickly find and select tools from many available options without memorizing names","Discover available commands and their usage without consulting documentation","Search for models by partial name when many models are installed","Reduce typing effort for long tool or command names"],"best_for":["Developers working with many MCP servers and tools who need quick discovery","Non-technical users who benefit from guided tool selection","Teams with large tool ecosystems requiring searchable interfaces"],"limitations":["Fuzzy matching is client-side only — no server-side indexing for remote tools","Index updates require tool refresh — new tools from servers aren't immediately available","Ranking algorithm is fixed — no customization of search relevance","Terminal-only implementation — no GUI autocomplete for non-terminal users"],"requires":["Python 3.9+","Terminal with interactive input support","FZF or equivalent fuzzy matching library"],"input_types":["User search query (partial string)","Available tools, commands, and models from MCP servers"],"output_types":["Ranked list of matching options","Selected tool/command/model name","Tool metadata and usage information"],"categories":["search-retrieval","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-jonigl-mcp-client-for-ollama__cap_6","uri":"capability://planning.reasoning.agent.mode.with.multi.step.reasoning.and.tool.orchestration","name":"agent mode with multi-step reasoning and tool orchestration","description":"Enables agentic mode where the LLM can autonomously plan and execute multi-step workflows using available tools. The system implements a reasoning loop that processes LLM responses, extracts tool calls, executes them, feeds results back into context, and repeats until the LLM signals completion. This supports both explicit thinking mode (where the LLM's reasoning is visible) and implicit reasoning, with configurable iteration limits and safety checkpoints.","intents":["Enable LLMs to autonomously solve complex problems requiring multiple tool calls","Observe the LLM's reasoning process in thinking mode for transparency","Limit agent iterations to prevent infinite loops or runaway execution","Maintain human oversight with approval gates between agent steps"],"best_for":["Developers building autonomous LLM agents for complex workflows","Teams requiring transparent AI reasoning for compliance or debugging","Solo developers prototyping agentic systems with local models"],"limitations":["Agent loops are synchronous — no parallel tool execution across steps","Iteration limits are fixed per session — no dynamic adjustment based on task complexity","Thinking mode output is verbose — can make conversations hard to follow","No built-in backtracking — agent cannot undo previous tool calls if they fail"],"requires":["Python 3.9+","LLM model capable of generating tool calls and reasoning text","At least one MCP server with tools available","User interaction for approval gates (unless auto-approval is enabled)"],"input_types":["User task or goal description","Available tools from MCP servers","LLM responses with tool calls and reasoning"],"output_types":["Multi-step execution trace with tool calls and results","Final agent response to user task","Reasoning steps (if thinking mode enabled)","Execution metrics (steps taken, tools used, latency)"],"categories":["planning-reasoning","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-jonigl-mcp-client-for-ollama__cap_7","uri":"capability://text.generation.language.mcp.prompt.management.and.system.prompt.customization","name":"mcp prompt management and system prompt customization","description":"Manages MCP server-provided prompts and allows users to define custom system prompts that shape LLM behavior. The system loads prompt definitions from MCP servers, enables/disables them, and merges them with user-defined system prompts before sending requests to Ollama. This enables prompt composition where multiple prompts can be combined to create complex behavioral instructions.","intents":["Use prompts provided by MCP servers to guide LLM behavior for specific tools","Define custom system prompts that persist across sessions","Combine multiple prompts to create complex behavioral instructions","Override or extend MCP-provided prompts with custom instructions"],"best_for":["Developers fine-tuning LLM behavior for specific domains or tools","Teams standardizing on shared system prompts across MCP deployments","Solo developers experimenting with prompt engineering for local models"],"limitations":["Prompt composition is sequential — no priority or conflict resolution between prompts","Custom prompts are stored in config files — no version control or audit trail","Prompt changes require session restart — no hot-swapping of system prompts","No prompt templates or variables — all prompts are static strings"],"requires":["Python 3.9+","MCP servers that provide prompt definitions (optional)","Write access to configuration files for custom prompts"],"input_types":["MCP server prompt definitions (from server metadata)","Custom system prompt text (string)","Prompt enable/disable flags"],"output_types":["Merged system prompt for Ollama API","List of active prompts with metadata","Prompt composition trace"],"categories":["text-generation-language","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-jonigl-mcp-client-for-ollama__cap_8","uri":"capability://automation.workflow.interactive.tui.with.command.parsing.and.session.management","name":"interactive tui with command parsing and session management","description":"Provides a rich terminal user interface built with Python TUI libraries that handles user input parsing, command execution, and session state management. The MCPClient class orchestrates the main interaction loop, parsing user commands (chat, tool management, model switching, configuration), executing them through appropriate managers, and rendering results to the terminal. The TUI maintains conversation history, manages session state, and provides visual feedback for all operations.","intents":["Provide an interactive interface for chatting with LLMs and using tools","Parse and execute user commands for configuration and tool management","Display conversation history and tool execution results in organized format","Maintain session state across multiple interactions"],"best_for":["Developers building local LLM applications with interactive interfaces","Non-technical users who prefer TUI over command-line arguments","Teams deploying MCP clients in terminal-based environments"],"limitations":["TUI is terminal-only — no GUI support for non-terminal environments","Command parsing is regex-based — complex commands may be ambiguous","Session state is in-memory — no persistence of conversation history by default","Terminal rendering is single-threaded — high-frequency updates may cause lag"],"requires":["Python 3.9+","Terminal with ANSI escape sequence support","Python TUI library (e.g., Rich, Textual, or similar)"],"input_types":["User text input from terminal","Command strings with arguments","Configuration and tool management directives"],"output_types":["Formatted terminal output with colors and formatting","Conversation history display","Command execution results and status messages"],"categories":["automation-workflow","text-generation-language"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-jonigl-mcp-client-for-ollama__cap_9","uri":"capability://tool.use.integration.dual.package.architecture.with.library.and.cli.separation","name":"dual-package architecture with library and cli separation","description":"Implements a modular architecture with separate library and CLI packages, allowing the core MCP client functionality to be imported as a Python library while also providing a standalone CLI tool. The library package (mcp-client-for-ollama) exports core classes like MCPClient, ModelManager, and ToolManager for programmatic use, while the CLI package (mcp-client-for-ollama-cli) provides the TUI application. This separation enables both library users and CLI users to depend on only what they need.","intents":["Use MCP client functionality as a Python library in custom applications","Deploy the standalone CLI tool without library dependencies","Extend the client with custom managers or integrations","Integrate MCP functionality into existing Python applications"],"best_for":["Developers building custom LLM applications using MCP client as a library","Teams deploying the CLI tool in production environments","Solo developers who want to extend the client with custom functionality"],"limitations":["Dual packages add maintenance complexity — changes must be coordinated across both","Library API is not guaranteed stable — breaking changes may occur between versions","CLI depends on library — CLI updates require library updates","Documentation must cover both library and CLI usage — can be confusing"],"requires":["Python 3.9+","pip or poetry for package installation","For library use: import mcp_client_for_ollama","For CLI use: mcp-client-for-ollama-cli command"],"input_types":["Python code importing library classes","CLI command-line arguments and configuration"],"output_types":["Library: Python objects and method return values","CLI: Terminal output and formatted results"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":47,"verified":false,"data_access_risk":"high","permissions":["Python 3.9+","Ollama runtime installed and accessible","MCP servers configured in ~/.mcp/servers.json or custom config path","Network access to remote servers if using SSE or HTTP transports","Active MCP server connections with tool definitions","LLM model capable of generating tool calls in expected format","User interaction capability (terminal for approval prompts)","Connected MCP servers that implement capability discovery","Servers must return valid tool schema definitions","LLM model with sufficient context window for conversation history"],"failure_modes":["STDIO transport limited to local process execution — no remote STDIO support","SSE connections require server-side event stream implementation — not all HTTP servers support this","Auto-discovery relies on configuration file scanning — no dynamic service registry support","Transport switching requires client restart — no hot-swapping between protocols","Tool execution is synchronous — no parallel tool invocation across multiple servers","Approval gates add latency — each tool call requires user interaction unless auto-approved","Tool schema validation is strict — malformed tool calls from LLM are rejected without fallback","No built-in tool result caching — repeated tool calls execute fresh each time","Schema discovery is one-time at connection — dynamic tool registration not supported","Tool schema validation is strict — servers with malformed schemas cause errors","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.3935198609627167,"quality":0.6,"ecosystem":0.6000000000000001,"match_graph":0.25,"freshness":0.75,"weights":{"adoption":0.25,"quality":0.25,"ecosystem":0.1,"match_graph":0.28,"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:34.856Z","last_commit":"2026-04-28T10:31:26Z"},"community":{"stars":684,"forks":92,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=mcp-jonigl-mcp-client-for-ollama","compare_url":"https://unfragile.ai/compare?artifact=mcp-jonigl-mcp-client-for-ollama"}},"signature":"yrTAUoqWvAtHV0SXdCLF9RqUk71laBPh6d9bvVkFHwzKSOdX7pZDPe7CZRPiio/8ozp7ZwTDiuf8bHAWrStODg==","signedAt":"2026-06-20T04:36:42.137Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/mcp-jonigl-mcp-client-for-ollama","artifact":"https://unfragile.ai/mcp-jonigl-mcp-client-for-ollama","verify":"https://unfragile.ai/api/v1/verify?slug=mcp-jonigl-mcp-client-for-ollama","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"}}