hyf

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

semantic_rank.mojo (3570B)

      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(
     29     ranked: List[CandidateEvaluation]
     30 ) raises -> Value:
     31     var scored = loads("[]")
     32     for evaluation in ranked:
     33         var candidate = loads("{}")
     34         candidate.set("id", Value(String(evaluation.candidate.id)))
     35         candidate.set("heuristic_score", Value(evaluation.score))
     36         candidate.set("matched_terms", string_array_value(evaluation.matched_terms))
     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("freshness_band", Value(String(evaluation.freshness_band)))
     44         candidate.set("scope_match", Value(evaluation.scope_match))
     45         scored.append(candidate)
     46     return scored^
     47 
     48 
     49 def _build_output(
     50     ranked: List[CandidateEvaluation],
     51     ranking_hints: List[String],
     52     extracted_filters: Value,
     53 ) raises -> Value:
     54     var output = loads("{}")
     55     var ranked_ids = loads("[]")
     56     var reasons = loads("{}")
     57 
     58     for evaluation in ranked:
     59         ranked_ids.append(Value(String(evaluation.candidate.id)))
     60         reasons.set(
     61             String(evaluation.candidate.id),
     62             string_array_value(evaluation.reasons),
     63         )
     64 
     65     output.set("ranked_ids", ranked_ids)
     66     output.set("reasons", reasons)
     67     output.set("scored_candidates", _build_scored_candidates(ranked))
     68     output.set("ranking_hints", string_array_value(ranking_hints))
     69     output.set("extracted_filters", extracted_filters)
     70     return output^
     71 
     72 
     73 def execute_semantic_rank(
     74     input: Value, context: RequestContext
     75 ) raises -> CapabilityResult:
     76     try:
     77         var request: SemanticRankRequest = parse_semantic_rank_request(input)
     78         var analysis = analyze_query_text(request.query_text, context)
     79         var ranked = rank_candidates(request.candidates, analysis, context)
     80 
     81         var signal_tags = query_signal_tags(analysis)
     82         signal_tags.append("candidate_set_evaluated")
     83 
     84         var source_refs = List[ProvenanceSourceRef]()
     85         source_refs.append(
     86             ProvenanceSourceRef(
     87                 source_kind="candidate_set",
     88                 source_ref="semantic_rank:candidates",
     89             )
     90         )
     91 
     92         return successful_capability(
     93             _build_output(
     94                 ranked=ranked,
     95                 ranking_hints=analysis.ranking_hints,
     96                 extracted_filters=serialize_extracted_filters(
     97                     analysis.extracted_filters
     98                 ),
     99             ),
    100             meta=build_deterministic_meta(
    101                 context=context,
    102                 capability_name="semantic_rank",
    103                 signal_tags=signal_tags,
    104                 extra_source_refs=source_refs^,
    105             ),
    106         )
    107     except e:
    108         return failed_capability(invalid_input_error(String(e)))