orchestrator-core 4.5.0a2__py3-none-any.whl → 4.5.0a3__py3-none-any.whl

{orchestrator_core-4.5.0a2.dist-info → orchestrator_core-4.5.0a3.dist-info}/RECORD

@@ -1,9 +1,9 @@
-orchestrator/__init__.py,sha256=xKpOlVZwRPcmklRABJcL_1Kwp63ENR1Z5K7RGckwtVs,1732
+orchestrator/__init__.py,sha256=2qjP04OyiwpdXVkj5X7tBnpTrC4iWMELv2zmJe2WZBs,1732
 orchestrator/agentic_app.py,sha256=bBMuH9Ub42nb8oFG0U00SzW_uQqnAayUX2tNs6yz1BM,2810
 orchestrator/app.py,sha256=UPKQuDpg8MWNC6r3SRRbp6l9RBzwb00IMIaGRk-jbCU,13203
 orchestrator/exception_handlers.py,sha256=UsW3dw8q0QQlNLcV359bIotah8DYjMsj2Ts1LfX4ClY,1268
 orchestrator/llm_settings.py,sha256=PJ3vf5aEugVigHFU7iw9haQon_bC7Y268GTFhfFaQHs,2075
-orchestrator/log_config.py,sha256=1tPRX5q65e57a6a_zEii_PFK8SzWT0mnA5w2sKg4hh8,1853
+orchestrator/log_config.py,sha256=1cPl_OXT4tEUyNxG8cwIWXrmadUm1E81vq0mdtrV-v4,1912
 orchestrator/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orchestrator/security.py,sha256=iXFxGxab54aav7oHEKLAVkTgrQMJGHy6IYLojEnD7gI,2422
 orchestrator/settings.py,sha256=30iYKd_wNtjIO12DZ4LrH9w9OJgtmQ2AFEOSnrVTsRg,4365
@@ -23,7 +23,7 @@ orchestrator/api/api_v1/endpoints/processes.py,sha256=238Bydgj4ILNyMU_7j_Q7a0WGl
 orchestrator/api/api_v1/endpoints/product_blocks.py,sha256=kZ6ywIOsS_S2qGq7RvZ4KzjvaS1LmwbGWR37AKRvWOw,2146
 orchestrator/api/api_v1/endpoints/products.py,sha256=BfFtwu9dZXEQbtKxYj9icc73GKGvAGMR5ytyf41nQlQ,3081
 orchestrator/api/api_v1/endpoints/resource_types.py,sha256=gGyuaDyOD0TAVoeFGaGmjDGnQ8eQQArOxKrrk4MaDzA,2145
-orchestrator/api/api_v1/endpoints/search.py,sha256=QFxnMFQ2HgpL9Ebdc-vta6Z7Rdq5Qb9OKxyiPy2Lu9o,10200
+orchestrator/api/api_v1/endpoints/search.py,sha256=sxiS2n1I0ghfQifo8Vf4PsAoxxGjKKqPTtHcAiuWrPE,10780
 orchestrator/api/api_v1/endpoints/settings.py,sha256=5s-k169podZjgGHUbVDmSQwpY_3Cs_Bbf2PPtZIkBcw,6184
 orchestrator/api/api_v1/endpoints/subscription_customer_descriptions.py,sha256=1_6LtgQleoq3M6z_W-Qz__Bj3OFUweoPrUqHMwSH6AM,3288
 orchestrator/api/api_v1/endpoints/subscriptions.py,sha256=7KaodccUiMkcVnrFnK2azp_V_-hGudcIyhov5WwVGQY,9810
@@ -138,7 +138,7 @@ orchestrator/db/sorting/sorting.py,sha256=WpwImCDRKiOp4Tr54vovWpHkoJIov8SNQNPods
 orchestrator/db/sorting/subscription.py,sha256=uepBMyfRFLZz5yoYK4VK3mdRBvO1Gc-6jSQXQ41fR-8,1441
 orchestrator/db/sorting/workflow.py,sha256=6-JceMyB99M994Re58E0MX5uhlpnTW5OJCxmXopEfRU,576
 orchestrator/devtools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orchestrator/devtools/populator.py,sha256=-8i3KDDP1cRgwiDKuYmomwrSlbmcMhpAaEaDvhyIbk4,19688
+orchestrator/devtools/populator.py,sha256=U7j5Gvu5mU8kvqx9jfno25aYyD5GFSk9ZQ2zYSagQOI,20399
 orchestrator/devtools/scripts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orchestrator/devtools/scripts/migrate_20.py,sha256=8-qLiWfjYctu2kNl5MHtZvfeCdUs0YzRjepy4VYOUkc,4891
 orchestrator/devtools/scripts/migrate_30.py,sha256=pRnJQFvmliwTLgbbDSUGyS9sCWqQcTms-g_3yfUO5vQ,3030
@@ -220,7 +220,7 @@ orchestrator/migrations/README,sha256=heMzebYwlGhnE8_4CWJ4LS74WoEZjBy-S-mIJRxAEK
 orchestrator/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orchestrator/migrations/alembic.ini,sha256=kMoADqhGeubU8xanILNaqm4oixLy9m4ngYtdGpZcc7I,873
 orchestrator/migrations/env.py,sha256=M_cPoAL2axuuup5fvMy8I_WTPHEw0RbPEHkhZ3QEGoE,3740
