relay-knowledge 1.1.9

Graph-database-based knowledge graph project.
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

use std::collections::BTreeMap;

use crate::domain::{RECIPROCAL_RANK_FUSION_K, RankingSignal, RetrievalHit, RetrieverSource};

use super::ScoredHit;

pub(super) fn merge_ranked(
    candidates: &mut BTreeMap<String, Candidate>,
    hits: Vec<ScoredHit>,
    fallback_source: RetrieverSource,
    explanation: &'static str,
) {
    for (index, scored) in hits.into_iter().enumerate() {
        let rank = index + 1;
        let rrf_score = 1.0 / (RECIPROCAL_RANK_FUSION_K + rank as f64);
        let source = match scored.source {
            RetrieverSource::CodeGraph => RetrieverSource::CodeGraph,
            _ => fallback_source,
        };
        let explanation_text = scored
            .explanation
            .unwrap_or_else(|| format!("{explanation}; modality={}", scored.modality));
        let candidate = candidates
            .entry(scored.key)
            .and_modify(|candidate| candidate.merge_hit(&scored.hit))
            .or_insert_with(|| Candidate::new(scored.hit));
        if !candidate.hit.retriever_sources.contains(&source) {
            candidate.hit.retriever_sources.push(source);
        }
        candidate.hit.ranking.push(RankingSignal {
            source,
            rank,
            score: scored.source_score,
            explanation: explanation_text,
        });
        candidate.rrf_score += rrf_score;
    }
}

pub(super) struct Candidate {
    hit: RetrievalHit,
    rrf_score: f64,
}

impl Candidate {
    fn new(hit: RetrievalHit) -> Self {
        Self {
            hit,
            rrf_score: 0.0,
        }
    }

    pub(super) fn into_hit(mut self) -> RetrievalHit {
        self.hit.score = self.rrf_score;
        self.hit
    }

    fn merge_hit(&mut self, hit: &RetrievalHit) {
        if !hit.content.is_empty() && !self.hit.content.contains(&hit.content) {
            if !self.hit.content.is_empty() {
                self.hit.content.push_str("\n\n");
            }
            self.hit.content.push_str(&hit.content);
        }
        if self.hit.source_path.is_none() {
            self.hit.source_path = hit.source_path.clone();
        }
        if self.hit.source_span.is_none() {
            self.hit.source_span = hit.source_span;
        }
        if self.hit.code_artifact.is_none() {
            self.hit.code_artifact = hit.code_artifact.clone();
        }
        for label in &hit.entity_labels {
            if !self.hit.entity_labels.contains(label) {
                self.hit.entity_labels.push(label.clone());
            }
        }
        for entity in &hit.entities {
            if !self
                .hit
                .entities
                .iter()
                .any(|existing| existing.id == entity.id)
            {
                self.hit.entities.push(entity.clone());
            }
        }
        for fact in &hit.graph_facts {
            if !self
                .hit
                .graph_facts
                .iter()
                .any(|existing| existing.fact_id == fact.fact_id && existing.kind == fact.kind)
            {
                self.hit.graph_facts.push(fact.clone());
            }
        }
    }
}