{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"trulens","slug":"trulens","name":"TruLens","type":"benchmark","url":"https://github.com/truera/trulens","page_url":"https://unfragile.ai/trulens","categories":["testing-quality"],"tags":[],"pricing":{"model":"free","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"trulens__cap_0","uri":"capability://automation.workflow.opentelemetry.based.application.instrumentation.with.automatic.span.generation","name":"opentelemetry-based application instrumentation with automatic span generation","description":"Wraps LLM application methods using the @instrument decorator to automatically generate structured OpenTelemetry spans (RECORD_ROOT, GENERATION, RETRIEVAL, EVAL) without modifying application logic. Uses TracerProvider to capture execution context, method inputs/outputs, and timing metadata across framework-specific wrappers (TruChain for LangChain, TruLlama for LlamaIndex, TruGraph for LangGraph, TruBasicApp for custom code). Spans are hierarchically organized to represent call chains and enable distributed tracing across microservices.","intents":["I want to trace execution of my LLM application without rewriting code","I need to capture what data flows through each step of my RAG pipeline","I want to understand latency bottlenecks in my LLM chain","I need to export traces to external observability systems"],"best_for":["LLM application developers building with LangChain, LlamaIndex, or LangGraph","teams adopting OpenTelemetry standards for observability","builders needing framework-agnostic tracing via TruBasicApp or TruCustomApp"],"limitations":["@instrument decorator requires explicit method wrapping or framework-specific wrapper class instantiation","OTEL span export to Snowflake requires Snowflake connector setup and event table schema configuration","Automatic span generation only captures method boundaries; internal LLM API calls require additional instrumentation"],"requires":["Python 3.8+","OpenTelemetry SDK (trulens-core dependency)","Framework-specific package (trulens-apps-langchain, trulens-apps-llama-index, or trulens-apps-langraph)","TruSession initialized with database connector"],"input_types":["Python application code with LLM framework integration","Method signatures and call arguments"],"output_types":["OpenTelemetry spans in OTEL format","Structured trace data (JSON-serializable span records)","Span exports to SQLite, PostgreSQL, MySQL, or Snowflake"],"categories":["automation-workflow","observability"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"trulens__cap_1","uri":"capability://data.processing.analysis.llm.based.feedback.function.evaluation.with.multi.provider.support","name":"llm-based feedback function evaluation with multi-provider support","description":"Computes evaluation metrics (groundedness, relevance, coherence, toxicity) by executing structured prompts against LLM APIs through a pluggable LLMProvider interface. Supports OpenAI, Anthropic (Bedrock), Snowflake Cortex, HuggingFace, and LiteLLM as evaluation backends. Feedback functions accept span data (context, response, retrieved documents) as input and return numerical scores or boolean verdicts. Evaluation can run synchronously during application execution or asynchronously via background Evaluator thread for deferred processing.","intents":["I want to measure groundedness of LLM responses against retrieved documents","I need to evaluate relevance of retrieved context to user queries","I want to detect toxic or harmful outputs in my LLM application","I need to run evaluations asynchronously without blocking application latency"],"best_for":["teams building RAG systems requiring quality metrics","LLM application builders needing cost-effective evaluation via open-source models (HuggingFace)","enterprises using Snowflake Cortex for evaluation within data warehouse","builders requiring custom evaluation logic via Feedback class extension"],"limitations":["Feedback functions add latency to application execution (synchronous mode) or require background thread management (asynchronous mode)","Evaluation quality depends on LLM provider quality; no built-in ground truth validation","Custom feedback functions require manual prompt engineering and output parsing","Deferred evaluation mode requires persistent queue/state management for reliability"],"requires":["Python 3.8+","API key for at least one LLM provider (OpenAI, Anthropic, HuggingFace, or Snowflake Cortex credentials)","trulens-core with feedback module","LLMProvider implementation for chosen backend"],"input_types":["Span data (context, response, retrieved documents)","Custom prompt templates","Structured feedback function parameters"],"output_types":["Numerical scores (0.0-1.0 range typical)","Boolean verdicts (pass/fail)","Structured evaluation records with provider metadata"],"categories":["data-processing-analysis","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"trulens__cap_10","uri":"capability://data.processing.analysis.snowflake.cortex.server.side.evaluation.pipeline.with.event.table.export","name":"snowflake cortex server-side evaluation pipeline with event table export","description":"Exports OTEL spans directly to Snowflake account event tables via SnowflakeEventTableDB, enabling server-side evaluation using Snowflake Cortex LLM functions. Evaluation queries run within Snowflake data warehouse without pulling data to Python, reducing latency and cost. Integrates with Snowflake's native SQL functions for groundedness, relevance, and toxicity evaluation. Supports both real-time span export and batch ingestion. Enables cost-effective evaluation at scale by leveraging Snowflake compute.","intents":["I want to run evaluations inside Snowflake without exporting data to Python","I need to evaluate at scale using Snowflake Cortex LLM functions","I want to consolidate LLM traces with my data warehouse analytics","I need cost-effective evaluation by leveraging Snowflake compute"],"best_for":["Snowflake customers consolidating LLM observability with data warehouse","teams evaluating high-volume LLM applications (>1000 requests/day)","enterprises requiring data residency within Snowflake","builders needing cost-effective evaluation via Snowflake Cortex"],"limitations":["Requires Snowflake account setup and event table schema configuration; non-trivial initial setup","Snowflake Cortex pricing may be higher than external LLM APIs for small-scale evaluation","Event table export latency (~1-5 seconds); real-time evaluation not possible","Snowflake SQL evaluation queries require manual tuning for complex feedback logic"],"requires":["Python 3.8+","Snowflake account with Cortex enabled","Snowflake Python connector","trulens-connectors-snowflake package","Event table schema in Snowflake account"],"input_types":["OTEL span records","Evaluation query templates (SQL)","Snowflake Cortex function specifications"],"output_types":["Snowflake event table rows","Server-side evaluation results (SQL query output)","Cost tracking via Snowflake query logs"],"categories":["data-processing-analysis","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"trulens__cap_11","uri":"capability://data.processing.analysis.run.management.system.with.experiment.metadata.tracking.and.comparison","name":"run management system with experiment metadata tracking and comparison","description":"RunManager tracks experiment metadata (model name, prompt version, parameters, timestamp) for each application execution. Enables comparison of runs across different configurations, prompt variations, and model selections. Stores run-level aggregations of evaluation metrics and costs. Integrates with leaderboard dashboard to display run rankings and enable filtering/sorting by metrics. Supports tagging runs for organization and retrieval.","intents":["I want to compare performance across different prompt versions","I need to track which model/configuration combination performs best","I want to organize runs by experiment or date range","I need to retrieve historical runs for analysis"],"best_for":["LLM application builders iterating on prompts and models","teams conducting A/B testing and multivariate experiments","researchers analyzing performance trends over time","builders requiring experiment reproducibility"],"limitations":["RunManager stores metadata only; actual trace data is in separate span records","No built-in statistical significance testing; comparison is visual/manual","Run tagging is free-form; no validation or controlled vocabulary","No automatic run deduplication; similar runs may be created multiple times"],"requires":["Python 3.8+","trulens-core with RunManager class","TruSession with database configured","Run metadata (model name, prompt version, parameters)"],"input_types":["Experiment metadata (model name, prompt version, parameters)","Run tags and labels","Timestamp and configuration"],"output_types":["Run records in database","Aggregated evaluation metrics per run","Run comparison data for leaderboard"],"categories":["data-processing-analysis","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"trulens__cap_2","uri":"capability://data.processing.analysis.multi.backend.persistence.with.database.abstraction.layer","name":"multi-backend persistence with database abstraction layer","description":"Stores instrumentation spans and evaluation results via DBConnector interface with implementations for SQLite (default), PostgreSQL, MySQL, and Snowflake event tables. SQLAlchemyDB provides ORM-based persistence for relational databases with automatic schema migration and versioning. SnowflakeEventTableDB exports OTEL spans directly to Snowflake account event tables, enabling server-side evaluation pipelines and integration with Snowflake Cortex. Session class manages database lifecycle, connection pooling, and transaction semantics.","intents":["I want to store LLM traces in my existing PostgreSQL or MySQL database","I need to export traces to Snowflake for analytics and cost tracking","I want to run evaluations server-side in Snowflake without pulling data to Python","I need automatic schema management and database migrations"],"best_for":["teams with existing PostgreSQL/MySQL infrastructure","Snowflake customers wanting to consolidate LLM observability with data warehouse","builders prototyping with SQLite and migrating to production databases","enterprises requiring multi-tenant data isolation via database-level separation"],"limitations":["SQLAlchemy ORM adds ~50-100ms per write operation for complex span hierarchies","Snowflake event table export requires Snowflake account setup and event table schema configuration","No built-in sharding or horizontal scaling; single database instance bottleneck for high-volume applications","Schema migrations are manual; no automatic rollback on version mismatch"],"requires":["Python 3.8+","Database credentials (PostgreSQL, MySQL, Snowflake, or local SQLite file)","SQLAlchemy 1.4+ for relational databases","Snowflake Python connector for Snowflake event table export","TruSession initialized with DBConnector instance"],"input_types":["OpenTelemetry span records (JSON-serializable)","Evaluation feedback results","Cost tracking metadata"],"output_types":["Persisted span records in relational schema","Snowflake event table rows","Query-able trace and evaluation history"],"categories":["data-processing-analysis","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"trulens__cap_3","uri":"capability://automation.workflow.experiment.tracking.and.leaderboard.visualization.with.streamlit.dashboard","name":"experiment tracking and leaderboard visualization with streamlit dashboard","description":"Provides Streamlit-based web interface (trulens_leaderboard()) for comparing LLM application performance across prompt variations, model changes, and configuration iterations. Dashboard displays evaluation metrics (groundedness, relevance, toxicity scores) as sortable leaderboards, record viewers for inspecting individual traces and span hierarchies, and feedback visualizations. Tracks experiment metadata (model name, prompt version, timestamp) and enables filtering/sorting by metric values. Integrates with TruSession to query persisted spans and evaluation results from configured database.","intents":["I want to compare performance of different prompts or models side-by-side","I need to visualize evaluation metrics across experiment runs","I want to inspect individual traces and understand why a response scored poorly","I need to track which model/prompt combination performs best"],"best_for":["LLM application builders iterating on prompts and models","teams conducting A/B testing of LLM configurations","non-technical stakeholders reviewing LLM quality metrics","researchers analyzing evaluation results across experiments"],"limitations":["Streamlit dashboard requires running separate process; no embedded visualization in notebooks","Leaderboard sorting is client-side only; large datasets (>10k runs) may have UI responsiveness issues","Record viewer requires full span hierarchy in database; sparse or incomplete traces display poorly","No built-in statistical significance testing or confidence intervals"],"requires":["Python 3.8+","Streamlit 1.0+","TruSession with populated database (spans and evaluation results)","Network access to Streamlit server (localhost:8501 by default)"],"input_types":["Persisted span records from database","Evaluation feedback results","Experiment metadata (model name, prompt version, timestamp)"],"output_types":["Interactive Streamlit web interface","Sortable leaderboard tables","Trace visualization (span hierarchy, timing, inputs/outputs)","Metric distribution charts"],"categories":["automation-workflow","search-retrieval"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"trulens__cap_4","uri":"capability://automation.workflow.custom.instrumentation.via.instrument.decorator.with.span.type.taxonomy","name":"custom instrumentation via @instrument decorator with span type taxonomy","description":"Enables developers to annotate arbitrary Python methods with @instrument decorator to generate custom OpenTelemetry spans with LLM-specific span types (RECORD_ROOT, GENERATION, RETRIEVAL, EVAL). Decorator captures method inputs, outputs, exceptions, and execution timing. Supports nested instrumentation for hierarchical call chains. Integrates with TracerProvider to emit spans to configured database and OTEL exporters. Allows custom span attributes and tags for domain-specific metadata.","intents":["I want to instrument custom code that isn't part of a standard LLM framework","I need to add custom span types for domain-specific operations","I want to capture intermediate computation results in traces","I need to instrument helper functions and utilities in my application"],"best_for":["builders extending TruLens with custom application logic","teams with proprietary LLM frameworks or orchestration code","developers needing fine-grained tracing beyond framework-level instrumentation","researchers instrumenting experimental LLM pipelines"],"limitations":["@instrument decorator adds ~5-10ms overhead per method call due to span creation and context management","Nested instrumentation depth >10 levels may cause stack overflow or performance degradation","Custom span attributes must be JSON-serializable; complex objects require manual serialization","No automatic retry or error recovery; exceptions in instrumented methods propagate to caller"],"requires":["Python 3.8+","trulens-core with @instrument decorator","TruSession initialized with TracerProvider","Understanding of OpenTelemetry span semantics"],"input_types":["Python method signatures","Custom span type enum values","Method arguments (any JSON-serializable type)"],"output_types":["OpenTelemetry spans with custom attributes","Nested span hierarchies","Captured method inputs/outputs in span events"],"categories":["automation-workflow","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"trulens__cap_5","uri":"capability://automation.workflow.session.based.lifecycle.management.with.database.and.otel.configuration","name":"session-based lifecycle management with database and otel configuration","description":"TruSession class provides centralized orchestration for database connections, OpenTelemetry setup, evaluation lifecycle, and run management. Manages DBConnector initialization, TracerProvider configuration, Evaluator thread spawning, and RunManager for tracking experiment metadata. Handles transaction semantics, connection pooling, and graceful shutdown. Enables context-based span emission and automatic span hierarchy construction. Supports both synchronous and asynchronous evaluation modes via background Evaluator thread.","intents":["I want a single entry point to configure database, OTEL, and evaluation settings","I need to manage database connections and ensure proper cleanup","I want to run evaluations in background without blocking application","I need to track experiment metadata and run history"],"best_for":["LLM application developers setting up TruLens for the first time","teams managing multiple database backends and OTEL exporters","builders requiring background evaluation for low-latency applications","researchers tracking experiment runs and comparing results"],"limitations":["TruSession is singleton-like; multiple instances may cause database connection conflicts","Background Evaluator thread requires manual shutdown; improper cleanup may leak resources","No built-in connection pooling limits; high-concurrency applications may exhaust database connections","Synchronous evaluation mode blocks application execution; latency-sensitive apps must use async mode"],"requires":["Python 3.8+","trulens-core with TruSession class","Configured DBConnector (SQLAlchemyDB, SnowflakeEventTableDB, or custom)","LLMProvider for feedback evaluation"],"input_types":["Database connection parameters","OTEL exporter configuration","Evaluation mode (sync/async)","Run metadata (model name, prompt version, etc.)"],"output_types":["Initialized TruSession instance","Database connection pool","TracerProvider with configured exporters","RunManager for experiment tracking"],"categories":["automation-workflow","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"trulens__cap_6","uri":"capability://automation.workflow.background.evaluation.with.asynchronous.evaluator.thread.and.deferred.processing","name":"background evaluation with asynchronous evaluator thread and deferred processing","description":"Evaluator thread processes feedback functions asynchronously without blocking application execution. Decouples evaluation from application latency by queuing feedback computations and processing them in background. Supports deferred evaluation mode where feedback functions are computed after application response is returned to user. Integrates with RunManager to track evaluation status and results. Enables low-latency LLM applications while maintaining comprehensive evaluation coverage.","intents":["I want to evaluate LLM responses without adding latency to user-facing requests","I need to process evaluations in background after application completes","I want to batch evaluate multiple responses efficiently","I need to handle evaluation failures gracefully without crashing the application"],"best_for":["production LLM applications with strict latency requirements (<500ms)","high-throughput systems processing hundreds of requests per second","teams using expensive evaluation models (GPT-4) that require batching","builders needing reliable evaluation without blocking user requests"],"limitations":["Background evaluation adds complexity; requires monitoring thread health and handling queue overflow","Deferred evaluation results are not immediately available; applications cannot use scores for real-time decisions","Queue-based processing may reorder evaluations; no guaranteed ordering for dependent feedback functions","Thread-based implementation is single-process; distributed evaluation requires external queue (Redis, RabbitMQ)"],"requires":["Python 3.8+","trulens-core with Evaluator thread","TruSession configured with async evaluation mode","Persistent database for storing queued evaluations"],"input_types":["Span records queued for evaluation","Feedback function definitions","LLMProvider configuration"],"output_types":["Asynchronously computed evaluation scores","Evaluation status tracking (pending, completed, failed)","Persisted feedback results in database"],"categories":["automation-workflow","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"trulens__cap_7","uri":"capability://data.processing.analysis.cost.tracking.and.endpoint.management.for.llm.provider.apis","name":"cost tracking and endpoint management for llm provider apis","description":"Tracks API costs for LLM providers (OpenAI, Anthropic, HuggingFace, Snowflake Cortex) used in both application execution and evaluation. Captures token counts, model names, and pricing metadata from provider responses. Aggregates costs by run, experiment, and provider. Enables cost-aware evaluation by tracking evaluation model costs separately from application model costs. Supports custom endpoint configuration for self-hosted or fine-tuned models.","intents":["I want to track how much my LLM application costs to run","I need to understand evaluation costs vs application costs","I want to optimize model selection based on cost-quality tradeoffs","I need to allocate costs across teams or projects"],"best_for":["teams managing LLM costs at scale","builders comparing cost-quality tradeoffs across models","enterprises requiring cost allocation and chargeback","researchers analyzing evaluation cost vs quality"],"limitations":["Cost tracking requires provider-specific token counting; not all providers expose token counts","Pricing data must be manually configured; no automatic price updates when providers change rates","Custom endpoint costs require manual configuration; no automatic cost inference","Cost aggregation is database-side; real-time cost dashboards require polling"],"requires":["Python 3.8+","trulens-core with cost tracking module","LLMProvider configuration with pricing metadata","Database with cost tracking schema"],"input_types":["Provider API responses with token counts","Model names and pricing configuration","Custom endpoint specifications"],"output_types":["Cost records per API call","Aggregated costs by run/experiment/provider","Cost-quality tradeoff analysis"],"categories":["data-processing-analysis","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"trulens__cap_8","uri":"capability://automation.workflow.framework.specific.application.wrapping.with.truchain.trullama.trugraph.and.trubasicapp","name":"framework-specific application wrapping with truchain, trullama, trugraph, and trubasicapp","description":"Provides framework-specific wrapper classes that intercept method calls on LLM applications without modifying source code. TruChain wraps LangChain chains, TruLlama wraps LlamaIndex query engines, TruGraph wraps LangGraph state machines, and TruBasicApp/TruCustomApp provide generic wrapping for custom code. Wrappers automatically instrument methods with @instrument decorator, emit OTEL spans, and integrate with feedback evaluation. Each wrapper maintains framework semantics while adding observability.","intents":["I want to add observability to my LangChain application without rewriting it","I need to trace LlamaIndex retrieval and generation steps","I want to instrument LangGraph state transitions and tool calls","I need to wrap custom Python code that doesn't use standard frameworks"],"best_for":["LangChain developers adding observability to existing chains","LlamaIndex users tracking retrieval quality and generation performance","LangGraph builders debugging state machine execution","teams with custom LLM orchestration code"],"limitations":["Framework-specific wrappers require matching framework version; breaking changes in framework may break wrapper","TruBasicApp/TruCustomApp require manual method wrapping; no automatic instrumentation","Wrappers add method call overhead (~5-10ms per wrapped method)","Framework-specific span types may not map cleanly to OTEL standard span types"],"requires":["Python 3.8+","Framework-specific package (trulens-apps-langchain, trulens-apps-llama-index, trulens-apps-langraph)","Matching framework version (LangChain 0.1+, LlamaIndex 0.9+, LangGraph 0.1+)","TruSession initialized with database and OTEL configuration"],"input_types":["LangChain Chain/Runnable objects","LlamaIndex QueryEngine objects","LangGraph StateGraph objects","Custom Python application code"],"output_types":["Wrapped application objects with instrumentation","OTEL spans for each method call","Structured trace data in database"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"trulens__cap_9","uri":"capability://data.processing.analysis.virtual.runs.and.log.ingestion.for.external.llm.application.traces","name":"virtual runs and log ingestion for external llm application traces","description":"Enables ingestion of traces from external LLM applications (e.g., third-party APIs, cloud services) via virtual runs. Allows developers to create run records without executing application code, then populate them with externally-generated trace data. Supports importing logs from LLM provider APIs (OpenAI, Anthropic) and custom trace formats. Integrates with evaluation framework to compute feedback metrics on imported traces. Enables observability for applications not directly instrumented with TruLens.","intents":["I want to evaluate traces from my LLM API provider without re-running queries","I need to import logs from third-party LLM services into TruLens","I want to apply TruLens evaluation metrics to externally-generated traces","I need to consolidate observability for applications I don't control"],"best_for":["teams using third-party LLM APIs (OpenAI, Anthropic, Cohere)","builders evaluating existing application logs without re-execution","enterprises consolidating observability across multiple LLM services","researchers analyzing historical LLM traces"],"limitations":["Virtual runs require manual trace format conversion; no automatic schema mapping","Imported traces may lack internal span hierarchy; evaluation metrics may be less accurate","Log ingestion is one-way; changes to TruLens evaluation don't update external logs","No automatic sync with external log sources; manual re-import required for updates"],"requires":["Python 3.8+","trulens-core with virtual run support","External trace data in supported format (OTEL, JSON, provider-specific)","TruSession with database configured"],"input_types":["External trace logs (JSON, OTEL format, or provider-specific)","Run metadata (model name, timestamp, parameters)","Custom trace format specifications"],"output_types":["Virtual run records in TruLens database","Imported span hierarchies","Computed evaluation metrics on imported traces"],"categories":["data-processing-analysis","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"trulens__headline","uri":"capability://testing.quality.observability.framework.for.llm.applications","name":"observability framework for llm applications","description":"TruLens is an observability framework designed specifically for Large Language Model applications, providing instrumentation, evaluation, and visualization capabilities to enhance model performance and reliability.","intents":["best observability framework for LLMs","LLM evaluation tools for performance tracking","how to instrument LLM applications","top frameworks for LLM observability","LLM toxicity and relevance evaluation tools"],"best_for":["developers working with LLMs","data scientists evaluating model outputs"],"limitations":[],"requires":[],"input_types":[],"output_types":[],"categories":["testing-quality"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":63,"verified":false,"data_access_risk":"high","permissions":["Python 3.8+","OpenTelemetry SDK (trulens-core dependency)","Framework-specific package (trulens-apps-langchain, trulens-apps-llama-index, or trulens-apps-langraph)","TruSession initialized with database connector","API key for at least one LLM provider (OpenAI, Anthropic, HuggingFace, or Snowflake Cortex credentials)","trulens-core with feedback module","LLMProvider implementation for chosen backend","Snowflake account with Cortex enabled","Snowflake Python connector","trulens-connectors-snowflake package"],"failure_modes":["@instrument decorator requires explicit method wrapping or framework-specific wrapper class instantiation","OTEL span export to Snowflake requires Snowflake connector setup and event table schema configuration","Automatic span generation only captures method boundaries; internal LLM API calls require additional instrumentation","Feedback functions add latency to application execution (synchronous mode) or require background thread management (asynchronous mode)","Evaluation quality depends on LLM provider quality; no built-in ground truth validation","Custom feedback functions require manual prompt engineering and output parsing","Deferred evaluation mode requires persistent queue/state management for reliability","Requires Snowflake account setup and event table schema configuration; non-trivial initial setup","Snowflake Cortex pricing may be higher than external LLM APIs for small-scale evaluation","Event table export latency (~1-5 seconds); real-time evaluation not possible","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.7,"quality":0.9,"ecosystem":0.39999999999999997,"match_graph":0.25,"freshness":0.52,"weights":{"adoption":0.25,"quality":0.35,"ecosystem":0.15,"match_graph":0.2,"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-06-17T09:51:05.297Z","last_scraped_at":null,"last_commit":null},"community":{"stars":null,"forks":null,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=trulens","compare_url":"https://unfragile.ai/compare?artifact=trulens"}},"signature":"VetLd4dQ/oDkxGExDGr6DuHdkr6S9SvjNphojUbmZFctro5LpJkzyXUbMEPPyGQ8K7rPvY999sSWq+8M/AriDw==","signedAt":"2026-06-21T07:45:18.842Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/trulens","artifact":"https://unfragile.ai/trulens","verify":"https://unfragile.ai/api/v1/verify?slug=trulens","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"}}