{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"pypi_pypi-triton-model-analyzer","slug":"pypi-triton-model-analyzer","name":"triton-model-analyzer","type":"cli","url":"https://pypi.org/project/triton-model-analyzer/","page_url":"https://unfragile.ai/pypi-triton-model-analyzer","categories":["deployment-infra"],"tags":["triton","tensorrt","inference","server","service","analyzer","nvidia"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"pypi_pypi-triton-model-analyzer__cap_0","uri":"capability://planning.reasoning.automated.model.configuration.search.with.constraint.optimization","name":"automated-model-configuration-search-with-constraint-optimization","description":"Systematically searches the configuration parameter space (batch sizes, instance groups, concurrency levels) using pluggable search strategies (brute-force, genetic algorithms, or automatic mode) to discover optimal Triton model deployments that maximize throughput while respecting user-defined latency and resource constraints. The Result Manager filters and ranks configurations against multi-objective criteria, enabling users to trade off performance metrics without manual trial-and-error.","intents":["Find the optimal batch size and instance count for my model to maximize throughput under a 100ms latency SLA","Discover configuration combinations that balance GPU memory usage against inference latency","Automatically test all viable parameter combinations and rank results by my custom performance objectives"],"best_for":["ML ops engineers deploying models to production Triton servers","teams optimizing inference costs by tuning batch sizes and concurrency","researchers benchmarking model performance across hardware configurations"],"limitations":["Search space explosion with >3 interdependent parameters; brute-force becomes impractical for large parameter grids","Genetic algorithm search adds ~10-30% overhead vs brute-force due to population management and fitness evaluation","Results are hardware-specific; configurations optimized on V100 may not transfer to A100 without re-profiling","No built-in support for dynamic batching optimization across multiple concurrent client streams"],"requires":["Triton Inference Server 2.0+ running locally, in Docker, or remotely accessible","Python 3.8+","Model files in Triton model repository format (TensorRT, ONNX, PyTorch, TensorFlow supported)","Perf Analyzer tool (bundled with Triton) for generating synthetic load"],"input_types":["YAML configuration files specifying parameter ranges and search strategy","CLI arguments for model path, batch size ranges, concurrency levels","Constraint definitions (max latency, max GPU memory, max CPU utilization)"],"output_types":["Ranked list of configurations with performance metrics (throughput, latency, GPU memory)","HTML/JSON reports with visualizations of Pareto-optimal configurations","Triton model configuration files (config.pbtxt) ready for deployment"],"categories":["planning-reasoning","optimization"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-triton-model-analyzer__cap_1","uri":"capability://data.processing.analysis.multi.model.concurrent.profiling.with.interference.analysis","name":"multi-model-concurrent-profiling-with-interference-analysis","description":"Profiles multiple models simultaneously on a single Triton server instance, measuring how resource contention (GPU memory, compute cores, memory bandwidth) affects individual model latency and throughput. The Metrics Manager collects per-model performance data while accounting for interference from co-located models, enabling users to understand deployment trade-offs when packing models onto shared hardware.","intents":["Measure how deploying model B alongside model A affects model A's latency SLA","Find the maximum number of models I can co-locate on a single GPU while meeting all latency constraints","Understand GPU memory fragmentation and scheduling overhead when running multiple models concurrently"],"best_for":["inference platform teams managing multi-tenant model serving","cost-optimization engineers maximizing GPU utilization across model portfolios","researchers studying resource contention in shared inference clusters"],"limitations":["Profiling time scales linearly with number of models; 10 models = ~10x longer profiling than single model","Interference patterns are workload-dependent; synthetic load from Perf Analyzer may not reflect real request distributions","No built-in model isolation (e.g., MPS, MIG) configuration; users must manually set up GPU partitioning","Results assume static model placement; dynamic load balancing and model migration not modeled"],"requires":["Triton Inference Server 2.0+ with multi-model support","Python 3.8+","Multiple model files in Triton repository","Sufficient GPU memory to load all models simultaneously"],"input_types":["YAML config specifying list of models and per-model parameter ranges","CLI flag: --multi-model or multi_model: true in config","Per-model constraints (latency SLA, max batch size)"],"output_types":["Per-model performance metrics (latency, throughput) under concurrent load","Interference matrix showing latency degradation for each model pair","Recommendations for model co-location based on constraint satisfaction"],"categories":["data-processing-analysis","performance-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-triton-model-analyzer__cap_10","uri":"capability://automation.workflow.kubernetes.deployment.integration.with.helm.charts","name":"kubernetes-deployment-integration-with-helm-charts","description":"Provides Helm charts and Kubernetes deployment manifests for running Model Analyzer as a Kubernetes Job or CronJob, enabling profiling workflows in containerized environments. The integration handles model repository mounting, Triton server coordination, and result persistence, allowing teams to schedule profiling jobs on Kubernetes clusters without manual orchestration.","intents":["Schedule a nightly profiling job on my Kubernetes cluster to re-optimize model configs","Deploy Model Analyzer as a sidecar to profile models in a multi-tenant Kubernetes environment","Integrate profiling results into a CI/CD pipeline that automatically updates model configurations"],"best_for":["teams running inference on Kubernetes clusters","ops teams automating profiling as part of model deployment pipelines","platforms offering managed model serving with automated optimization"],"limitations":["Kubernetes integration requires custom RBAC and PVC setup; not plug-and-play","Model repository must be accessible via shared storage (NFS, EBS); local model paths don't work","Profiling results must be persisted to shared storage; no built-in result aggregation across jobs","Helm charts assume specific Kubernetes versions; compatibility issues may arise with older clusters"],"requires":["Kubernetes 1.18+","Helm 3.0+","Persistent volume for model repository and results","Triton Inference Server running on the cluster (or accessible remotely)"],"input_types":["Helm values.yaml with cluster-specific configuration","Model repository path (mounted PVC)","Profiling configuration (YAML or ConfigMap)"],"output_types":["Kubernetes Job/CronJob manifests","Profiling results stored in persistent volume","Logs accessible via kubectl logs"],"categories":["automation-workflow","infrastructure-deployment"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-triton-model-analyzer__cap_11","uri":"capability://planning.reasoning.automatic.search.strategy.selection.based.on.model.type","name":"automatic-search-strategy-selection-based-on-model-type","description":"Implements an automatic mode in the Configuration System that selects the optimal search strategy (brute-force for simple models, genetic algorithm for complex ensembles) based on model type, parameter space size, and user constraints. This enables non-expert users to run profiling without manually choosing search algorithms.","intents":["Run profiling on my model without understanding search algorithms; let the tool pick the best strategy","Automatically switch from brute-force to genetic algorithm when my parameter space becomes too large","Get recommendations on search strategy efficiency and expected profiling time"],"best_for":["non-expert users unfamiliar with optimization algorithms","teams wanting consistent profiling workflows across diverse models","rapid prototyping scenarios where manual tuning is too slow"],"limitations":["Automatic strategy selection is heuristic-based; may not be optimal for unusual model types","No visibility into why a particular strategy was chosen; users cannot override automatic decisions easily","Genetic algorithm convergence is non-deterministic; results may vary across runs","Profiling time estimates are approximate; actual time depends on Triton server responsiveness"],"requires":["Python 3.8+","Model type information (single, ensemble, BLS, LLM) in configuration"],"input_types":["Model configuration (model_type, parameter ranges)","Optional: search_strategy: auto in YAML"],"output_types":["Selected search strategy (brute_force, genetic_algorithm, or other)","Estimated profiling time and search space size","Profiling results using selected strategy"],"categories":["planning-reasoning","automation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-triton-model-analyzer__cap_2","uri":"capability://planning.reasoning.ensemble.and.bls.model.configuration.optimization","name":"ensemble-and-bls-model-configuration-optimization","description":"Extends configuration search to ensemble models (multiple models chained via Triton's ensemble feature) and Business Logic Scripts (BLS), where performance depends on both individual model configs and inter-model communication overhead. The Model Manager orchestrates profiling of ensemble graphs, measuring end-to-end latency and identifying bottleneck stages, enabling optimization of complex multi-stage inference pipelines.","intents":["Optimize batch sizes for a 3-stage ensemble (preprocessing → inference → postprocessing) to minimize end-to-end latency","Find the optimal number of instances for each stage in a BLS pipeline to balance throughput","Identify which stage in my ensemble is the bottleneck and needs more resources"],"best_for":["teams deploying complex inference pipelines with multiple stages","researchers optimizing multi-model workflows (e.g., retrieval-augmented generation)","production systems requiring fine-grained control over ensemble stage allocation"],"limitations":["Ensemble profiling requires valid ensemble configuration files; invalid DAGs will fail silently or produce misleading results","BLS models require Python code; profiling cannot optimize BLS logic itself, only resource allocation","Inter-model communication overhead (queue latency, serialization) is measured but not decomposed per stage","No support for dynamic ensemble routing or conditional branching optimization"],"requires":["Triton Inference Server 2.0+ with ensemble support","Python 3.8+","Valid ensemble configuration files (config.pbtxt with ensemble_scheduling)","For BLS: Python 3.8+ and tritonpython backend installed"],"input_types":["YAML config with ensemble_model: true and list of constituent models","Ensemble configuration files defining DAG structure","Per-stage parameter ranges (batch sizes, instance counts)"],"output_types":["End-to-end latency breakdown by stage","Per-stage throughput and resource utilization metrics","Bottleneck identification and recommendations for stage-specific optimization"],"categories":["planning-reasoning","performance-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-triton-model-analyzer__cap_3","uri":"capability://automation.workflow.checkpoint.based.resumable.profiling.with.state.persistence","name":"checkpoint-based-resumable-profiling-with-state-persistence","description":"Implements a State Manager that periodically saves profiling progress to disk, enabling interrupted profiling sessions to resume from the last checkpoint rather than restarting from scratch. Checkpoints store completed configuration evaluations, search state, and metrics, allowing users to pause long-running profiling jobs and resume on different hardware or after server restarts.","intents":["Resume a 12-hour profiling job after the Triton server crashed without losing 10 hours of progress","Pause profiling on a development machine and resume on a production GPU cluster","Incrementally add new models to an existing profiling checkpoint and extend the search"],"best_for":["teams running long-duration profiling jobs (>1 hour) on unstable infrastructure","researchers iteratively refining model configurations across multiple profiling runs","production systems requiring non-disruptive profiling of large model portfolios"],"limitations":["Checkpoint format is version-specific; upgrading Model Analyzer may invalidate old checkpoints","Resuming requires the same Triton server version and model files; hardware changes may invalidate cached metrics","Checkpoint storage grows linearly with number of configurations tested; large searches can consume >1GB disk space","No built-in checkpoint versioning or branching; users cannot explore multiple search paths from a single checkpoint"],"requires":["Python 3.8+","Writable filesystem with >1GB free space for large profiling jobs","Same Triton server version and model files as the original profiling run"],"input_types":["Checkpoint file (binary format, stored in --output-model-repository or specified path)","CLI flag: --checkpoint-directory to specify checkpoint location"],"output_types":["Resumed profiling session with progress restored","Checkpoint file updated with new profiling results","Final report incorporating all completed configurations (original + resumed)"],"categories":["automation-workflow","state-management"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-triton-model-analyzer__cap_4","uri":"capability://data.processing.analysis.performance.metrics.collection.via.perf.analyzer.integration","name":"performance-metrics-collection-via-perf-analyzer-integration","description":"Integrates with Triton's Perf Analyzer tool to generate synthetic load and collect detailed performance metrics (latency percentiles, throughput, GPU memory, CPU utilization) for each configuration. The Metrics Manager orchestrates Perf Analyzer invocations with varying concurrency levels and batch sizes, aggregating results into a structured metrics database that feeds the Result Manager.","intents":["Measure p50, p95, p99 latency for each configuration to ensure tail latency meets SLAs","Collect GPU memory usage and GPU utilization metrics to understand resource efficiency","Generate synthetic load at varying concurrency levels to simulate production traffic patterns"],"best_for":["performance engineers validating inference latency and throughput","ops teams collecting metrics for capacity planning and cost analysis","researchers benchmarking model performance across configurations"],"limitations":["Perf Analyzer generates synthetic load; real-world request distributions (burstiness, request size variance) are not captured","Metrics collection adds 5-15 seconds per configuration due to Perf Analyzer warmup and stabilization","GPU memory metrics are sampled at fixed intervals; peak memory usage may be underestimated","No built-in support for custom metrics (e.g., model-specific inference accuracy); only standard Triton metrics collected"],"requires":["Perf Analyzer tool (bundled with Triton Inference Server 2.0+)","Python 3.8+","Triton server running and accessible (local, Docker, or remote)"],"input_types":["Configuration parameters (batch size, concurrency level, instance count)","Perf Analyzer flags (measurement window, warmup duration, request rate)"],"output_types":["Latency metrics: min, max, mean, p50, p95, p99 (in milliseconds)","Throughput: inferences/second","Resource metrics: GPU memory (MB), GPU utilization (%), CPU utilization (%)","Structured JSON/CSV with per-configuration metrics"],"categories":["data-processing-analysis","metrics-collection"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-triton-model-analyzer__cap_5","uri":"capability://data.processing.analysis.llm.model.profiling.with.token.generation.metrics","name":"llm-model-profiling-with-token-generation-metrics","description":"Extends profiling to Large Language Models (LLMs) where performance depends on input/output token counts and generation strategies (greedy, beam search). The Metrics Manager collects token-level metrics (tokens/second, time-to-first-token, generation latency) and accounts for variable-length outputs, enabling optimization of LLM serving configurations for throughput and latency under realistic token distributions.","intents":["Measure tokens/second throughput for my LLM at different batch sizes and sequence lengths","Optimize batch size to minimize time-to-first-token while maximizing overall throughput","Understand how input sequence length and output token count affect latency and resource usage"],"best_for":["teams deploying LLMs (GPT, Llama, etc.) on Triton for production inference","researchers optimizing LLM serving configurations for latency-sensitive applications","cost optimization engineers maximizing LLM throughput per GPU"],"limitations":["Token generation is inherently variable-length; profiling requires sampling across realistic token distributions","Time-to-first-token is sensitive to batch size and scheduling; synthetic load may not reflect real request patterns","Beam search and other generation strategies add non-linear overhead; profiling must test each strategy separately","No built-in support for speculative decoding or other advanced LLM optimization techniques"],"requires":["Triton Inference Server 2.0+ with LLM support (vLLM, TensorRT-LLM, or similar backend)","Python 3.8+","LLM model files in supported format (ONNX, TensorRT, etc.)","Tokenizer for the LLM to generate realistic token sequences"],"input_types":["LLM model configuration (model_type: llm in YAML)","Token distribution parameters (input length range, output length range)","Generation strategy (greedy, beam search, etc.)"],"output_types":["Tokens/second throughput metric","Time-to-first-token latency (milliseconds)","Token generation latency (milliseconds per token)","Per-configuration metrics accounting for variable-length outputs"],"categories":["data-processing-analysis","performance-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-triton-model-analyzer__cap_6","uri":"capability://tool.use.integration.triton.launch.mode.abstraction.with.multi.backend.support","name":"triton-launch-mode-abstraction-with-multi-backend-support","description":"Abstracts Triton server lifecycle management across four launch modes (local process, Docker container, remote server, C API) via a pluggable launcher interface. Users specify --triton-launch-mode to select the deployment target without changing profiling logic, enabling the same analysis workflow to work across development (local), staging (Docker), and production (remote) environments.","intents":["Profile models on my local machine during development, then run the same profiling on a remote production server","Launch Triton in Docker for isolated profiling without affecting system packages","Use Triton's C API for direct in-process profiling without network overhead"],"best_for":["development teams testing models locally before production deployment","ops teams profiling models across heterogeneous infrastructure (local, cloud, on-prem)","researchers comparing profiling results across different Triton deployment modes"],"limitations":["Docker mode requires Docker daemon running and sufficient disk space for image; adds 30-60 second startup overhead","Remote mode requires network connectivity and firewall rules; latency measurements include network overhead","C API mode requires Triton C++ libraries installed; not available on all platforms (Windows unsupported)","Results are not directly comparable across modes due to different overhead profiles (network latency, process isolation)"],"requires":["Python 3.8+","For local mode: Triton Inference Server 2.0+ installed locally","For Docker mode: Docker daemon running, Triton Docker image available","For remote mode: Network access to remote Triton server (gRPC port 8001 or HTTP port 8000)","For C API mode: Triton C++ libraries and headers installed"],"input_types":["CLI flag: --triton-launch-mode [local|docker|remote|c_api]","For Docker: --triton-docker-image to specify custom image","For remote: --triton-server-url to specify server address"],"output_types":["Profiling results (same format regardless of launch mode)","Server logs and diagnostics specific to launch mode"],"categories":["tool-use-integration","infrastructure-abstraction"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-triton-model-analyzer__cap_7","uri":"capability://data.processing.analysis.yaml.and.cli.configuration.parsing.with.defaults.and.validation","name":"yaml-and-cli-configuration-parsing-with-defaults-and-validation","description":"Implements a Configuration System that parses YAML config files and CLI arguments, merges them with sensible defaults, and validates parameter ranges and constraints. The system supports hierarchical config (global + per-model overrides) and generates human-readable error messages for invalid configurations, enabling users to specify complex profiling jobs declaratively.","intents":["Define a complex multi-model profiling job in YAML with per-model batch size ranges and constraints","Override specific parameters via CLI flags without editing the YAML file","Get clear error messages when my configuration has invalid parameter ranges or conflicting constraints"],"best_for":["ops teams managing profiling jobs via infrastructure-as-code (YAML configs in git)","developers prototyping profiling configurations iteratively","teams standardizing profiling workflows across models"],"limitations":["YAML syntax errors produce generic parsing errors; users must debug manually","No schema validation for custom constraints; invalid constraint definitions fail at runtime","CLI argument parsing is positional and order-dependent; complex configs are easier to specify in YAML","No support for config templating or variable substitution; large deployments require manual config duplication"],"requires":["Python 3.8+","PyYAML library (included in requirements.txt)"],"input_types":["YAML configuration file with model definitions, search parameters, constraints","CLI arguments (--model-repository, --batch-sizes, --concurrency-levels, etc.)","Environment variables for sensitive data (API keys, server URLs)"],"output_types":["Parsed configuration object (Python dict)","Validation errors with line numbers and suggestions","Effective configuration (merged YAML + CLI + defaults)"],"categories":["data-processing-analysis","configuration-management"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-triton-model-analyzer__cap_8","uri":"capability://planning.reasoning.result.ranking.and.filtering.with.multi.objective.optimization","name":"result-ranking-and-filtering-with-multi-objective-optimization","description":"Implements a Result Manager that ranks configurations against user-defined objectives (maximize throughput, minimize latency, minimize GPU memory) and filters by constraints (max latency, max memory). The system computes Pareto-optimal configurations and enables multi-dimensional sorting, helping users navigate trade-offs between competing metrics.","intents":["Find all configurations that meet my latency SLA and rank them by throughput","Identify Pareto-optimal configurations where no other config is better on all metrics","Filter results to show only configurations using <8GB GPU memory"],"best_for":["performance engineers making deployment trade-off decisions","ops teams selecting configurations that balance multiple objectives","researchers analyzing Pareto frontiers of model performance"],"limitations":["Pareto optimality is computed in 2D (throughput vs latency); higher-dimensional trade-offs are not visualized","Constraint satisfaction is binary; no support for soft constraints or weighted penalties","Ranking is deterministic but may not reflect user preferences; users must manually review results","No built-in support for cost-aware optimization (e.g., minimize cost per inference)"],"requires":["Python 3.8+","Completed profiling results with metrics for all configurations"],"input_types":["Objectives: list of metrics to optimize (throughput, latency, memory)","Constraints: max/min values for metrics","Sorting preferences: primary and secondary sort keys"],"output_types":["Ranked list of configurations meeting constraints","Pareto-optimal configurations (2D: throughput vs latency)","Filtered results based on constraint satisfaction"],"categories":["planning-reasoning","optimization"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-triton-model-analyzer__cap_9","uri":"capability://text.generation.language.html.and.json.report.generation.with.visualizations","name":"html-and-json-report-generation-with-visualizations","description":"Implements a Report Manager that generates human-readable HTML reports and machine-readable JSON summaries of profiling results. Reports include performance charts (throughput vs latency scatter plots, latency distributions), configuration recommendations, and bottleneck analysis, enabling stakeholders to understand profiling results without technical expertise.","intents":["Generate an HTML report showing throughput vs latency trade-offs for my manager's review","Export profiling results as JSON for integration with other tools (dashboards, cost calculators)","Create a summary report identifying the top 3 recommended configurations"],"best_for":["teams presenting profiling results to non-technical stakeholders","ops teams integrating profiling results into monitoring dashboards","researchers publishing benchmark results with visualizations"],"limitations":["HTML reports are static; no interactive filtering or drill-down capabilities","Visualizations are 2D (throughput vs latency); higher-dimensional analysis requires external tools","Report generation adds 10-30 seconds overhead for large result sets","No built-in support for custom report templates; users cannot customize layout or metrics"],"requires":["Python 3.8+","Completed profiling results with metrics"],"input_types":["Profiling results (configurations + metrics)","Report format preference (html, json, or both)","Optional: custom report title and metadata"],"output_types":["HTML report with embedded charts and tables","JSON file with structured results (configurations, metrics, recommendations)","CSV export for spreadsheet analysis"],"categories":["text-generation-language","reporting"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":33,"verified":false,"data_access_risk":"high","permissions":["Triton Inference Server 2.0+ running locally, in Docker, or remotely accessible","Python 3.8+","Model files in Triton model repository format (TensorRT, ONNX, PyTorch, TensorFlow supported)","Perf Analyzer tool (bundled with Triton) for generating synthetic load","Triton Inference Server 2.0+ with multi-model support","Multiple model files in Triton repository","Sufficient GPU memory to load all models simultaneously","Kubernetes 1.18+","Helm 3.0+","Persistent volume for model repository and results"],"failure_modes":["Search space explosion with >3 interdependent parameters; brute-force becomes impractical for large parameter grids","Genetic algorithm search adds ~10-30% overhead vs brute-force due to population management and fitness evaluation","Results are hardware-specific; configurations optimized on V100 may not transfer to A100 without re-profiling","No built-in support for dynamic batching optimization across multiple concurrent client streams","Profiling time scales linearly with number of models; 10 models = ~10x longer profiling than single model","Interference patterns are workload-dependent; synthetic load from Perf Analyzer may not reflect real request distributions","No built-in model isolation (e.g., MPS, MIG) configuration; users must manually set up GPU partitioning","Results assume static model placement; dynamic load balancing and model migration not modeled","Kubernetes integration requires custom RBAC and PVC setup; not plug-and-play","Model repository must be accessible via shared storage (NFS, EBS); local model paths don't work","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.05,"quality":0.49,"ecosystem":0.6000000000000001,"match_graph":0.25,"freshness":0.52,"weights":{"adoption":0.25,"quality":0.25,"ecosystem":0.1,"match_graph":0.28,"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-05-24T12:16:25.061Z","last_scraped_at":"2026-05-03T15:20:19.404Z","last_commit":null},"community":{"stars":null,"forks":null,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=pypi-triton-model-analyzer","compare_url":"https://unfragile.ai/compare?artifact=pypi-triton-model-analyzer"}},"signature":"m4CMN+zZ12RVcCtAH0Cice2WXKAaE5bB0WE29vpgyhhvMMljC20/+lHPF+inJ8azieZYyar3hDtYNQ9HAjvOCw==","signedAt":"2026-06-21T16:25:40.909Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/pypi-triton-model-analyzer","artifact":"https://unfragile.ai/pypi-triton-model-analyzer","verify":"https://unfragile.ai/api/v1/verify?slug=pypi-triton-model-analyzer","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"}}