{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"openllmetry","slug":"openllmetry","name":"OpenLLMetry","type":"framework","url":"https://github.com/traceloop/openllmetry","page_url":"https://unfragile.ai/openllmetry","categories":["observability"],"tags":[],"pricing":{"model":"free","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"openllmetry__cap_0","uri":"capability://safety.moderation.automatic.instrumentation.of.llm.api.calls.with.zero.code.integration","name":"automatic instrumentation of llm api calls with zero-code integration","description":"Automatically intercepts and traces LLM API calls (OpenAI, Anthropic, Bedrock, Cohere, etc.) by wrapping provider SDKs at the library level using OpenTelemetry instrumentation hooks, capturing model parameters, prompts, completions, token usage, and latency without requiring manual span creation or code modification. Uses monkey-patching of HTTP clients and SDK methods to inject telemetry collection at runtime.","intents":["I want to trace all LLM API calls in my application without modifying existing code","I need to capture token usage and cost metrics automatically from every model call","I want to see detailed spans for each LLM request including parameters and responses"],"best_for":["teams building LLM applications with LangChain, LlamaIndex, or direct SDK usage","developers needing observability without refactoring existing code","organizations tracking LLM costs and usage patterns across multiple providers"],"limitations":["Streaming responses require additional configuration for proper span closure timing","Sensitive data (prompts, completions) captured by default — requires explicit privacy controls to redact","Instrumentation adds ~5-15ms overhead per LLM call due to span creation and serialization","Only supports Python 3.8+ — no JavaScript/TypeScript instrumentation in core SDK"],"requires":["Python 3.8+","OpenTelemetry SDK (opentelemetry-api, opentelemetry-sdk)","Provider SDK installed (openai, anthropic, boto3, etc.)","Traceloop SDK initialized via Traceloop.init() at application startup"],"input_types":["LLM API calls (intercepted at library level)","Model parameters (temperature, max_tokens, system prompts)","Function/tool calls and responses"],"output_types":["OpenTelemetry spans with semantic attributes","Structured telemetry data (model name, tokens, latency, cost)"],"categories":["safety-moderation","observability"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"openllmetry__cap_1","uri":"capability://planning.reasoning.framework.level.tracing.for.langchain.and.llamaindex.with.chain.agent.visibility","name":"framework-level tracing for langchain and llamaindex with chain/agent visibility","description":"Instruments LangChain chains, agents, and retrievers and LlamaIndex query engines at the framework abstraction level, creating parent-child span hierarchies that capture the full execution graph including tool calls, retrieval steps, and agent reasoning loops. Uses framework-specific hooks and callbacks to track high-level operations beyond raw API calls.","intents":["I want to see the full execution flow of my LangChain agent including tool calls and decision points","I need to trace LlamaIndex query engine steps to understand retrieval and synthesis latency","I want to identify bottlenecks in my RAG pipeline by seeing which chain steps are slowest"],"best_for":["developers building complex agentic workflows with LangChain or LlamaIndex","teams debugging multi-step RAG pipelines and agent decision-making","organizations optimizing retrieval and synthesis performance"],"limitations":["Custom chain implementations require manual decorator usage if not using standard LangChain abstractions","Agent loop tracing depends on framework version compatibility — older LangChain versions may have incomplete coverage","Nested span depth can exceed backend limits (e.g., Datadog has 128-span depth limit) for deeply nested chains","Tool/function call arguments and results captured in full — requires privacy controls for sensitive data"],"requires":["LangChain 0.0.200+ or LlamaIndex 0.8.0+","Python 3.8+","Traceloop SDK initialized before framework imports"],"input_types":["LangChain chains, agents, tools, retrievers","LlamaIndex query engines, retrievers, response synthesizers","Tool/function call definitions and execution results"],"output_types":["Hierarchical OpenTelemetry spans representing chain/agent execution graph","Span attributes capturing tool names, retrieval queries, agent decisions"],"categories":["planning-reasoning","observability"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"openllmetry__cap_10","uri":"capability://memory.knowledge.prompt.management.and.versioning.with.semantic.tagging","name":"prompt management and versioning with semantic tagging","description":"Captures and versions prompts used in LLM calls with semantic tags and metadata, enabling prompt lineage tracking and A/B testing analysis. Stores prompt versions with associated spans, allowing developers to correlate model outputs with specific prompt versions and identify which prompts produce better results.","intents":["I want to track which prompt version was used for each LLM call","I need to compare model outputs across different prompt versions for A/B testing","I want to see the history of prompt changes and their impact on model performance"],"best_for":["teams iterating on prompt engineering and A/B testing","developers tracking prompt versions and their impact on model outputs","organizations managing prompt libraries and versioning"],"limitations":["Prompt versioning requires manual tagging or external prompt management system integration","No built-in A/B testing framework — requires manual analysis of prompt variants","Prompt storage and versioning not included — requires external prompt management system (e.g., Langfuse, Promptfoo)","Semantic tagging is manual — no automatic prompt similarity or clustering"],"requires":["Python 3.8+","Traceloop SDK with prompt tagging support","Manual prompt version management or external prompt system"],"input_types":["Prompt text and parameters","Semantic tags and metadata","Version identifiers"],"output_types":["Span attributes with prompt metadata","Prompt-to-span associations for lineage tracking"],"categories":["memory-knowledge","observability"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"openllmetry__cap_11","uri":"capability://tool.use.integration.custom.span.processor.framework.for.extensible.telemetry.pipelines","name":"custom span processor framework for extensible telemetry pipelines","description":"Provides an extensible span processor interface that allows developers to implement custom telemetry processing logic (filtering, enrichment, transformation, routing) as pluggable components. Span processors intercept spans before export, enabling custom logic like dynamic sampling, attribute enrichment, backend routing, and data transformation without modifying core instrumentation.","intents":["I want to implement custom sampling logic based on span attributes or trace context","I need to enrich spans with custom attributes from my application context","I want to route spans to different backends based on trace properties"],"best_for":["developers building custom observability pipelines with specialized requirements","teams implementing complex sampling or filtering logic","organizations with custom telemetry processing needs"],"limitations":["Span processor performance directly impacts application latency — inefficient processors can add significant overhead","Processor ordering matters — incorrect ordering can cause data loss or incorrect enrichment","No built-in processor library — developers must implement custom logic from scratch","Debugging processor issues requires deep OpenTelemetry knowledge"],"requires":["Python 3.8+","OpenTelemetry SDK with span processor support","Custom Python code implementing SpanProcessor interface"],"input_types":["OpenTelemetry spans before export","Custom processor configuration"],"output_types":["Modified or filtered spans","Routed spans to different exporters"],"categories":["tool-use-integration","observability"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"openllmetry__cap_12","uri":"capability://memory.knowledge.association.properties.for.linking.traces.to.business.context","name":"association properties for linking traces to business context","description":"Provides APIs to attach business context metadata (user IDs, session IDs, request IDs, organization IDs) to traces as association properties, enabling correlation of traces with business entities and user sessions. Association properties are propagated through the entire trace tree, allowing observability backends to group and filter traces by business context.","intents":["I want to link traces to specific users or sessions for debugging user-specific issues","I need to group traces by organization or tenant for multi-tenant cost tracking","I want to correlate LLM traces with upstream request IDs for end-to-end tracing"],"best_for":["multi-tenant SaaS applications needing per-tenant observability","teams debugging user-specific issues with trace correlation","organizations tracking costs and usage by customer or organization"],"limitations":["Association properties must be set manually — no automatic extraction from request context","High-cardinality properties (e.g., unique user IDs) can cause cardinality explosion in backends","Association properties are not automatically propagated across service boundaries — requires manual context passing","No built-in filtering or querying by association properties — requires backend support"],"requires":["Python 3.8+","Traceloop SDK with association property support","Manual context setting in application code"],"input_types":["Business context identifiers (user ID, session ID, organization ID, request ID)","Custom association property names and values"],"output_types":["Span attributes with business context metadata","Trace-to-business-entity associations"],"categories":["memory-knowledge","observability"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"openllmetry__cap_13","uri":"capability://automation.workflow.batch.initialization.and.configuration.management","name":"batch initialization and configuration management","description":"Provides a centralized initialization API (Traceloop.init()) that configures all instrumentation, exporters, and span processors in a single call with environment variable or code-based configuration. Supports batch configuration of multiple instrumentation packages, exporter backends, and privacy controls, reducing boilerplate and enabling environment-specific configuration without code changes.","intents":["I want to initialize all LLM instrumentation with a single function call instead of configuring each package separately","I need to configure different exporters for different environments (dev, staging, prod) without code changes","I want to enable/disable instrumentation packages based on environment variables"],"best_for":["Teams building LLM applications and wanting minimal instrumentation boilerplate","Organizations needing environment-specific observability configuration","Developers who prefer configuration-driven setup over code-based instrumentation"],"limitations":["Centralized initialization requires all instrumentation to be configured upfront; dynamic instrumentation changes require restart","Configuration complexity increases with number of instrumentation packages and exporters","Environment variable configuration may be insufficient for complex scenarios; code-based configuration may be needed"],"requires":["Python 3.8+","traceloop-sdk","OpenTelemetry SDK and instrumentation packages"],"input_types":["Configuration parameters: exporter type, API key, batch size, flush interval, instrumentation packages","Environment variables for configuration"],"output_types":["Initialized OpenTelemetry SDK with all instrumentation and exporters configured","Ready-to-use tracing system"],"categories":["automation-workflow","observability"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"openllmetry__cap_2","uri":"capability://search.retrieval.vector.database.query.tracing.with.retrieval.metrics","name":"vector database query tracing with retrieval metrics","description":"Automatically instruments vector database operations (Pinecone, Weaviate, Chroma, Milvus) to capture retrieval queries, result counts, similarity scores, and latency. Creates spans for each vector search operation with metadata about query embeddings, filters applied, and results returned, enabling performance analysis of RAG retrieval stages.","intents":["I want to trace vector database queries to understand retrieval latency in my RAG pipeline","I need to see which documents are being retrieved and their similarity scores for debugging","I want to identify slow vector searches and optimize my indexing strategy"],"best_for":["teams building RAG systems with vector databases","developers optimizing retrieval performance and relevance","organizations analyzing vector search patterns and costs"],"limitations":["Vector embeddings themselves are not captured (only query metadata) to reduce payload size","Some vector DB SDKs (e.g., older Pinecone versions) may not have full instrumentation coverage","Batch operations may create many spans, increasing cardinality and backend costs","Filter expressions and metadata queries captured in full — requires privacy controls"],"requires":["Vector database SDK installed (pinecone-client, weaviate-client, chromadb, etc.)","Python 3.8+","Corresponding OpenLLMetry instrumentation package (e.g., opentelemetry-instrumentation-pinecone)"],"input_types":["Vector search queries (text or embedding vectors)","Filter expressions and metadata queries","Batch operation parameters"],"output_types":["OpenTelemetry spans with retrieval metrics","Attributes: query latency, result count, similarity scores, filters applied"],"categories":["search-retrieval","observability"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"openllmetry__cap_3","uri":"capability://planning.reasoning.decorator.based.custom.span.creation.and.association","name":"decorator-based custom span creation and association","description":"Provides Python decorators (@traceloop.workflow, @traceloop.task, @traceloop.agent) to manually wrap custom functions and create spans with automatic context propagation. Decorators capture function arguments, return values, exceptions, and execution time, and automatically associate spans with parent traces through context variables, enabling tracing of application-specific logic beyond instrumented libraries.","intents":["I want to trace my custom business logic functions alongside LLM calls","I need to create spans for application-specific operations like data validation or post-processing","I want to associate custom spans with the parent LLM trace automatically"],"best_for":["developers extending observability to custom application code","teams building complex workflows mixing LLM calls with business logic","organizations needing end-to-end tracing from user request to LLM response"],"limitations":["Decorators capture function arguments and return values in full — requires explicit filtering for sensitive data","Async function support requires Python 3.7+ and proper async context handling","Decorator stacking order matters — incorrect ordering can break context propagation","No automatic dependency injection — requires manual decorator application to each function"],"requires":["Python 3.8+","Traceloop SDK initialized","Functions must be decorated before execution"],"input_types":["Function arguments (any Python type)","Return values","Exception objects"],"output_types":["OpenTelemetry spans with function metadata","Attributes: function name, arguments, return value, execution time, exceptions"],"categories":["planning-reasoning","observability"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"openllmetry__cap_4","uri":"capability://data.processing.analysis.streaming.response.handling.with.span.lifecycle.management","name":"streaming response handling with span lifecycle management","description":"Handles OpenTelemetry span lifecycle for streaming LLM responses by deferring span closure until the entire stream completes, capturing partial tokens, stream events, and final completion metrics. Implements custom span processors that buffer streaming events and flush them on stream termination, preventing premature span closure before all data is available.","intents":["I want to trace streaming LLM responses without losing partial token data","I need to capture the full completion including streamed tokens in a single span","I want to measure end-to-end latency for streaming responses including time-to-first-token"],"best_for":["applications using streaming LLM APIs (OpenAI streaming, Anthropic streaming)","teams measuring time-to-first-token and streaming performance metrics","developers building real-time LLM interfaces with streaming responses"],"limitations":["Streaming span closure timing is framework-dependent — requires custom span processor configuration per backend","Buffering streamed events increases memory usage for long-running streams","Partial token capture requires SDK version compatibility with streaming APIs","Some observability backends have limits on span event count — high-frequency token streams may exceed limits"],"requires":["Python 3.8+","LLM provider SDK with streaming support (openai, anthropic, etc.)","Custom span processor configuration for streaming backends"],"input_types":["Streaming response iterators/generators","Stream events (token deltas, choices, finish reasons)"],"output_types":["OpenTelemetry spans with streaming metadata","Attributes: time-to-first-token, total tokens streamed, stream events"],"categories":["data-processing-analysis","observability"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"openllmetry__cap_5","uri":"capability://safety.moderation.privacy.aware.data.redaction.and.pii.filtering","name":"privacy-aware data redaction and pii filtering","description":"Provides configurable privacy controls to redact sensitive data from captured spans before export, including prompt/completion masking, PII detection and removal, and selective attribute filtering. Implements span processors that inspect span attributes and events, applying regex patterns and semantic rules to redact or drop sensitive fields while preserving trace structure for debugging.","intents":["I want to remove prompts and completions from traces before sending to external observability platforms","I need to redact PII (emails, phone numbers, API keys) from captured data automatically","I want to control which span attributes are exported based on data sensitivity"],"best_for":["organizations with strict data privacy requirements (HIPAA, GDPR, SOC2)","teams handling sensitive customer data in LLM applications","developers exporting traces to third-party observability platforms"],"limitations":["Redaction rules are regex-based and may miss context-specific PII patterns","Performance overhead increases with number of redaction rules — complex patterns can add 10-50ms per span","Redaction is applied at export time — data is still in memory unredacted, requiring secure infrastructure","No built-in ML-based PII detection — relies on pattern matching and allowlists"],"requires":["Python 3.8+","Traceloop SDK with privacy module","Custom span processor configuration for redaction rules"],"input_types":["OpenTelemetry spans with sensitive attributes","Redaction rules (regex patterns, field names, allowlists)"],"output_types":["Redacted OpenTelemetry spans with sensitive data removed","Audit logs of redaction operations (optional)"],"categories":["safety-moderation","observability"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"openllmetry__cap_6","uri":"capability://tool.use.integration.multi.backend.telemetry.export.with.opentelemetry.protocol.support","name":"multi-backend telemetry export with opentelemetry protocol support","description":"Exports captured traces, metrics, and events to any OpenTelemetry-compatible backend (Datadog, Honeycomb, Grafana, Jaeger, Traceloop, etc.) using OTLP (OpenTelemetry Protocol) over gRPC or HTTP. Configures exporters and span processors to route telemetry to multiple backends simultaneously, with support for sampling, batching, and retry logic to handle network failures and backend unavailability.","intents":["I want to export LLM traces to my existing observability platform (Datadog, Grafana, etc.)","I need to send traces to multiple backends simultaneously for redundancy and analysis","I want to configure sampling and batching to control telemetry volume and costs"],"best_for":["organizations with existing observability infrastructure (Datadog, Honeycomb, Grafana)","teams needing multi-backend telemetry for redundancy or cross-platform analysis","developers managing telemetry costs through sampling and batching"],"limitations":["OTLP export adds network latency — batching and async export required to avoid blocking application","Backend-specific semantic conventions may not map perfectly to OpenTelemetry standard attributes","Sampling decisions made at SDK level — cannot retroactively sample traces after export","No built-in support for backend-specific features (e.g., Datadog tags, Honeycomb markers) beyond standard OTLP"],"requires":["Python 3.8+","OpenTelemetry exporter package (opentelemetry-exporter-otlp, opentelemetry-exporter-datadog, etc.)","Backend endpoint URL and authentication credentials","Network connectivity to observability backend"],"input_types":["OpenTelemetry spans, metrics, and events","Exporter configuration (endpoint, credentials, sampling rules)"],"output_types":["OTLP-formatted telemetry data","Backend-specific trace and metric records"],"categories":["tool-use-integration","observability"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"openllmetry__cap_7","uri":"capability://data.processing.analysis.semantic.convention.mapping.for.llm.specific.attributes","name":"semantic convention mapping for llm-specific attributes","description":"Defines and enforces OpenTelemetry semantic conventions for LLM operations, mapping LLM-specific concepts (model name, token counts, cost, temperature) to standardized span attributes. Implements attribute mappers that normalize data from different LLM providers into consistent attribute names and types, enabling cross-provider querying and analysis in observability backends.","intents":["I want to query traces across multiple LLM providers using consistent attribute names","I need to calculate costs and token usage metrics from standardized span attributes","I want to build dashboards that work across OpenAI, Anthropic, and other providers"],"best_for":["organizations using multiple LLM providers and needing unified observability","teams building cost tracking and usage analytics across providers","developers creating provider-agnostic observability dashboards"],"limitations":["Semantic conventions are evolving — older backend versions may not support all LLM-specific attributes","Provider-specific attributes (e.g., OpenAI's finish_reason variants) may not map perfectly to standard conventions","Custom models and fine-tuned variants may not have standardized attribute mappings","Cost calculation requires provider-specific pricing data — not captured in semantic conventions"],"requires":["Python 3.8+","Traceloop SDK with semantic convention support","Observability backend supporting custom attributes"],"input_types":["LLM provider responses with model, token, and cost data","Provider-specific attribute formats"],"output_types":["Standardized OpenTelemetry span attributes","Normalized attribute names and types (gen_ai.model.name, gen_ai.usage.input_tokens, etc.)"],"categories":["data-processing-analysis","observability"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"openllmetry__cap_8","uri":"capability://automation.workflow.context.propagation.and.trace.association.across.async.boundaries","name":"context propagation and trace association across async boundaries","description":"Manages OpenTelemetry context propagation across Python async/await boundaries, thread pools, and concurrent operations using context variables and contextvars. Ensures that spans created in async tasks, thread pool workers, and concurrent operations are correctly associated with parent traces, preventing context loss in complex concurrent workflows.","intents":["I want traces to be correctly associated across async/await calls in my async LLM application","I need to trace concurrent LLM calls in thread pools without losing parent context","I want to see the full trace tree even when using asyncio, concurrent.futures, or other concurrency patterns"],"best_for":["developers building async LLM applications with asyncio","teams using thread pools or concurrent.futures for parallel LLM calls","organizations with complex concurrent workflows mixing sync and async code"],"limitations":["Context propagation requires Python 3.7+ contextvars support — older versions require manual context passing","Thread pool context propagation requires explicit context copying — automatic propagation not guaranteed","Asyncio task creation may lose context if not using context-aware task factories","Third-party async libraries (e.g., Celery, RQ) may not preserve OpenTelemetry context without custom integration"],"requires":["Python 3.8+ with contextvars support","Traceloop SDK initialized before async operations","Proper async/await usage or explicit context propagation for thread pools"],"input_types":["Async function calls and coroutines","Thread pool tasks and futures","Concurrent operation contexts"],"output_types":["OpenTelemetry spans with correct parent-child relationships","Trace trees showing concurrent operation hierarchy"],"categories":["automation-workflow","observability"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"openllmetry__cap_9","uri":"capability://data.processing.analysis.metrics.collection.for.token.usage.latency.and.cost.tracking","name":"metrics collection for token usage, latency, and cost tracking","description":"Collects OpenTelemetry metrics (histograms, counters, gauges) for LLM operations including token counts (input/output), request latency, error rates, and estimated costs. Implements metric exporters that aggregate metrics over time windows and export to observability backends, enabling dashboards and alerts based on LLM usage patterns and costs.","intents":["I want to track total tokens used across all LLM calls for cost management","I need to monitor request latency percentiles (p50, p95, p99) for performance optimization","I want to set up alerts when token usage or costs exceed thresholds"],"best_for":["organizations tracking LLM costs and usage budgets","teams monitoring LLM performance and latency SLOs","developers building cost dashboards and usage analytics"],"limitations":["Cost calculation requires provider-specific pricing data — not automatically updated with new pricing","Metrics aggregation happens at SDK level — distributed tracing across services requires backend-level aggregation","High-cardinality metrics (e.g., per-model, per-user) can cause cardinality explosion in backends","Real-time cost tracking requires synchronous metric export — async export introduces latency"],"requires":["Python 3.8+","OpenTelemetry metrics SDK (opentelemetry-api, opentelemetry-sdk)","Metric exporter configured for observability backend","Provider pricing data for cost calculation"],"input_types":["LLM API responses with token counts and latency","Provider pricing configuration","Custom metric definitions"],"output_types":["OpenTelemetry metrics (histograms, counters, gauges)","Aggregated metrics data (token counts, latency percentiles, costs)"],"categories":["data-processing-analysis","observability"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"openllmetry__headline","uri":"capability://data.processing.analysis.observability.framework.for.llm.applications","name":"observability framework for llm applications","description":"OpenLLMetry is an open-source observability framework designed specifically for Large Language Model applications, enabling automatic instrumentation and telemetry data capture for various AI frameworks and services.","intents":["best observability framework for LLMs","observability tools for AI applications","how to monitor LLM performance","automatic instrumentation for LangChain","OpenTelemetry solutions for AI"],"best_for":["developers working with LLMs","teams using OpenTelemetry"],"limitations":[],"requires":[],"input_types":[],"output_types":[],"categories":["data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":57,"verified":false,"data_access_risk":"high","permissions":["Python 3.8+","OpenTelemetry SDK (opentelemetry-api, opentelemetry-sdk)","Provider SDK installed (openai, anthropic, boto3, etc.)","Traceloop SDK initialized via Traceloop.init() at application startup","LangChain 0.0.200+ or LlamaIndex 0.8.0+","Traceloop SDK initialized before framework imports","Traceloop SDK with prompt tagging support","Manual prompt version management or external prompt system","OpenTelemetry SDK with span processor support","Custom Python code implementing SpanProcessor interface"],"failure_modes":["Streaming responses require additional configuration for proper span closure timing","Sensitive data (prompts, completions) captured by default — requires explicit privacy controls to redact","Instrumentation adds ~5-15ms overhead per LLM call due to span creation and serialization","Only supports Python 3.8+ — no JavaScript/TypeScript instrumentation in core SDK","Custom chain implementations require manual decorator usage if not using standard LangChain abstractions","Agent loop tracing depends on framework version compatibility — older LangChain versions may have incomplete coverage","Nested span depth can exceed backend limits (e.g., Datadog has 128-span depth limit) for deeply nested chains","Tool/function call arguments and results captured in full — requires privacy controls for sensitive data","Prompt versioning requires manual tagging or external prompt management system integration","No built-in A/B testing framework — requires manual analysis of prompt variants","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.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:04.693Z","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=openllmetry","compare_url":"https://unfragile.ai/compare?artifact=openllmetry"}},"signature":"dr2P4Sm0qCQsAOI4wGNntQ1AIEdnIuj9g2SPYzefQHm8vXEYuFGXHYexRi2R6eVjHW8HILYcyU0QfKpDz8ptDQ==","signedAt":"2026-06-20T14:28:30.510Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/openllmetry","artifact":"https://unfragile.ai/openllmetry","verify":"https://unfragile.ai/api/v1/verify?slug=openllmetry","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"}}