-orchestrator/migrations/helpers.py,sha256=CAGGKhxpmhyKGfYcO-SUCPfMTOCZPfEpkJrcm2MYfcE,47979
+orchestrator/migrations/helpers.py,sha256=g3G8P5IQ1OI4kmlNP8L0v9nzWvekzXwilXLdEvbN9ZI,47992
 orchestrator/migrations/script.py.mako,sha256=607Zrgp-Z-m9WGLt4wewN1QDOmHeifxcePUdADkSZyM,510
 orchestrator/migrations/templates/alembic.ini.j2,sha256=8v7UbKvOiWEbEKQa-Au3uONKUuYx6aflulYanZX6r2I,883
 orchestrator/migrations/templates/env.py.j2,sha256=LIt0ildZTZvNEx3imhy4GNzfFi_rPZg-8H7rGgrBOP8,2717
@@ -271,44 +271,50 @@ orchestrator/schemas/process.py,sha256=UACBNt-4g4v9Y528u-gZ-Wk7YxwJHhnI4cEu5CtQm
 orchestrator/schemas/product.py,sha256=MhMCh058ZuS2RJq-wSmxIPUNlhQexxXIx3DSz2OmOh4,1570
 orchestrator/schemas/product_block.py,sha256=kCqvm6qadHpegMr9aWI_fYX-T7mS-5S-ldPxnGQZg7M,1519
 orchestrator/schemas/resource_type.py,sha256=VDju4XywcDDLxdpbWU62RTvR9QF8x_GRrpTlN_NE8uI,1064
-orchestrator/schemas/search.py,sha256=yOlkG61BxSTL5xvepxrG-Qz_NceSw5E0g-7GUkjaj9Q,2837
+orchestrator/schemas/search.py,sha256=Q89GAPrmHf2DnwTJiPMYog1xAIC3QMJ3IItFZdVVFXg,3417
 orchestrator/schemas/subscription.py,sha256=-jXyHZIed9Xlia18ksSDyenblNN6Q2yM2FlGELyJ458,3423
 orchestrator/schemas/subscription_descriptions.py,sha256=Ft_jw1U0bf9Z0U8O4OWfLlcl0mXCVT_qYVagBP3GbIQ,1262
-orchestrator/schemas/workflow.py,sha256=VqQ9XfV4fVd6MjY0LRRQzWBJHmlPsAamWfTwDx1cZkg,2102
+orchestrator/schemas/workflow.py,sha256=StVoRGyNT2iIeq3z8BIlTPt0bcafzbeYxXRrCucR6LU,2146
 orchestrator/search/__init__.py,sha256=2uhTQexKx-cdBP1retV3CYSNCs02s8WL3fhGvupRGZk,571
-orchestrator/search/agent/__init__.py,sha256=ucZF-4ZsDc911Zyjmc1OK2ZcA6C64GFdMOVP26sWW7Q,166
-orchestrator/search/agent/agent.py,sha256=6wgsoOkGay_Qnaz8GJNrhKkA50ijotKTnj9ivXvswZg,1740
-orchestrator/search/agent/prompts.py,sha256=XdS97esjAJacNHtaeYATO-4JXVXnHibAd09BCtlvzBI,3821
-orchestrator/search/agent/state.py,sha256=DPCbvp6_WCxXwuJq1IU9glfKNZ1mRODoFcLjb9AOke0,203
-orchestrator/search/agent/tools.py,sha256=n5fdVgbvadWjgNN2MZwl5WyeLCKNS6Az_x4b9L6qljs,8382
-orchestrator/search/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orchestrator/search/core/embedding.py,sha256=s7P_2hrofnRXnfUFKuDJcpYkm_KzFkmhFe5j2n8_W7U,2297
-orchestrator/search/core/exceptions.py,sha256=uIlePbEyShcoM5uSCGcOlI-WEfEae3uBECGT4p40eaA,448
-orchestrator/search/core/types.py,sha256=Zm3NgoKwmvu3wTRDUrQ8Wn5l05r2hOXh-OkB-uGzLNs,8228
-orchestrator/search/core/validators.py,sha256=Ny80tH3SHuM64yZCi-9kfX-66NKGjsp_0oG7uJ21JVk,624
+orchestrator/search/agent/__init__.py,sha256=guIh2VaXHvR8wkdOJMhoFmSQCLju4qTXyZDuLc12zrA,746
+orchestrator/search/agent/agent.py,sha256=iejwwBl4YPDVpYIBy9NzNdOSW7xbOUZedfC_7iGHpSg,2320
+orchestrator/search/agent/prompts.py,sha256=2VS0Ho-jq9u2kqrlcCIAHRqs35eww1eC0tZXPlhTbaE,4401
+orchestrator/search/agent/state.py,sha256=1WHYol5UlYpq2QZz-BVsBFYrJZms5P18ohN2Ur8P2F4,783
+orchestrator/search/agent/tools.py,sha256=4kvY0tG7i5-w8C-ZMuSabxb_sJmd_TpFl3F4xeGgzok,9513
+orchestrator/search/core/__init__.py,sha256=q5G0z3nKjIHKFs1PkEG3nvTUy3Wp4kCyBtCbqUITj3A,579
+orchestrator/search/core/embedding.py,sha256=ESeI5Vcobb__CRRZE_RP-m4eAz8JUP8S16aGLJh4uAY,2751
+orchestrator/search/core/exceptions.py,sha256=qp7ZdyDvN5b2HD5_oZXMgoLJgy79krpClszKh3KPuAw,1029
+orchestrator/search/core/types.py,sha256=Gaf77cKUqnE8vJNCpk-g3h2U5912axhIgZZnF_0_O48,8831
+orchestrator/search/core/validators.py,sha256=zktY5A3RTBmfdARJoxoz9rnnyTZj7L30Kbmh9UTQz2o,1204
 orchestrator/search/docs/index.md,sha256=zKzE2fbtHDfYTKaHg628wAsqCTOJ5yFUWV0ucFH3pAg,863
 orchestrator/search/docs/running_local_text_embedding_inference.md,sha256=KlFxyAjHfLyCeV9fXAFVUqZOFWYwGPH-_oBjWx2Vgng,1255
