{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"pypi_pypi-txtai","slug":"pypi-txtai","name":"txtai","type":"framework","url":"https://github.com/neuml/txtai","page_url":"https://unfragile.ai/pypi-txtai","categories":["frameworks-sdks"],"tags":["search","embedding","machine-learning","nlp"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"pypi_pypi-txtai__cap_0","uri":"capability://memory.knowledge.hybrid.vector.graph.relational.embeddings.database.with.multi.backend.ann.support","name":"hybrid vector-graph-relational embeddings database with multi-backend ann support","description":"Unified embeddings storage layer combining dense vector indexes (FAISS, Annoy, HNSW), sparse BM25 indexes, graph networks for relationship modeling, and SQL relational storage in a single queryable index. Supports multiple vector model backends (sentence transformers, local LLMs, API-based embeddings) with automatic quantization, persistence, and recovery. Implements co-location of vector, graph, and relational data enabling complex queries across all three modalities without separate systems.","intents":["Build semantic search over large document collections without managing separate vector DB, graph DB, and SQL database","Query embeddings with hybrid dense+sparse retrieval to combine semantic and keyword matching","Store and traverse relationship graphs alongside vector embeddings for knowledge graph applications","Persist embeddings locally with automatic recovery and avoid cloud API costs for inference"],"best_for":["Teams building RAG systems who want single-system simplicity over specialized databases","Developers prototyping semantic search without infrastructure overhead","Organizations with privacy requirements needing on-premise embeddings storage"],"limitations":["Single-machine deployment by default; distributed sharding requires manual configuration via clustering layer","Vector index size limited by available RAM unless using disk-based backends (slower)","Graph traversal performance degrades with very large graphs (100M+ nodes) without optimization","No built-in multi-tenancy isolation; requires separate index instances per tenant"],"requires":["Python 3.9+","Optional: sentence-transformers, torch, or transformers for local embedding models","Optional: FAISS, Annoy, or HNSW for specific ANN backends","Optional: SQLite, PostgreSQL, or MySQL for relational storage backend"],"input_types":["text documents","structured data (JSON, CSV)","pre-computed embeddings (numpy arrays)","metadata and relationships"],"output_types":["ranked search results with scores","graph traversal paths","SQL query results","hybrid result sets combining all three"],"categories":["memory-knowledge","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-txtai__cap_1","uri":"capability://planning.reasoning.llm.agnostic.rag.pipeline.with.prompt.engineering.and.context.ranking","name":"llm-agnostic rag pipeline with prompt engineering and context ranking","description":"Orchestrates retrieval-augmented generation by composing embeddings search, context ranking, prompt templating, and LLM inference into a configurable pipeline. Supports multiple LLM backends (OpenAI, Anthropic, Ollama, local transformers) with provider-agnostic prompt engineering. Implements context ranking strategies (BM25, semantic similarity, reranking models) to optimize retrieved context quality before passing to LLM, reducing hallucination and improving answer relevance.","intents":["Build RAG systems that work with any LLM provider without rewriting retrieval logic","Optimize retrieved context quality through ranking before LLM inference to reduce hallucinations","Template prompts with dynamic context injection and support multiple prompt strategies","Chain multiple retrieval and ranking steps for complex question-answering workflows"],"best_for":["Teams building production RAG applications needing LLM provider flexibility","Developers optimizing RAG quality through context ranking and prompt engineering","Organizations using multiple LLM providers and wanting unified interface"],"limitations":["Context window management is manual; no automatic chunking/sliding window strategy built-in","Ranking overhead adds 50-200ms per query depending on reranker model size","Prompt engineering is configuration-based, not learned; requires manual tuning per use case","No built-in evaluation metrics for RAG quality; requires external frameworks"],"requires":["Python 3.9+","API key for at least one LLM provider (OpenAI, Anthropic, etc.) OR local Ollama/transformers setup","Embeddings database instance (txtai Embeddings or compatible)","Optional: reranking model (cross-encoder) for context ranking"],"input_types":["user queries (text)","retrieved documents/context (text)","prompt templates (YAML/JSON)","LLM configuration (provider, model, parameters)"],"output_types":["generated text responses","ranked context passages","structured outputs (JSON if LLM supports function calling)"],"categories":["planning-reasoning","text-generation-language"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-txtai__cap_10","uri":"capability://data.processing.analysis.sql.relational.storage.with.structured.data.indexing","name":"sql relational storage with structured data indexing","description":"Relational database layer enabling storage of structured metadata alongside embeddings and graphs. Supports multiple backends (SQLite, PostgreSQL, MySQL) with automatic schema creation. Enables SQL queries on metadata (filtering, aggregation) combined with semantic search. Implements full-text search on text columns and supports complex WHERE clauses for precise filtering.","intents":["Store and query structured metadata (dates, categories, authors) alongside semantic search","Filter search results using SQL predicates (date ranges, category membership)","Perform aggregations on metadata (count documents per category, average scores)","Combine SQL queries with semantic search for precise result filtering"],"best_for":["Teams building search systems with rich metadata","Developers implementing faceted search and filtering","Organizations needing structured data alongside semantic search"],"limitations":["SQL queries are limited to metadata; full-text search is basic (no phrase queries)","Schema must be defined upfront; dynamic schema changes require migration","No automatic schema inference; metadata structure must be explicitly defined","Query optimization is manual; no query planner for complex queries"],"requires":["Python 3.9+","SQLite (built-in) or PostgreSQL/MySQL with connection string","Schema definition for metadata"],"input_types":["structured metadata (dictionaries, JSON)","SQL filter predicates","schema definitions"],"output_types":["query results (rows matching predicates)","aggregation results (counts, sums, averages)","combined semantic + SQL results"],"categories":["data-processing-analysis","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-txtai__cap_11","uri":"capability://automation.workflow.distributed.clustering.and.sharding.for.horizontal.scaling","name":"distributed clustering and sharding for horizontal scaling","description":"Clustering layer enabling horizontal scaling of txtai across multiple machines. Implements index sharding (partitioning embeddings across nodes), request routing to appropriate shards, and result aggregation. Supports multiple sharding strategies (hash-based, range-based). Coordinates cluster state and handles node failures with automatic failover. Enables transparent scaling without application code changes.","intents":["Scale embeddings database across multiple machines for large datasets","Distribute search queries across shards for parallel execution","Handle node failures with automatic failover and recovery","Scale txtai API endpoints horizontally for high throughput"],"best_for":["Teams deploying txtai at scale (100M+ documents)","Organizations needing high availability and fault tolerance","Developers building distributed AI systems"],"limitations":["Clustering requires manual configuration; no automatic node discovery","Sharding strategy must be chosen upfront; resharding is manual and expensive","Network latency adds overhead (10-100ms per request for coordination)","No built-in load balancing; requires external load balancer (nginx, HAProxy)"],"requires":["Python 3.9+","Multiple machines with txtai installed","Network connectivity between nodes","Optional: Redis or similar for cluster coordination","Optional: load balancer (nginx, HAProxy)"],"input_types":["cluster configuration (node addresses, sharding strategy)","index data to be sharded","queries to be distributed"],"output_types":["sharded indexes across nodes","aggregated query results from all shards","cluster status and health metrics"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-txtai__cap_12","uri":"capability://automation.workflow.persistence.and.recovery.with.automatic.index.snapshots","name":"persistence and recovery with automatic index snapshots","description":"Persistence layer enabling saving and loading of embeddings indexes to disk. Implements automatic snapshots at configurable intervals for disaster recovery. Supports incremental updates to avoid full index rewrite. Handles recovery from crashes with automatic index validation and repair. Enables reproducible results by persisting exact index state.","intents":["Save embeddings index to disk to avoid recomputation on restart","Create backups of embeddings for disaster recovery","Recover from crashes with automatic index validation","Version control embeddings state for reproducibility"],"best_for":["Teams running long-lived txtai applications needing persistence","Developers building production systems with disaster recovery requirements","Organizations needing reproducible embeddings state"],"limitations":["Snapshot overhead adds latency during writes (10-100ms depending on index size)","Incremental updates are complex; full snapshots are simpler but slower","No built-in backup replication; requires external backup system","Recovery validation is basic; corrupted indexes may not be detected"],"requires":["Python 3.9+","Writable filesystem with sufficient space for index snapshots","Optional: external backup system (S3, GCS, etc.)"],"input_types":["embeddings index","snapshot configuration (interval, location)","recovery parameters"],"output_types":["persisted index files","snapshot metadata (timestamp, size)","recovery status and validation results"],"categories":["automation-workflow","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-txtai__cap_2","uri":"capability://automation.workflow.yaml.driven.workflow.orchestration.with.task.composition.and.scheduling","name":"yaml-driven workflow orchestration with task composition and scheduling","description":"Declarative workflow engine that composes tasks (pipelines, agents, custom functions) into directed acyclic graphs (DAGs) defined in YAML configuration. Supports task dependencies, conditional branching, parallel execution, and scheduling via cron expressions. Implements task state management, error handling with retry logic, and result passing between tasks through a shared context object. Enables non-technical users to define complex AI workflows without code.","intents":["Define multi-step AI workflows (extract → transform → summarize → store) in YAML without writing orchestration code","Schedule recurring workflows (daily reports, periodic indexing) using cron expressions","Compose reusable tasks with dependencies and conditional logic for complex business processes","Enable non-technical users to modify workflows by editing YAML configuration"],"best_for":["Teams building production AI systems needing workflow orchestration without Airflow/Prefect complexity","Organizations with non-technical users who need to modify workflows","Developers prototyping multi-step AI pipelines quickly"],"limitations":["No distributed execution; all tasks run on single machine (no horizontal scaling)","Limited error recovery; retry logic is basic (fixed backoff, no exponential backoff)","No built-in monitoring/observability; requires external logging integration","Task dependencies are linear DAGs only; no complex graph patterns (fan-out/fan-in limited)"],"requires":["Python 3.9+","YAML configuration file defining workflow","All referenced pipelines/agents must be defined in same application","Optional: APScheduler for scheduling support"],"input_types":["YAML workflow definition","task inputs (text, data, configuration)","context from previous tasks"],"output_types":["task results (text, data, structured output)","workflow execution logs","final workflow output"],"categories":["automation-workflow","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-txtai__cap_3","uri":"capability://planning.reasoning.autonomous.agent.system.with.tool.integration.and.multi.agent.collaboration","name":"autonomous agent system with tool integration and multi-agent collaboration","description":"Agent framework enabling autonomous task execution through iterative reasoning loops (think → act → observe). Agents have access to tool registry (function calling) with native bindings for common APIs and custom tools. Implements agent teams for collaborative multi-agent workflows where agents delegate tasks, share context, and coordinate toward goals. Uses LLM reasoning for tool selection and execution planning with built-in safety guardrails and execution limits.","intents":["Build autonomous agents that can reason about tasks and select appropriate tools without explicit programming","Create agent teams that collaborate on complex tasks by delegating and sharing context","Integrate custom tools and APIs into agent tool registry for domain-specific capabilities","Implement safety constraints (execution limits, tool restrictions) for production agent deployments"],"best_for":["Teams building autonomous AI systems for customer support, research, or automation","Developers creating multi-agent systems for complex problem-solving","Organizations needing tool-using agents with safety constraints"],"limitations":["Agent reasoning quality depends entirely on LLM capability; weaker models produce poor tool selection","No built-in long-term memory; agents lose context between sessions without external persistence","Tool execution is synchronous; no async tool support for long-running operations","Safety guardrails are basic (execution limits, tool whitelisting); no advanced adversarial robustness"],"requires":["Python 3.9+","LLM with function calling support (OpenAI, Anthropic, or compatible)","Tool definitions (functions or API schemas)","Optional: embeddings database for agent memory/context retrieval"],"input_types":["user task/goal (text)","tool definitions (function signatures, API schemas)","agent configuration (model, tools, constraints)"],"output_types":["task completion result (text, data, or action)","reasoning trace (thought process, tool calls)","execution logs"],"categories":["planning-reasoning","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-txtai__cap_4","uri":"capability://data.processing.analysis.multi.modal.pipeline.framework.with.text.audio.image.and.data.processing","name":"multi-modal pipeline framework with text, audio, image, and data processing","description":"Extensible pipeline architecture supporting specialized processing chains for different modalities: text (NLP, summarization), audio (transcription, speech-to-text), image (OCR, classification, object detection), and data (ETL, transformation). Each pipeline type implements a standard interface enabling composition into larger workflows. Pipelines are configured declaratively and can be chained together with automatic type conversion between modalities.","intents":["Process documents with OCR, then extract text, then summarize in single pipeline","Transcribe audio files and feed transcripts into RAG or summarization pipelines","Build multi-modal workflows combining text, image, and audio processing","Create reusable pipeline components for common NLP/data processing tasks"],"best_for":["Teams building document processing systems handling mixed media types","Developers creating ETL pipelines with AI-powered transformation steps","Organizations processing audio/video content with text extraction and analysis"],"limitations":["Audio/image pipelines require external model dependencies (speech-to-text, OCR models)","No streaming support; all inputs must be loaded into memory","Pipeline composition is sequential; no parallel branch execution within single pipeline","Type conversion between modalities is manual; no automatic format detection"],"requires":["Python 3.9+","Optional: transformers, torch for text pipelines","Optional: librosa, speech_recognition for audio pipelines","Optional: PIL, opencv for image pipelines","Optional: pandas for data pipelines"],"input_types":["text (documents, strings)","audio (WAV, MP3, raw bytes)","images (PNG, JPG, raw arrays)","structured data (CSV, JSON, pandas DataFrames)"],"output_types":["processed text","transcriptions","extracted text from images","transformed/normalized data","structured outputs (JSON)"],"categories":["data-processing-analysis","text-generation-language"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-txtai__cap_5","uri":"capability://tool.use.integration.rest.api.and.openai.compatible.endpoint.exposure.with.mcp.support","name":"rest api and openai-compatible endpoint exposure with mcp support","description":"Application layer exposing all txtai components (embeddings, pipelines, workflows, agents) via HTTP REST endpoints and OpenAI-compatible chat/completion APIs. Implements Model Context Protocol (MCP) for integration with Claude and other MCP-compatible clients. Handles request routing, authentication, clustering/sharding coordination, and response serialization. Enables deployment of txtai applications as microservices without code changes.","intents":["Deploy txtai applications as REST APIs without writing HTTP handler code","Use txtai with OpenAI-compatible clients (LiteLLM, Ollama, etc.) for drop-in compatibility","Integrate txtai with Claude via MCP for AI assistant augmentation","Scale txtai across multiple machines via clustering with transparent request routing"],"best_for":["Teams deploying txtai as production microservices","Developers integrating txtai with OpenAI-compatible tooling","Organizations using Claude and needing txtai capabilities via MCP"],"limitations":["Authentication is basic (API keys only); no OAuth, JWT, or RBAC","Clustering requires manual configuration; no automatic node discovery","Request/response serialization adds overhead (~10-50ms per request)","No built-in rate limiting or quota management"],"requires":["Python 3.9+","FastAPI or Flask for HTTP server","Optional: uvicorn or gunicorn for production ASGI/WSGI server","Optional: Redis or similar for clustering coordination"],"input_types":["HTTP requests (JSON payloads)","OpenAI-compatible chat/completion requests","MCP tool calls"],"output_types":["HTTP responses (JSON)","OpenAI-compatible chat completions","MCP tool results"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-txtai__cap_6","uri":"capability://search.retrieval.semantic.search.with.hybrid.dense.sparse.retrieval.and.ranking","name":"semantic search with hybrid dense-sparse retrieval and ranking","description":"Semantic search capability combining dense vector similarity (learned embeddings) with sparse keyword matching (BM25) in single query. Implements multiple ranking strategies: semantic similarity scoring, BM25 keyword matching, and optional neural reranking models. Supports filtering by metadata, date ranges, and custom predicates. Returns ranked results with relevance scores and supports pagination for large result sets.","intents":["Search document collections using semantic meaning rather than exact keyword matching","Combine semantic and keyword search to improve recall and precision","Filter search results by metadata (date, category, author) alongside semantic relevance","Rank search results using multiple signals (semantic + keyword + custom scoring)"],"best_for":["Teams building search features for document/knowledge bases","Developers implementing semantic search without Elasticsearch/Solr complexity","Organizations needing hybrid search combining semantic and keyword matching"],"limitations":["Search quality depends on embedding model quality; weak models produce poor semantic results","Hybrid search requires tuning weights between dense and sparse components","Reranking adds latency (50-200ms depending on model size)","No full-text search features (phrase queries, wildcards); only semantic + BM25"],"requires":["Python 3.9+","Embeddings database with indexed documents","Embedding model (local or API-based)","Optional: reranking model for neural ranking"],"input_types":["query text (string)","filter predicates (metadata, date ranges)","ranking configuration (weights, strategy)"],"output_types":["ranked results (documents with scores)","relevance scores (float 0-1)","metadata for each result"],"categories":["search-retrieval","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-txtai__cap_7","uri":"capability://data.processing.analysis.local.embedding.model.inference.with.quantization.and.caching","name":"local embedding model inference with quantization and caching","description":"Embedding inference engine supporting multiple model sources: sentence-transformers, local transformers, and API-based providers (OpenAI, Hugging Face). Implements automatic quantization (int8, float16) to reduce model size and inference latency. Caches embeddings to avoid recomputation and supports batch inference for efficiency. Abstracts model provider differences enabling seamless switching between local and API-based embeddings.","intents":["Generate embeddings locally without cloud API calls for privacy and cost savings","Switch between embedding models (sentence-transformers, OpenAI, etc.) without code changes","Optimize embedding inference speed through quantization and batching","Cache embeddings to avoid recomputation for repeated documents"],"best_for":["Teams with privacy requirements needing on-premise embeddings","Developers optimizing embedding inference cost and latency","Organizations using multiple embedding providers and wanting flexibility"],"limitations":["Local inference requires GPU for reasonable performance; CPU inference is slow (100-500ms per document)","Quantization reduces embedding quality slightly (1-5% accuracy loss typical)","Model size varies widely (50MB to 2GB); large models require significant disk/memory","Batch inference requires buffering inputs; no streaming inference support"],"requires":["Python 3.9+","Optional: torch, transformers for local models","Optional: sentence-transformers for pre-trained embedding models","Optional: GPU (CUDA/ROCm) for fast inference","Optional: API key for cloud embedding providers"],"input_types":["text documents (strings)","batch of documents (list)","embedding model configuration"],"output_types":["embeddings (numpy arrays, float32 or quantized)","embedding dimensions (typically 384-1536)","inference metadata (latency, model used)"],"categories":["data-processing-analysis","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-txtai__cap_8","uri":"capability://automation.workflow.configuration.driven.application.lifecycle.management.with.yaml","name":"configuration-driven application lifecycle management with yaml","description":"Application class that reads YAML configuration files and instantiates all txtai components (embeddings, pipelines, workflows, agents) with dependency injection. Manages component lifecycle (initialization, shutdown, persistence). Supports environment variable substitution in YAML for deployment flexibility. Enables reproducible application setup and deployment without code changes.","intents":["Define entire AI application (embeddings, pipelines, agents) in single YAML file","Deploy applications across environments (dev, staging, prod) by changing YAML config","Enable non-technical users to modify application behavior through configuration","Reproduce application state by version-controlling YAML configuration"],"best_for":["Teams deploying AI applications across multiple environments","Organizations with non-technical stakeholders modifying application behavior","Developers building reusable application templates"],"limitations":["Complex logic must be implemented as custom pipeline/agent code; YAML is declarative only","Debugging YAML configuration errors can be difficult; error messages are sometimes unclear","No schema validation; invalid YAML may fail at runtime rather than configuration time","Environment variable substitution is basic; no conditional logic in YAML"],"requires":["Python 3.9+","YAML configuration file","All referenced components must be importable/available"],"input_types":["YAML configuration file","environment variables","component definitions (pipelines, agents, etc.)"],"output_types":["initialized Application instance","component instances (embeddings, pipelines, workflows, agents)","configuration validation results"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-txtai__cap_9","uri":"capability://memory.knowledge.graph.network.construction.and.traversal.for.relationship.modeling","name":"graph network construction and traversal for relationship modeling","description":"Graph database layer enabling storage and traversal of relationships between entities. Supports directed and undirected edges with properties, enabling knowledge graph construction. Implements graph algorithms (shortest path, community detection, centrality) for relationship analysis. Integrates with embeddings database enabling hybrid queries combining semantic similarity with graph traversal.","intents":["Build knowledge graphs representing relationships between entities (people, organizations, concepts)","Query relationships using graph traversal (find all connections between two entities)","Analyze entity importance using graph algorithms (PageRank, centrality measures)","Combine semantic search with relationship traversal for richer context retrieval"],"best_for":["Teams building knowledge graphs and relationship-based applications","Developers implementing recommendation systems using relationship data","Organizations analyzing entity networks and relationship patterns"],"limitations":["Graph traversal performance degrades with very large graphs (100M+ nodes)","Graph algorithms are basic; no advanced algorithms (community detection, influence propagation)","No SPARQL or Cypher support; graph queries are programmatic only","Graph visualization is not built-in; requires external tools"],"requires":["Python 3.9+","Embeddings database instance","Entity and relationship definitions"],"input_types":["entity definitions (nodes)","relationship definitions (edges with properties)","traversal queries (start node, traversal rules)"],"output_types":["traversal paths (sequence of nodes/edges)","connected entities","graph algorithm results (centrality scores, communities)"],"categories":["memory-knowledge","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":31,"verified":false,"data_access_risk":"high","permissions":["Python 3.9+","Optional: sentence-transformers, torch, or transformers for local embedding models","Optional: FAISS, Annoy, or HNSW for specific ANN backends","Optional: SQLite, PostgreSQL, or MySQL for relational storage backend","API key for at least one LLM provider (OpenAI, Anthropic, etc.) OR local Ollama/transformers setup","Embeddings database instance (txtai Embeddings or compatible)","Optional: reranking model (cross-encoder) for context ranking","SQLite (built-in) or PostgreSQL/MySQL with connection string","Schema definition for metadata","Multiple machines with txtai installed"],"failure_modes":["Single-machine deployment by default; distributed sharding requires manual configuration via clustering layer","Vector index size limited by available RAM unless using disk-based backends (slower)","Graph traversal performance degrades with very large graphs (100M+ nodes) without optimization","No built-in multi-tenancy isolation; requires separate index instances per tenant","Context window management is manual; no automatic chunking/sliding window strategy built-in","Ranking overhead adds 50-200ms per query depending on reranker model size","Prompt engineering is configuration-based, not learned; requires manual tuning per use case","No built-in evaluation metrics for RAG quality; requires external frameworks","SQL queries are limited to metadata; full-text search is basic (no phrase queries)","Schema must be defined upfront; dynamic schema changes require migration","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.05,"quality":0.5,"ecosystem":0.52,"match_graph":0.25,"freshness":0.52,"weights":{"adoption":0.3,"quality":0.2,"ecosystem":0.15,"match_graph":0.23,"freshness":0.12}},"observed_outcomes":{"matches":0,"success_rate":0,"avg_confidence":0,"top_intents":[],"last_matched_at":null},"maintenance":{"status":"active","updated_at":"2026-06-17T09:51:05.295Z","last_scraped_at":"2026-05-03T15:20:13.888Z","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=pypi-txtai","compare_url":"https://unfragile.ai/compare?artifact=pypi-txtai"}},"signature":"cNDMLvzw6UOk0sULZUnJ6HhC3w44yfe0eFSCXK27ebiyUKh5C4GdW2jcxOCgqmZMxdYp2PtTkY6XVH76xnPYDw==","signedAt":"2026-06-21T10:19:37.882Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/pypi-txtai","artifact":"https://unfragile.ai/pypi-txtai","verify":"https://unfragile.ai/api/v1/verify?slug=pypi-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"}}