vecgraph-proto 0.1.1

Protobuf definitions for vecgraph's gRPC API.
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

use crate::{RerankParams, SearchKind, SearchQuery, SearchResult};
use vecgraph_core::VecGraphError;

impl TryFrom<SearchQuery> for vecgraph_core::SearchQuery {
    type Error = VecGraphError;

    fn try_from(proto: SearchQuery) -> Result<Self, Self::Error> {
        let proto_search_kind = SearchKind::try_from(proto.search_kind).map_err(|_| {
            VecGraphError::Other(format!("invalid search_kind value: {}", proto.search_kind))
        })?;

        let search_kind: vecgraph_core::SearchKind = proto_search_kind.try_into()?;

        let rerank = proto.rerank.map(|rp| vecgraph_core::RerankParams {
            vector: rp.vectors,
            kind: rp.kind,
            weight: rp.weight,
        });

        Ok(vecgraph_core::SearchQuery {
            query_vec: proto.query_vecs,
            top_k: proto.top_k as usize,
            search_kind,
            rerank,
            exclude_names: proto.exclude_names,
            kind: proto.kind,
            namespace: proto.namespace,
        })
    }
}

impl TryFrom<vecgraph_core::SearchQuery> for SearchQuery {
    type Error = VecGraphError;

    fn try_from(core: vecgraph_core::SearchQuery) -> Result<Self, Self::Error> {
        let search_kind = SearchKind::from(core.search_kind);
        let rerank = core.rerank.map(|rp| RerankParams {
            vectors: rp.vector,
            kind: rp.kind,
            weight: rp.weight,
        });

        Ok(SearchQuery {
            query_vecs: core.query_vec,
            top_k: core.top_k as u32,
            search_kind: search_kind.into(),
            rerank,
            exclude_names: core.exclude_names,
            kind: core.kind,
            namespace: core.namespace,
        })
    }
}

impl TryFrom<RerankParams> for vecgraph_core::RerankParams {
    type Error = VecGraphError;

    fn try_from(proto: RerankParams) -> Result<Self, Self::Error> {
        let vector = proto.vectors;

        Ok(vecgraph_core::RerankParams {
            vector,
            kind: proto.kind,
            weight: proto.weight,
        })
    }
}

impl TryFrom<SearchKind> for vecgraph_core::SearchKind {
    type Error = VecGraphError;

    fn try_from(proto: SearchKind) -> Result<Self, Self::Error> {
        match proto {
            SearchKind::Edge => Ok(vecgraph_core::SearchKind::Edge),
            SearchKind::Node => Ok(vecgraph_core::SearchKind::Node),
            SearchKind::AllUnspecified => Ok(vecgraph_core::SearchKind::All),
        }
    }
}

impl TryFrom<SearchResult> for vecgraph_core::SearchResult {
    type Error = VecGraphError;

    fn try_from(proto: SearchResult) -> Result<Self, Self::Error> {
        let search_kind = match SearchKind::try_from(proto.hit_kind).ok() {
            Some(SearchKind::Edge) => vecgraph_core::SearchKind::Edge,
            Some(SearchKind::Node) => vecgraph_core::SearchKind::Node,
            Some(SearchKind::AllUnspecified) => vecgraph_core::SearchKind::All,
            _ => {
                return Err(VecGraphError::Other(format!(
                    "Invalid search hit kind: {}",
                    proto.hit_kind
                )));
            }
        };
        Ok(vecgraph_core::SearchResult {
            node_id: proto.node_id.into(),
            kind: proto.kind,
            score: proto.score,
            hit_kind: search_kind,
        })
    }
}

// Reverse

impl From<vecgraph_core::SearchKind> for SearchKind {
    fn from(core: vecgraph_core::SearchKind) -> Self {
        match core {
            vecgraph_core::SearchKind::Edge => SearchKind::Edge,
            vecgraph_core::SearchKind::Node => SearchKind::Node,
            vecgraph_core::SearchKind::All => SearchKind::AllUnspecified,
        }
    }
}

impl From<vecgraph_core::SearchResult> for SearchResult {
    fn from(core: vecgraph_core::SearchResult) -> Self {
        let hit_kind = SearchKind::from(core.hit_kind);
        SearchResult {
            node_id: core.node_id.0,
            kind: core.kind,
            score: core.score,
            hit_kind: hit_kind.into(),
        }
    }
}

impl From<vecgraph_core::RerankParams> for RerankParams {
    fn from(core: vecgraph_core::RerankParams) -> Self {
        RerankParams {
            vectors: core.vector,
            kind: core.kind,
            weight: core.weight,
        }
    }
}