Enum Commands 

pub enum Commands {
    Model {
        action: ModelCommands,
    },
    Generate {

        prompt: Option<String>,
        model: String,
        model_path: Option<String>,
        max_tokens: usize,
        temperature: f32,
        top_k: Option<usize>,
        top_p: Option<f32>,
        min_p: Option<f32>,
        repetition_penalty: f32,
        greedy: bool,
        gpu: bool,
        no_stream: bool,
        quiet: bool,
    
},
    Summarize {
        input: Option<String>,
        model: String,
        model_path: Option<String>,
        min_length: Option<usize>,
        max_length: Option<usize>,
        num_beams: Option<usize>,
        length_penalty: Option<f32>,
        no_repeat_ngram: Option<usize>,
        greedy: bool,
        no_stream: bool,
        gpu: bool,
        quiet: bool,
    },
    Translate {

        input: Option<String>,
        model: String,
        model_path: Option<String>,
        src: Option<String>,
        dst: Option<String>,
        max_length: Option<usize>,
        num_beams: Option<usize>,
        length_penalty: Option<f32>,
        no_repeat_ngram: Option<usize>,
        greedy: bool,
        no_stream: bool,
        gpu: bool,
        quiet: bool,
    
},
    Inspect {
        path: String,
    },
    Embed {
        input: Option<String>,
        model: String,
        model_path: Option<String>,
        format: String,
        normalize: bool,
        pooling: String,
        gpu: bool,
        quiet: bool,
    },
    Transcribe {
        file: String,
        model: String,
        model_path: Option<String>,
        language: Option<String>,
        translate: bool,
        timestamps: bool,
        max_tokens: Option<usize>,
        no_stream: bool,
        gpu: bool,
        quiet: bool,
    },
    Classify {

        input: Vec<String>,
        model: String,
        model_path: Option<String>,
        labels: Option<String>,
        top_k: usize,
        threshold: Option<f32>,
        max_length: Option<usize>,
        batch_size: Option<usize>,
        multi_label: bool,
        format: String,
        gpu: bool,
        dtype: Option<String>,
        quiet: bool,
    
},
    Rerank {
        query: String,
        documents: Vec<String>,
        model: String,
        model_path: Option<String>,
        top_k: Option<usize>,
        format: String,
        gpu: bool,
        quiet: bool,
    },
    Chat {
        model: String,
        model_path: Option<String>,
        system: Option<String>,
        temperature: f32,
        max_tokens: usize,
        gpu: bool,
        quiet: bool,
    },
    Index {
        action: IndexCommands,
    },
    Search {
        index_path: String,
        query: String,
        top_k: usize,
        mode: String,
        model: String,
        rerank_model: Option<String>,
        format: String,
        gpu: bool,
        quiet: bool,
    },
    Similarity {
        text1: String,
        text2: String,
        model: String,
        gpu: bool,
        quiet: bool,
    },
}

Variants

Model

Manage models (list, download, info)

Fields

action: ModelCommands

Generate

Generate text from a prompt

Fields

prompt: Option<String>

The prompt (or file path, or stdin if not provided)

model: String

model_path: Option<String>

Load weights from a local file or directory instead of the registry

max_tokens: usize

Maximum tokens to generate

temperature: f32

Sampling temperature (0.0 = greedy, higher = more random)

top_k: Option<usize>

Top-K sampling (limits to K most likely tokens)

top_p: Option<f32>

Top-P (nucleus) sampling threshold

min_p: Option<f32>

Min-P sampling threshold

repetition_penalty: f32

Repetition penalty (1.0 = no penalty)

greedy: bool

Use greedy decoding (ignores temperature)

gpu: bool

Use GPU

no_stream: bool

Disable streaming output

quiet: bool

Suppress status messages

Summarize

Summarize text

Fields

input: Option<String>

Input text (or read from stdin)

model: String

Model to use

model_path: Option<String>

Path to local model Load weights from a local file or directory instead of the registry

min_length: Option<usize>

Minimum summary length

max_length: Option<usize>

Maximum summary length

num_beams: Option<usize>

Number of beams for beam search

length_penalty: Option<f32>

Length penalty for beam search (< 1 shorter, > 1 longer)

no_repeat_ngram: Option<usize>

Block repeated n-grams of this size

greedy: bool

Use greedy decoding (deterministic, fastest)

no_stream: bool

Disable streaming output

gpu: bool

Use GPU

quiet: bool

Suppress progress messages

Translate

Translate text between languages

Fields

input: Option<String>

Input text (or read from stdin)

model: String

Model to use

model_path: Option<String>

Path to local model Load weights from a local file or directory instead of the registry

src: Option<String>

Source language (e.g., en, de, fr)

dst: Option<String>

Target language (e.g., en, de, fr)

max_length: Option<usize>

Maximum output length

num_beams: Option<usize>

Number of beams for beam search

length_penalty: Option<f32>

Length penalty for beam search (< 1 shorter, > 1 longer)

