{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"pypi_pypi-bentoml","slug":"pypi-bentoml","name":"bentoml","type":"framework","url":"https://pypi.org/project/bentoml/","page_url":"https://unfragile.ai/pypi-bentoml","categories":["deployment-infra"],"tags":["BentoML","Compound","AI","Systems","LLMOps","MLOps","Model","Deployment","Model","Inference","Model","Serving"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"pypi_pypi-bentoml__cap_0","uri":"capability://tool.use.integration.declarative.service.definition.with.python.decorators","name":"declarative-service-definition-with-python-decorators","description":"BentoML uses Python decorators (@bentoml.service) to declaratively define ML service endpoints with type hints and dependency injection. The framework parses decorator metadata to auto-generate OpenAPI schemas, request/response validation, and service routing without boilerplate. Services are defined as Python classes with methods decorated as endpoints, enabling IDE autocomplete and static type checking while maintaining runtime flexibility for model loading and inference logic.","intents":["Define a model serving endpoint with automatic request validation and OpenAPI documentation","Create multi-model services where different endpoints call different model instances","Expose async inference endpoints that handle concurrent requests without manual threading"],"best_for":["ML engineers building production inference services","Teams migrating from Flask/FastAPI to specialized ML serving frameworks","Organizations needing automatic API documentation and schema validation"],"limitations":["Decorator-based approach requires learning BentoML-specific patterns; not compatible with existing FastAPI/Flask codebases without refactoring","Type hints are parsed at runtime, adding ~50ms overhead during service startup for schema generation","Limited support for complex nested types — deeply nested Pydantic models may require manual serialization"],"requires":["Python 3.8+","bentoml package installed via pip","Type hints in service method signatures (recommended but not strictly required)"],"input_types":["Python objects with type hints","JSON payloads","multipart form data","binary data (images, audio)"],"output_types":["JSON","binary data","streaming responses","structured Python objects"],"categories":["tool-use-integration","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-bentoml__cap_1","uri":"capability://automation.workflow.model.artifact.packaging.and.versioning","name":"model-artifact-packaging-and-versioning","description":"BentoML packages trained models, preprocessors, and dependencies into immutable Bento artifacts with semantic versioning and content-addressed storage. Each Bento is a self-contained bundle containing the model binary, Python environment specification (via pip/conda), custom code, and metadata. The framework uses a local model store (by default ~/.bentoml) with tag-based retrieval, enabling reproducible deployments and easy model rollback without re-training.","intents":["Package a trained PyTorch/TensorFlow model with its exact Python dependencies for reproducible serving","Version multiple model iterations and easily switch between them in production","Share model artifacts across teams without exposing training code or raw model files"],"best_for":["ML teams with frequent model retraining cycles needing version control","Organizations deploying to multiple environments (dev/staging/prod) requiring consistent model versions","Teams using CI/CD pipelines where model artifacts must be immutable and traceable"],"limitations":["Model store is local filesystem-based by default; scaling to teams requires external artifact registry (S3, Docker Hub, or BentoCloud)","Large models (>10GB) can be slow to package and push; no built-in compression or delta-based updates","Dependency resolution uses pip/conda as-is; complex dependency conflicts require manual resolution before packaging"],"requires":["Python 3.8+","bentoml package","Trained model file (pickle, ONNX, SavedModel, etc.)","Optional: Docker for containerization, S3/artifact registry for remote storage"],"input_types":["Model files (PyTorch .pt, TensorFlow SavedModel, ONNX, scikit-learn pickle, etc.)","Python objects (custom preprocessors, feature transformers)","requirements.txt or environment.yml"],"output_types":["Bento artifact (directory structure)","Docker image","OCI container image"],"categories":["automation-workflow","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-bentoml__cap_10","uri":"capability://code.generation.editing.model.signature.inference.and.schema.generation","name":"model-signature-inference-and-schema-generation","description":"BentoML automatically infers model input/output signatures from type hints and generates OpenAPI schemas without manual specification. The framework inspects service method signatures, IODescriptor types, and model metadata to generate complete API documentation. Generated schemas include request/response examples, validation rules, and are served via /docs (Swagger UI) and /openapi.json endpoints.","intents":["Auto-generate API documentation without writing OpenAPI specs manually","Enable client code generation from service signatures","Validate requests against inferred schemas automatically"],"best_for":["Teams wanting automatic API documentation without manual OpenAPI specs","Organizations using API client generators (OpenAPI Generator, Swagger Codegen)","Services with complex input/output types requiring detailed schema documentation"],"limitations":["Schema inference relies on type hints; untyped code produces incomplete schemas","Complex nested types or custom classes may not generate accurate schemas without manual IODescriptor implementation","Generated schemas may not capture all validation rules (e.g., regex patterns, value ranges) without custom IODescriptor"],"requires":["bentoml package","Type hints in service method signatures","Optional: custom IODescriptor for complex types"],"input_types":["Service method signatures with type hints","IODescriptor definitions"],"output_types":["OpenAPI 3.0 schema (JSON)","Swagger UI documentation","Request/response examples"],"categories":["code-generation-editing","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-bentoml__cap_11","uri":"capability://automation.workflow.bentocloud.deployment.integration","name":"bentocloud-deployment-integration","description":"BentoML integrates with BentoCloud (managed hosting platform) for one-command deployment of Bento artifacts. The framework provides CLI commands (bentoml deploy) that package services, authenticate with BentoCloud, and deploy with automatic scaling, monitoring, and API endpoint provisioning. Deployments are tracked with version history, and rollback is supported via CLI commands.","intents":["Deploy a service to production without managing Kubernetes or cloud infrastructure","Enable automatic scaling based on request volume","Access managed monitoring, logging, and alerting for deployed services"],"best_for":["Teams without DevOps expertise wanting managed ML model serving","Startups and small teams avoiding infrastructure management overhead","Organizations needing quick time-to-market for ML services"],"limitations":["BentoCloud is a proprietary platform with vendor lock-in; services are tied to BentoCloud infrastructure","Pricing scales with compute usage; not cost-effective for high-volume inference compared to self-hosted Kubernetes","Limited customization of deployment environment (no custom networking, security policies, or compliance requirements)"],"requires":["bentoml package with BentoCloud integration","BentoCloud account and API token","Bento artifact created and saved locally"],"input_types":["Bento artifact (directory with service definition and models)","Deployment configuration (instance type, scaling policy, environment variables)"],"output_types":["Deployed service endpoint (HTTPS URL)","Deployment metadata (version, status, logs)","Scaling metrics (request count, latency)"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-bentoml__cap_12","uri":"capability://code.generation.editing.local.development.server.with.hot.reload","name":"local-development-server-with-hot-reload","description":"BentoML provides a local development server (bentoml serve) that runs services locally with automatic hot-reload on code changes. The server watches service files and reloads the service without restarting, enabling rapid iteration during development. The server exposes the same API endpoints, health checks, and metrics as production deployments, enabling local testing before containerization.","intents":["Develop and test services locally with automatic reload on code changes","Debug service behavior before deploying to production","Test API endpoints locally using Swagger UI"],"best_for":["ML engineers developing services locally","Teams iterating on model serving code","Developers testing API changes before deployment"],"limitations":["Hot-reload may not work correctly for all code changes (e.g., model loading logic); full restart may be required","Local server performance may differ from production (single-process, no batching optimization)","Large models may take time to load on startup, slowing development iteration"],"requires":["bentoml package","Python 3.8+","Service definition file (service.py or similar)"],"input_types":["Service code (Python files)","Model artifacts (local or remote)"],"output_types":["Running service (HTTP server on localhost)","API documentation (Swagger UI)","Logs and debug output"],"categories":["code-generation-editing","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-bentoml__cap_13","uri":"capability://automation.workflow.dependency.management.with.environment.specification","name":"dependency-management-with-environment-specification","description":"BentoML captures Python dependencies (via pip or conda) in the Bento artifact and automatically includes them in generated Docker images. Dependencies are specified in requirements.txt or environment.yml and are resolved during Bento creation. The framework validates that all imports in service code are declared as dependencies, preventing runtime import errors in production.","intents":["Ensure all Python dependencies are captured and reproducible across environments","Automatically include dependencies in Docker images without manual Dockerfile editing","Detect missing dependencies before deployment"],"best_for":["Teams deploying to multiple environments requiring consistent dependencies","Organizations with strict reproducibility requirements","Services with complex dependency graphs (many packages, version constraints)"],"limitations":["Dependency resolution uses pip/conda as-is; complex conflicts require manual resolution","No built-in support for system-level dependencies (e.g., CUDA, system libraries); requires custom Dockerfile","Dependency validation is basic; missing dependencies may not be detected if imports are conditional or dynamic"],"requires":["bentoml package","requirements.txt or environment.yml with all dependencies","Python 3.8+"],"input_types":["requirements.txt (pip format)","environment.yml (conda format)","Service code (for import validation)"],"output_types":["Dependency list in Bento artifact","Docker image with dependencies installed","Validation report (missing dependencies, version conflicts)"],"categories":["automation-workflow","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-bentoml__cap_2","uri":"capability://automation.workflow.automatic.containerization.and.docker.generation","name":"automatic-containerization-and-docker-generation","description":"BentoML automatically generates Dockerfiles and builds OCI-compliant container images from Bento artifacts without manual Docker configuration. The framework introspects the service definition, dependencies, and model artifacts to create optimized multi-stage Dockerfiles with minimal image size. Generated images include the BentoML runtime, service code, model binaries, and all dependencies, ready for deployment to Kubernetes, Docker Swarm, or cloud platforms.","intents":["Convert a Python service definition into a production-ready Docker image without writing Dockerfile","Deploy the same service to multiple cloud platforms (AWS, GCP, Azure) with consistent containerization","Reduce Docker image size by automatically excluding unused dependencies and using multi-stage builds"],"best_for":["ML teams unfamiliar with Docker wanting to containerize services quickly","Organizations with CI/CD pipelines requiring automated image building and registry pushes","Teams deploying to Kubernetes needing consistent, reproducible container images"],"limitations":["Generated Dockerfiles are optimized for BentoML services; custom Docker features (health checks, signal handling) require manual Dockerfile editing","Image size can be large for models with heavy dependencies (PyTorch, TensorFlow); no built-in image optimization beyond multi-stage builds","GPU support requires manual configuration of base images and CUDA dependencies; not automatically detected"],"requires":["Docker daemon running","bentoml package with Docker support","Bento artifact created and saved locally","Optional: Docker registry credentials for pushing images"],"input_types":["Bento artifact (directory with service definition and models)","Optional: custom Dockerfile template for overrides"],"output_types":["Dockerfile (generated)","OCI container image (built locally or pushed to registry)","Image metadata (tags, digests)"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-bentoml__cap_3","uri":"capability://automation.workflow.adaptive.batching.for.inference.optimization","name":"adaptive-batching-for-inference-optimization","description":"BentoML implements server-side request batching that automatically groups incoming inference requests and processes them together to maximize GPU/CPU utilization. The framework uses configurable batch windows (time-based or size-based) to accumulate requests before invoking the model, reducing per-request overhead and improving throughput. Batching is transparent to the client — individual requests are queued, batched, and responses are returned asynchronously without client-side coordination.","intents":["Increase inference throughput by batching multiple requests together on GPU","Reduce latency variance by processing requests in optimal batch sizes for the model","Maximize hardware utilization without requiring clients to implement batching logic"],"best_for":["Services with high request volume (>100 req/s) where batching significantly improves throughput","GPU-based inference where batch processing provides 2-10x throughput improvement","Applications where slight latency increase (10-100ms) is acceptable for higher throughput"],"limitations":["Batching adds latency (configurable 10-500ms per batch window); not suitable for ultra-low-latency requirements (<10ms)","Batch size must be tuned per model; suboptimal batching can reduce throughput or increase memory usage","Stateful models or models with request-specific side effects may not be compatible with transparent batching"],"requires":["bentoml package with batching support","Service method decorated with @bentoml.api with batch configuration","Model that supports variable batch sizes (most modern frameworks do)"],"input_types":["Individual inference requests (JSON, binary, etc.)","Batch configuration parameters (batch_size, batch_wait_timeout_ms)"],"output_types":["Individual responses (one per request, in order)","Batch processing metrics (batch size, latency)"],"categories":["automation-workflow","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-bentoml__cap_4","uri":"capability://planning.reasoning.multi.model.composition.and.pipeline.orchestration","name":"multi-model-composition-and-pipeline-orchestration","description":"BentoML enables defining services with multiple models and composing them into inference pipelines where outputs from one model feed into another. Services can declare multiple model dependencies, load them with different configurations, and orchestrate their execution through explicit method calls or implicit dependency injection. The framework handles model lifecycle (loading, caching, unloading) and enables conditional routing (e.g., route to model A or B based on input features) without external orchestration tools.","intents":["Build an ensemble service that combines predictions from multiple models (e.g., voting, averaging)","Create a multi-stage pipeline where a classifier routes inputs to specialized models","Serve multiple model versions simultaneously for A/B testing or gradual rollout"],"best_for":["Teams building ensemble models or multi-stage inference pipelines","Organizations running A/B tests requiring multiple model versions in parallel","Services with conditional logic based on input features or model outputs"],"limitations":["Pipeline orchestration is imperative (explicit method calls); no declarative DAG definition like Airflow or Kubeflow","No built-in fault tolerance — if one model fails, the entire request fails (requires manual error handling)","Debugging multi-model pipelines requires manual logging; no built-in tracing or observability"],"requires":["bentoml package","Multiple trained models packaged as Bento artifacts","Service class with methods for each model and orchestration logic"],"input_types":["Input features (JSON, numpy arrays, etc.)","Model selection parameters (for routing)"],"output_types":["Ensemble predictions (averaged, voted, or combined)","Pipeline execution metadata (which models were called, latencies)"],"categories":["planning-reasoning","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-bentoml__cap_5","uri":"capability://tool.use.integration.framework.agnostic.model.loading.with.custom.runners","name":"framework-agnostic-model-loading-with-custom-runners","description":"BentoML abstracts model loading through a Runner abstraction that supports any ML framework (PyTorch, TensorFlow, scikit-learn, XGBoost, ONNX, custom Python code) without framework-specific code in the service definition. Runners are initialized with model artifacts and expose a predict() interface; the framework handles model lifecycle (lazy loading, GPU memory management, multi-process execution). Custom runners can be implemented for proprietary models or non-standard inference logic by subclassing bentoml.Runner.","intents":["Load and serve models from any ML framework without rewriting service code","Switch between model frameworks (e.g., PyTorch to ONNX) without changing the service definition","Implement custom inference logic (e.g., preprocessing, post-processing) as a Runner"],"best_for":["Organizations with heterogeneous model stacks (multiple frameworks)","Teams migrating models between frameworks (PyTorch → ONNX → TensorRT)","Services requiring custom inference logic beyond standard model.predict() calls"],"limitations":["Runner abstraction adds ~5-10ms overhead per inference call due to serialization/deserialization","Custom runners require understanding BentoML's Runner API; not suitable for users unfamiliar with the framework","Framework-specific optimizations (e.g., TensorFlow's graph optimization) may not be fully leveraged through the Runner abstraction"],"requires":["bentoml package","Model file compatible with supported framework (PyTorch, TensorFlow, ONNX, etc.)","Optional: custom Runner implementation for non-standard models"],"input_types":["Model files (any supported format)","Model configuration (framework, input/output shapes, etc.)"],"output_types":["Predictions (numpy arrays, tensors, or custom Python objects)","Runner metadata (framework, model size, latency)"],"categories":["tool-use-integration","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-bentoml__cap_6","uri":"capability://data.processing.analysis.request.response.serialization.with.custom.io.descriptors","name":"request-response-serialization-with-custom-io-descriptors","description":"BentoML uses IODescriptor classes to define how requests and responses are serialized/deserialized (JSON, binary, images, numpy arrays, pandas DataFrames, etc.). Descriptors are attached to service methods via type hints and automatically handle content-type negotiation, validation, and conversion. Custom IODescriptors can be implemented for domain-specific formats (e.g., medical imaging DICOM, audio WAV) by subclassing bentoml.io.IODescriptor.","intents":["Accept image uploads and automatically deserialize them to numpy arrays for model inference","Return predictions as JSON with automatic schema validation","Support multiple input formats (JSON, CSV, binary) for the same endpoint"],"best_for":["Services handling diverse input types (images, audio, structured data)","Teams needing automatic content-type negotiation and validation","Applications with domain-specific serialization requirements"],"limitations":["IODescriptor overhead adds ~10-20ms per request for serialization/deserialization; not suitable for ultra-high-throughput scenarios","Custom IODescriptors require understanding BentoML's serialization API; limited documentation for advanced use cases","Large binary payloads (>100MB) may cause memory issues; no built-in streaming support for large files"],"requires":["bentoml package","Type hints in service method signatures","Optional: custom IODescriptor for non-standard formats"],"input_types":["JSON","binary data","images (PNG, JPEG, etc.)","numpy arrays","pandas DataFrames","custom formats via IODescriptor"],"output_types":["JSON","binary data","images","numpy arrays","pandas DataFrames","custom formats"],"categories":["data-processing-analysis","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-bentoml__cap_7","uri":"capability://automation.workflow.distributed.inference.with.multi.process.runners","name":"distributed-inference-with-multi-process-runners","description":"BentoML supports multi-process runners that distribute inference across multiple worker processes, enabling true parallelism on multi-core CPUs and avoiding Python GIL limitations. Runners can be configured with a process pool, and requests are automatically distributed across workers. The framework handles inter-process communication, request queuing, and response aggregation transparently, enabling horizontal scaling within a single container.","intents":["Parallelize CPU-bound inference across multiple cores without GIL contention","Increase throughput for CPU-only models by distributing requests across worker processes","Scale inference within a single container before adding more replicas"],"best_for":["CPU-bound inference services (scikit-learn, XGBoost, traditional ML models)","Multi-core systems where GIL contention limits throughput","Services where adding container replicas is expensive (cost, latency)"],"limitations":["Multi-process overhead (IPC, serialization) adds ~5-20ms per request; not beneficial for very fast models (<1ms)","Memory usage scales with number of workers (each process loads the full model); not suitable for memory-constrained environments","Debugging multi-process services is complex; errors in worker processes may not propagate clearly to the main process"],"requires":["bentoml package with multi-process support","Multi-core CPU","Runner configuration with process_count parameter"],"input_types":["Inference requests (any format supported by IODescriptors)"],"output_types":["Predictions (same format as single-process)","Worker utilization metrics"],"categories":["automation-workflow","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-bentoml__cap_8","uri":"capability://automation.workflow.health.checks.and.readiness.probes.for.orchestration","name":"health-checks-and-readiness-probes-for-orchestration","description":"BentoML services expose standard health check endpoints (/healthz, /readyz) compatible with Kubernetes liveness and readiness probes. Health checks verify that the service is running and models are loaded; readiness probes confirm the service is ready to accept traffic. Custom health check logic can be implemented by overriding the health_check() method, enabling checks for external dependencies (database, cache, API availability).","intents":["Enable Kubernetes to automatically restart unhealthy service instances","Prevent traffic routing to services that are still loading models","Monitor service health and alert on failures"],"best_for":["Services deployed to Kubernetes requiring liveness/readiness probes","Organizations with health monitoring and alerting systems","Services with external dependencies requiring custom health checks"],"limitations":["Health checks add ~10-50ms latency per check; frequent checks can impact performance","Custom health checks require manual implementation; no built-in checks for common dependencies","Health check failures may cause cascading restarts if not tuned correctly (probe timeout, failure threshold)"],"requires":["bentoml package","Kubernetes or container orchestration platform (optional but recommended)","Optional: custom health check implementation"],"input_types":["Health check configuration (probe interval, timeout, failure threshold)"],"output_types":["HTTP 200 (healthy) or 503 (unhealthy)","Health check metadata (model load status, dependency status)"],"categories":["automation-workflow","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-bentoml__cap_9","uri":"capability://safety.moderation.metrics.collection.and.prometheus.export","name":"metrics-collection-and-prometheus-export","description":"BentoML automatically collects inference metrics (request count, latency, error rate) and exports them in Prometheus format via a /metrics endpoint. Metrics are collected per endpoint and can be scraped by Prometheus or other monitoring systems. Custom metrics can be added by instrumenting service code with bentoml.metrics APIs, enabling tracking of business metrics (e.g., model confidence, prediction distribution) alongside infrastructure metrics.","intents":["Monitor inference latency and error rates in production","Set up alerts for performance degradation or increased error rates","Track custom metrics (e.g., model confidence, prediction distribution) for model monitoring"],"best_for":["Organizations with Prometheus/Grafana monitoring stacks","Teams needing observability into model performance and inference metrics","Services requiring SLA monitoring and alerting"],"limitations":["Metrics collection adds ~1-5% overhead to inference latency","Cardinality explosion if metrics are tagged with high-cardinality labels (e.g., user IDs); requires careful metric design","No built-in support for distributed tracing (e.g., Jaeger); requires separate instrumentation"],"requires":["bentoml package with metrics support","Prometheus or compatible monitoring system (optional but recommended)","Optional: custom metric instrumentation in service code"],"input_types":["Inference requests (automatically tracked)","Custom metric values (via bentoml.metrics API)"],"output_types":["Prometheus metrics (text format)","Metric data (request count, latency, error rate, custom metrics)"],"categories":["safety-moderation","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":29,"verified":false,"data_access_risk":"high","permissions":["Python 3.8+","bentoml package installed via pip","Type hints in service method signatures (recommended but not strictly required)","bentoml package","Trained model file (pickle, ONNX, SavedModel, etc.)","Optional: Docker for containerization, S3/artifact registry for remote storage","Type hints in service method signatures","Optional: custom IODescriptor for complex types","bentoml package with BentoCloud integration","BentoCloud account and API token"],"failure_modes":["Decorator-based approach requires learning BentoML-specific patterns; not compatible with existing FastAPI/Flask codebases without refactoring","Type hints are parsed at runtime, adding ~50ms overhead during service startup for schema generation","Limited support for complex nested types — deeply nested Pydantic models may require manual serialization","Model store is local filesystem-based by default; scaling to teams requires external artifact registry (S3, Docker Hub, or BentoCloud)","Large models (>10GB) can be slow to package and push; no built-in compression or delta-based updates","Dependency resolution uses pip/conda as-is; complex dependency conflicts require manual resolution before packaging","Schema inference relies on type hints; untyped code produces incomplete schemas","Complex nested types or custom classes may not generate accurate schemas without manual IODescriptor implementation","Generated schemas may not capture all validation rules (e.g., regex patterns, value ranges) without custom IODescriptor","BentoCloud is a proprietary platform with vendor lock-in; services are tied to BentoCloud infrastructure","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.05,"quality":0.35,"ecosystem":0.6000000000000001,"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-05-24T12:16:25.060Z","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-bentoml","compare_url":"https://unfragile.ai/compare?artifact=pypi-bentoml"}},"signature":"2GguOLvj+AKI27feq57MPTp0Fc/tCT/im3xqXvmPy46p0I/AmxYdKdopFurSjZ8CYwjJCxMwMK4orp7islbDCw==","signedAt":"2026-06-20T01:39:37.604Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/pypi-bentoml","artifact":"https://unfragile.ai/pypi-bentoml","verify":"https://unfragile.ai/api/v1/verify?slug=pypi-bentoml","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"}}