Hybrid search

CREATE FULLTEXT INDEX `abstract-fulltext` IF NOT EXISTS
FOR (abstract:Abstract)
ON EACH [abstract.text];

DROP INDEX `abstract-embeddings` IF EXISTS;

CALL db.index.vector.createNodeIndex(
  'abstract-embeddings',
  'Abstract',
  'embedding',
  1536,
  'cosine'
);

CALL db.awaitIndexes(30);

WITH
  $query AS query,
  $queryVector AS queryVector,
  $sourceK AS sourceK,
  $finalK AS finalK,
  $rrfConstant AS rrfConstant,
  $sourceWeights AS sourceWeights

CALL {
  WITH query, sourceK, rrfConstant, sourceWeights
  CALL db.index.fulltext.queryNodes('abstract-fulltext', query, {limit: sourceK})
  YIELD node AS abstract, score
  WITH abstract, score, rrfConstant, sourceWeights
  ORDER BY score DESC, abstract.id ASC
  WITH collect(abstract) AS abstracts, rrfConstant, sourceWeights
  WITH abstracts, rrfConstant, coalesce(sourceWeights['fulltext'], 1.0) AS weight
  UNWIND CASE WHEN size(abstracts) = 0 THEN [] ELSE range(0, size(abstracts) - 1) END AS rankIndex
  RETURN
    abstracts[rankIndex] AS abstract,
    weight / (rrfConstant + rankIndex + 1) AS contribution

  UNION ALL

  WITH queryVector, sourceK, rrfConstant, sourceWeights
  CALL db.index.vector.queryNodes('abstract-embeddings', sourceK, queryVector)
  YIELD node AS abstract, score
  WITH abstract, score, sourceK, rrfConstant, sourceWeights
  ORDER BY score DESC, abstract.id ASC
  WITH collect(abstract) AS abstracts, sourceK, rrfConstant, sourceWeights
  WITH abstracts, rrfConstant, coalesce(sourceWeights['vector'], 1.0) AS weight
  UNWIND CASE WHEN size(abstracts) = 0 THEN [] ELSE range(0, size(abstracts) - 1) END AS rankIndex
  RETURN
    abstracts[rankIndex] AS abstract,
    weight / (rrfConstant + rankIndex + 1) AS contribution
}
WITH abstract, finalK, sum(contribution) AS wrrf
ORDER BY wrrf DESC, abstract.id ASC
WITH collect({abstract: abstract, wrrf: wrrf}) AS orderedRows, finalK
UNWIND orderedRows[..finalK] AS row
WITH row.abstract AS abstract, row.wrrf AS wrrf
MATCH (abstract)<--(:Paper)-->(title:Title)
RETURN title.text AS title, abstract.text AS text, wrrf
ORDER BY wrrf DESC, abstract.id ASC;

CREATE FULLTEXT INDEX `decision-text` IF NOT EXISTS
FOR (decision:Decision)
ON EACH [decision.text];

DROP INDEX `decision-semantic` IF EXISTS;
DROP INDEX `decision-structural` IF EXISTS;

CALL db.index.vector.createNodeIndex(
  'decision-semantic',
  'Decision',
  'semanticEmbedding',
  3,
  'cosine'
);

CALL db.index.vector.createNodeIndex(
  'decision-structural',
  'Decision',
  'structuralEmbedding',
  3,
  'cosine'
);

CALL db.awaitIndexes(30);

WITH
  $query AS query,
  $queryVector AS queryVector,
  $structuralQueryVector AS structuralQueryVector,
  $sourceK AS sourceK,
  $finalK AS finalK,
  $rrfConstant AS rrfConstant,
  $sourceWeights AS sourceWeights

CALL {
  WITH query, sourceK
  CALL db.index.fulltext.queryNodes('decision-text', query, {limit: sourceK})
  YIELD node AS decision, score
  WITH decision, score
  ORDER BY score DESC, decision.id ASC
  WITH collect({node: decision, rawScore: score}) AS rows
  UNWIND CASE WHEN size(rows) = 0 THEN [] ELSE range(0, size(rows) - 1) END AS rankIndex
  RETURN
    rows[rankIndex].node AS decision,
    'fulltext' AS source,
    rankIndex + 1 AS sourceRank,
    rows[rankIndex].rawScore AS rawScore

  UNION ALL

  WITH queryVector, sourceK
  CALL db.index.vector.queryNodes('decision-semantic', sourceK, queryVector)
  YIELD node AS decision, score
  WITH decision, score
  ORDER BY score DESC, decision.id ASC
  WITH collect({node: decision, rawScore: score}) AS rows
  UNWIND CASE WHEN size(rows) = 0 THEN [] ELSE range(0, size(rows) - 1) END AS rankIndex
  RETURN
    rows[rankIndex].node AS decision,
    'semantic' AS source,
    rankIndex + 1 AS sourceRank,
    rows[rankIndex].rawScore AS rawScore

  UNION ALL

  WITH structuralQueryVector, sourceK
  CALL db.index.vector.queryNodes('decision-structural', sourceK, structuralQueryVector)
  YIELD node AS decision, score
  WITH decision, score
  ORDER BY score DESC, decision.id ASC
  WITH collect({node: decision, rawScore: score}) AS rows
  UNWIND CASE WHEN size(rows) = 0 THEN [] ELSE range(0, size(rows) - 1) END AS rankIndex
  RETURN
    rows[rankIndex].node AS decision,
    'structural' AS source,
    rankIndex + 1 AS sourceRank,
    rows[rankIndex].rawScore AS rawScore
}

WITH decision, finalK, source, sourceRank, rawScore,
  coalesce(sourceWeights[source], 1.0) AS weight,
  rrfConstant
WITH decision, finalK, source, sourceRank, rawScore, weight,
  weight / (rrfConstant + sourceRank) AS contribution
ORDER BY decision.id ASC, source ASC, sourceRank ASC

WITH
  decision,
  finalK,
  collect({
    source: source,
    sourceRank: sourceRank,
    weight: weight,
    rawScore: rawScore,
    contribution: contribution
  }) AS contributions

WITH decision, finalK, contributions,
  reduce(wrrf = 0.0, contribution IN contributions |
    wrrf + contribution.contribution
  ) AS wrrf

ORDER BY wrrf DESC, decision.id ASC

WITH collect({
  decision: decision,
  sources: [contribution IN contributions | contribution.source],
  wrrf: wrrf
}) AS orderedRows, finalK
WITH orderedRows[..finalK] AS limitedRows

UNWIND limitedRows AS row
RETURN
  row.decision.title AS title,
  row.sources AS sources,
  row.wrrf AS wrrf
ORDER BY row.wrrf DESC, row.decision.id ASC;