ollama-vision 0.2.0

Robust Ollama vision model toolkit for image tagging and captioning
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

use serde::{Deserialize, Serialize};
use std::time::Duration;

/// Configuration for the Ollama vision client.
#[derive(Debug, Clone)]
pub struct OllamaVisionConfig {
    /// Ollama API endpoint (e.g., "http://localhost:11434")
    pub endpoint: String,
    /// Vision model name (e.g., "llava", "llava-llama3", "minicpm-v")
    pub model: String,
    /// Request timeout (default: 120s)
    pub timeout: Duration,
    /// TCP connection timeout (default: 10s)
    pub connect_timeout: Duration,
    /// Generation options sent to Ollama
    pub options: GenerateOptions,
}

/// Ollama generation options controlling output quality.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GenerateOptions {
    /// Maximum tokens to generate
    pub num_predict: u32,
    /// Penalize repeated tokens (default: 1.2)
    pub repeat_penalty: f32,
    /// Window for repeat penalty (default: 128)
    pub repeat_last_n: u32,
    /// Temperature (default: None, uses Ollama default)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub temperature: Option<f32>,
    /// Top-p sampling (default: None, uses Ollama default)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub top_p: Option<f32>,
}

impl Default for GenerateOptions {
    fn default() -> Self {
        Self {
            num_predict: 512,
            repeat_penalty: 1.2,
            repeat_last_n: 128,
            temperature: None,
            top_p: None,
        }
    }
}

impl Default for OllamaVisionConfig {
    fn default() -> Self {
        Self {
            endpoint: "http://localhost:11434".to_string(),
            model: "llava".to_string(),
            timeout: Duration::from_secs(120),
            connect_timeout: Duration::from_secs(10),
            options: GenerateOptions::default(),
        }
    }
}

impl OllamaVisionConfig {
    /// Create a new config with the given model name.
    pub fn with_model(model: impl Into<String>) -> Self {
        Self {
            model: model.into(),
            ..Default::default()
        }
    }

    /// Set the connection timeout.
    pub fn connect_timeout(mut self, timeout: Duration) -> Self {
        self.connect_timeout = timeout;
        self
    }

    /// Set the Ollama endpoint.
    pub fn endpoint(mut self, endpoint: impl Into<String>) -> Self {
        self.endpoint = endpoint.into();
        self
    }

    /// Set the request timeout.
    pub fn timeout(mut self, timeout: Duration) -> Self {
        self.timeout = timeout;
        self
    }

    /// Set the generation options.
    pub fn options(mut self, options: GenerateOptions) -> Self {
        self.options = options;
        self
    }
}

/// Tag configuration for controlling tag extraction behavior.
#[derive(Debug, Clone)]
pub struct TagOptions {
    /// Custom system prompt (overrides default)
    pub prompt: Option<String>,
    /// Request JSON format from Ollama (default: true)
    pub request_json_format: bool,
    /// Maximum number of tags to return. Tags beyond this limit are dropped.
    /// Default: 30.
    pub max_tags: usize,
    /// Maximum length of a single tag in characters. Tags longer than this
    /// are truncated. Default: 50.
    pub max_tag_length: usize,
    /// Maximum number of retries on transient failures. Default: 2.
    pub max_retries: u32,
}

impl Default for TagOptions {
    fn default() -> Self {
        Self {
            prompt: None,
            request_json_format: true,
            max_tags: 30,
            max_tag_length: 50,
            max_retries: 2,
        }
    }
}

/// Caption configuration for controlling caption generation.
#[derive(Debug, Clone)]
pub struct CaptionOptions {
    /// Custom prompt (overrides default)
    pub prompt: Option<String>,
    /// Maximum caption length in characters. Captions beyond this are truncated
    /// at the last word boundary. Default: 500.
    pub max_caption_length: usize,
    /// Maximum number of retries on transient failures. Default: 2.
    pub max_retries: u32,
}

impl Default for CaptionOptions {
    fn default() -> Self {
        Self {
            prompt: None,
            max_caption_length: 500,
            max_retries: 2,
        }
    }
}