kbolt-core 0.1.1

Core engine for kbolt local-first retrieval
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

use kbolt_types::{ModelInfo, ModelStatus};

use crate::config::Config;
use crate::Result;

mod chat;
mod completion;
mod embedder;
mod expander;
mod gateway;
mod http;
mod inference;
mod reranker;
mod text;
mod variants_expander;

pub(crate) use embedder::{Embedder, EmbeddingDocumentSizer, EmbeddingInputKind};
pub(crate) use expander::{normalize_query_text, Expander};
pub(crate) use inference::build_inference_clients;
pub(crate) use reranker::Reranker;

use gateway::{resolve_inference_gateway_bindings, ProviderDeployment};
use http::HttpJsonClient;

pub fn status(config: &Config) -> Result<ModelStatus> {
    let bindings = resolve_inference_gateway_bindings(config)?;
    Ok(ModelStatus {
        embedder: bindings
            .embedder
            .as_ref()
            .map(|binding| readiness_for_binding(&binding.provider_name, &binding.deployment))
            .unwrap_or_else(unconfigured_model_info),
        reranker: bindings
            .reranker
            .as_ref()
            .map(|binding| readiness_for_binding(&binding.provider_name, &binding.deployment))
            .unwrap_or_else(unconfigured_model_info),
        expander: bindings
            .expander
            .as_ref()
            .map(|binding| readiness_for_binding(&binding.provider_name, &binding.deployment))
            .unwrap_or_else(unconfigured_model_info),
    })
}

fn readiness_for_binding(profile: &str, deployment: &ProviderDeployment) -> ModelInfo {
    let client = HttpJsonClient::new(
        &deployment.base_url,
        deployment.api_key_env.as_deref(),
        deployment.timeout_ms,
        0,
        deployment.operation.as_str(),
        deployment.kind.as_str(),
    );
    let readiness = client.probe_readiness();
    ModelInfo {
        configured: true,
        ready: readiness.ready,
        profile: Some(profile.to_string()),
        kind: Some(deployment.kind.as_str().to_string()),
        operation: Some(deployment.operation.as_str().to_string()),
        model: Some(deployment.model.clone()),
        endpoint: Some(deployment.base_url.clone()),
        issue: readiness.issue,
    }
}

fn unconfigured_model_info() -> ModelInfo {
    ModelInfo {
        configured: false,
        ready: false,
        profile: None,
        kind: None,
        operation: None,
        model: None,
        endpoint: None,
        issue: None,
    }
}

#[cfg(test)]
mod tests;