llm 1.3.8

A Rust library unifying multiple LLM backends.
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

use llm::builder::{LLMBackend, LLMBuilder};
use llm::LLMProvider;

use crate::provider::error::ProviderBuildError;

use super::ResolvedConfig;

pub(super) fn build_provider(
    backend: &LLMBackend,
    resolved: &ResolvedConfig,
    tool_builders: Vec<llm::builder::FunctionBuilder>,
) -> Result<Box<dyn LLMProvider>, ProviderBuildError> {
    let builder = LLMBuilder::new().backend(backend.clone());
    let builder = resolved.apply(builder);
    let builder = apply_tools(builder, tool_builders);
    builder
        .build()
        .map_err(|err| ProviderBuildError::Build(err.to_string()))
}

impl ResolvedConfig {
    fn apply(&self, mut builder: LLMBuilder) -> LLMBuilder {
        if let Some(value) = self.model.clone() {
            builder = builder.model(value);
        }
        if let Some(value) = self.system.clone() {
            builder = builder.system(value);
        }
        if let Some(value) = self.api_key.clone() {
            builder = builder.api_key(value);
        }
        if let Some(value) = self.base_url.clone() {
            builder = builder.base_url(value);
        }
        if let Some(value) = self.temperature {
            builder = builder.temperature(value);
        }
        if let Some(value) = self.max_tokens {
            builder = builder.max_tokens(value);
        }
        if let Some(value) = self.timeout_seconds {
            builder = builder.timeout_seconds(value);
        }
        builder
    }
}

fn apply_tools(
    mut builder: LLMBuilder,
    tool_builders: Vec<llm::builder::FunctionBuilder>,
) -> LLMBuilder {
    for tool in tool_builders {
        builder = builder.function(tool);
    }
    builder
}