markhor_core 0.1.0-alpha.0.2

Core library for Markhor, a project connecting AI models, documents, and workflows for knowledge work
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

use std::sync::Arc;

use serde::{Deserialize, Serialize};

use crate::{chat::{chat::ChatApi, prompter::Prompter}, chunking::Chunker, convert::Converter, embedding::Embedder};

use super::{Extension, F11y, FunctionalityType};


#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ExtensionConfig {

}

#[derive(Clone)]
pub struct ActiveExtension {
    inner: Arc<(Box<dyn Extension>, ExtensionConfig)>,
}

impl ActiveExtension {
    pub fn new(extension: impl Extension + 'static, config: ExtensionConfig) -> Self {
        Self {
            inner: Arc::new((Box::new(extension), config)),
        }
    }

    fn extension(&self) -> &dyn Extension {
        &*self.inner.0
    }

    fn config(&self) -> &ExtensionConfig {
        &self.inner.1
    }

    pub fn uri(&self) -> &str {
        self.extension().uri()
    }

    pub fn name(&self) -> &str {
        self.extension().name()
    }

    pub fn description(&self) -> &str {
        self.extension().description()
    }

    pub fn chat_providers(&self) -> impl Iterator<Item = F11y<dyn ChatApi>> {
        self.extension().chat_model().into_iter().map(|model| F11y {
            trait_object: model,
            functionality_type: FunctionalityType::ChatProvider,
            extension: self.clone(),
        })
    }

    pub fn embedders(&self) -> impl Iterator<Item = F11y<dyn Embedder>> {
        self.extension().embedding_model().into_iter().map(|model| F11y {
            trait_object: model,
            functionality_type: FunctionalityType::Embedder,
            extension: self.clone(),
        })
    }

    pub fn chunkers(&self) -> impl Iterator<Item = F11y<dyn Chunker>> {
        self.extension().chunker().into_iter().map(|model| F11y {
            trait_object: model,
            functionality_type: FunctionalityType::Chunker,
            extension: self.clone(),
        })
    }

    pub fn converters(&self) -> impl Iterator<Item = F11y<dyn Converter>> {
        self.extension().converter().into_iter().map(|model| F11y {
            trait_object: model,
            functionality_type: FunctionalityType::Converter,
            extension: self.clone(),
        })
    }

    pub fn prompters(&self) -> impl Iterator<Item = F11y<dyn Prompter>> {
        self.extension().prompters().into_iter().map(|model| F11y {
            trait_object: model,
            functionality_type: FunctionalityType::Prompter,
            extension: self.clone(),
        })
    }
}