hyf

Context-aware query service for Radroots
git clone https://radroots.dev/git/hyf.git
Log | Files | Refs | README | LICENSE

semantic_rank.mojo (3608B)

      1 from std.collections import List
      2 
      3 from json import Value, loads
      4 
      5 from hyf_core.capabilities.query_analysis import (
      6     analyze_query_text,
      7     build_deterministic_meta,
      8     query_signal_tags,
      9     serialize_extracted_filters,
     10     string_array_value,
     11 )
     12 from hyf_core.capabilities.ranking_support import (
     13     CandidateEvaluation,
     14     SemanticRankRequest,
     15     parse_semantic_rank_request,
     16     rank_candidates,
     17 )
     18 from hyf_core.errors import (
     19     CapabilityResult,
     20     failed_capability,
     21     invalid_input_error,
     22     successful_capability,
     23 )
     24 from hyf_core.provenance import ProvenanceSourceRef
     25 from hyf_core.request_context import RequestContext
     26 
     27 
     28 def _build_scored_candidates(ranked: List[CandidateEvaluation]) raises -> Value:
     29     var scored = loads("[]")
     30     for evaluation in ranked:
     31         var candidate = loads("{}")
     32         candidate.set("id", Value(String(evaluation.candidate.id)))
     33         candidate.set("heuristic_score", Value(evaluation.score))
     34         candidate.set(
     35             "matched_terms", string_array_value(evaluation.matched_terms)
     36         )
     37         candidate.set("reasons", string_array_value(evaluation.reasons))
     38         candidate.set(
     39             "delivery_alignment",
     40             Value(String(evaluation.delivery_alignment)),
     41         )
     42         candidate.set("distance_band", Value(String(evaluation.distance_band)))
     43         candidate.set(
     44             "freshness_band", Value(String(evaluation.freshness_band))
     45         )
     46         candidate.set("scope_match", Value(evaluation.scope_match))
     47         scored.append(candidate)
     48     return scored^
     49 
     50 
     51 def _build_output(
     52     ranked: List[CandidateEvaluation],
     53     ranking_hints: List[String],
     54     extracted_filters: Value,
     55 ) raises -> Value:
     56     var output = loads("{}")
     57     var ranked_ids = loads("[]")
     58     var reasons = loads("{}")
     59 
     60     for evaluation in ranked:
     61         ranked_ids.append(Value(String(evaluation.candidate.id)))
     62         reasons.set(
     63             String(evaluation.candidate.id),
     64             string_array_value(evaluation.reasons),
     65         )
     66 
     67     output.set("ranked_ids", ranked_ids)
     68     output.set("reasons", reasons)
     69     output.set("scored_candidates", _build_scored_candidates(ranked))
     70     output.set("ranking_hints", string_array_value(ranking_hints))
     71     output.set("extracted_filters", extracted_filters)
     72     return output^
     73 
     74 
     75 def execute_semantic_rank(
     76     input: Value, context: RequestContext
     77 ) raises -> CapabilityResult:
     78     try:
     79         var request: SemanticRankRequest = parse_semantic_rank_request(input)
     80         var analysis = analyze_query_text(request.query_text, context)
     81         var ranked = rank_candidates(request.candidates, analysis, context)
     82 
     83         var signal_tags = query_signal_tags(analysis)
     84         signal_tags.append("candidate_set_evaluated")
     85 
     86         var source_refs = List[ProvenanceSourceRef]()
     87         source_refs.append(
     88             ProvenanceSourceRef(
     89                 source_kind="candidate_set",
     90                 source_ref="semantic_rank:candidates",
     91             )
     92         )
     93 
     94         return successful_capability(
     95             _build_output(
     96                 ranked=ranked,
     97                 ranking_hints=analysis.ranking_hints,
     98                 extracted_filters=serialize_extracted_filters(
     99                     analysis.extracted_filters
    100                 ),
    101             ),
    102             meta=build_deterministic_meta(
    103                 context=context,
    104                 capability_name="semantic_rank",
    105                 signal_tags=signal_tags,
    106                 extra_source_refs=source_refs^,
    107             ),
    108         )
    109     except e:
    110         return failed_capability(invalid_input_error(String(e)))