-orchestrator/search/filters/__init__.py,sha256=h9wjnKLcIfG1TwiuwtnlDvv9XMWLxkjCBD9D8qCOoQU,642
-orchestrator/search/filters/base.py,sha256=E6fXcYEdFOAel90yHo41lVGplbCqUsPvPiMJbCO5FCk,11152
-orchestrator/search/filters/date_filters.py,sha256=dDbTPI-badVnaKM404waQ3yzTOHJNn59kYoqHvW3XFE,2460
-orchestrator/search/filters/definitions.py,sha256=oIwW8dWz7HuRkEvCbCfj2WOOdE_PKh0b5n8Re5x_lS0,3455
-orchestrator/search/filters/ltree_filters.py,sha256=kyMmm1EYKYVUwPK5p9tyL-da0SrCe6LPmFW56_6y0uY,1696
-orchestrator/search/filters/numeric_filter.py,sha256=GPBcZgrip2ruxsBx2AHZqxS16zkQG3C6zLJAGC2s2VU,2194
-orchestrator/search/indexing/__init__.py,sha256=7IVylH0S5FPUh6jb9H9vNLb61gQQIk_sNrSHc8WoSD0,82
-orchestrator/search/indexing/indexer.py,sha256=9l4bXwNAfsjMrrzit601solAl6W07Pyj9-SRldmZjGU,14391
-orchestrator/search/indexing/registry.py,sha256=cSeZe6aq3XME-RRz4AMD8BHXzx7dvU6tBa05ecjTzfk,2468
-orchestrator/search/indexing/tasks.py,sha256=k7GihQLov8FMhzYM_6f-IlWPMuP1w2QZpfOyloppKFM,1783
-orchestrator/search/indexing/traverse.py,sha256=_lWbUHy1S5-oDyo-4dDeivb9KTn6VUq_T_KXxFm_A2Y,13775
-orchestrator/search/retrieval/__init__.py,sha256=EixZVzUzP3FOC-hWwf3pqvz0XHZe1HyHBsmJlTEU0Cw,65
-orchestrator/search/retrieval/builder.py,sha256=homctoLPN1wnbsraJWEX82zyL3vANPymhtRAcrnF0qk,4064
-orchestrator/search/retrieval/engine.py,sha256=yJn65Nv-HIRJ6yLGwgRxdNAdsXmWvoLUK2WB9PRF1fg,5554
-orchestrator/search/retrieval/pagination.py,sha256=-j-vtdPsmUlKCuN7ffwMzEeWG7vLKlJ2NDmRGAGahxM,2773
-orchestrator/search/retrieval/retriever.py,sha256=140SMmBnCGhckPC9nZbe0T-DFPpQBNd6w-_3mY0-_Vs,17465
-orchestrator/search/retrieval/utils.py,sha256=BhrCqSO5fDlDEzqS81dR-Lpd52JgbnR3YS4h9TXx4Bs,3862
-orchestrator/search/retrieval/validation.py,sha256=KvPjvnl67mq2iMbjBc3YLMZ_XMiK3AygRDxrWKAPP_Y,5829
-orchestrator/search/schemas/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orchestrator/search/schemas/parameters.py,sha256=X74WzGO6tmiQ9XAQ2GdgIpqt3KzzqvaByrfB_tdWEX4,4110
-orchestrator/search/schemas/results.py,sha256=NZtiycuJ54DSMV_pfo4K3heuNgSqaHRqqDYe5GSKqrI,1406
+orchestrator/search/filters/__init__.py,sha256=Yutr21lv8RtZf5OKaBozlYufgmmV2QHuzAPPjvUamLE,1222
+orchestrator/search/filters/base.py,sha256=sk9m65M_viJV08YpBUm8CrLwmb-o9GcqAMXztqVAVtU,11612
+orchestrator/search/filters/date_filters.py,sha256=0a6nbUTK647_Qf4XXZMLDvBLVjF5Qqy9eJ-9SrTGaGg,3040
+orchestrator/search/filters/definitions.py,sha256=wl2HiXlTWXQN4JmuSq2SBuhTMvyIeonTtUZoCrJAK6M,4093
+orchestrator/search/filters/ltree_filters.py,sha256=1OOmM5K90NsGBQmTqyoDlphdAOGd9r2rmz1rNItm8yk,2341
+orchestrator/search/filters/numeric_filter.py,sha256=lcOAOpPNTwA0SW8QPiMOs1oKTYZLwGDQSrwFydXgMUU,2774
+orchestrator/search/indexing/__init__.py,sha256=Or78bizNPiuNOgwLGJQ0mspCF1G_gSe5C9Ap7qi0MZk,662
+orchestrator/search/indexing/indexer.py,sha256=Iw9BZWWpMPdhMffMwpZt1QrACSmmMVFg29R04zYuQgA,14971
+orchestrator/search/indexing/registry.py,sha256=zEOUmQDmZHJ4xzT63VSJzuuHWVTnuBSvhZg4l6lFTUU,3048
+orchestrator/search/indexing/tasks.py,sha256=UKG5EKE_QZGrYMSuVZB8UWw14U3f6enanTzQVbxS3Is,2363
+orchestrator/search/indexing/traverse.py,sha256=NKkKSri-if1d1vwzTQlDCF0hvBdB2IbWWuMdPrQ78Jg,14330
+orchestrator/search/retrieval/__init__.py,sha256=JP5WGYhmjd2RKXEExorvU6koMBLsTLdlDGCR_r1t8ug,645
+orchestrator/search/retrieval/builder.py,sha256=70cEvbsWI1dj-4H-LJq4o6Q71e3WERd-V6bzlZhGtHw,4607
+orchestrator/search/retrieval/engine.py,sha256=b7qEw-DA-JEnOTXNm9baKNqLFpNAy9RHQF9s4oEFzvo,6312
+orchestrator/search/retrieval/exceptions.py,sha256=oHoLGLLxxmVcV-W36uK0V-Pn4vf_iw6hajpQbap3NqI,3588
+orchestrator/search/retrieval/pagination.py,sha256=bRcXtWxxWvOhCQyhjwfJ7S6q_Dn3pYm8TCg7ofjVP44,3353
+orchestrator/search/retrieval/utils.py,sha256=svhF9YfMClq2MVPArS3ir3pg5_e_bremquv_l6tTsOQ,4597
+orchestrator/search/retrieval/validation.py,sha256=AjhttVJWlZDaT1_pUL_LaypQV11U21JpTCE4OwnpoqA,5849
+orchestrator/search/retrieval/retrievers/__init__.py,sha256=1bGmbae0GYRM6e1vxf0ww79NaTSmfOMe9S0pPVmh3CM,897
+orchestrator/search/retrieval/retrievers/base.py,sha256=zg1Sbz_YKBXIfyn69tiTrW8quFvwmeFGNNMU8QQvHfU,4525
+orchestrator/search/retrieval/retrievers/fuzzy.py,sha256=U_WNAaxSUVUlVrmFrYFt-s0ebw9ift1Z2zBHG8TSPLE,3839
+orchestrator/search/retrieval/retrievers/hybrid.py,sha256=iQ977OF7GeAv-Pv2eALAxz-KwOL6EUmooSVnHZl5Dsw,7628
+orchestrator/search/retrieval/retrievers/semantic.py,sha256=oWNJ9DuqM16BXYXUwmRmkfDmp_2vQH2PySNMk8TcvVk,3961
+orchestrator/search/retrieval/retrievers/structured.py,sha256=OHsHEjjLg1QwtEytQNeyWcCBQd8rJxHVf59HxvA9_vc,1452
+orchestrator/search/schemas/__init__.py,sha256=q5G0z3nKjIHKFs1PkEG3nvTUy3Wp4kCyBtCbqUITj3A,579
+orchestrator/search/schemas/parameters.py,sha256=aglbVvvM_gT-zTpVQh05wIUnfn2mD1JKIiWH_VaTqaM,4690
+orchestrator/search/schemas/results.py,sha256=EsbYS8XJ8r5JoN17N4z1lHIShgg7RW973mi6yILcHOI,1987
 orchestrator/services/__init__.py,sha256=GyHNfEFCGKQwRiN6rQmvSRH2iYX7npjMZn97n8XzmLU,571
 orchestrator/services/fixed_inputs.py,sha256=kyz7s2HLzyDulvcq-ZqefTw1om86COvyvTjz0_5CmgI,876
 orchestrator/services/input_state.py,sha256=6BZOpb3cHpO18K-XG-3QUIV9pIM25_ufdODrp5CmXG4,2390
