{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"github-truefoundry--cognita","slug":"truefoundry--cognita","name":"cognita","type":"repo","url":"https://cognita.truefoundry.com","page_url":"https://unfragile.ai/truefoundry--cognita","categories":["rag-knowledge","deployment-infra"],"tags":["agent","ai","application","data","deep-learning","fine-tuning","framework","generative-ai","llm","llm-ops","llmops","machine-learning","mlops","model-deployment","python","rag","retrieval-augmented-generation","typescript"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"github-truefoundry--cognita__cap_0","uri":"capability://automation.workflow.modular.rag.codebase.organization.with.api.driven.architecture","name":"modular rag codebase organization with api-driven architecture","description":"Provides a structured framework that organizes RAG components (data sources, indexing, retrieval, LLM integration) into discrete, independently deployable modules with FastAPI-based REST endpoints. Uses a layered architecture where each component (Model Gateway, Vector DB, Metadata Store, Query Controllers) is loosely coupled and can be extended or replaced without affecting others, enabling teams to move from experimental prototypes to production systems without architectural rewrites.","intents":["I want to structure my RAG codebase so it's maintainable and production-ready from day one","I need to swap vector databases or embedding models without rewriting my entire application","I want to organize my RAG components so different team members can work on them independently"],"best_for":["teams building production RAG systems who want to avoid monolithic prototype code","developers migrating RAG experiments from notebooks to deployable applications","organizations needing to standardize RAG architecture across multiple projects"],"limitations":["Requires understanding of RAG concepts and component interactions; not suitable for users unfamiliar with retrieval-augmented generation patterns","Modular design adds complexity compared to simple single-file RAG scripts; overhead is justified only for multi-component systems","Extensibility requires writing custom classes that inherit from base abstractions; not zero-code for custom components"],"requires":["Python 3.8+","FastAPI 0.95+","Vector database (Qdrant, MongoDB, Milvus, or Weaviate)","LLM API key (OpenAI, Anthropic, or self-hosted via Ollama/Infinity Server)"],"input_types":["configuration files (YAML/JSON)","Python class definitions for custom components","API requests (JSON)"],"output_types":["REST API endpoints","Python module instances","Structured metadata (collections, data sources, indexing status)"],"categories":["automation-workflow","framework-architecture"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-truefoundry--cognita__cap_1","uri":"capability://data.processing.analysis.incremental.document.indexing.with.change.detection","name":"incremental document indexing with change detection","description":"Implements a stateful indexing pipeline that compares the current state of data sources against the Vector Database to identify newly added, updated, and deleted documents, then selectively re-indexes only changed files. The system maintains metadata about each indexing run (status, timestamps, file hashes) in a Metadata Store, enabling efficient incremental updates without full re-indexing. Supports multiple data source types (local directories, URLs, GitHub repos, TrueFoundry artifacts) through an extensible loader interface.","intents":["I want to add new documents to my knowledge base without re-embedding everything that's already indexed","I need to track which documents were successfully indexed and when, for audit and debugging purposes","I want to automatically detect when source documents have been updated and re-index only those changes"],"best_for":["teams managing large document collections where full re-indexing is prohibitively expensive","applications with frequently updated data sources (documentation, knowledge bases, code repositories)","production systems requiring audit trails and reproducible indexing history"],"limitations":["Change detection relies on file hashes or timestamps; may miss semantic changes in documents with identical content","Incremental indexing adds complexity to the indexing pipeline; full re-index is simpler for small collections (<1000 documents)","Metadata Store must be kept in sync with Vector DB state; inconsistencies can cause duplicate or missed documents"],"requires":["Metadata Store (SQLite, PostgreSQL, or compatible)","Vector Database with collection state tracking","Data source access (read permissions for files, URLs, or repositories)","Indexer service running with access to both Metadata Store and Vector DB"],"input_types":["data source configuration (paths, URLs, credentials)","document files (PDF, TXT, MD, DOCX, etc.)","parsing configuration (chunk size, overlap, format-specific rules)"],"output_types":["vector embeddings (stored in Vector DB)","indexing run metadata (status, file counts, timestamps)","document chunks with metadata (source, page number, hash)"],"categories":["data-processing-analysis","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-truefoundry--cognita__cap_10","uri":"capability://automation.workflow.production.deployment.with.docker.and.cloud.platform.support","name":"production deployment with docker and cloud platform support","description":"Provides Docker Compose configuration and cloud deployment templates (TrueFoundry YAML) for deploying Cognita to production environments. Includes containerized backend (FastAPI), frontend (React), and supporting services (Vector DB, Metadata Store). Deployment configuration is externalized through environment variables and YAML files, enabling environment-specific customization (dev, staging, production) without code changes. Supports scaling through container orchestration platforms.","intents":["I want to deploy Cognita to production with proper isolation and resource management","I need to configure different settings for development, staging, and production environments","I want to scale Cognita horizontally to handle increased query and indexing load"],"best_for":["teams deploying RAG systems to production with Docker/Kubernetes infrastructure","organizations needing environment-specific configurations (dev vs production)","systems requiring horizontal scaling and high availability"],"limitations":["Docker deployment adds operational complexity; requires Docker and container orchestration knowledge","Stateful components (Vector DB, Metadata Store) require persistent storage configuration; not suitable for ephemeral deployments","Scaling is limited by Vector DB and Metadata Store scalability; these become bottlenecks at high load"],"requires":["Docker and Docker Compose (for local deployment)","Kubernetes cluster (for production deployment)","Persistent storage for Vector DB and Metadata Store","Environment variables or YAML configuration files","Container registry for storing images"],"input_types":["Docker Compose YAML configuration","TrueFoundry YAML deployment manifest","environment variables (.env files)","container images (backend, frontend, supporting services)"],"output_types":["running containers (backend API, frontend UI, Vector DB, Metadata Store)","exposed ports and endpoints (API URL, UI URL)","logs and monitoring data (container logs, metrics)"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-truefoundry--cognita__cap_11","uri":"capability://tool.use.integration.extensible.architecture.for.custom.components.and.strategies","name":"extensible architecture for custom components and strategies","description":"Enables developers to extend Cognita by implementing custom classes that inherit from base abstractions: custom Parsers for new document formats, custom DataSources for new data origins, custom QueryControllers for different retrieval strategies, custom Model providers for new LLM/embedding services. The modular architecture allows these custom components to be registered and used without modifying core Cognita code. Documentation and examples guide developers through the extension process.","intents":["I want to add support for a proprietary document format without modifying Cognita core","I need to implement a custom retrieval strategy (e.g., multi-hop reasoning) that's not in the built-in Query Controllers","I want to integrate a new LLM provider that's not yet supported by the Model Gateway"],"best_for":["teams with specialized requirements that don't fit built-in components","organizations building proprietary RAG systems on top of Cognita","developers contributing new components back to the Cognita community"],"limitations":["Extension development requires understanding base class interfaces and Cognita architecture; not suitable for non-developers","Custom components must follow Cognita's patterns and conventions; incompatible designs may not integrate cleanly","Testing custom components requires setting up test fixtures and mocking Cognita dependencies"],"requires":["Python 3.8+","Understanding of Cognita architecture and base class interfaces","Cognita source code or documentation","Development environment with testing tools (pytest, etc.)"],"input_types":["base class definitions (Parser, DataSource, QueryController, etc.)","example implementations (reference custom components)","documentation and API contracts"],"output_types":["custom component classes (inheriting from base abstractions)","registered components (available for use in Cognita)","integration tests (verifying component behavior)"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-truefoundry--cognita__cap_2","uri":"capability://tool.use.integration.unified.model.gateway.with.multi.provider.abstraction","name":"unified model gateway with multi-provider abstraction","description":"Provides a single abstraction layer that unifies access to embedding models, LLMs, rerankers, and audio processors across multiple providers (OpenAI, Anthropic, Ollama, Infinity Server, custom providers). The Model Gateway exposes a consistent Python API regardless of underlying provider, allowing applications to switch providers by changing configuration without code changes. Internally routes requests to provider-specific APIs and handles response normalization, error handling, and fallback logic.","intents":["I want to switch from OpenAI embeddings to a self-hosted Ollama model without rewriting my indexing code","I need to use different LLM providers in different environments (OpenAI in production, Ollama in development) with the same code","I want to add a new embedding model provider without modifying the core RAG application logic"],"best_for":["teams avoiding vendor lock-in by supporting multiple LLM/embedding providers","organizations with hybrid deployments (cloud + self-hosted models)","developers building extensible RAG systems that need to support customer-provided models"],"limitations":["Abstraction layer adds ~50-100ms latency per request due to routing and response normalization","Not all providers support identical feature sets (e.g., some lack reranking); applications must handle provider-specific capabilities gracefully","Custom provider integration requires implementing provider-specific adapter classes; no automatic provider discovery"],"requires":["Python 3.8+","API credentials for at least one provider (OpenAI API key, Ollama endpoint, etc.)","Model Gateway module from Cognita backend","Provider-specific Python SDK (openai, anthropic, ollama, etc.)"],"input_types":["configuration (provider name, model ID, API credentials)","text for embedding or LLM inference","structured requests (prompt, temperature, max_tokens)"],"output_types":["embeddings (numpy arrays or lists of floats)","LLM responses (text, structured JSON)","reranking scores (float arrays)"],"categories":["tool-use-integration","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-truefoundry--cognita__cap_3","uri":"capability://data.processing.analysis.extensible.document.parsing.with.format.specific.handlers","name":"extensible document parsing with format-specific handlers","description":"Provides a pluggable parser system that handles multiple document formats (PDF, TXT, DOCX, MD, HTML, JSON, etc.) with format-specific extraction logic. Each parser inherits from a base Parser class and implements format-specific chunking, metadata extraction, and content normalization. The system stores parsing configuration per data source in the Metadata Store, allowing different sources to use different parsers and chunk sizes. Supports custom parsers for domain-specific formats through inheritance and registration.","intents":["I need to extract text from PDFs while preserving table structure and page numbers as metadata","I want to parse Markdown documentation differently than plain text files (respecting heading hierarchy for chunking)","I need to add a custom parser for proprietary document formats without modifying the core indexing pipeline"],"best_for":["applications handling heterogeneous document collections (mixed PDFs, docs, web pages, code files)","teams with domain-specific document formats requiring custom extraction logic","systems where parsing strategy varies by data source (e.g., aggressive chunking for dense PDFs, minimal chunking for sparse docs)"],"limitations":["Parser quality varies by format; complex PDFs with tables/images may lose structural information","Custom parser development requires understanding the base Parser interface and format-specific libraries","Parsing configuration is per-data-source; global parsing strategy changes require updating multiple data source records"],"requires":["Python 3.8+","Format-specific libraries (PyPDF2 for PDFs, python-docx for DOCX, etc.)","Metadata Store to persist parsing configuration","Base Parser class from Cognita backend"],"input_types":["document files (PDF, DOCX, TXT, MD, HTML, JSON)","parsing configuration (chunk size, overlap, format-specific options)","metadata extraction rules (regex patterns, field mappings)"],"output_types":["document chunks (text strings with configurable size)","chunk metadata (source file, page number, section heading, extraction confidence)","structured data (tables, key-value pairs extracted from documents)"],"categories":["data-processing-analysis","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-truefoundry--cognita__cap_4","uri":"capability://search.retrieval.semantic.search.with.vector.database.abstraction","name":"semantic search with vector database abstraction","description":"Abstracts vector database operations behind a unified interface that supports multiple backends (Qdrant, MongoDB, Milvus, Weaviate) for storing and querying embedded document chunks. The system handles vector storage, similarity search, metadata filtering, and collection management through provider-agnostic methods. Queries are executed by converting user questions to embeddings via the Model Gateway, then performing semantic similarity search in the Vector DB, with optional reranking to improve result quality.","intents":["I want to find documents semantically similar to a user query without keyword matching","I need to switch from Qdrant to MongoDB for vector storage without rewriting my search code","I want to filter search results by metadata (source file, date, category) while maintaining semantic relevance"],"best_for":["RAG systems requiring semantic search over large document collections","teams wanting to avoid vector DB vendor lock-in through abstraction","applications combining semantic search with metadata filtering (hybrid search)"],"limitations":["Semantic search quality depends on embedding model quality; poor embeddings produce poor results regardless of vector DB","Vector DB abstraction adds ~100-200ms latency per query due to embedding generation and network round-trips","Metadata filtering capabilities vary by vector DB backend; some filters may not be supported across all providers"],"requires":["Vector Database (Qdrant, MongoDB, Milvus, or Weaviate) running and accessible","Embedding model configured in Model Gateway","Document chunks already indexed in Vector DB","Vector DB abstraction module from Cognita backend"],"input_types":["user query (text string)","search parameters (top_k results, similarity threshold, metadata filters)","collection name (which vector DB collection to search)"],"output_types":["ranked document chunks (text + metadata + similarity score)","source file references (path, page number, section)","reranking scores (if reranker is enabled)"],"categories":["search-retrieval","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-truefoundry--cognita__cap_5","uri":"capability://memory.knowledge.collection.based.document.organization.with.metadata.management","name":"collection-based document organization with metadata management","description":"Organizes documents into named collections, each with associated data sources, embedding configuration, and vector DB collection mappings. The Metadata Store maintains collection metadata (name, description, vector DB collection name, embedding model, parsing configuration) and tracks associations between collections and data sources. Collections enable multi-tenant or multi-project document organization within a single Cognita instance, with independent indexing and querying per collection.","intents":["I want to organize documents from different projects into separate collections so they don't interfere with each other","I need to use different embedding models for different document collections based on their content type","I want to track which data sources contribute to each collection and manage them independently"],"best_for":["multi-tenant RAG systems serving different customers or projects","organizations with heterogeneous document types requiring different embedding strategies","teams managing multiple RAG applications within a single Cognita deployment"],"limitations":["Collection isolation is logical, not physical; all collections share the same backend infrastructure","Cross-collection search is not natively supported; queries are scoped to a single collection","Collection metadata is stored in Metadata Store; schema changes require database migrations"],"requires":["Metadata Store (SQLite, PostgreSQL, or compatible)","Vector Database with support for multiple named collections","Collection creation API or UI","Data source registration for each collection"],"input_types":["collection configuration (name, description, embedding model, vector DB collection name)","data source associations (which data sources belong to this collection)","parsing configuration (chunk size, overlap, format-specific rules per collection)"],"output_types":["collection metadata (stored in Metadata Store)","collection-scoped search results","collection-specific indexing status and statistics"],"categories":["memory-knowledge","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-truefoundry--cognita__cap_6","uri":"capability://automation.workflow.no.code.document.management.and.query.ui.docsqa","name":"no-code document management and query ui (docsqa)","description":"Provides a React-based web interface (DocsQA) for non-technical users to upload documents, manage collections, configure data sources, and query the RAG system without writing code. The UI communicates with the FastAPI backend through REST endpoints, handling file uploads, collection creation, data source registration, and query submission. Supports drag-and-drop document upload, collection browsing, and interactive query results with source attribution.","intents":["I want non-technical team members to upload documents and ask questions without touching code","I need a UI to manage which documents are indexed and in which collections","I want to demonstrate RAG capabilities to stakeholders through an interactive interface"],"best_for":["organizations with non-technical users who need to manage documents and ask questions","teams building internal knowledge bases or customer-facing RAG applications","proof-of-concept and demo scenarios requiring quick UI setup"],"limitations":["UI is opinionated and may not match all application designs; customization requires React development","No-code interface hides advanced RAG configuration options; power users may need API access for fine-tuning","UI performance degrades with very large collections (>10,000 documents) due to browser limitations"],"requires":["Node.js 16+ for building/running the React frontend","FastAPI backend running and accessible at a known URL","Modern web browser (Chrome, Firefox, Safari, Edge)","Vector Database and Metadata Store configured and running"],"input_types":["document files (drag-and-drop or file picker)","collection names and descriptions (text input)","data source URLs or paths (text input)","user queries (text input)"],"output_types":["rendered HTML UI with collection browser, document uploader, query interface","query results with source attribution and relevance scores","collection and data source management screens"],"categories":["automation-workflow","search-retrieval"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-truefoundry--cognita__cap_7","uri":"capability://planning.reasoning.query.controller.with.retrieval.and.llm.integration","name":"query controller with retrieval and llm integration","description":"Orchestrates the RAG query pipeline by retrieving relevant documents from the Vector DB via semantic search, optionally reranking results, and passing them to an LLM for answer generation. Query Controllers implement different retrieval strategies (simple similarity search, multi-query expansion, hypothetical document embeddings) and integrate with the Model Gateway for both embedding generation and LLM inference. Supports streaming responses and configurable result ranking/filtering.","intents":["I want to retrieve the most relevant documents for a user query and generate an answer using an LLM","I need to try different retrieval strategies (simple search vs multi-query expansion) to improve answer quality","I want to stream LLM responses to users in real-time rather than waiting for full generation"],"best_for":["RAG applications requiring end-to-end query processing from retrieval to answer generation","teams experimenting with different retrieval strategies to optimize answer quality","systems needing streaming responses for better user experience"],"limitations":["Query latency is sum of embedding generation + vector search + LLM inference; can exceed 5-10 seconds for large contexts","LLM hallucination is not prevented by retrieval; retrieved documents may be misinterpreted or ignored by the LLM","Different retrieval strategies have different performance characteristics; no single strategy is optimal for all queries"],"requires":["Vector Database with indexed documents","Embedding model configured in Model Gateway","LLM configured in Model Gateway","Query Controller implementation (built-in or custom)"],"input_types":["user query (text string)","retrieval parameters (top_k, similarity threshold, reranking enabled)","LLM parameters (temperature, max_tokens, system prompt)"],"output_types":["LLM-generated answer (text or streaming chunks)","source documents (with relevance scores and metadata)","query metadata (retrieval time, LLM inference time, token counts)"],"categories":["planning-reasoning","search-retrieval"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-truefoundry--cognita__cap_8","uri":"capability://tool.use.integration.data.source.abstraction.with.custom.loader.support","name":"data source abstraction with custom loader support","description":"Provides an extensible interface for connecting to various data sources (local directories, web URLs, GitHub repositories, TrueFoundry artifacts, custom sources) through pluggable loader classes. Each data source loader implements methods to list available documents, download content, and track changes. The system stores data source configuration in the Metadata Store and associates sources with collections. Custom loaders can be implemented by inheriting from a base DataSource class and registering with the system.","intents":["I want to index documents from multiple sources (local files, GitHub, web URLs) into a single collection","I need to add a custom data source type (e.g., internal wiki, proprietary database) without modifying Cognita core","I want to automatically detect when source documents have changed and trigger re-indexing"],"best_for":["systems pulling documents from heterogeneous sources (files, APIs, repositories, web pages)","teams with custom data sources requiring specialized loaders","applications needing automated document synchronization from external systems"],"limitations":["Custom loader development requires understanding the DataSource interface and source-specific APIs","Change detection relies on source-provided metadata (timestamps, ETags); some sources may not support efficient change tracking","Data source credentials must be securely stored in configuration; no built-in secrets management"],"requires":["Python 3.8+","Base DataSource class from Cognita backend","Source-specific libraries (requests for HTTP, PyGithub for GitHub, etc.)","Metadata Store to persist data source configuration","Network access to data sources"],"input_types":["data source configuration (source type, URL/path, credentials, refresh interval)","collection association (which collection this source belongs to)","parsing configuration (which parser to use for documents from this source)"],"output_types":["list of available documents (with metadata like size, last modified)","document content (text, binary, or structured data)","change detection results (new, updated, deleted files)"],"categories":["tool-use-integration","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-truefoundry--cognita__cap_9","uri":"capability://memory.knowledge.metadata.store.for.configuration.and.state.persistence","name":"metadata store for configuration and state persistence","description":"Provides a persistent store (SQLite, PostgreSQL, or compatible) that maintains all system configuration and state: collection definitions, data source associations, parsing configurations, embedding model settings, indexing run history, and document metadata. The Metadata Store enables reproducible indexing, audit trails, and state recovery after failures. Queries against the Metadata Store inform indexing decisions (e.g., which documents have changed since last run) and collection management.","intents":["I want to track the history of indexing runs and debug why certain documents failed to index","I need to persist collection and data source configuration so the system survives restarts","I want to know which documents are currently indexed and when they were last updated"],"best_for":["production RAG systems requiring audit trails and reproducibility","teams managing multiple collections and data sources with complex configurations","systems needing to recover from failures without losing indexing state"],"limitations":["Metadata Store must be kept in sync with Vector DB state; inconsistencies can cause duplicate or missed documents","Schema changes require database migrations; no automatic schema evolution","Query performance degrades with very large indexing run histories (>100,000 runs); archival/cleanup needed"],"requires":["Relational database (SQLite for development, PostgreSQL for production)","Database connection string and credentials","Database schema initialized (migrations run)","Read/write access to database"],"input_types":["collection configuration (name, description, embedding model, vector DB collection name)","data source configuration (source type, URL/path, credentials, refresh interval)","indexing run data (status, file counts, error logs, timestamps)"],"output_types":["collection metadata (retrieved for UI and API)","data source associations (which sources belong to which collections)","indexing run history (for debugging and audit)","document metadata (source file, chunk ID, embedding model, last updated)"],"categories":["memory-knowledge","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":48,"verified":false,"data_access_risk":"high","permissions":["Python 3.8+","FastAPI 0.95+","Vector database (Qdrant, MongoDB, Milvus, or Weaviate)","LLM API key (OpenAI, Anthropic, or self-hosted via Ollama/Infinity Server)","Metadata Store (SQLite, PostgreSQL, or compatible)","Vector Database with collection state tracking","Data source access (read permissions for files, URLs, or repositories)","Indexer service running with access to both Metadata Store and Vector DB","Docker and Docker Compose (for local deployment)","Kubernetes cluster (for production deployment)"],"failure_modes":["Requires understanding of RAG concepts and component interactions; not suitable for users unfamiliar with retrieval-augmented generation patterns","Modular design adds complexity compared to simple single-file RAG scripts; overhead is justified only for multi-component systems","Extensibility requires writing custom classes that inherit from base abstractions; not zero-code for custom components","Change detection relies on file hashes or timestamps; may miss semantic changes in documents with identical content","Incremental indexing adds complexity to the indexing pipeline; full re-index is simpler for small collections (<1000 documents)","Metadata Store must be kept in sync with Vector DB state; inconsistencies can cause duplicate or missed documents","Docker deployment adds operational complexity; requires Docker and container orchestration knowledge","Stateful components (Vector DB, Metadata Store) require persistent storage configuration; not suitable for ephemeral deployments","Scaling is limited by Vector DB and Metadata Store scalability; these become bottlenecks at high load","Extension development requires understanding base class interfaces and Cognita architecture; not suitable for non-developers","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.571942178696556,"quality":0.49,"ecosystem":0.7000000000000001,"match_graph":0.25,"freshness":0.6,"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.064Z","last_scraped_at":"2026-05-03T13:58:29.527Z","last_commit":"2026-03-13T15:04:36Z"},"community":{"stars":4409,"forks":386,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=truefoundry--cognita","compare_url":"https://unfragile.ai/compare?artifact=truefoundry--cognita"}},"signature":"FiZ5KdWKUhAzfd9WUWMDsnryl9g/U/gtO5LXxmeCeoAv3Wx8S98ggtedXdiE8b4Lo1zWSn6JYBs5WZKbQPlVDA==","signedAt":"2026-06-22T02:58:57.438Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/truefoundry--cognita","artifact":"https://unfragile.ai/truefoundry--cognita","verify":"https://unfragile.ai/api/v1/verify?slug=truefoundry--cognita","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"}}