orch 0.0.16

Language model orchestration library
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

use serde::{Deserialize, Serialize};

use crate::lm::{LanguageModel, LanguageModelProviderError};

use super::{Anthropic, Ollama, OpenAi};

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum LanguageModelProvider {
    #[serde(rename = "ollama")]
    Ollama,
    #[serde(rename = "openai")]
    OpenAi,
    #[serde(rename = "anthropic")]
    Anthropic,
}

impl TryFrom<&str> for LanguageModelProvider {
    type Error = LanguageModelProviderError;

    fn try_from(value: &str) -> Result<Self, Self::Error> {
        Ok(match value {
            "ollama" => LanguageModelProvider::Ollama,
            "openai" => LanguageModelProvider::OpenAi,
            "anthropic" => LanguageModelProvider::Anthropic,
            _ => return Err(LanguageModelProviderError::InvalidValue(value.to_string())),
        })
    }
}

impl LanguageModelProvider {
    /// Returns whether the provider runs local inference or not.
    pub fn is_local(&self) -> bool {
        match self {
            LanguageModelProvider::Ollama => true,
            LanguageModelProvider::OpenAi => false,
            LanguageModelProvider::Anthropic => false,
        }
    }
}

pub enum OrchLanguageModel {
    Ollama(Ollama),
    OpenAi(OpenAi),
    Anthropic(Anthropic),
}

impl OrchLanguageModel {
    pub fn provider(&self) -> LanguageModelProvider {
        match self {
            OrchLanguageModel::Ollama(_) => LanguageModelProvider::Ollama,
            OrchLanguageModel::OpenAi(_) => LanguageModelProvider::OpenAi,
            OrchLanguageModel::Anthropic(_) => LanguageModelProvider::Anthropic,
        }
    }

    pub fn text_completion_model_name(&self) -> String {
        match self {
            OrchLanguageModel::Ollama(lm) => lm.text_completion_model_name(),
            OrchLanguageModel::OpenAi(lm) => lm.text_completion_model_name(),
            OrchLanguageModel::Anthropic(lm) => lm.text_completion_model_name(),
        }
    }

    pub fn embedding_model_name(&self) -> String {
        match self {
            OrchLanguageModel::Ollama(lm) => lm.embedding_model_name(),
            OrchLanguageModel::OpenAi(lm) => lm.embedding_model_name(),
            OrchLanguageModel::Anthropic(lm) => lm.embedding_model_name(),
        }
    }
}