{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"aichat","slug":"aichat","name":"aichat","type":"cli","url":"https://github.com/sigoden/aichat","page_url":"https://unfragile.ai/aichat","categories":["cli-tools","rag-knowledge"],"tags":[],"pricing":{"model":"free","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"aichat__cap_0","uri":"capability://tool.use.integration.unified.multi.provider.llm.client.abstraction","name":"unified multi-provider llm client abstraction","description":"Abstracts 20+ LLM providers (OpenAI, Anthropic, Claude, Gemini, Ollama, etc.) behind a single Client trait with unified request/response handling. Uses a provider registry pattern loaded from models.yaml that maps provider identifiers to concrete client implementations, enabling seamless provider switching without code changes. Token counting and model selection are handled uniformly across all providers through a centralized model registry system.","intents":["switch between different LLM providers without rewriting integration code","support multiple API keys for different providers in a single CLI tool","add new LLM providers without modifying core application logic","manage model-specific token limits and capabilities uniformly"],"best_for":["developers building multi-provider LLM applications","teams evaluating multiple LLM providers simultaneously","CLI tool builders wanting provider flexibility"],"limitations":["Provider-specific features (vision, function calling) require explicit capability detection per provider","Token counting accuracy varies by provider — some use approximate counts rather than exact tokenization","Streaming response handling differs subtly across providers, may require provider-specific tuning"],"requires":["API keys for desired providers (OpenAI, Anthropic, etc.)","models.yaml configuration file with provider definitions","Rust 1.70+ for compilation"],"input_types":["text prompts","file paths","URLs","command outputs"],"output_types":["text responses","streaming text","structured JSON (with function calling)"],"categories":["tool-use-integration","multi-provider-abstraction"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"aichat__cap_1","uri":"capability://text.generation.language.interactive.repl.mode.with.stateful.conversation.sessions","name":"interactive repl mode with stateful conversation sessions","description":"Provides an interactive shell interface (REPL) that maintains conversation state across multiple turns, with support for role-based context switching and session persistence. The REPL mode loads configuration from GlobalConfig (wrapped in Arc<RwLock<Config>>), manages message history in memory, and supports commands for switching roles, models, and sessions. Sessions can be saved to disk and resumed later, preserving the full conversation context.","intents":["have multi-turn conversations with an LLM in an interactive shell","switch between different conversation roles (e.g., 'assistant', 'code-reviewer') mid-session","save and resume conversations across CLI invocations","maintain separate conversation threads for different tasks"],"best_for":["developers iterating on prompts and responses interactively","teams using aichat as a persistent knowledge assistant","users building complex multi-turn workflows in the terminal"],"limitations":["Message history is stored in memory during a session — no real-time persistence to disk during conversation","Session switching requires explicit commands; no automatic context merging across sessions","REPL mode does not support concurrent conversations — only one active session per process"],"requires":["Interactive terminal (TTY)","Configuration file with at least one role defined","Sufficient memory for conversation history (depends on model context window)"],"input_types":["text prompts","file references (via @ syntax)","shell commands","REPL commands (e.g., .role, .session)"],"output_types":["streaming text responses","formatted markdown with syntax highlighting","session metadata (saved to disk)"],"categories":["text-generation-language","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"aichat__cap_10","uri":"capability://automation.workflow.configuration.system.with.yaml.based.model.and.role.definitions","name":"configuration system with yaml-based model and role definitions","description":"Manages application configuration through YAML files (models.yaml, config.yaml) that define available LLM providers, models, roles, agents, and tools. Configuration is loaded at startup and wrapped in Arc<RwLock<Config>> for thread-safe access across async tasks. The system supports configuration merging from multiple sources (system defaults, user config, environment variables) with clear precedence rules.","intents":["define available LLM providers and models in a declarative format","configure conversation roles with system instructions and model preferences","define agents, tools, and RAG settings without code changes","override configuration via environment variables for containerized deployments"],"best_for":["teams standardizing on model and role definitions","DevOps engineers deploying aichat in containers","users wanting to avoid code changes for configuration"],"limitations":["YAML parsing errors are not always clear — invalid syntax may produce cryptic error messages","Configuration is loaded once at startup — no hot-reloading of configuration changes","Environment variable overrides are limited to top-level keys — no nested overrides","No schema validation for configuration — invalid model definitions may not be caught until runtime"],"requires":["YAML files in correct format (models.yaml, config.yaml)","Valid provider names and model identifiers","File system access to configuration directory"],"input_types":["YAML configuration files","environment variables (for overrides)","CLI flags (for runtime overrides)"],"output_types":["parsed configuration (in-memory)","available models and roles (for CLI completion)","provider credentials (from environment)"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"aichat__cap_11","uri":"capability://data.processing.analysis.token.counting.and.context.window.management","name":"token counting and context window management","description":"Implements token counting for different models to ensure prompts fit within context windows. The system uses model-specific tokenizers (or approximations) to count tokens in messages, truncates long inputs to fit within limits, and provides warnings when approaching context limits. Token counting is integrated into the message building pipeline, ensuring all inputs are validated before sending to the LLM.","intents":["ensure prompts fit within model context windows before sending to LLM","truncate long documents or conversations to fit available context","estimate token usage for cost calculation","warn users when approaching context limits"],"best_for":["developers working with large documents or long conversations","teams managing LLM costs and wanting to track token usage","users wanting to avoid context window errors"],"limitations":["Token counting is approximate for some models — exact counts may differ from provider's count","Truncation is naive (simple length-based) — may cut off important context","No support for dynamic context window adjustment — limits are fixed per model","Token counting adds latency to message building — may be noticeable for very long inputs"],"requires":["Model-specific token counter or approximation","Context window size defined for each model","Input text to count"],"input_types":["text (for token counting)","model name (to determine context window)"],"output_types":["token count (numeric)","truncated text (if exceeds limit)","warnings (if approaching limit)"],"categories":["data-processing-analysis","text-generation-language"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"aichat__cap_12","uri":"capability://text.generation.language.macro.system.for.command.substitution.and.templating","name":"macro system for command substitution and templating","description":"Provides a macro system that enables text substitution and templating within prompts and configuration. Macros can reference environment variables, configuration values, or built-in functions (e.g., {{date}}, {{user}}, {{env:VAR_NAME}}). Macros are expanded at runtime before sending prompts to the LLM, enabling dynamic context injection without manual editing.","intents":["inject dynamic context (date, user, environment) into prompts automatically","create reusable prompt templates with variable placeholders","reference environment variables in configuration without hardcoding","avoid manual prompt editing for context-dependent tasks"],"best_for":["teams building context-aware AI assistants","developers wanting to avoid hardcoded values in prompts","users automating repetitive tasks with varying context"],"limitations":["Macro syntax is limited to simple {{key}} format — no complex expressions","Macro expansion is single-pass — no nested macro support","Built-in macros are fixed (date, user, env) — no custom macro functions","Macro errors (undefined variables) produce warnings but don't fail — may result in literal {{key}} in output"],"requires":["Macro syntax in prompts or configuration ({{key}})","Environment variables for {{env:VAR_NAME}} macros","Valid macro names (date, user, env, etc.)"],"input_types":["text with macro placeholders","environment variables","configuration values"],"output_types":["expanded text with macros substituted","warnings for undefined macros"],"categories":["text-generation-language","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"aichat__cap_13","uri":"capability://text.generation.language.one.shot.command.mode.for.non.interactive.llm.queries","name":"one-shot command mode for non-interactive llm queries","description":"Provides a CMD mode for single-turn LLM interactions where a prompt is passed as a command-line argument, the LLM generates a response, and the process exits. This mode is optimized for scripting and piping, with minimal overhead and no interactive state management. CMD mode uses the same underlying LLM client and configuration system as REPL mode, ensuring consistent behavior.","intents":["query an LLM from shell scripts or command pipelines","integrate LLM capabilities into existing CLI workflows","generate one-off responses without starting an interactive session","pipe command outputs to an LLM for analysis"],"best_for":["shell script developers integrating LLM capabilities","DevOps engineers analyzing logs or outputs with AI","users wanting quick LLM responses without interactive overhead"],"limitations":["No conversation history — each invocation is independent","No session persistence — context is lost after the command exits","Streaming output may not work well in all shell contexts — buffering may be needed"],"requires":["Prompt text as command-line argument","Configuration file with at least one model defined","API key for the selected provider"],"input_types":["prompt text (inline or from stdin)","file references (via @ syntax)","URLs (for content fetching)"],"output_types":["LLM response (text)","exit code (0 for success, non-zero for error)"],"categories":["text-generation-language","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"aichat__cap_2","uri":"capability://text.generation.language.role.based.conversation.context.with.dynamic.instructions","name":"role-based conversation context with dynamic instructions","description":"Implements a role system where each role encapsulates a set of system instructions, model preferences, and conversation parameters. Roles are defined in configuration files and can be dynamically selected at runtime. The system supports variable substitution within role instructions (e.g., {{date}}, {{user}}) through a dynamic instructions system, enabling context-aware prompting without manual editing.","intents":["define reusable conversation templates for different tasks (e.g., 'code-reviewer', 'translator')","inject dynamic context into system prompts (current date, user info, environment variables)","switch between different instruction sets without changing configuration files","maintain consistent behavior across multiple conversations with the same role"],"best_for":["teams standardizing on conversation patterns across team members","developers building task-specific AI assistants","users wanting to avoid prompt engineering for common tasks"],"limitations":["Variable substitution is limited to predefined variables (date, user, etc.) — no custom variable injection from CLI","Role definitions are static in configuration files — no runtime role creation or modification","Role switching does not automatically summarize or transfer context from previous role"],"requires":["Configuration file with role definitions","Role name specified via CLI flag or REPL command","Valid variable names for dynamic instruction substitution"],"input_types":["role name (string)","system instructions (text with variable placeholders)","model preferences (string)"],"output_types":["resolved system prompt (text with variables substituted)","conversation responses in role context"],"categories":["text-generation-language","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"aichat__cap_3","uri":"capability://memory.knowledge.hybrid.rag.system.with.document.ingestion.and.semantic.search","name":"hybrid rag system with document ingestion and semantic search","description":"Implements a Retrieval-Augmented Generation (RAG) system that ingests documents through a multi-format pipeline (text, PDF, markdown, URLs), chunks them using configurable strategies, and stores embeddings in a local vector database. The hybrid search system combines keyword-based BM25 search with semantic vector similarity search to retrieve relevant documents. Retrieved documents are automatically injected into the LLM context before generating responses.","intents":["augment LLM responses with knowledge from local documents or URLs","search across multiple documents using both keyword and semantic similarity","build a knowledge base from PDFs, markdown files, and web content","reduce hallucination by grounding responses in retrieved documents"],"best_for":["teams building domain-specific AI assistants with proprietary knowledge","developers wanting local RAG without external vector databases","users managing large document collections for Q&A"],"limitations":["Vector database is stored locally in memory or simple file-based storage — not suitable for millions of documents","Chunking strategy is fixed (configurable size/overlap) — no adaptive chunking based on document structure","Embedding generation requires a local model or API call — adds latency to document ingestion","Hybrid search weights (BM25 vs semantic) are fixed — no dynamic weighting based on query type"],"requires":["Documents in supported formats (text, PDF, markdown, URLs)","Embedding model configured (local or API-based)","Sufficient disk space for vector database","Python 3.9+ or equivalent for document processing"],"input_types":["file paths (PDF, markdown, text)","URLs","directory paths (for batch ingestion)","query text (for retrieval)"],"output_types":["retrieved document chunks (text)","relevance scores (numeric)","augmented LLM responses (text)"],"categories":["memory-knowledge","search-retrieval"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"aichat__cap_4","uri":"capability://tool.use.integration.function.calling.with.recursive.tool.execution","name":"function calling with recursive tool execution","description":"Implements a function calling system that parses LLM-generated function calls from structured output (JSON), validates them against a schema registry, and executes them with error handling and retry logic. The system supports recursive tool calling where the LLM can call tools, receive results, and call additional tools based on those results. Tool definitions are loaded from configuration and support variable substitution and conditional execution.","intents":["enable LLMs to call external tools and APIs as part of reasoning","execute shell commands, API calls, or custom functions based on LLM decisions","build multi-step workflows where tool outputs feed into subsequent LLM calls","validate tool calls against a schema before execution to prevent errors"],"best_for":["developers building LLM agents that interact with external systems","teams automating complex workflows with LLM decision-making","users building AI-powered CLI tools with tool integration"],"limitations":["Recursive tool calling depth is limited to prevent infinite loops — default max depth is configurable but finite","Tool execution errors are caught and returned to the LLM — no automatic retry with exponential backoff","Tool definitions are static in configuration — no dynamic tool registration at runtime","Schema validation is basic (JSON schema) — no support for complex validation rules"],"requires":["LLM provider supporting function calling (OpenAI, Anthropic, etc.)","Tool definitions in configuration file with schema","Execution permissions for shell commands or API calls","Error handling for tool execution failures"],"input_types":["tool name (string)","tool parameters (JSON)","tool schema (JSON schema)","previous tool results (for recursive calls)"],"output_types":["tool execution results (text, JSON, or structured data)","error messages (if tool execution fails)","final LLM response (after tool calls complete)"],"categories":["tool-use-integration","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"aichat__cap_5","uri":"capability://data.processing.analysis.multi.form.input.processing.with.document.loading","name":"multi-form input processing with document loading","description":"Processes diverse input types (text, files, URLs, command outputs, stdin) through a unified input pipeline that detects input type, loads content, and normalizes it into a message format. The system supports file references via @ syntax, URL fetching with automatic content extraction, shell command execution with output capture, and stdin piping. Input is tokenized and truncated to fit within model context windows using token counting.","intents":["pass files, URLs, or command outputs as context to LLM without manual copy-paste","process large documents by automatically chunking and truncating to fit context windows","combine multiple input sources (text + file + URL) in a single prompt","pipe shell command outputs directly into LLM for analysis"],"best_for":["developers analyzing code, logs, or documents with LLMs","DevOps engineers piping command outputs to AI for troubleshooting","teams building AI-powered CLI workflows"],"limitations":["File size limits are enforced by token counting — very large files are truncated silently","URL fetching requires network access and may fail for authentication-protected content","Command execution runs in the user's shell context — no sandboxing or permission isolation","Input type detection is heuristic-based — ambiguous inputs may be misclassified"],"requires":["File system access for local files","Network access for URL fetching","Shell access for command execution","Token counter configured for the selected model"],"input_types":["text (inline)","file paths (with @ prefix)","URLs (http/https)","shell commands (with | prefix)","stdin (piped input)"],"output_types":["normalized message text","token count","truncated content (if exceeds context window)"],"categories":["data-processing-analysis","text-generation-language"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"aichat__cap_6","uri":"capability://text.generation.language.streaming.response.rendering.with.terminal.aware.markdown.formatting","name":"streaming response rendering with terminal-aware markdown formatting","description":"Renders LLM responses in real-time as they stream from the provider, with terminal-aware markdown formatting that includes syntax highlighting for code blocks, bold/italic text, and proper line wrapping. The system detects whether the output is a TTY and applies markdown rendering only when appropriate, falling back to raw text for non-interactive contexts. Streaming is handled asynchronously using tokio to avoid blocking the terminal.","intents":["see LLM responses appear in real-time as they're generated","read formatted code blocks with syntax highlighting in the terminal","get properly wrapped and formatted text output that respects terminal width","pipe LLM output to other commands without markdown formatting"],"best_for":["interactive CLI users wanting real-time feedback","developers reading code snippets in terminal output","teams building CLI tools that need to support both interactive and non-interactive modes"],"limitations":["Markdown rendering is limited to basic formatting (bold, italic, code blocks) — no tables or complex layouts","Syntax highlighting is language-based on code block hints — may be inaccurate for ambiguous languages","Streaming adds latency compared to buffered output — first token appears after network round-trip","Terminal width detection may fail on some terminal emulators — falls back to default width"],"requires":["TTY for markdown rendering (detected automatically)","Terminal emulator supporting ANSI color codes","Tokio runtime for async streaming"],"input_types":["streaming text from LLM provider","markdown-formatted text"],"output_types":["formatted terminal output with colors and styling","raw text (when piped to non-TTY)"],"categories":["text-generation-language","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"aichat__cap_7","uri":"capability://tool.use.integration.http.server.mode.with.rest.api.for.llm.interactions","name":"http server mode with rest api for llm interactions","description":"Exposes aichat functionality as an HTTP server with REST endpoints for chat, RAG, function calling, and session management. The server mode uses the same underlying LLM client abstraction and configuration system as CLI/REPL modes, enabling consistent behavior across all interfaces. Requests are processed asynchronously using tokio, with support for streaming responses via Server-Sent Events (SSE) or chunked transfer encoding.","intents":["integrate aichat into web applications or microservices","expose LLM capabilities as a REST API without building custom wrappers","enable multiple clients to share a single aichat instance with session isolation","stream LLM responses to web clients in real-time"],"best_for":["teams building web applications that need LLM integration","developers creating microservices around aichat","organizations wanting a self-hosted LLM API server"],"limitations":["No built-in authentication or authorization — requires external reverse proxy for security","Session isolation is per-request — no persistent sessions across HTTP calls without explicit session IDs","Streaming responses use SSE or chunked encoding — may not work with all HTTP clients","No rate limiting or request throttling — requires external API gateway for production use"],"requires":["HTTP server port available (default 8000)","Tokio runtime for async request handling","Configuration file with models and roles defined"],"input_types":["JSON request body with prompt, model, role","Query parameters for session ID, streaming mode","File uploads (for RAG document ingestion)"],"output_types":["JSON response with LLM output","Server-Sent Events (SSE) stream","Chunked transfer encoding (for streaming)"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"aichat__cap_8","uri":"capability://planning.reasoning.agent.based.task.decomposition.with.variable.substitution","name":"agent-based task decomposition with variable substitution","description":"Implements an agent system where complex tasks are decomposed into subtasks defined in configuration files. Each agent has a set of variables (inputs), instructions (system prompt), and a sequence of steps that can reference variables and previous step outputs. The agent executor runs steps sequentially, substituting variables at each step and collecting outputs for use in subsequent steps. Agents support conditional execution and error handling.","intents":["break down complex tasks into manageable steps that an LLM can execute sequentially","reuse agent definitions across multiple invocations with different variable inputs","build multi-step workflows where each step's output feeds into the next","automate repetitive tasks that require LLM reasoning at each step"],"best_for":["teams automating complex workflows with LLM decision-making","developers building AI agents for specific domains","users wanting to avoid writing custom orchestration code"],"limitations":["Agent definitions are static in configuration files — no dynamic agent creation at runtime","Step execution is sequential — no parallel step execution or branching logic","Variable substitution is simple string replacement — no complex variable transformations","Error handling is basic — failed steps stop the agent unless explicitly handled"],"requires":["Agent definition in configuration file with variables and steps","Input variables provided via CLI or API","LLM provider configured for each step"],"input_types":["agent name (string)","input variables (key-value pairs)","step definitions (text with variable placeholders)"],"output_types":["step outputs (text)","final agent output (text)","variable substitution results"],"categories":["planning-reasoning","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"aichat__cap_9","uri":"capability://automation.workflow.command.line.argument.parsing.with.context.aware.defaults","name":"command-line argument parsing with context-aware defaults","description":"Parses CLI arguments to determine execution mode (CMD, REPL, Server), model selection, role selection, and input sources. The parser supports context-aware defaults where missing arguments fall back to configuration file values or environment variables. Argument parsing is done using a custom parser that understands aichat-specific syntax (@ for files, | for commands, http:// for URLs).","intents":["invoke aichat with different execution modes from the command line","override default model or role via CLI flags","specify input sources (files, URLs, commands) using intuitive syntax","use environment variables to set defaults without editing configuration"],"best_for":["developers building CLI workflows around aichat","teams standardizing on CLI argument conventions","users wanting to avoid configuration file edits for common tasks"],"limitations":["Argument parsing is custom — may not support all standard CLI conventions","Context-aware defaults require configuration files — no pure CLI-only mode","Argument validation is basic — invalid arguments may produce unclear error messages"],"requires":["Valid CLI arguments matching aichat syntax","Configuration file for default values (optional)","Environment variables for overrides (optional)"],"input_types":["command-line arguments (strings)","flags (--model, --role, etc.)","positional arguments (prompt text)"],"output_types":["parsed execution mode","selected model and role","input sources (files, URLs, commands)"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"aichat__headline","uri":"capability://tool.use.integration.ai.command.line.interface.for.multi.provider.llm.interaction","name":"ai command-line interface for multi-provider llm interaction","description":"Aichat is a versatile command-line tool that integrates with over 20 large language model providers, offering features like Retrieval-Augmented Generation, function calling, and role-based conversations, making it ideal for developers seeking a comprehensive AI CLI solution.","intents":["best AI CLI tool","AI command-line interface for LLMs","AI tools for shell integration","RAG framework for command line","best CLI for AI function calling"],"best_for":["developers","AI researchers"],"limitations":[],"requires":[],"input_types":["text","files","URLs"],"output_types":["text","streaming responses"],"categories":["tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":71,"verified":false,"data_access_risk":"high","permissions":["API keys for desired providers (OpenAI, Anthropic, etc.)","models.yaml configuration file with provider definitions","Rust 1.70+ for compilation","Interactive terminal (TTY)","Configuration file with at least one role defined","Sufficient memory for conversation history (depends on model context window)","YAML files in correct format (models.yaml, config.yaml)","Valid provider names and model identifiers","File system access to configuration directory","Model-specific token counter or approximation"],"failure_modes":["Provider-specific features (vision, function calling) require explicit capability detection per provider","Token counting accuracy varies by provider — some use approximate counts rather than exact tokenization","Streaming response handling differs subtly across providers, may require provider-specific tuning","Message history is stored in memory during a session — no real-time persistence to disk during conversation","Session switching requires explicit commands; no automatic context merging across sessions","REPL mode does not support concurrent conversations — only one active session per process","YAML parsing errors are not always clear — invalid syntax may produce cryptic error messages","Configuration is loaded once at startup — no hot-reloading of configuration changes","Environment variable overrides are limited to top-level keys — no nested overrides","No schema validation for configuration — invalid model definitions may not be caught until runtime","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.7,"quality":0.9,"ecosystem":0.49999999999999994,"match_graph":0.25,"freshness":0.52,"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-06-17T09:51:02.370Z","last_scraped_at":null,"last_commit":null},"community":{"stars":null,"forks":null,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=aichat","compare_url":"https://unfragile.ai/compare?artifact=aichat"}},"signature":"BxFaahrJ1/3kQcoR49sk5809kgKIzimmbzgZp3YU6FojZJO7pGFDeQHUx2HNW7LDB7BncvQ5+vgDP598BRXzCQ==","signedAt":"2026-06-21T07:50:07.924Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/aichat","artifact":"https://unfragile.ai/aichat","verify":"https://unfragile.ai/api/v1/verify?slug=aichat","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"}}