@@ -360,9 +366,9 @@ orchestrator/workflows/tasks/__init__.py,sha256=GyHNfEFCGKQwRiN6rQmvSRH2iYX7npjM
 orchestrator/workflows/tasks/cleanup_tasks_log.py,sha256=BfWYbPXhnLAHUJ0mlODDnjZnQQAvKCZJDVTwbwOWI04,1624
 orchestrator/workflows/tasks/resume_workflows.py,sha256=T3iobSJjVgiupe0rClD34kUZ7KF4pL5yK2AVeRLZog8,4313
 orchestrator/workflows/tasks/validate_product_type.py,sha256=paG-NAY1bdde3Adt8zItkcBKf5Pxw6f5ngGW6an6dYU,3192
-orchestrator/workflows/tasks/validate_products.py,sha256=GZJBoFF-WMphS7ghMs2-gqvV2iL1F0POhk0uSNt93n0,8510
+orchestrator/workflows/tasks/validate_products.py,sha256=kXBGZTkobfYH8e_crhdErT-ypdouH0a3_WLImmbKXcE,8523
 orchestrator/workflows/translations/en-GB.json,sha256=ST53HxkphFLTMjFHonykDBOZ7-P_KxksktZU3GbxLt0,846
-orchestrator_core-4.5.0a2.dist-info/licenses/LICENSE,sha256=b-aA5OZQuuBATmLKo_mln8CQrDPPhg3ghLzjPjLn4Tg,11409
-orchestrator_core-4.5.0a2.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
-orchestrator_core-4.5.0a2.dist-info/METADATA,sha256=fxKSeq4fVKEvTapkag42vtmn2h1HegxEqXJPHEHDiCc,6177
-orchestrator_core-4.5.0a2.dist-info/RECORD,,
+orchestrator_core-4.5.0a3.dist-info/licenses/LICENSE,sha256=b-aA5OZQuuBATmLKo_mln8CQrDPPhg3ghLzjPjLn4Tg,11409
+orchestrator_core-4.5.0a3.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+orchestrator_core-4.5.0a3.dist-info/METADATA,sha256=m1FaoxcMxdfPSE_HwuQ0QSJc432amisFx_jE82A6lPI,6169
+orchestrator_core-4.5.0a3.dist-info/RECORD,,

