{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"github-hkuds--rag-anything","slug":"hkuds--rag-anything","name":"RAG-Anything","type":"repo","url":"http://arxiv.org/abs/2510.12323","page_url":"https://unfragile.ai/hkuds--rag-anything","categories":["productivity"],"tags":["multi-modal-rag","retrieval-augmented-generation"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"inactive","verified":false},"capabilities":[{"id":"github-hkuds--rag-anything__cap_0","uri":"capability://data.processing.analysis.unified.multimodal.document.parsing.with.format.specific.optimization","name":"unified multimodal document parsing with format-specific optimization","description":"Processes heterogeneous document types (PDFs, Office documents, images, text files) through a pluggable parser architecture supporting multiple backends (MinerU, Docling) with format-specific optimization. The system implements a parse caching layer to avoid redundant processing and maintains document status tracking across the pipeline, enabling resumable and incremental document ingestion at scale.","intents":["I need to ingest mixed-format documents (PDFs, Word, images) into a single RAG system without writing custom parsers for each format","I want to cache parsed documents to avoid re-parsing the same files repeatedly during development and iteration","I need to track which documents have been processed and handle partial failures gracefully in batch operations"],"best_for":["teams building enterprise document management systems with heterogeneous source formats","researchers processing academic papers, technical reports, and supplementary materials in bulk","developers migrating from single-format RAG systems to multimodal knowledge bases"],"limitations":["Parser installation complexity — MinerU and Docling have separate dependency chains that may conflict with existing environments","Parse caching is file-based and not distributed — scaling to multi-node deployments requires external cache coordination","Format-specific optimizations are backend-dependent; unsupported formats fall back to generic text extraction with potential quality loss"],"requires":["Python 3.9+","MinerU or Docling parser backend installed (optional but recommended for PDF quality)","Sufficient disk space for parse cache (typically 2-5x source document size)"],"input_types":["PDF files","Microsoft Office documents (DOCX, XLSX, PPTX)","Images (PNG, JPG, TIFF)","Plain text files","Markdown documents"],"output_types":["structured content lists with modality labels (text, image, table, equation)","parse cache entries (serialized document representations)","document status metadata (processed, failed, pending)"],"categories":["data-processing-analysis","document-parsing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-hkuds--rag-anything__cap_1","uri":"capability://data.processing.analysis.specialized.modal.processor.pipeline.for.images.tables.and.equations","name":"specialized modal processor pipeline for images, tables, and equations","description":"Decomposes multimodal content into specialized processors that extract semantic meaning from images (via vision models), tables (via structure-aware parsing), and mathematical equations (via LaTeX/MathML extraction). The architecture uses a ProcessorMixin pattern where each modality has a dedicated processor class that can be extended or replaced, enabling custom modal processor development without modifying core pipeline logic.","intents":["I need to extract meaningful descriptions from images in documents rather than treating them as opaque blobs","I want to preserve table structure and relationships when indexing tabular data, not flatten it to plain text","I need to handle mathematical equations as queryable entities, not skip them or treat them as text"],"best_for":["academic and scientific document processing (papers with equations, figures, data tables)","technical documentation teams handling diagrams, flowcharts, and structured data","enterprises processing financial reports, technical specifications, and research materials"],"limitations":["Image processing requires a vision language model (VLM) API call per image, adding ~500ms-2s latency per image depending on model and network","Table extraction accuracy depends on table structure complexity; nested or irregular tables may require manual correction","Equation processing assumes standard LaTeX/MathML formats; handwritten or non-standard mathematical notation requires custom processors","Custom modal processor development requires understanding the ProcessorMixin interface and LightRAG integration points"],"requires":["Vision language model API access (OpenAI Vision, Claude, or compatible VLM)","For table processing: optional table detection model (built-in or custom)","For equation processing: LaTeX or MathML parsing libraries (included in dependencies)"],"input_types":["images (PNG, JPG, TIFF, WebP)","table data (extracted from PDFs or structured formats)","equation text (LaTeX, MathML, or plain mathematical expressions)"],"output_types":["image descriptions and semantic embeddings","table structure representations (JSON, markdown, or graph format)","equation metadata and normalized mathematical expressions"],"categories":["data-processing-analysis","image-visual"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-hkuds--rag-anything__cap_10","uri":"capability://tool.use.integration.direct.content.list.insertion.for.programmatic.document.ingestion","name":"direct content list insertion for programmatic document ingestion","description":"Enables programmatic document ingestion by accepting pre-structured content lists (bypassing file parsing) through insert_content_list() method. This capability allows users to integrate RAG-Anything with custom data sources (databases, APIs, streaming sources) by converting their data to content list format and inserting directly into the pipeline. Content lists skip the parsing stage and proceed directly to modal processing and indexing.","intents":["I want to ingest documents from a database or API without writing them to disk first","I need to integrate RAG-Anything with a custom data pipeline that already extracts and structures content","I want to process streaming or real-time data sources without file I/O overhead"],"best_for":["teams integrating RAG with existing data pipelines or databases","developers building real-time RAG systems that ingest streaming data","organizations with custom document formats that require programmatic conversion"],"limitations":["Content list format must be correctly structured; malformed content lists cause silent failures or incorrect processing","Direct insertion bypasses format validation; users are responsible for content correctness","No automatic format detection; users must manually specify content modalities (text, image, table, equation)","Streaming ingestion requires external orchestration; RAG-Anything provides no built-in streaming support"],"requires":["Content list in RAG-Anything format (structured dictionary with modality labels)","Python 3.9+","Custom code to convert source data to content list format"],"input_types":["content list (structured dictionary with text, images, tables, equations)","document metadata (optional)"],"output_types":["indexed documents in LightRAG backend","knowledge graph entries from extracted entities"],"categories":["tool-use-integration","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-hkuds--rag-anything__cap_11","uri":"capability://automation.workflow.performance.optimization.through.parse.caching.and.incremental.indexing","name":"performance optimization through parse caching and incremental indexing","description":"Implements parse caching that stores parsed document representations to avoid redundant parsing on subsequent runs, and incremental indexing that only processes new or modified documents. The caching system tracks document modification times and content hashes to detect changes, enabling efficient re-indexing of large document collections. Combined with batch processing status tracking, this enables fast iteration during development and efficient updates in production.","intents":["I want to avoid re-parsing documents when I modify my RAG configuration or add new documents","I need to update my knowledge base with new documents without re-indexing the entire collection","I want to optimize development iteration speed by caching expensive parsing operations"],"best_for":["teams iterating on RAG configurations with large document collections","organizations with frequently-updated document sources requiring incremental indexing","developers optimizing RAG system performance during development"],"limitations":["Parse cache is file-based and not distributed; multi-node deployments require external cache coordination","Cache invalidation is based on file modification time and content hash; external document changes may not be detected","Incremental indexing only detects document-level changes; changes within documents require full re-parsing","Cache storage overhead is significant (2-5x source document size); disk space must be provisioned accordingly"],"requires":["Disk space for parse cache (typically 2-5x source document size)","File system with reliable modification time tracking","Python 3.9+"],"input_types":["document files or content lists","cache configuration (cache directory, TTL)"],"output_types":["cached parse results (reused on subsequent runs)","incremental indexing report (new/modified documents processed)"],"categories":["automation-workflow","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-hkuds--rag-anything__cap_2","uri":"capability://automation.workflow.five.stage.document.processing.pipeline.with.lightrag.integration","name":"five-stage document processing pipeline with lightrag integration","description":"Orchestrates document ingestion through a five-stage pipeline (parsing → modal processing → context extraction → knowledge graph construction → storage) built on top of LightRAG. Each stage is implemented as a method in ProcessorMixin, with intermediate outputs cached and document status tracked, enabling resumable processing and fine-grained error handling. The pipeline integrates LightRAG's knowledge graph construction to automatically extract entities and relationships across all modalities.","intents":["I want a structured, resumable pipeline for processing documents from raw files to queryable knowledge graphs","I need to understand where failures occur in document processing and retry specific stages without reprocessing earlier stages","I want to leverage knowledge graph construction to extract entities and relationships from multimodal content, not just store raw text"],"best_for":["teams building production RAG systems requiring reliability and observability","organizations processing large document batches where resumability and partial failure handling are critical","developers integrating RAG into existing knowledge management systems that need entity/relationship extraction"],"limitations":["Pipeline stages are sequential by default; parallelization requires custom batch processing implementation","Knowledge graph construction latency scales with document complexity; large documents with many entities may add 5-10s per document","Intermediate outputs are stored in memory during processing; very large documents may cause memory pressure without streaming implementations","Stage interdependencies are implicit in method calls; debugging pipeline failures requires understanding the five-stage sequence"],"requires":["LightRAG instance (initialized and configured)","Python 3.9+","Sufficient memory for intermediate document representations (typically 100MB-1GB for typical batch sizes)"],"input_types":["file paths (string)","content lists (structured document representations from parsers)","document metadata (optional)"],"output_types":["knowledge graph nodes (entities extracted from documents)","knowledge graph edges (relationships between entities)","indexed document chunks (stored in LightRAG backend)"],"categories":["automation-workflow","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-hkuds--rag-anything__cap_3","uri":"capability://automation.workflow.batch.document.processing.with.status.tracking.and.error.recovery","name":"batch document processing with status tracking and error recovery","description":"Implements a BatchMixin that processes multiple documents concurrently while maintaining per-document status tracking (processed, failed, pending) and enabling selective retry of failed documents. The batch processor integrates with the parse caching system to skip already-processed documents and provides detailed error logs for debugging processing failures across large document collections.","intents":["I need to ingest 1000+ documents efficiently without manually tracking which ones succeeded or failed","I want to retry only the documents that failed in a previous batch run, not reprocess the entire collection","I need visibility into processing errors per document to debug format-specific issues at scale"],"best_for":["teams processing large document collections (100+ documents) where tracking state is critical","organizations with unreliable document sources where retry logic is essential","developers building automated document ingestion pipelines that need to resume from failures"],"limitations":["Batch processing is single-threaded by default; concurrent processing requires explicit configuration and may hit API rate limits","Status tracking is file-based and not distributed; multi-process batch jobs require external coordination","Error recovery is document-level only; partial failures within a document (e.g., one image fails) may require manual intervention","Batch size is memory-constrained; processing very large documents in batches may require chunking or streaming implementations"],"requires":["BatchMixin integration (included in RAGAnything class)","Document status storage backend (file-based by default)","Python 3.9+"],"input_types":["list of file paths","list of content items","batch configuration (concurrency, retry policy)"],"output_types":["batch processing report (success count, failure count, error details)","document status log (per-document processing state)","indexed documents in LightRAG backend"],"categories":["automation-workflow","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-hkuds--rag-anything__cap_4","uri":"capability://search.retrieval.context.aware.multimodal.query.execution.with.vlm.enhancement","name":"context-aware multimodal query execution with vlm enhancement","description":"Executes three query modes (text-only, multimodal, VLM-enhanced) through a QueryMixin that retrieves relevant documents and modal content based on query intent. Text queries use semantic search over embeddings; multimodal queries retrieve both text and images; VLM-enhanced queries pass retrieved images to a vision language model for deeper semantic understanding. The query system integrates with LightRAG's knowledge graph to support entity and relationship queries.","intents":["I want to query documents using natural language and get back relevant text passages, images, and tables together","I need to ask questions about images in my document collection and get answers based on visual understanding, not just image captions","I want to query the knowledge graph to find entities and relationships extracted from my documents"],"best_for":["teams building multimodal search interfaces for document collections","researchers querying academic papers with figures and tables","enterprises building internal knowledge bases with visual content"],"limitations":["VLM-enhanced queries add 1-3s latency per retrieved image due to API calls; large result sets may be slow","Query relevance depends on embedding quality; poor embeddings lead to irrelevant retrieval","Knowledge graph queries require entities to be extracted during document processing; missing entity extraction reduces query effectiveness","Multimodal query results may be heterogeneous (text, images, tables); application code must handle multiple result types"],"requires":["Indexed documents in LightRAG backend","Embedding model configured (OpenAI, local, or compatible)","For VLM-enhanced queries: Vision language model API access","Query configuration (retrieval parameters, result limits)"],"input_types":["natural language query string","query mode (text, multimodal, vlm-enhanced)","optional filters (document type, date range, etc.)"],"output_types":["retrieved text passages with relevance scores","retrieved images with descriptions","retrieved tables with structure","knowledge graph entities and relationships","VLM-generated answers for image-based queries"],"categories":["search-retrieval","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-hkuds--rag-anything__cap_5","uri":"capability://tool.use.integration.flexible.storage.backend.abstraction.with.pluggable.persistence","name":"flexible storage backend abstraction with pluggable persistence","description":"Abstracts storage operations through a configurable backend system that supports multiple persistence targets (local file system, vector databases, graph databases) without changing application code. The storage architecture is configured through RAGAnythingConfig, allowing users to swap backends by changing configuration parameters. Integration with LightRAG's storage layer enables seamless persistence of indexed documents, embeddings, and knowledge graph data.","intents":["I want to switch from local file storage to a cloud vector database without rewriting my RAG code","I need to deploy RAG-Anything in an offline environment with local-only storage","I want to persist both document embeddings and knowledge graph data in a single backend"],"best_for":["teams deploying RAG systems across multiple environments (dev, staging, production)","organizations with strict data residency requirements requiring on-premise storage","developers building RAG applications that need to support multiple storage backends"],"limitations":["Backend abstraction adds configuration complexity; users must understand storage backend options and trade-offs","Not all backends support all features; some backends may not support knowledge graph persistence or semantic search","Storage backend performance varies significantly; local file storage is slower than cloud vector databases for large-scale queries","Data migration between backends is not automated; switching backends requires manual data export/import"],"requires":["RAGAnythingConfig with storage backend specification","Backend-specific credentials or connection strings (if using cloud storage)","Python 3.9+"],"input_types":["storage backend configuration (type, credentials, parameters)","indexed documents and embeddings from pipeline","knowledge graph data"],"output_types":["persisted document chunks in backend storage","persisted embeddings in vector store","persisted knowledge graph in graph database (if applicable)"],"categories":["tool-use-integration","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-hkuds--rag-anything__cap_6","uri":"capability://tool.use.integration.extensible.modal.processor.framework.for.custom.content.types","name":"extensible modal processor framework for custom content types","description":"Provides a ProcessorMixin-based framework for developing custom modal processors that handle domain-specific content types beyond images, tables, and equations. Custom processors inherit from a base processor class and implement extraction and embedding logic, integrating seamlessly into the five-stage pipeline. The framework enables users to add processors for specialized formats (e.g., audio transcripts, video frames, chemical structures) without modifying core pipeline code.","intents":["I need to extract meaning from domain-specific content types (e.g., chemical structures, audio transcripts) not supported by built-in processors","I want to add custom extraction logic for a proprietary document format without forking the RAG-Anything codebase","I need to integrate specialized models (e.g., domain-specific vision models) into the document processing pipeline"],"best_for":["researchers and enterprises with domain-specific document formats (chemistry, medicine, finance)","teams building vertical-specific RAG systems with custom content types","developers extending RAG-Anything for proprietary or emerging content modalities"],"limitations":["Custom processor development requires understanding the ProcessorMixin interface and LightRAG integration","Custom processors must handle their own error cases and logging; debugging is the developer's responsibility","Performance optimization of custom processors is not automatic; developers must profile and optimize their implementations","Custom processors are not automatically tested; integration testing with the full pipeline is required"],"requires":["Understanding of ProcessorMixin interface and base processor class","Python 3.9+","Domain-specific extraction libraries or models (developer-provided)"],"input_types":["custom content type data (format-dependent)","document context (surrounding text, metadata)"],"output_types":["extracted semantic representations","embeddings for custom content type","metadata and relationships to other content"],"categories":["tool-use-integration","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-hkuds--rag-anything__cap_7","uri":"capability://memory.knowledge.knowledge.graph.construction.with.cross.modal.entity.extraction","name":"knowledge graph construction with cross-modal entity extraction","description":"Automatically constructs a knowledge graph by extracting entities and relationships from all modalities (text, images, tables, equations) using LightRAG's entity extraction engine. The system maps entities across modalities (e.g., linking an entity mentioned in text to an image containing that entity) and builds a unified graph representation. Entity extraction is configurable per modality, allowing users to tune extraction parameters for different content types.","intents":["I want to automatically extract entities and relationships from my documents to build a queryable knowledge graph","I need to link entities across modalities (e.g., connect text mentions to images and tables containing those entities)","I want to query my documents by entity relationships, not just keyword search"],"best_for":["teams building enterprise knowledge graphs from heterogeneous documents","researchers analyzing document collections for entity relationships and patterns","organizations building semantic search systems that leverage entity relationships"],"limitations":["Entity extraction quality depends on LLM capability; weaker models produce lower-quality entity graphs","Cross-modal entity linking requires semantic similarity matching; ambiguous entities may be incorrectly linked","Knowledge graph construction adds significant latency (5-10s per document for typical sizes) due to LLM calls","Entity extraction is language-dependent; non-English documents may have lower extraction quality depending on LLM support"],"requires":["LightRAG instance with entity extraction configured","LLM API access for entity extraction (OpenAI, Anthropic, or compatible)","Python 3.9+"],"input_types":["parsed document content (text, images, tables, equations)","entity extraction configuration (entity types, relationship types)"],"output_types":["knowledge graph nodes (entities with types and attributes)","knowledge graph edges (relationships with types and confidence scores)","entity-to-content mappings (which documents/modalities contain each entity)"],"categories":["memory-knowledge","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-hkuds--rag-anything__cap_8","uri":"capability://tool.use.integration.configuration.driven.system.initialization.with.environment.variable.support","name":"configuration-driven system initialization with environment variable support","description":"Centralizes all system configuration through RAGAnythingConfig dataclass, supporting environment variable overrides for deployment flexibility. Configuration covers model providers (LLM, embedding, vision models), storage backends, parser selection, and processing parameters. The config system enables users to deploy the same codebase across environments (dev, staging, production) by changing configuration without code modifications.","intents":["I want to configure RAG-Anything through environment variables for containerized deployment","I need to support multiple LLM providers (OpenAI, Anthropic, local) without code changes","I want to tune processing parameters (batch size, cache settings, timeouts) per environment"],"best_for":["teams deploying RAG-Anything in containerized environments (Docker, Kubernetes)","organizations with multiple deployment environments requiring configuration flexibility","developers building RAG applications that need to support multiple model providers"],"limitations":["Configuration complexity increases with number of options; users must understand all available parameters","Environment variable naming conventions must be documented; incorrect variable names silently fall back to defaults","Configuration validation is limited; invalid configurations may only fail at runtime","Configuration changes require system restart; no hot-reload support for parameter updates"],"requires":["RAGAnythingConfig class instantiation","Environment variables (optional, for overrides)","Python 3.9+"],"input_types":["configuration dictionary or environment variables","model provider credentials (API keys)","storage backend connection strings"],"output_types":["RAGAnythingConfig instance with all parameters resolved","initialized LightRAG instance with configured backend","configured model providers (LLM, embedding, vision)"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-hkuds--rag-anything__cap_9","uri":"capability://tool.use.integration.local.llm.integration.with.offline.deployment.support","name":"local llm integration with offline deployment support","description":"Supports integration with local language models (via Ollama, vLLM, or compatible APIs) for offline deployment scenarios where cloud API access is unavailable. The system abstracts LLM provider selection through configuration, allowing users to swap between OpenAI, Anthropic, and local models without code changes. Offline deployment is fully supported with local embeddings, local LLMs, and local storage backends.","intents":["I need to deploy RAG-Anything in an air-gapped environment without cloud API access","I want to use open-source models (Llama, Mistral) instead of proprietary APIs for cost or privacy reasons","I need to run RAG-Anything on-premise with full data residency compliance"],"best_for":["organizations with strict data residency or security requirements","teams deploying RAG in air-gapped or offline environments","developers building cost-sensitive RAG applications using open-source models"],"limitations":["Local LLM performance depends on hardware; GPU access is strongly recommended for reasonable latency","Open-source models generally have lower quality than proprietary models; entity extraction and semantic understanding may suffer","Local embedding models are slower than cloud APIs; indexing large document collections takes significantly longer","Offline deployment requires pre-downloading all models; storage requirements are substantial (10-50GB+ for typical model sets)"],"requires":["Local LLM server (Ollama, vLLM, or compatible) running and accessible","Local embedding model (sentence-transformers or compatible)","GPU with sufficient VRAM (8GB+ recommended for reasonable performance)","Python 3.9+"],"input_types":["local LLM endpoint configuration (URL, model name)","local embedding model specification","documents for processing"],"output_types":["indexed documents with local embeddings","knowledge graph constructed using local LLM","query results from local models"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":44,"verified":false,"data_access_risk":"high","permissions":["Python 3.9+","MinerU or Docling parser backend installed (optional but recommended for PDF quality)","Sufficient disk space for parse cache (typically 2-5x source document size)","Vision language model API access (OpenAI Vision, Claude, or compatible VLM)","For table processing: optional table detection model (built-in or custom)","For equation processing: LaTeX or MathML parsing libraries (included in dependencies)","Content list in RAG-Anything format (structured dictionary with modality labels)","Custom code to convert source data to content list format","Disk space for parse cache (typically 2-5x source document size)","File system with reliable modification time tracking"],"failure_modes":["Parser installation complexity — MinerU and Docling have separate dependency chains that may conflict with existing environments","Parse caching is file-based and not distributed — scaling to multi-node deployments requires external cache coordination","Format-specific optimizations are backend-dependent; unsupported formats fall back to generic text extraction with potential quality loss","Image processing requires a vision language model (VLM) API call per image, adding ~500ms-2s latency per image depending on model and network","Table extraction accuracy depends on table structure complexity; nested or irregular tables may require manual correction","Equation processing assumes standard LaTeX/MathML formats; handwritten or non-standard mathematical notation requires custom processors","Custom modal processor development requires understanding the ProcessorMixin interface and LightRAG integration points","Content list format must be correctly structured; malformed content lists cause silent failures or incorrect processing","Direct insertion bypasses format validation; users are responsible for content correctness","No automatic format detection; users must manually specify content modalities (text, image, table, equation)","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.734463849031179,"quality":0.24,"ecosystem":0.46,"match_graph":0.25,"freshness":0.5,"weights":{"adoption":0.3,"quality":0.2,"ecosystem":0.15,"match_graph":0.3,"freshness":0.05}},"observed_outcomes":{"matches":0,"success_rate":0,"avg_confidence":0,"top_intents":[],"last_matched_at":null},"maintenance":{"status":"inactive","updated_at":"2026-05-05T11:48:09.007Z","last_scraped_at":"2026-05-03T13:58:29.527Z","last_commit":"2026-04-25T09:54:48Z"},"community":{"stars":19548,"forks":2239,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=hkuds--rag-anything","compare_url":"https://unfragile.ai/compare?artifact=hkuds--rag-anything"}},"signature":"3NSGZKzt2UY8ozHKnvDV1GwMTqCBkwNKjxLllTbWWXt7PC8xYt6hTRq/qTwuEfEXnxiMvrPnqHaUhIVl2or9AA==","signedAt":"2026-06-20T13:16:11.760Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/hkuds--rag-anything","artifact":"https://unfragile.ai/hkuds--rag-anything","verify":"https://unfragile.ai/api/v1/verify?slug=hkuds--rag-anything","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"}}