Struct Graph 

pub struct Graph {
    pub seeds: Vec<(EntityId, f32)>,
    pub hops: usize,
    pub k: usize,
    pub graph: String,
    /* private fields */
}

Graph-anchored retrieval operator.

Construction is fluent — wire at recall()-build time, the network call only happens at .retrieve() time. The entity_ids come from the RETRIEVE-13 planner stub (extracted from query text) per D-13. Empty entity_ids short-circuits to an empty result set without touching storage (the planner returns no entities when the query has no entity mentions; treat that as “graph branch contributes nothing” rather than an error).

Fields

seeds: Vec<(EntityId, f32)>

Anchor seeds with per-seed confidence in [0.0, 1.0]. The operator snapshots a HashMap<EntityId, f32> from this vector at construction for O(1) confidence lookup after Cypher returns.

hops: usize

k: usize

graph: String

Implementations

impl Graph

pub fn anchored(seeds: Vec<(EntityId, f32)>, hops: usize) -> Graph

Graph::anchored(seeds, hops) — primary constructor per D-13.

seeds carries (EntityId, confidence) pairs where confidence is the planner’s belief that the entity is actually relevant to the query. Values are clamped to [0.0, 1.0]. Duplicates collapse to MAX (safe default — never demote a high-confidence anchor by passing a low-confidence duplicate).

hops is clamped to [1, MAX_GRAPH_HOPS] (D-14):

• hops greater than 5 — clamped to 5 (DoS defense; bounded BFS fan-out)
• hops == 0 — clamped up to 1 (zero-hop traversal would only return the anchor entities, which the caller already has)

k defaults to DEFAULT_GRAPH_K (matches Vector/Keyword default of 30) and is clamped via super::clamp_k.

pub fn with_decay(self, decay: GraphDecay) -> Graph

Apply recency decay to the traversal (ADD task ft-navigate-recall). The λ rides StoragePort::graph_traverse_decayed; backends without capabilities().graph_decay_native surface NotSupported — gate on the capability before composing decay into a recall.

pub fn entity_ids(&self) -> Vec<EntityId>

Convenience: list of seed EntityIds (without confidence). Mirrors the pre-Wave-4 entity_ids field for callers that only need the keys.

pub fn with_k(self, k: usize) -> Graph

Override the candidate count. Clamped at super::MAX_K.

pub fn with_graph(self, graph: impl Into<String>) -> Graph

Override the graph name (defaults to LUNARIS_GRAPH_NAME). Useful for tenant-isolated deployments that scope each tenant to its own AGE / Moon graph.

pub fn and<R>(self, other: R) -> AndRetriever

where R: Retriever + 'static,

Concurrent fan-out — runs THIS graph branch alongside other and concatenates results (per-source ranking preserved via SourceOp). Downstream fuse_rrf groups by source_op to fold per-branch rankings.

pub fn or<R>(self, other: R) -> OrRetriever

where R: Retriever + 'static,

Concurrent fan-out — runs THIS graph branch alongside other and unions results by id (max score wins on duplicate id).

pub fn then<R>(self, other: R) -> ThenRetriever

where R: Retriever + 'static,

Sequential narrow — runs THIS graph branch first, then passes its hit ids as a Filter::Or(Filter::Eq{id, …}) to other.

pub fn top(self, n: usize) -> TopRetriever

Cap the final result set after the graph traversal resolves.

pub fn rerank(self, reranker: Arc<dyn Reranker>) -> RerankRetriever

Wrap with a cross-encoder rerank pass (Plan 02-03).

pub fn degraded_fallback<R>(self, fallback: R) -> DegradedFallbackRetriever

where R: Retriever + 'static,

Wrap with a fallback retriever — if THIS graph path errors (e.g., a backend without graph support returns NotSupported, or Moon GRAPH.QUERY hits a transient disconnect), switch to fallback and tag returned hits with degraded: true (Plan 02-03).

Trait Implementations

impl Clone for Graph

fn clone(&self) -> Graph

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Graph

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Retriever for Graph

fn retrieve<'life0, 'life1, 'async_trait>( &'life0 self, ctx: &'life1 QueryContext, ) -> Pin<Box<dyn Future<Output = Result<Vec<RawHit>, LunarisError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Graph: 'async_trait,

Run the operator against ctx and return the unranked-or-ranked raw hits this operator produces. The downstream stage (combinator or fuse_rrf) decides what to do with them.

fn as_any(&self) -> &(dyn Any + 'static)

Cast this operator to &dyn Any so the RRF routing dispatcher can recover the concrete operator type. Concrete operators override with fn as_any(&self) -> &dyn Any { self }. The default returns a sentinel &() so unknown operators downcast as None (and the dispatcher falls back to client-side RRF instead of misrouting).