orchestrator-core 4.5.0a7__tar.gz → 4.5.0a8__tar.gz

{orchestrator_core-4.5.0a7 → orchestrator_core-4.5.0a8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: orchestrator-core
-Version: 4.5.0a7
+Version: 4.5.0a8
 Summary: This is the orchestrator workflow engine.
 Author-email: SURF <automation-beheer@surf.nl>
 Requires-Python: >=3.11,<3.14
@@ -63,15 +63,17 @@ Requires-Dist: structlog>=25.4.0
 Requires-Dist: tabulate==0.9.0
 Requires-Dist: typer==0.15.4
 Requires-Dist: uvicorn[standard]~=0.34.0
+Requires-Dist: pydantic-ai-slim ==0.7.0 ; extra == "agent"
+Requires-Dist: ag-ui-protocol>=0.1.8 ; extra == "agent"
+Requires-Dist: litellm>=1.75.7 ; extra == "agent"
 Requires-Dist: celery~=5.5.1 ; extra == "celery"
-Requires-Dist: pydantic-ai-slim ==0.7.0 ; extra == "llm"
-Requires-Dist: ag-ui-protocol>=0.1.8 ; extra == "llm"
-Requires-Dist: litellm>=1.75.7 ; extra == "llm"
+Requires-Dist: litellm>=1.75.7 ; extra == "search"
 Project-URL: Documentation, https://workfloworchestrator.org/orchestrator-core
 Project-URL: Homepage, https://workfloworchestrator.org/orchestrator-core
 Project-URL: Source, https://github.com/workfloworchestrator/orchestrator-core
+Provides-Extra: agent
 Provides-Extra: celery
-Provides-Extra: llm
+Provides-Extra: search
 
 # Orchestrator-Core
 

{orchestrator_core-4.5.0a7 → orchestrator_core-4.5.0a8}/orchestrator/__init__.py

@@ -13,7 +13,7 @@
 
 """This is the orchestrator workflow engine."""
 
-__version__ = "4.5.0a7"
+__version__ = "4.5.0a8"
 
 
 from structlog import get_logger
@@ -25,18 +25,9 @@ logger.info("Starting the orchestrator", version=__version__)
 from orchestrator.llm_settings import llm_settings
 from orchestrator.settings import app_settings
 
-if llm_settings.LLM_ENABLED:
-    try:
-        from importlib import import_module
+if llm_settings.SEARCH_ENABLED or llm_settings.AGENT_ENABLED:
 
-        import_module("pydantic_ai")
-        from orchestrator.agentic_app import AgenticOrchestratorCore as OrchestratorCore
-
-    except ImportError:
-        logger.error(
-            "Unable to import 'pydantic_ai' module, please install the orchestrator with llm dependencies. `pip install orchestrator-core[llm]",
-        )
-        exit(1)
+    from orchestrator.agentic_app import LLMOrchestratorCore as OrchestratorCore
 else:
     from orchestrator.app import OrchestratorCore  # type: ignore[assignment]
 

orchestrator_core-4.5.0a8/orchestrator/agentic_app.py

@@ -0,0 +1,103 @@
+#!/usr/bin/env python3
+"""The main application module.
+
+This module contains the main `LLMOrchestratorCore` class for the `FastAPI` backend and
+provides the ability to run the CLI with LLM features (search and/or agent).
+"""
+# Copyright 2019-2025 SURF
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from typing import TYPE_CHECKING, Any
+
+import typer
+from structlog import get_logger
+
+from orchestrator.app import OrchestratorCore
+from orchestrator.cli.main import app as cli_app
+from orchestrator.llm_settings import LLMSettings, llm_settings
+
+if TYPE_CHECKING:
+    from pydantic_ai.models.openai import OpenAIModel
+    from pydantic_ai.toolsets import FunctionToolset
+
+logger = get_logger(__name__)
+
+
+class LLMOrchestratorCore(OrchestratorCore):
+    def __init__(
+        self,
+        *args: Any,
+        llm_settings: LLMSettings = llm_settings,
+        agent_model: "OpenAIModel | str | None" = None,
+        agent_tools: "list[FunctionToolset] | None" = None,
+        **kwargs: Any,
+    ) -> None:
+        """Initialize the `LLMOrchestratorCore` class.
+
+        This class extends `OrchestratorCore` with LLM features (search and agent).
+        It runs the search migration and mounts the agent endpoint based on feature flags.
+
+        Args:
+            *args: All the normal arguments passed to the `OrchestratorCore` class.
+            llm_settings: A class of settings for the LLM
+            agent_model: Override the agent model (defaults to llm_settings.AGENT_MODEL)
+            agent_tools: A list of tools that can be used by the agent
+            **kwargs: Additional arguments passed to the `OrchestratorCore` class.
+
+        Returns:
+            None
+        """
+        self.llm_settings = llm_settings
+        self.agent_model = agent_model or llm_settings.AGENT_MODEL
+        self.agent_tools = agent_tools
+
+        super().__init__(*args, **kwargs)
+
+        # Run search migration if search or agent is enabled
+        if self.llm_settings.SEARCH_ENABLED or self.llm_settings.AGENT_ENABLED:
+            logger.info("Running search migration")
+            try:
+                from orchestrator.db import db
+                from orchestrator.search.llm_migration import run_migration
+
+                with db.engine.begin() as connection:
+                    run_migration(connection)
+            except ImportError as e:
+                logger.error(
+                    "Unable to run search migration. Please install search dependencies: "
+                    "`pip install orchestrator-core[search]`",
+                    error=str(e),
+                )
+                raise
+
+        # Mount agent endpoint if agent is enabled
+        if self.llm_settings.AGENT_ENABLED:
+            logger.info("Initializing agent features", model=self.agent_model)
+            try:
+                from orchestrator.search.agent import build_agent_router
+
+                agent_app = build_agent_router(self.agent_model, self.agent_tools)
+                self.mount("/agent", agent_app)
+            except ImportError as e:
+                logger.error(
+                    "Unable to initialize agent features. Please install agent dependencies: "
+                    "`pip install orchestrator-core[agent]`",
+                    error=str(e),
+                )
+                raise
+
+
+main_typer_app = typer.Typer()
+main_typer_app.add_typer(cli_app, name="orchestrator", help="The orchestrator CLI commands")
+
+if __name__ == "__main__":
+    main_typer_app()

{orchestrator_core-4.5.0a7 → orchestrator_core-4.5.0a8}/orchestrator/api/api_v1/api.py

@@ -89,7 +89,7 @@ api_router.include_router(
     ws.router, prefix="/ws", tags=["Core", "Events"]
 )  # Auth on the websocket is handled in the Websocket Manager
 
-if llm_settings.LLM_ENABLED:
+if llm_settings.SEARCH_ENABLED:
     from orchestrator.api.api_v1.endpoints import search
 
     api_router.include_router(

{orchestrator_core-4.5.0a7 → orchestrator_core-4.5.0a8}/orchestrator/api/api_v1/endpoints/search.py

@@ -24,6 +24,7 @@ from orchestrator.db import (
     db,
 )
 from orchestrator.domain.base import SubscriptionModel
+from orchestrator.domain.context_cache import cache_subscription_models
 from orchestrator.schemas.search import (
     PageInfoSchema,
     PathsResponse,
@@ -192,17 +193,22 @@ async def search_subscriptions(
     page_info = PageInfoSchema(has_next_page=has_next_page, next_page_cursor=next_page_cursor)
 
     search_info_map = {res.entity_id: res for res in search_response.results}
-    results_data = []
-    for sub_id, search_info in search_info_map.items():
-        subscription_model = SubscriptionModel.from_subscription(sub_id)
-        sub_data = subscription_model.model_dump(exclude_unset=False)
-        search_result_item = SubscriptionSearchResult(
-            subscription=format_special_types(sub_data),
+
+    with cache_subscription_models():
+        subscriptions_data = {
+            sub_id: SubscriptionModel.from_subscription(sub_id).model_dump(exclude_unset=False)
+            for sub_id in search_info_map
+        }
+
+    results_data = [
+        SubscriptionSearchResult(
+            subscription=format_special_types(subscriptions_data[sub_id]),
             score=search_info.score,
             perfect_match=search_info.perfect_match,
             matching_field=search_info.matching_field,
         )
-        results_data.append(search_result_item)
+        for sub_id, search_info in search_info_map.items()
+    ]
 
     return SearchResultsSchema(data=results_data, page_info=page_info, search_metadata=search_response.metadata)
 

{orchestrator_core-4.5.0a7 → orchestrator_core-4.5.0a8}/orchestrator/cli/main.py

@@ -25,8 +25,8 @@ app.add_typer(scheduler.app, name="scheduler", help="Access all the scheduler fu
 app.add_typer(database.app, name="db", help="Interact with the application database")
 app.add_typer(generate.app, name="generate", help="Generate products, workflows and other artifacts")
 
-if llm_settings.LLM_ENABLED:
-    from orchestrator.cli import index_llm, resize_embedding, search_explore, speedtest
+if llm_settings.SEARCH_ENABLED:
+    from orchestrator.cli.search import index_llm, resize_embedding, search_explore, speedtest
 
     app.add_typer(index_llm.app, name="index", help="(Re-)Index the search table.")
     app.add_typer(search_explore.app, name="search", help="Try out different search types.")

orchestrator_core-4.5.0a8/orchestrator/cli/search/__init__.py

@@ -0,0 +1,32 @@
+# Copyright 2019-2020 SURF.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import typer
+
+from orchestrator.cli.search import index_llm, resize_embedding, search_explore, speedtest
+
+
+def register_commands(app: typer.Typer) -> None:
+    """Register all LLM/search related commands to the main app."""
+    app.add_typer(index_llm.app, name="index", help="(Re-)Index the search table.")
+    app.add_typer(search_explore.app, name="search", help="Try out different search types.")
+    app.add_typer(
+        resize_embedding.app,
+        name="embedding",
+        help="Resize the vector dimension of the embedding column in the search table.",
+    )
+    app.add_typer(
+        speedtest.app,
+        name="speedtest",
+        help="Search performance testing and analysis.",
+    )

{orchestrator_core-4.5.0a7 → orchestrator_core-4.5.0a8}/orchestrator/llm_settings.py

@@ -18,7 +18,10 @@ logger = get_logger(__name__)
 
 
 class LLMSettings(BaseSettings):
-    LLM_ENABLED: bool = False  # Default to false
+    # Feature flags for LLM functionality
+    SEARCH_ENABLED: bool = False  # Enable search/indexing with embeddings
+    AGENT_ENABLED: bool = False  # Enable agentic functionality
+
     # Pydantic-ai Agent settings
     AGENT_MODEL: str = "gpt-4o-mini"  # See pydantic-ai docs for supported models.
     AGENT_MODEL_VERSION: str = "2025-01-01-preview"
@@ -30,11 +33,11 @@ class LLMSettings(BaseSettings):
         0.1, description="Safety margin as a percentage (e.g., 0.1 for 10%) for token budgeting.", ge=0, le=1
     )
 
-    # The following settings are only needed for local models.
+    # The following settings are only needed for local models or system constraints.
     # By default, they are set conservative assuming a small model like All-MiniLM-L6-V2.
     OPENAI_BASE_URL: str | None = None
     EMBEDDING_FALLBACK_MAX_TOKENS: int | None = 512
-    EMBEDDING_MAX_BATCH_SIZE: int | None = 32
+    EMBEDDING_MAX_BATCH_SIZE: int | None = None
 
     # General LiteLLM settings
     LLM_MAX_RETRIES: int = 3

{orchestrator_core-4.5.0a7 → orchestrator_core-4.5.0a8}/orchestrator/search/agent/__init__.py

@@ -14,8 +14,8 @@
 # This module requires: pydantic-ai==0.7.0, ag-ui-protocol>=0.1.8
 
 
-from orchestrator.search.agent.agent import build_agent_app
+from orchestrator.search.agent.agent import build_agent_router
 
 __all__ = [
-    "build_agent_app",
+    "build_agent_router",
 ]

{orchestrator_core-4.5.0a7 → orchestrator_core-4.5.0a8}/orchestrator/search/agent/agent.py

@@ -14,13 +14,13 @@
 from typing import Any
 
 import structlog
-from fastapi import FastAPI, HTTPException
-from pydantic_ai.ag_ui import StateDeps
+from fastapi import APIRouter, HTTPException, Request
+from pydantic_ai.ag_ui import StateDeps, handle_ag_ui_request
 from pydantic_ai.agent import Agent
 from pydantic_ai.models.openai import OpenAIModel
 from pydantic_ai.settings import ModelSettings
 from pydantic_ai.toolsets import FunctionToolset
-from starlette.types import ASGIApp
+from starlette.responses import Response
 
 from orchestrator.search.agent.prompts import get_base_instructions, get_dynamic_instructions
 from orchestrator.search.agent.state import SearchState
@@ -29,17 +29,9 @@ from orchestrator.search.agent.tools import search_toolset
 logger = structlog.get_logger(__name__)
 
 
-def _disabled_agent_app(reason: str) -> FastAPI:
-    app = FastAPI(title="Agent disabled")
+def build_agent_router(model: str | OpenAIModel, toolsets: list[FunctionToolset[Any]] | None = None) -> APIRouter:
+    router = APIRouter()
 
-    @app.api_route("/{path:path}", methods=["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "HEAD"])
-    async def _disabled(path: str) -> None:
-        raise HTTPException(status_code=503, detail=f"Agent disabled: {reason}")
-
-    return app
-
-
-def build_agent_app(model: str | OpenAIModel, toolsets: list[FunctionToolset[Any]] | None = None) -> ASGIApp:
     try:
         toolsets = toolsets + [search_toolset] if toolsets else [search_toolset]
 
@@ -54,7 +46,17 @@ def build_agent_app(model: str | OpenAIModel, toolsets: list[FunctionToolset[Any
         agent.instructions(get_base_instructions)
         agent.instructions(get_dynamic_instructions)
 
-        return agent.to_ag_ui(deps=StateDeps(SearchState()))
+        @router.post("/")
+        async def agent_endpoint(request: Request) -> Response:
+            return await handle_ag_ui_request(agent, request, deps=StateDeps(SearchState()))
+
+        return router
     except Exception as e:
         logger.error("Agent init failed; serving disabled stub.", error=str(e))
-        return _disabled_agent_app(str(e))
+        error_msg = f"Agent disabled: {str(e)}"
+
+        @router.api_route("/{path:path}", methods=["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "HEAD"])
+        async def _disabled(path: str) -> None:
+            raise HTTPException(status_code=503, detail=error_msg)
+
+        return router

{orchestrator_core-4.5.0a7 → orchestrator_core-4.5.0a8}/orchestrator/search/docs/running_local_text_embedding_inference.md

@@ -18,6 +18,7 @@ Point your backend to the local endpoint and declare the new vector size:
 ```env
 OPENAI_BASE_URL=http://localhost:8080/v1
 EMBEDDING_DIMENSION=384
+EMBEDDING_MAX_BATCH_SIZE=32 # Not required when using OpenAI embeddings
 ```
 
 Depending on the model, you might want to change the `EMBEDDING_FALLBACK_MAX_TOKENS` and `EMBEDDING_MAX_BATCH_SIZE` settings, which are set conservatively and according to the requirements of the setup used in this example.

{orchestrator_core-4.5.0a7 → orchestrator_core-4.5.0a8}/orchestrator/search/filters/base.py

@@ -226,6 +226,38 @@ class FilterTree(BaseModel):
                 leaves.extend(child.get_all_leaves())
         return leaves
 
+    @staticmethod
+    def _build_correlates(
+        alias: Any, entity_id_col: SQLAColumn, entity_type_value: str | None
+    ) -> list[ColumnElement[bool]]:
+        """Build the correlation predicates that link the subquery to the outer query."""
+        correlates = [alias.entity_id == entity_id_col]
+        if entity_type_value is not None:
+            correlates.append(alias.entity_type == entity_type_value)
+        return correlates
+
+    @staticmethod
+    def _handle_ltree_filter(pf: PathFilter, alias: Any, correlates: list[ColumnElement[bool]]) -> ColumnElement[bool]:
+        """Handle path-only filters (has_component, not_has_component, ends_with)."""
+        # row-level predicate is always positive
+        positive = pf.condition.to_expression(alias.path, pf.path)
+        subq = select(1).select_from(alias).where(and_(*correlates, positive))
+        if pf.condition.op == FilterOp.NOT_HAS_COMPONENT:
+            return ~exists(subq)  # NOT at the entity level
+        return exists(subq)
+
+    @staticmethod
+    def _handle_value_filter(pf: PathFilter, alias: Any, correlates: list[ColumnElement[bool]]) -> ColumnElement[bool]:
+        """Handle value-based filters (equality, comparison, etc)."""
+        if "." not in pf.path:
+            path_pred = LtreeFilter(op=FilterOp.ENDS_WITH, value=pf.path).to_expression(alias.path, "")
+        else:
+            path_pred = alias.path == Ltree(pf.path)
+
+        value_pred = pf.to_expression(alias.value, alias.value_type)
+        subq = select(1).select_from(alias).where(and_(*correlates, path_pred, value_pred))
+        return exists(subq)
+
     def to_expression(
         self,
         entity_id_col: SQLAColumn,
@@ -241,35 +273,18 @@ class FilterTree(BaseModel):
         Returns:
             ColumnElement[bool]: A SQLAlchemy expression suitable for use in a WHERE clause.
         """
+        from sqlalchemy.orm import aliased
 
         alias_idx = count(1)
 
         def leaf_exists(pf: PathFilter) -> ColumnElement[bool]:
-            from sqlalchemy.orm import aliased
-
+            """Convert a PathFilter into an EXISTS subquery."""
             alias = aliased(AiSearchIndex, name=f"flt_{next(alias_idx)}")
-
-            correlates = [alias.entity_id == entity_id_col]
-            if entity_type_value is not None:
-                correlates.append(alias.entity_type == entity_type_value)
+            correlates = self._build_correlates(alias, entity_id_col, entity_type_value)
 
             if isinstance(pf.condition, LtreeFilter):
-                # row-level predicate is always positive
-                positive = pf.condition.to_expression(alias.path, pf.path)
-                subq = select(1).select_from(alias).where(and_(*correlates, positive))
-                if pf.condition.op == FilterOp.NOT_HAS_COMPONENT:
-                    return ~exists(subq)  # NOT at the entity level
-                return exists(subq)
-
-            # value leaf: path predicate + typed value compare
-            if "." not in pf.path:
-                path_pred = LtreeFilter(op=FilterOp.ENDS_WITH, value=pf.path).to_expression(alias.path, "")
-            else:
-                path_pred = alias.path == Ltree(pf.path)
-
-            value_pred = pf.to_expression(alias.value, alias.value_type)
-            subq = select(1).select_from(alias).where(and_(*correlates, path_pred, value_pred))
-            return exists(subq)
+                return self._handle_ltree_filter(pf, alias, correlates)
+            return self._handle_value_filter(pf, alias, correlates)
 
         def compile_node(node: FilterTree | PathFilter) -> ColumnElement[bool]:
             if isinstance(node, FilterTree):

{orchestrator_core-4.5.0a7 → orchestrator_core-4.5.0a8}/orchestrator/search/indexing/indexer.py

@@ -226,9 +226,7 @@ class Indexer:
         safe_margin = int(max_ctx * llm_settings.EMBEDDING_SAFE_MARGIN_PERCENT)
         token_budget = max(1, max_ctx - safe_margin)
 
-        max_batch_size = None
-        if llm_settings.OPENAI_BASE_URL:  # We are using a local model
-            max_batch_size = llm_settings.EMBEDDING_MAX_BATCH_SIZE
+        max_batch_size = llm_settings.EMBEDDING_MAX_BATCH_SIZE
 
         for entity_id, field in fields_to_upsert:
             if field.value_type.is_embeddable(field.value):

{orchestrator_core-4.5.0a7 → orchestrator_core-4.5.0a8}/orchestrator/search/indexing/tasks.py

@@ -15,6 +15,7 @@ import structlog
 from sqlalchemy.orm import Query
 
 from orchestrator.db import db
+from orchestrator.domain.context_cache import cache_subscription_models
 from orchestrator.search.core.types import EntityType
 from orchestrator.search.indexing.indexer import Indexer
 from orchestrator.search.indexing.registry import ENTITY_CONFIG_REGISTRY
@@ -63,4 +64,6 @@ def run_indexing_for_entity(
     entities = db.session.execute(stmt).scalars()
 
     indexer = Indexer(config=config, dry_run=dry_run, force_index=force_index, chunk_size=chunk_size)
-    indexer.run(entities)
+
+    with cache_subscription_models():
+        indexer.run(entities)

orchestrator_core-4.5.0a8/orchestrator/search/llm_migration.py

@@ -0,0 +1,102 @@
+# Copyright 2019-2025 SURF
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Simple search migration function that runs when SEARCH_ENABLED = True."""
+
+from sqlalchemy import text
+from sqlalchemy.engine import Connection
+from structlog import get_logger
+
+from orchestrator.search.core.types import FieldType
+
+logger = get_logger(__name__)
+
+TABLE = "ai_search_index"
+TARGET_DIM = 1536
+
+
+def run_migration(connection: Connection) -> None:
+    """Run LLM migration with ON CONFLICT DO NOTHING pattern."""
+    logger.info("Running LLM migration")
+
+    try:
+        # Create PostgreSQL extensions
+        connection.execute(text("CREATE EXTENSION IF NOT EXISTS ltree;"))
+        connection.execute(text("CREATE EXTENSION IF NOT EXISTS unaccent;"))
+        connection.execute(text("CREATE EXTENSION IF NOT EXISTS pg_trgm;"))
+        connection.execute(text("CREATE EXTENSION IF NOT EXISTS vector;"))
+
+        # Create field_type enum
+        field_type_values = "', '".join([ft.value for ft in FieldType])
+        connection.execute(
+            text(
+                f"""
+            DO $$
+            BEGIN
+                IF NOT EXISTS (SELECT 1 FROM pg_type WHERE typname = 'field_type') THEN
+                    CREATE TYPE field_type AS ENUM ('{field_type_values}');
+                END IF;
+            END $$;
+        """
+            )
+        )
+
+        # Create table with ON CONFLICT DO NOTHING pattern
+        connection.execute(
+            text(
+                f"""
+            CREATE TABLE IF NOT EXISTS {TABLE} (
+                entity_type TEXT NOT NULL,
+                entity_id UUID NOT NULL,
+                path LTREE NOT NULL,
+                value TEXT NOT NULL,
+                embedding VECTOR({TARGET_DIM}),
+                content_hash VARCHAR(64) NOT NULL,
+                value_type field_type NOT NULL DEFAULT '{FieldType.STRING.value}',
+                CONSTRAINT pk_ai_search_index PRIMARY KEY (entity_id, path)
+            );
+        """
+            )
+        )
+
+        # Drop default
+        connection.execute(text(f"ALTER TABLE {TABLE} ALTER COLUMN value_type DROP DEFAULT;"))
+
+        # Create indexes with IF NOT EXISTS
+        connection.execute(text(f"CREATE INDEX IF NOT EXISTS ix_ai_search_index_entity_id ON {TABLE} (entity_id);"))
+        connection.execute(
+            text(f"CREATE INDEX IF NOT EXISTS idx_ai_search_index_content_hash ON {TABLE} (content_hash);")
+        )
+        connection.execute(
+            text(f"CREATE INDEX IF NOT EXISTS ix_flat_path_gist ON {TABLE} USING GIST (path gist_ltree_ops);")
+        )
+        connection.execute(text(f"CREATE INDEX IF NOT EXISTS ix_flat_path_btree ON {TABLE} (path);"))
+        connection.execute(
+            text(f"CREATE INDEX IF NOT EXISTS ix_flat_value_trgm ON {TABLE} USING GIN (value gin_trgm_ops);")
+        )
+        connection.execute(
+            text(
+                f"CREATE INDEX IF NOT EXISTS ix_flat_embed_hnsw ON {TABLE} USING HNSW (embedding vector_l2_ops) WITH (m = 16, ef_construction = 64);"
+            )
+        )
+
+        connection.commit()
+        logger.info("LLM migration completed successfully")
+
+    except Exception as e:
+        logger.error("LLM migration failed", error=str(e))
+        raise Exception(
+            f"LLM migration failed. This likely means the pgvector extension "
+            f"is not installed. Please install pgvector and ensure your PostgreSQL "
+            f"version supports it. Error: {e}"
+        ) from e

{orchestrator_core-4.5.0a7 → orchestrator_core-4.5.0a8}/orchestrator/search/retrieval/engine.py

@@ -86,11 +86,7 @@ def _format_response(
 
 
 def _extract_matching_field_from_filters(filters: FilterTree) -> MatchingField | None:
-    """Extract the first path filter to use as matching field for structured searches.
-
-    TODO: Should we allow a list of matched fields in the MatchingField model?
-    We need a different approach, probably a cross join in StructuredRetriever.
-    """
+    """Extract the first path filter to use as matching field for structured searches."""
     leaves = filters.get_all_leaves()
     if len(leaves) != 1:
         return None

{orchestrator_core-4.5.0a7 → orchestrator_core-4.5.0a8}/orchestrator/search/retrieval/retrievers/base.py

@@ -112,7 +112,8 @@ class Retriever(ABC):
 
     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"))
+        quantizer = Decimal(1).scaleb(-self.SCORE_PRECISION)
+        pas_dec = Decimal(str(score_value)).quantize(quantizer)
         return literal(pas_dec, type_=self.SCORE_NUMERIC_TYPE)
 
     @property