no_repeat_ngram: Option<usize>

Block repeated n-grams of this size

greedy: bool

Use greedy decoding (deterministic, fastest)

no_stream: bool

Disable streaming output

gpu: bool

Use GPU

quiet: bool

Suppress progress messages

Inspect

Show a model’s metadata, config and tensor layout

Fields

path: String

Path to a .gguf, a .safetensors directory, or a name in ~/.cache/kjarni

Embed

Generate embeddings for text

Fields

input: Option<String>

Input text, file path, or stdin if not provided

model: String

Embedding model

model_path: Option<String>

Load weights from a local file or directory instead of the registry

format: String

Output format: raw, json

normalize: bool

Scale each vector to unit length

pooling: String

Pooling strategy: mean, cls, max

Mean matches what sentence-transformers does for these models, and what the library bindings and presets already default to. Pooling changes the vector itself, so a different choice here does not produce a slightly different answer, it produces one that cannot be compared against the others.

gpu: bool

Run on the GPU

quiet: bool

Suppress status messages

Transcribe

Transcribe audio to text

Fields

file: String

Path to audio file (wav, mp3, flac, ogg)

model: String

Model to use (whisper-small, whisper-large-v3)

model_path: Option<String>

Path to local model directory (not yet implemented) Load weights from a local file or directory instead of the registry

language: Option<String>

Language code (e.g., en, fr, de). Omit for auto-detect.

translate: bool

Translate to English instead of transcribing

timestamps: bool

Include timestamps in output

max_tokens: Option<usize>

Maximum tokens per 30-second chunk

no_stream: bool

Disable streaming (wait for full result)

gpu: bool

Use GPU acceleration

quiet: bool

Suppress progress output

Classify

Classify text using a classification model

Fields

input: Vec<String>

Input text(s) to classify. Use - for stdin.

model: String

Model name from registry

model_path: Option<String>

Load model from local path instead of registry

labels: Option<String>

Custom labels (comma-separated, order must match model output) Example: –labels “negative,positive” or –labels “neikvætt,jákvætt”

top_k: usize

Return top K predictions

threshold: Option<f32>

Minimum confidence threshold (0.0-1.0)

max_length: Option<usize>

Maximum sequence length (truncates longer inputs)

batch_size: Option<usize>

Batch size for inference

multi_label: bool

Use multi-label classification (sigmoid instead of softmax)

format: String

Output format: json, jsonl, text

gpu: bool

Run on GPU

dtype: Option<String>

Model precision: f32, f16, bf16

quiet: bool

Suppress progress output

Rerank

Rerank documents by relevance to a query

Fields

query: String

The query to rank against

documents: Vec<String>

Documents to rerank (or read from stdin, one per line)

model: String

model_path: Option<String>

Load weights from a local file or directory instead of the registry

top_k: Option<usize>

Return only top K results

format: String

Output format: json, jsonl, text, docs

gpu: bool

Run on the GPU

quiet: bool

Suppress progress output

Chat

Interactive chat mode

Fields

model: String

model_path: Option<String>

Load weights from a local file or directory instead of the registry

system: Option<String>

System prompt to set assistant behavior

temperature: f32

Sampling temperature

max_tokens: usize

Max tokens per response

gpu: bool

Run on the GPU

quiet: bool

Suppress progress output

Index

Create or manage search indexes

Fields

action: IndexCommands

Search

Search an index

Fields

index_path: String

Path to the index file

query: String

Search query

top_k: usize

Number of results to return

mode: String

Search mode: hybrid, semantic, keyword

model: String

Encoder model for semantic search

rerank_model: Option<String>

Reranking model (optional) Use a cross-encoder model to rerank initial results Example: –rerank-model “ms-marco-minilm”

format: String

Output format: json, jsonl, text

gpu: bool

Run on the GPU

quiet: bool

Suppress progress output

Similarity

Compute similarity between two texts

Fields

text1: String

First text (or file path)

text2: String

Second text (or file path)

model: String

Encoder model

gpu: bool

Run on the GPU

quiet: bool

Suppress progress output

Trait Implementations

impl Debug for Commands

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

Formats the value using the given formatter.

impl FromArgMatches for Commands

fn from_arg_matches(__clap_arg_matches: &ArgMatches) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn from_arg_matches_mut( __clap_arg_matches: &mut ArgMatches, ) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn update_from_arg_matches( &mut self, __clap_arg_matches: &ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

fn update_from_arg_matches_mut<'b>( &mut self, __clap_arg_matches: &mut ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

impl PartialEq for Commands

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Commands

impl Subcommand for Commands

fn augment_subcommands<'b>(__clap_app: Command) -> Command

Append to Command so it can instantiate Self via FromArgMatches::from_arg_matches_mut

fn augment_subcommands_for_update<'b>(__clap_app: Command) -> Command

Append to Command so it can instantiate self via FromArgMatches::update_from_arg_matches_mut

fn has_subcommand(__clap_name: &str) -> bool

Test whether Self can parse a specific subcommand