Struct ModelManifest 

pub struct ModelManifest {

    pub model_id: String,
    pub name: String,
    pub model_type: ModelType,
    pub format: ModelFormat,
    pub version: String,
    pub quantization: Quantization,
    pub size_bytes: u64,
    pub sha256: String,
    pub blob_hash: Option<String>,
    pub download_url: Option<String>,
    pub requirements: HardwareRequirements,
    pub features: Vec<String>,
    pub params_billions: Option<f32>,
    pub context_length: Option<u32>,
    pub classes: Option<Vec<String>>,
    pub license: String,
    pub source: String,
    pub created_at: DateTime<Utc>,
    pub metadata: HashMap<String, Value>,
}

Model manifest containing all metadata for distribution

This is the primary type for announcing and distributing models across Peat.

Fields

model_id: String

Unique model identifier (e.g., “ministral-3b-q4km”)

name: String

Human-readable name

model_type: ModelType

Model type (detector, LLM, etc.)

format: ModelFormat

Model file format

version: String

Version string (semver or date-based)

quantization: Quantization

Quantization level

size_bytes: u64

Model size in bytes

sha256: String

SHA-256 hash for verification

blob_hash: Option<String>

iroh-blobs content hash (for P2P distribution)

download_url: Option<String>

Direct download URL (fallback if P2P unavailable)

requirements: HardwareRequirements

Hardware requirements

features: Vec<String>

Model capabilities/features (e.g., “chat”, “vision”, “function_calling”)

params_billions: Option<f32>

Number of parameters in billions

context_length: Option<u32>

Context length in tokens (for LLMs)

classes: Option<Vec<String>>

Supported classes (for detectors)

license: String

License identifier (SPDX format)

source: String

Source/attribution

created_at: DateTime<Utc>

When this manifest was created

metadata: HashMap<String, Value>

Additional metadata

Implementations

impl ModelManifest

pub fn new( model_id: impl Into<String>, name: impl Into<String>, model_type: ModelType, ) -> Self

Create a new model manifest

pub fn ministral_3b(quantization: Quantization) -> Self

Create manifest for Ministral 3B

pub fn ministral_8b(quantization: Quantization) -> Self

Create manifest for Ministral 8B

pub fn yolov8n() -> Self

Create manifest for YOLOv8n

pub fn with_version(self, version: impl Into<String>) -> Self

pub fn with_format(self, format: ModelFormat) -> Self

pub fn with_quantization(self, quantization: Quantization) -> Self

pub fn with_size_bytes(self, size: u64) -> Self

pub fn with_sha256(self, hash: impl Into<String>) -> Self

pub fn with_blob_hash(self, hash: impl Into<String>) -> Self

pub fn with_download_url(self, url: impl Into<String>) -> Self

pub fn with_requirements(self, requirements: HardwareRequirements) -> Self

pub fn with_feature(self, feature: impl Into<String>) -> Self

pub fn with_params(self, billions: f32) -> Self

pub fn with_context_length(self, length: u32) -> Self

pub fn with_classes(self, classes: Vec<String>) -> Self

pub fn with_license(self, license: impl Into<String>) -> Self

pub fn with_source(self, source: impl Into<String>) -> Self

pub fn with_metadata(self, key: impl Into<String>, value: Value) -> Self

pub fn estimated_vram_mb(&self) -> u32

Get estimated VRAM usage in MB based on parameters and quantization

pub fn filename(&self) -> String

Generate a filename for this model

pub fn can_run_on(&self, vram_mb: u32, ram_mb: u32, arch: &str) -> bool

Check if this model can run on given hardware

Trait Implementations

impl Clone for ModelManifest

fn clone(&self) -> ModelManifest

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ModelManifest

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ModelManifest

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ModelManifest

fn eq(&self, other: &ModelManifest) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ModelManifest

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ModelManifest