orchestrator/search/retrieval/retriever.py

@@ -1,447 +0,0 @@
-from abc import ABC, abstractmethod
-from decimal import Decimal
-
-import structlog
-from sqlalchemy import BindParameter, Numeric, Select, and_, bindparam, case, cast, func, literal, or_, select
-from sqlalchemy.sql.expression import ColumnElement
-
-from orchestrator.db.models import AiSearchIndex
-from orchestrator.search.core.types import FieldType, SearchMetadata
-from orchestrator.search.schemas.parameters import BaseSearchParameters
-
-from .pagination import PaginationParams
-
-logger = structlog.get_logger(__name__)
-
-
-class Retriever(ABC):
-    """Abstract base class for applying a ranking strategy to a search query."""
-
-    SCORE_PRECISION = 12
-    SCORE_NUMERIC_TYPE = Numeric(38, 12)
-    HIGHLIGHT_TEXT_LABEL = "highlight_text"
-    HIGHLIGHT_PATH_LABEL = "highlight_path"
-    SCORE_LABEL = "score"
-    SEARCHABLE_FIELD_TYPES = [
-        FieldType.STRING.value,
-        FieldType.UUID.value,
-        FieldType.BLOCK.value,
-        FieldType.RESOURCE_TYPE.value,
-    ]
-
-    @classmethod
-    async def from_params(
-        cls,
-        params: BaseSearchParameters,
-        pagination_params: PaginationParams,
-    ) -> "Retriever":
-        """Create the appropriate retriever instance from search parameters.
-
-        Parameters
-        ----------
-        params : BaseSearchParameters
-            Search parameters including vector queries, fuzzy terms, and filters.
-        pagination_params : PaginationParams
-            Pagination parameters for cursor-based paging.
-
-        Returns:
-        -------
-        Retriever
-            A concrete retriever instance (semantic, fuzzy, hybrid, or structured).
-        """
-        fuzzy_term = params.fuzzy_term
-        q_vec = await cls._get_query_vector(params.vector_query, pagination_params.q_vec_override)
-
-        # If semantic search was attempted but failed, fall back to fuzzy with the full query
-        fallback_fuzzy_term = fuzzy_term
-        if q_vec is None and params.vector_query is not None and params.query is not None:
-            fallback_fuzzy_term = params.query
-
-        if q_vec is not None and fallback_fuzzy_term is not None:
-            return RrfHybridRetriever(q_vec, fallback_fuzzy_term, pagination_params)
-        if q_vec is not None:
-            return SemanticRetriever(q_vec, pagination_params)
-        if fallback_fuzzy_term is not None:
-            return FuzzyRetriever(fallback_fuzzy_term, pagination_params)
-
-        return StructuredRetriever(pagination_params)
-
-    @classmethod
-    async def _get_query_vector(
-        cls, vector_query: str | None, q_vec_override: list[float] | None
-    ) -> list[float] | None:
-        """Get query vector either from override or by generating from text."""
-        if q_vec_override:
-            return q_vec_override
-
-        if not vector_query:
-            return None
-
-        from orchestrator.search.core.embedding import QueryEmbedder
-
-        q_vec = await QueryEmbedder.generate_for_text_async(vector_query)
-        if not q_vec:
-            logger.warning("Embedding generation failed; using non-semantic retriever")
-            return None
-
-        return q_vec
-
-    @abstractmethod
-    def apply(self, candidate_query: Select) -> Select:
-        """Apply the ranking logic to the given candidate query.
-
-        Parameters
-        ----------
-        candidate_query : Select
-            A SQLAlchemy `Select` statement returning candidate entity IDs.
-
-        Returns:
-        -------
-        Select
-            A new `Select` statement with ranking expressions applied.
-        """
-        ...
-
-    def _quantize_score_for_pagination(self, score_value: float) -> BindParameter[Decimal]:
-        """Convert score value to properly quantized Decimal parameter for pagination."""
-        pas_dec = Decimal(str(score_value)).quantize(Decimal("0.000000000001"))
-        return literal(pas_dec, type_=self.SCORE_NUMERIC_TYPE)
-
-    @property
-    @abstractmethod
-    def metadata(self) -> SearchMetadata:
-        """Return metadata describing this search strategy."""
-        ...
-
-
-class StructuredRetriever(Retriever):
-    """Applies a dummy score for purely structured searches with no text query."""
-
-    def __init__(self, pagination_params: PaginationParams) -> None:
-        self.page_after_id = pagination_params.page_after_id
-
-    def apply(self, candidate_query: Select) -> Select:
-        cand = candidate_query.subquery()
-        stmt = select(cand.c.entity_id, literal(1.0).label("score")).select_from(cand)
-
-        if self.page_after_id:
-            stmt = stmt.where(cand.c.entity_id > self.page_after_id)
-
-        return stmt.order_by(cand.c.entity_id.asc())
-
-    @property
-    def metadata(self) -> SearchMetadata:
-        return SearchMetadata.structured()
-
-
-class FuzzyRetriever(Retriever):
-    """Ranks results based on the max of fuzzy text similarity scores."""
-
-    def __init__(self, fuzzy_term: str, pagination_params: PaginationParams) -> None:
-        self.fuzzy_term = fuzzy_term
-        self.page_after_score = pagination_params.page_after_score
-        self.page_after_id = pagination_params.page_after_id
-
-    def apply(self, candidate_query: Select) -> Select:
-        cand = candidate_query.subquery()
-
-        similarity_expr = func.word_similarity(self.fuzzy_term, AiSearchIndex.value)
-
-        raw_max = func.max(similarity_expr).over(partition_by=AiSearchIndex.entity_id)
-        score = cast(
-            func.round(cast(raw_max, self.SCORE_NUMERIC_TYPE), self.SCORE_PRECISION), self.SCORE_NUMERIC_TYPE
-        ).label(self.SCORE_LABEL)
-
-        combined_query = (
-            select(
-                AiSearchIndex.entity_id,
-                score,
-                func.first_value(AiSearchIndex.value)
-                .over(partition_by=AiSearchIndex.entity_id, order_by=[similarity_expr.desc(), AiSearchIndex.path.asc()])
-                .label(self.HIGHLIGHT_TEXT_LABEL),
-                func.first_value(AiSearchIndex.path)
-                .over(partition_by=AiSearchIndex.entity_id, order_by=[similarity_expr.desc(), AiSearchIndex.path.asc()])
-                .label(self.HIGHLIGHT_PATH_LABEL),
-            )
-            .select_from(AiSearchIndex)
-            .join(cand, cand.c.entity_id == AiSearchIndex.entity_id)
-            .where(
-                and_(
-                    AiSearchIndex.value_type.in_(self.SEARCHABLE_FIELD_TYPES),
-                    literal(self.fuzzy_term).op("<%")(AiSearchIndex.value),
-                )
-            )
-            .distinct(AiSearchIndex.entity_id)
-        )
-        final_query = combined_query.subquery("ranked_fuzzy")
-
-        stmt = select(
-            final_query.c.entity_id,
-            final_query.c.score,
-            final_query.c.highlight_text,
-            final_query.c.highlight_path,
-        ).select_from(final_query)
-
-        stmt = self._apply_score_pagination(stmt, final_query.c.score, final_query.c.entity_id)
-
-        return stmt.order_by(final_query.c.score.desc().nulls_last(), final_query.c.entity_id.asc())
-
-    @property
-    def metadata(self) -> SearchMetadata:
-        return SearchMetadata.fuzzy()
-
-    def _apply_score_pagination(
-        self, stmt: Select, score_column: ColumnElement, entity_id_column: ColumnElement
-    ) -> Select:
-        """Apply standard score + entity_id pagination."""
-        if self.page_after_score is not None and self.page_after_id is not None:
-            stmt = stmt.where(
-                or_(
-                    score_column < self.page_after_score,
-                    and_(
-                        score_column == self.page_after_score,
-                        entity_id_column > self.page_after_id,
-                    ),
-                )
-            )
-        return stmt
-
-
-class SemanticRetriever(Retriever):
-    """Ranks results based on the minimum semantic vector distance."""
-
-    def __init__(self, vector_query: list[float], pagination_params: PaginationParams) -> None:
-        self.vector_query = vector_query
-        self.page_after_score = pagination_params.page_after_score
-        self.page_after_id = pagination_params.page_after_id
-
-    def apply(self, candidate_query: Select) -> Select:
-        cand = candidate_query.subquery()
-
-        dist = AiSearchIndex.embedding.l2_distance(self.vector_query)
-
-        raw_min = func.min(dist).over(partition_by=AiSearchIndex.entity_id)
-
-        # Normalize score to preserve ordering in accordance with other retrievers:
-        # smaller distance = higher score
-        similarity = literal(1.0, type_=self.SCORE_NUMERIC_TYPE) / (
-            literal(1.0, type_=self.SCORE_NUMERIC_TYPE) + cast(raw_min, self.SCORE_NUMERIC_TYPE)
-        )
-
-        score = cast(
-            func.round(cast(similarity, self.SCORE_NUMERIC_TYPE), self.SCORE_PRECISION), self.SCORE_NUMERIC_TYPE
-        ).label(self.SCORE_LABEL)
-
-        combined_query = (
-            select(
-                AiSearchIndex.entity_id,
-                score,
-                func.first_value(AiSearchIndex.value)
-                .over(partition_by=AiSearchIndex.entity_id, order_by=[dist.asc(), AiSearchIndex.path.asc()])
-                .label(self.HIGHLIGHT_TEXT_LABEL),
-                func.first_value(AiSearchIndex.path)
-                .over(partition_by=AiSearchIndex.entity_id, order_by=[dist.asc(), AiSearchIndex.path.asc()])
-                .label(self.HIGHLIGHT_PATH_LABEL),
-            )
-            .select_from(AiSearchIndex)
-            .join(cand, cand.c.entity_id == AiSearchIndex.entity_id)
-            .where(AiSearchIndex.embedding.isnot(None))
-            .distinct(AiSearchIndex.entity_id)
-        )
-        final_query = combined_query.subquery("ranked_semantic")
-
-        stmt = select(
-            final_query.c.entity_id,
-            final_query.c.score,
-            final_query.c.highlight_text,
-            final_query.c.highlight_path,
-        ).select_from(final_query)
-
-        stmt = self._apply_semantic_pagination(stmt, final_query.c.score, final_query.c.entity_id)
-
-        return stmt.order_by(final_query.c.score.desc().nulls_last(), final_query.c.entity_id.asc())
-
-    @property
-    def metadata(self) -> SearchMetadata:
-        return SearchMetadata.semantic()
-
-    def _apply_semantic_pagination(
-        self, stmt: Select, score_column: ColumnElement, entity_id_column: ColumnElement
-    ) -> Select:
-        """Apply semantic score pagination with precise Decimal handling."""
-        if self.page_after_score is not None and self.page_after_id is not None:
-            score_param = self._quantize_score_for_pagination(self.page_after_score)
-            stmt = stmt.where(
-                or_(
-                    score_column < score_param,
-                    and_(score_column == score_param, entity_id_column > self.page_after_id),
-                )
-            )
-        return stmt
-
-
-class RrfHybridRetriever(Retriever):
-    """Reciprocal Rank Fusion of semantic and fuzzy ranking with parent-child retrieval."""
-
-    def __init__(
-        self,
-        q_vec: list[float],
-        fuzzy_term: str,
-        pagination_params: PaginationParams,
-        k: int = 60,
-        field_candidates_limit: int = 100,
-    ) -> None:
-        self.q_vec = q_vec
-        self.fuzzy_term = fuzzy_term
-        self.page_after_score = pagination_params.page_after_score
-        self.page_after_id = pagination_params.page_after_id
-        self.k = k
-        self.field_candidates_limit = field_candidates_limit
-
-    def apply(self, candidate_query: Select) -> Select:
-        cand = candidate_query.subquery()
-        q_param: BindParameter[list[float]] = bindparam("q_vec", self.q_vec, type_=AiSearchIndex.embedding.type)
-
-        best_similarity = func.word_similarity(self.fuzzy_term, AiSearchIndex.value)
-        sem_expr = case(
-            (AiSearchIndex.embedding.is_(None), None),
-            else_=AiSearchIndex.embedding.op("<->")(q_param),
-        )
-        sem_val = func.coalesce(sem_expr, literal(1.0)).label("semantic_distance")
-
-        filter_condition = literal(self.fuzzy_term).op("<%")(AiSearchIndex.value)
-
-        field_candidates = (
-            select(
-                AiSearchIndex.entity_id,
-                AiSearchIndex.path,
-                AiSearchIndex.value,
-                sem_val,
-                best_similarity.label("fuzzy_score"),
-            )
-            .select_from(AiSearchIndex)
-            .join(cand, cand.c.entity_id == AiSearchIndex.entity_id)
-            .where(
-                and_(
-                    AiSearchIndex.value_type.in_(self.SEARCHABLE_FIELD_TYPES),
-                    filter_condition,
-                )
-            )
-            .order_by(
-                best_similarity.desc().nulls_last(),
-                sem_expr.asc().nulls_last(),
-                AiSearchIndex.entity_id.asc(),
-            )
-            .limit(self.field_candidates_limit)
-        ).cte("field_candidates")
-
-        entity_scores = (
-            select(
-                field_candidates.c.entity_id,
-                func.avg(field_candidates.c.semantic_distance).label("avg_semantic_distance"),
-                func.avg(field_candidates.c.fuzzy_score).label("avg_fuzzy_score"),
-            ).group_by(field_candidates.c.entity_id)
-        ).cte("entity_scores")
-
-        entity_highlights = (
-            select(
-                field_candidates.c.entity_id,
-                func.first_value(field_candidates.c.value)
-                .over(
-                    partition_by=field_candidates.c.entity_id,
-                    order_by=[field_candidates.c.fuzzy_score.desc(), field_candidates.c.path.asc()],
-                )
-                .label(self.HIGHLIGHT_TEXT_LABEL),
-                func.first_value(field_candidates.c.path)
-                .over(
-                    partition_by=field_candidates.c.entity_id,
-                    order_by=[field_candidates.c.fuzzy_score.desc(), field_candidates.c.path.asc()],
-                )
-                .label(self.HIGHLIGHT_PATH_LABEL),
-            ).distinct(field_candidates.c.entity_id)
-        ).cte("entity_highlights")
-
-        ranked = (
-            select(
-                entity_scores.c.entity_id,
-                entity_scores.c.avg_semantic_distance,
-                entity_scores.c.avg_fuzzy_score,
-                entity_highlights.c.highlight_text,
-                entity_highlights.c.highlight_path,
-                func.dense_rank()
-                .over(
-                    order_by=[entity_scores.c.avg_semantic_distance.asc().nulls_last(), entity_scores.c.entity_id.asc()]
-                )
-                .label("sem_rank"),
-                func.dense_rank()
-                .over(order_by=[entity_scores.c.avg_fuzzy_score.desc().nulls_last(), entity_scores.c.entity_id.asc()])
-                .label("fuzzy_rank"),
-            ).select_from(
-                entity_scores.join(entity_highlights, entity_scores.c.entity_id == entity_highlights.c.entity_id)
-            )
-        ).cte("ranked_results")
-
-        # RRF (rank-based)
-        rrf_raw = (1.0 / (self.k + ranked.c.sem_rank)) + (1.0 / (self.k + ranked.c.fuzzy_rank))
-        rrf_num = cast(rrf_raw, self.SCORE_NUMERIC_TYPE)
-
-        # Perfect flag to boost near perfect fuzzy matches as this most likely indicates the desired record.
-        perfect = case((ranked.c.avg_fuzzy_score >= 0.9, 1), else_=0).label("perfect_match")
-
-        # Dynamic beta based on k (and number of sources)
-        # rrf_max = n_sources / (k + 1)
-        k_num = literal(float(self.k), type_=self.SCORE_NUMERIC_TYPE)
-        n_sources = literal(2.0, type_=self.SCORE_NUMERIC_TYPE)  # semantic + fuzzy
-        rrf_max = n_sources / (k_num + literal(1.0, type_=self.SCORE_NUMERIC_TYPE))
-
-        # Choose a small positive margin above rrf_max to ensure strict separation
-        # Keep it small to avoid compressing perfects near 1 after normalization
-        margin = rrf_max * literal(0.05, type_=self.SCORE_NUMERIC_TYPE)  # 5% above bound
-        beta = rrf_max + margin
-
-        fused_num = rrf_num + beta * cast(perfect, self.SCORE_NUMERIC_TYPE)
-
-        # Normalize to [0,1] via the theoretical max (beta + rrf_max)
-        norm_den = beta + rrf_max
-        normalized_score = fused_num / norm_den
-
-        score = cast(
-            func.round(cast(normalized_score, self.SCORE_NUMERIC_TYPE), self.SCORE_PRECISION),
-            self.SCORE_NUMERIC_TYPE,
-        ).label(self.SCORE_LABEL)
-
-        stmt = select(
-            ranked.c.entity_id,
-            score,
-            ranked.c.highlight_text,
-            ranked.c.highlight_path,
-            perfect.label("perfect_match"),
-        ).select_from(ranked)
-
-        stmt = self._apply_fused_pagination(stmt, score, ranked.c.entity_id)
-
-        return stmt.order_by(
-            score.desc().nulls_last(),
-            ranked.c.entity_id.asc(),
-        ).params(q_vec=self.q_vec)
-
-    def _apply_fused_pagination(
-        self,
-        stmt: Select,
-        score_column: ColumnElement,
-        entity_id_column: ColumnElement,
-    ) -> Select:
-        """Keyset paginate by fused score + id."""
-        if self.page_after_score is not None and self.page_after_id is not None:
-            score_param = self._quantize_score_for_pagination(self.page_after_score)
-            stmt = stmt.where(
-                or_(
-                    score_column < score_param,
-                    and_(score_column == score_param, entity_id_column > self.page_after_id),
-                )
-            )
-        return stmt
-
-    @property
-    def metadata(self) -> SearchMetadata:
-        return SearchMetadata.hybrid()