{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"github-neuml--txtai","slug":"neuml--txtai","name":"txtai","type":"repo","url":"https://neuml.github.io/txtai","page_url":"https://unfragile.ai/neuml--txtai","categories":["frameworks-sdks"],"tags":["agents","ai","ai-agents","embeddings","information-retrieval","language-model","large-language-models","llm","nlp","python","rag","retrieval-augmented-generation","search","search-engine","semantic-search","sentence-embeddings","transformers","txtai","vector-database","vector-search"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"github-neuml--txtai__cap_0","uri":"capability://search.retrieval.multi.backend.vector.search.with.hybrid.sparse.dense.indexing","name":"multi-backend vector search with hybrid sparse-dense indexing","description":"Implements a union of sparse (BM25) and dense (neural embedding) vector indexes within a single Embeddings database, enabling hybrid semantic search that combines lexical and semantic relevance. The architecture supports pluggable ANN backends (Faiss, Annoy, HNSW) for dense vectors and automatically routes queries to both index types, merging results via configurable scoring methods. This design allows semantic search to capture meaning while preserving exact-match precision for technical queries.","intents":["I need to search documents by semantic meaning, not just keywords","I want both semantic and keyword search in one unified index","I need to choose between different vector database backends without rewriting code","I want to optimize search latency and accuracy for my specific domain"],"best_for":["Teams building RAG systems that need both semantic and keyword relevance","Developers migrating from traditional search engines to neural search","Organizations with heterogeneous hardware (CPU-only to GPU clusters)"],"limitations":["Hybrid scoring adds ~50-100ms latency per query due to dual-index traversal","Sparse index requires preprocessing (tokenization, BM25 statistics) that adds indexing overhead","ANN backends have accuracy-speed tradeoffs; approximate search may miss rare but relevant results","No built-in distributed search across multiple machines — requires external sharding layer"],"requires":["Python 3.9+","Optional: Faiss (CPU or GPU), Annoy, or HNSW for ANN backend","Sentence transformer model or compatible embedding model (HuggingFace, OpenAI, local)"],"input_types":["text documents","structured metadata (JSON)","pre-computed embeddings (numpy arrays)"],"output_types":["ranked search results with scores","document IDs with relevance scores","embedding vectors"],"categories":["search-retrieval","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-neuml--txtai__cap_1","uri":"capability://memory.knowledge.graph.network.construction.and.traversal.for.knowledge.representation","name":"graph network construction and traversal for knowledge representation","description":"Builds and maintains knowledge graphs as part of the embeddings database, allowing entities and relationships to be indexed alongside vector embeddings. The system supports graph traversal operations (neighbor queries, path finding) that integrate with vector search results, enabling multi-hop reasoning and relationship-aware retrieval. Graph networks are persisted in the same storage backend as vectors, providing unified indexing without separate graph database dependencies.","intents":["I need to represent and query relationships between documents or entities","I want to perform multi-hop reasoning over a knowledge base","I need to combine graph traversal with semantic search in a single query","I want to build a knowledge graph without adding a separate graph database"],"best_for":["Knowledge management systems requiring entity relationship queries","RAG systems that need to traverse relationships between source documents","Teams building question-answering systems over structured knowledge"],"limitations":["Graph traversal depth is limited by memory; deep multi-hop queries (>5 hops) become expensive","No built-in graph algorithms (PageRank, community detection) — requires custom implementation","Graph updates require re-indexing; no incremental graph mutation support","Graph storage overhead adds ~20-30% to index size compared to vector-only indexes"],"requires":["Python 3.9+","Embeddings database instance with graph support enabled","Structured data defining entities and relationships (JSON, CSV, or programmatic)"],"input_types":["entity definitions (text, metadata)","relationship tuples (source, relation, target)","structured knowledge bases"],"output_types":["graph traversal results (neighbor lists, paths)","combined vector + graph search results","relationship metadata"],"categories":["memory-knowledge","search-retrieval"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-neuml--txtai__cap_10","uri":"capability://data.processing.analysis.quantization.and.model.compression.for.efficient.local.deployment","name":"quantization and model compression for efficient local deployment","description":"Supports quantization of embedding models and LLMs to reduce memory footprint and inference latency for local deployment. Quantization strategies include INT8, INT4, and bfloat16 precision reduction with minimal accuracy loss. The system automatically applies quantization during model loading and handles quantized model inference transparently, enabling deployment on resource-constrained devices.","intents":["I want to run embedding models on CPU without GPU memory constraints","I need to reduce LLM inference latency for real-time applications","I want to deploy txtai on edge devices or serverless functions","I need to minimize model storage size for bandwidth-constrained environments"],"best_for":["Edge deployment scenarios (mobile, IoT, embedded systems)","Cost-sensitive cloud deployments (reduced memory = smaller instances)","Real-time inference applications requiring low latency"],"limitations":["Quantization reduces model accuracy by 1-5% depending on quantization level","INT4 quantization requires specialized hardware (some GPUs) for fast inference","Quantized models are not compatible with all downstream tasks (e.g., fine-tuning)","Quantization overhead during model loading adds 10-30 seconds to startup time"],"requires":["Python 3.9+","Quantization library: bitsandbytes (for LLMs) or ONNX Runtime (for embeddings)","Compatible model architecture (most HuggingFace models supported)"],"input_types":["pre-trained embedding models","pre-trained LLMs"],"output_types":["quantized model weights","inference results (identical API to non-quantized models)"],"categories":["data-processing-analysis","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-neuml--txtai__cap_11","uri":"capability://automation.workflow.clustering.and.distributed.indexing.with.sharding.support","name":"clustering and distributed indexing with sharding support","description":"Enables horizontal scaling of the embeddings database across multiple machines through document sharding and distributed search. The system partitions documents across cluster nodes based on configurable sharding strategies (hash-based, range-based), routes queries to relevant shards, and aggregates results. Clustering is transparent to the application layer, allowing seamless scaling without code changes.","intents":["I need to scale my embeddings database to billions of documents","I want to distribute indexing load across multiple machines","I need to query across sharded indexes and aggregate results","I want to add/remove cluster nodes without reindexing"],"best_for":["Large-scale search systems (billions of documents)","Organizations with distributed infrastructure","High-throughput search applications"],"limitations":["Sharding adds network latency for cross-shard queries; no local caching of remote results","Rebalancing shards during node addition/removal is manual; no automatic rebalancing","Consistency guarantees are eventual; concurrent updates may cause stale reads","No built-in replication; node failure causes data loss for that shard"],"requires":["Python 3.9+","Multiple machines with txtai installed","Network connectivity between cluster nodes","Shared storage or distributed file system for persistence (optional)"],"input_types":["documents to index","sharding configuration (strategy, number of shards)","cluster topology (node addresses)"],"output_types":["distributed search results","aggregated rankings across shards"],"categories":["automation-workflow","search-retrieval"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-neuml--txtai__cap_12","uri":"capability://tool.use.integration.language.bindings.and.polyglot.api.access","name":"language bindings and polyglot api access","description":"Provides language bindings beyond Python (Java, JavaScript, Go, etc.) enabling txtai to be used from non-Python applications. Bindings wrap the Python core via language-specific interfaces and handle serialization/deserialization of complex types. This design allows polyglot teams to integrate txtai without Python expertise.","intents":["I want to use txtai from a Java or Go application","I need to integrate txtai into a Node.js backend","I want to call txtai from multiple programming languages","I need language-native APIs without Python subprocess calls"],"best_for":["Polyglot organizations with multiple language stacks","Teams integrating txtai into non-Python services","Developers building language-agnostic AI platforms"],"limitations":["Language bindings add serialization overhead (~50-100ms per call)","Not all txtai features are exposed in all language bindings","Bindings require Python runtime; no true native compilation","Debugging issues requires understanding both language binding and Python core"],"requires":["Python 3.9+ (for Python core)","Language-specific runtime (Java 11+, Node.js 14+, Go 1.16+, etc.)","Language-specific txtai binding package"],"input_types":["language-native data types (objects, arrays, strings)"],"output_types":["language-native data types"],"categories":["tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-neuml--txtai__cap_13","uri":"capability://automation.workflow.persistence.and.recovery.with.configurable.storage.backends","name":"persistence and recovery with configurable storage backends","description":"Provides pluggable storage backends (SQLite, PostgreSQL, custom) for persisting embeddings, metadata, and indexes to disk or remote storage. The system supports incremental indexing, checkpoint-based recovery, and backup/restore operations. Storage backends are abstracted, allowing seamless migration between storage systems without data loss.","intents":["I need to persist my embeddings database to disk","I want to recover from crashes without reindexing","I need to backup and restore my indexes","I want to migrate from SQLite to PostgreSQL without downtime"],"best_for":["Production deployments requiring data durability","Systems with large indexes that take hours to build","Organizations with backup and disaster recovery requirements"],"limitations":["Persistence adds write latency; indexing is slower than in-memory","Recovery from checkpoints may require replaying recent updates","Storage backend migration requires downtime or complex dual-write logic","Backup size equals index size; no built-in compression or deduplication"],"requires":["Python 3.9+","Storage backend: SQLite (included), PostgreSQL, or custom adapter","Disk space or remote storage (S3, GCS, etc.) for index persistence"],"input_types":["documents to index","checkpoint/backup specifications"],"output_types":["persisted indexes","backup files","recovery logs"],"categories":["automation-workflow","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-neuml--txtai__cap_2","uri":"capability://data.processing.analysis.sql.relational.storage.and.structured.data.indexing","name":"sql relational storage and structured data indexing","description":"Embeds a relational database (SQLite by default, extensible to other backends) within the embeddings database to store structured metadata, document content, and query results. The system automatically indexes text columns for full-text search and allows SQL queries to filter vector search results by metadata predicates. This design eliminates the need for a separate metadata store, providing co-located structured and unstructured data indexing.","intents":["I need to filter vector search results by metadata (date, category, author)","I want to store and query both embeddings and structured data in one system","I need full-text search on document content alongside semantic search","I want to avoid managing a separate database for document metadata"],"best_for":["RAG systems that need metadata filtering on search results","Document management systems combining structured and unstructured data","Teams wanting single-system deployment without external databases"],"limitations":["SQLite is single-writer, limiting concurrent indexing to one process","Complex SQL joins with large result sets can block vector search operations","No distributed SQL transactions — sharding requires external coordination","Full-text search is basic (no advanced ranking, no phrase queries in all backends)"],"requires":["Python 3.9+","SQLite (included) or compatible SQL backend (PostgreSQL, MySQL with custom adapter)","Schema definition for structured data"],"input_types":["structured records (JSON, dictionaries)","document text with metadata","SQL queries for filtering"],"output_types":["filtered search results","structured query results","combined vector + SQL results"],"categories":["data-processing-analysis","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-neuml--txtai__cap_3","uri":"capability://text.generation.language.llm.agnostic.pipeline.orchestration.with.model.provider.abstraction","name":"llm-agnostic pipeline orchestration with model provider abstraction","description":"Provides a unified pipeline framework that abstracts over multiple LLM providers (OpenAI, Anthropic, Ollama, local transformers) through a provider-agnostic interface. Pipelines are defined declaratively (YAML or Python) and support chaining multiple LLM calls, prompt templating, and result post-processing. The architecture uses a plugin pattern where each provider implements a standard interface, allowing seamless switching between models without code changes.","intents":["I want to switch between OpenAI, Anthropic, and local LLMs without rewriting code","I need to chain multiple LLM calls with intermediate processing","I want to define complex LLM workflows declaratively in YAML","I need to test my LLM pipeline with different models and providers"],"best_for":["Teams evaluating multiple LLM providers for cost and latency","Organizations with multi-model strategies (GPT-4 for complex tasks, cheaper models for simple ones)","Developers building portable LLM applications"],"limitations":["Provider abstraction adds ~50-100ms overhead per LLM call due to adapter layer","Not all provider features are exposed (e.g., vision, function calling) — requires custom adapters","Prompt templating is basic; complex prompt engineering requires custom pipeline steps","No built-in cost tracking or usage monitoring across providers"],"requires":["Python 3.9+","API keys for desired providers (OpenAI, Anthropic, etc.) or local model server (Ollama)","Sentence transformer or embedding model for RAG pipelines"],"input_types":["text prompts","structured data (JSON)","documents for RAG context"],"output_types":["LLM text responses","structured outputs (JSON, parsed results)","pipeline execution logs"],"categories":["text-generation-language","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-neuml--txtai__cap_4","uri":"capability://text.generation.language.rag.pipeline.with.retrieval.augmented.generation.and.context.injection","name":"rag pipeline with retrieval-augmented generation and context injection","description":"Implements a specialized LLM pipeline that automatically retrieves relevant documents from the embeddings database, injects them as context into LLM prompts, and generates responses grounded in retrieved content. The pipeline supports configurable retrieval strategies (top-k, similarity threshold, metadata filtering), prompt templating with context injection, and result post-processing. This design enables fact-grounded generation without requiring manual context management.","intents":["I want to generate answers grounded in my document collection","I need to reduce hallucination by providing retrieved context to the LLM","I want to build a question-answering system over my documents","I need to control what context is retrieved and how it's injected into prompts"],"best_for":["Question-answering systems over document collections","Customer support chatbots grounded in knowledge bases","Research assistants that cite sources"],"limitations":["Retrieval quality directly impacts generation quality; poor embeddings lead to irrelevant context","Context injection increases prompt length, raising LLM latency and cost","No built-in source attribution or citation tracking — requires custom post-processing","Retrieval-generation coupling makes it hard to debug which component failed"],"requires":["Python 3.9+","Embeddings database with indexed documents","LLM provider API key or local model","Embedding model for document retrieval"],"input_types":["user queries (text)","document collection (indexed in embeddings database)","retrieval parameters (top-k, threshold, filters)"],"output_types":["generated text responses","retrieved context documents","confidence scores"],"categories":["text-generation-language","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-neuml--txtai__cap_5","uri":"capability://automation.workflow.workflow.orchestration.with.task.scheduling.and.multi.step.execution","name":"workflow orchestration with task scheduling and multi-step execution","description":"Provides a workflow engine that orchestrates multi-step AI tasks with support for sequential execution, conditional branching, parallel task execution, and scheduled runs. Workflows are defined declaratively in YAML and support task dependencies, error handling, and state persistence. The engine integrates with pipelines, agents, and external tools, enabling complex automation without custom orchestration code.","intents":["I need to run a sequence of AI tasks with dependencies and error handling","I want to schedule recurring AI workflows (daily reports, periodic indexing)","I need to coordinate parallel execution of multiple AI tasks","I want to define complex automation logic without writing orchestration code"],"best_for":["Data processing pipelines with multiple AI steps","Scheduled batch jobs (daily indexing, report generation)","Teams automating multi-step workflows"],"limitations":["No distributed execution — workflows run on single machine; scaling requires external orchestration","Task state is in-memory; no built-in persistence for long-running workflows","Error handling is basic (retry, skip, fail) — no complex compensation logic","Scheduling is local; no integration with external schedulers (Airflow, Kubernetes)"],"requires":["Python 3.9+","YAML workflow definition","Task implementations (pipelines, agents, or custom functions)"],"input_types":["YAML workflow definitions","task inputs (text, data, parameters)","schedule specifications (cron-like)"],"output_types":["workflow execution results","task outputs","execution logs and metrics"],"categories":["automation-workflow","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-neuml--txtai__cap_6","uri":"capability://planning.reasoning.autonomous.agent.system.with.tool.integration.and.multi.step.reasoning","name":"autonomous agent system with tool integration and multi-step reasoning","description":"Implements an agent framework that enables LLMs to autonomously plan and execute multi-step tasks by selecting from a registry of tools (search, SQL queries, external APIs). Agents use chain-of-thought reasoning to decompose problems, call tools with generated parameters, and iterate based on results. The architecture supports agent teams with collaboration patterns and integrates with the embeddings database for knowledge access.","intents":["I want an AI agent that can search my documents and answer questions autonomously","I need an agent that can query databases and APIs to gather information","I want agents to collaborate and delegate tasks to each other","I need to define custom tools that agents can use"],"best_for":["Autonomous question-answering systems over documents and databases","Multi-step research tasks requiring tool use","Teams building agent-based automation"],"limitations":["Agent reasoning adds 2-5x latency compared to direct LLM calls due to iterative tool use","Tool selection is LLM-dependent; poor prompting leads to wrong tool choices","No built-in cost control; agents can make expensive tool calls without limits","Agent teams require careful prompt engineering to avoid infinite loops or conflicting actions"],"requires":["Python 3.9+","LLM provider API key or local model with function calling support","Tool definitions (search, SQL, APIs, custom functions)","Embeddings database for knowledge access"],"input_types":["user queries or tasks (text)","tool definitions (function signatures, descriptions)","knowledge base (indexed documents)"],"output_types":["agent responses with reasoning trace","tool call logs","final results with source attribution"],"categories":["planning-reasoning","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-neuml--txtai__cap_7","uri":"capability://tool.use.integration.rest.api.with.openai.compatibility.and.model.context.protocol.support","name":"rest api with openai compatibility and model context protocol support","description":"Exposes txtai capabilities through a REST API that mimics OpenAI's API endpoints, enabling drop-in compatibility with OpenAI client libraries. Additionally supports the Model Context Protocol (MCP) for integration with Claude and other MCP-compatible clients. The API layer handles request routing, authentication, clustering support, and automatic serialization of complex types (embeddings, search results).","intents":["I want to use txtai with OpenAI client libraries without code changes","I need to expose my RAG system as an API for external applications","I want to integrate txtai with Claude via Model Context Protocol","I need to scale txtai across multiple machines with load balancing"],"best_for":["Teams integrating txtai into existing OpenAI-based applications","Developers building multi-tenant AI services","Organizations deploying txtai in cloud environments"],"limitations":["OpenAI compatibility is partial — not all endpoints/parameters are supported","API serialization adds ~50-100ms overhead per request","Clustering requires external load balancer; no built-in distributed request routing","Authentication is basic (API keys); no OAuth, SAML, or fine-grained access control"],"requires":["Python 3.9+","txtai installation with API dependencies","OpenAI client library (optional, for compatibility testing)","MCP client (optional, for Claude integration)"],"input_types":["HTTP requests (JSON)","OpenAI-compatible API calls","MCP protocol messages"],"output_types":["JSON responses","OpenAI-compatible response format","MCP protocol responses"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-neuml--txtai__cap_8","uri":"capability://automation.workflow.yaml.driven.configuration.and.declarative.component.initialization","name":"yaml-driven configuration and declarative component initialization","description":"Provides a configuration-driven application layer where all components (embeddings database, pipelines, workflows, agents) are defined declaratively in YAML files. The Application class reads YAML configuration and automatically instantiates and wires components, eliminating boilerplate initialization code. This design enables reproducible deployments and configuration-as-code patterns.","intents":["I want to define my entire AI application in YAML without writing initialization code","I need to version control my AI system configuration","I want to deploy the same configuration across development, staging, and production","I need to modify my AI system without recompiling or restarting"],"best_for":["Teams practicing infrastructure-as-code for AI systems","Organizations with non-technical stakeholders who need to configure AI systems","DevOps teams deploying txtai in containerized environments"],"limitations":["YAML schema is complex; no validation or IDE autocomplete support","Dynamic configuration (runtime parameter changes) requires code; YAML is static","Debugging configuration errors can be difficult; error messages are generic","No built-in configuration templating or variable substitution (requires external tools)"],"requires":["Python 3.9+","YAML file with valid txtai configuration schema","All referenced models, APIs, and resources available at initialization time"],"input_types":["YAML configuration files","environment variables (for secrets)"],"output_types":["initialized Application instance","running API server (if configured)"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-neuml--txtai__cap_9","uri":"capability://data.processing.analysis.multi.modal.pipeline.support.for.text.audio.image.and.data.processing","name":"multi-modal pipeline support for text, audio, image, and data processing","description":"Extends the pipeline framework to support diverse input modalities beyond text: audio transcription and analysis, image processing and OCR, structured data transformation, and training data pipelines. Each modality has specialized preprocessing, embedding, and post-processing steps. Pipelines automatically route inputs to appropriate modality handlers and can chain multi-modal operations (e.g., transcribe audio → extract entities → search documents).","intents":["I need to index and search audio content alongside documents","I want to extract text from images and index it semantically","I need to process structured data (CSV, JSON) and embed it","I want to build pipelines that combine multiple input modalities"],"best_for":["Organizations with heterogeneous data (documents, audio, images, structured data)","Multi-modal RAG systems","Teams building comprehensive knowledge indexing systems"],"limitations":["Audio transcription requires external models (Whisper) or APIs; adds latency and cost","Image OCR quality varies by image quality; no built-in image enhancement","Data transformation pipelines are generic; domain-specific transformations require custom code","Multi-modal embeddings are not aligned; audio and image embeddings may not be comparable to text"],"requires":["Python 3.9+","Modality-specific dependencies: librosa (audio), Pillow (images), pandas (data)","External models: Whisper (audio), Tesseract or vision APIs (OCR)","Multi-modal embedding model (optional, for cross-modal search)"],"input_types":["audio files (MP3, WAV, etc.)","images (PNG, JPG, etc.)","structured data (CSV, JSON, Parquet)","text documents"],"output_types":["transcribed text","extracted text from images","transformed structured data","multi-modal embeddings"],"categories":["data-processing-analysis","image-visual"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":47,"verified":false,"data_access_risk":"high","permissions":["Python 3.9+","Optional: Faiss (CPU or GPU), Annoy, or HNSW for ANN backend","Sentence transformer model or compatible embedding model (HuggingFace, OpenAI, local)","Embeddings database instance with graph support enabled","Structured data defining entities and relationships (JSON, CSV, or programmatic)","Quantization library: bitsandbytes (for LLMs) or ONNX Runtime (for embeddings)","Compatible model architecture (most HuggingFace models supported)","Multiple machines with txtai installed","Network connectivity between cluster nodes","Shared storage or distributed file system for persistence (optional)"],"failure_modes":["Hybrid scoring adds ~50-100ms latency per query due to dual-index traversal","Sparse index requires preprocessing (tokenization, BM25 statistics) that adds indexing overhead","ANN backends have accuracy-speed tradeoffs; approximate search may miss rare but relevant results","No built-in distributed search across multiple machines — requires external sharding layer","Graph traversal depth is limited by memory; deep multi-hop queries (>5 hops) become expensive","No built-in graph algorithms (PageRank, community detection) — requires custom implementation","Graph updates require re-indexing; no incremental graph mutation support","Graph storage overhead adds ~20-30% to index size compared to vector-only indexes","Quantization reduces model accuracy by 1-5% depending on quantization level","INT4 quantization requires specialized hardware (some GPUs) for fast inference","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.6693135219670556,"quality":0.35,"ecosystem":0.6000000000000001,"match_graph":0.25,"freshness":0.75,"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":"active","updated_at":"2026-05-24T12:16:22.062Z","last_scraped_at":"2026-05-03T13:58:29.527Z","last_commit":"2026-05-01T15:49:54Z"},"community":{"stars":12453,"forks":806,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=neuml--txtai","compare_url":"https://unfragile.ai/compare?artifact=neuml--txtai"}},"signature":"F8JdyTWN6GRT/wnHbgBIGMepkHXCzz9xhLYV78PZ9ddY5d2wbMIbSUtwLoTJ0RVoqg1FnoajVLEcEwr8vUiKCw==","signedAt":"2026-06-20T17:32:04.531Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/neuml--txtai","artifact":"https://unfragile.ai/neuml--txtai","verify":"https://unfragile.ai/api/v1/verify?slug=neuml--txtai","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"}}