nucliadb-agentic-api 1.0.0.post211__tar.gz → 1.0.0.post230__tar.gz

{nucliadb_agentic_api-1.0.0.post211 → nucliadb_agentic_api-1.0.0.post230}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nucliadb_agentic_api
-Version: 1.0.0.post211
+Version: 1.0.0.post230
 Summary: NucliaDB Agentic API for Hyperforge
 Author: AI Data Team
 Author-email: AI Data Team <learning@nuclia.com>

nucliadb_agentic_api-1.0.0.post230/VERSION

@@ -0,0 +1 @@
+1.0.0.post230

nucliadb_agentic_api-1.0.0.post230/alembic/versions/c4d5e6f7a8b9_add_agentic_config_soft_deletion.py

@@ -0,0 +1,39 @@
+"""Add agentic config soft deletion
+
+Revision ID: c4d5e6f7a8b9
+Revises: b3c4d5e6f7a8
+Create Date: 2026-08-06 00:00:00.000000
+
+"""
+
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+
+from alembic import op
+
+revision: str = "c4d5e6f7a8b9"
+down_revision: Union[str, None] = "b3c4d5e6f7a8"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    op.add_column(
+        "agentic_config_table",
+        sa.Column("deleted_at", sa.DateTime(timezone=True), nullable=True),
+    )
+    op.create_index(
+        op.f("ix_agentic_config_table_deleted_at"),
+        "agentic_config_table",
+        ["deleted_at"],
+        unique=False,
+    )
+
+
+def downgrade() -> None:
+    op.drop_index(
+        op.f("ix_agentic_config_table_deleted_at"),
+        table_name="agentic_config_table",
+    )
+    op.drop_column("agentic_config_table", "deleted_at")

{nucliadb_agentic_api-1.0.0.post211 → nucliadb_agentic_api-1.0.0.post230}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "nucliadb_agentic_api"
-version = "1.0.0.post211"
+version = "1.0.0.post230"
 description = "NucliaDB Agentic API for Hyperforge"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -28,6 +28,7 @@ nucliadb-agentic-api = "nucliadb_agentic_api.commands:run"
 nucliadb-agentic-server = "nucliadb_agentic_api.server.server:run"
 nucliadb-agentic-sandbox = "hyperforge.server.sandbox:run"
 nucliadb-agentic-api-extract-openapi = "nucliadb_agentic_api.commands:extract_openapi"
+nucliadb-agentic-api-purge-deleted-configs = "nucliadb_agentic_api.commands:purge_deleted_agentic_configs"
 
 [tool.setuptools.packages.find]
 where = ["src/"]
@@ -65,13 +66,13 @@ server = [
     "aiohttp<3.14.0",
     "backoff",
     "nats-py",
-    "nuclia>=4.11.5",
+    "nuclia>=4.14.0",
     "nuclia-models>=0.59.0",
     "nucliadb-protos",
     "nucliadb-sdk>=6.14.0.post6532",
     "nucliadb-telemetry[otel]>=6.14.0.post6534",
     "nucliadb-utils[storages,fastapi]>=6.15.0.post6671",
-    "hyperforge>=1.0.0.post88",
+    "hyperforge>=1.0.0.post237",
     "hyperforge_conditional>=1.0.0.post27",
     "hyperforge_mcp>=1.0.0.post41",
     "hyperforge_nucliadb>=1.0.0.post46",

{nucliadb_agentic_api-1.0.0.post211 → nucliadb_agentic_api-1.0.0.post230}/pyproject.toml.orig

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "nucliadb_agentic_api"
-version = "1.0.0.post211"
+version = "1.0.0.post230"
 authors = [{ name = "AI Data Team", email = "learning@nuclia.com" }]
 description = "NucliaDB Agentic API for Hyperforge"
 readme = "README.md"
@@ -52,6 +52,7 @@ nucliadb-agentic-api = "nucliadb_agentic_api.commands:run"
 nucliadb-agentic-server = "nucliadb_agentic_api.server.server:run"
 nucliadb-agentic-sandbox = "hyperforge.server.sandbox:run"
 nucliadb-agentic-api-extract-openapi = "nucliadb_agentic_api.commands:extract_openapi"
+nucliadb-agentic-api-purge-deleted-configs = "nucliadb_agentic_api.commands:purge_deleted_agentic_configs"
 
 [dependency-groups]
 
@@ -60,13 +61,13 @@ server = [
     "aiohttp<3.14.0",
     "backoff",
     "nats-py",
-    "nuclia>=4.11.5",
+    "nuclia>=4.14.0",
     "nuclia-models>=0.59.0",
     "nucliadb-protos",
     "nucliadb-sdk>=6.14.0.post6532",
     "nucliadb-telemetry[otel]>=6.14.0.post6534",
     "nucliadb-utils[storages,fastapi]>=6.15.0.post6671",
-    "hyperforge>=1.0.0.post88",
+    "hyperforge>=1.0.0.post237",
     "hyperforge_conditional>=1.0.0.post27",
     "hyperforge_mcp>=1.0.0.post41",
     "hyperforge_nucliadb>=1.0.0.post46",

{nucliadb_agentic_api-1.0.0.post211 → nucliadb_agentic_api-1.0.0.post230}/src/nucliadb_agentic_api/agentic/ask_handler.py

@@ -8,6 +8,7 @@ from hyperforge_nucliadb_agentic.ask.model import (
 from hyperforge_nucliadb_agentic.ask.search.ask import (
     handled_ask_exceptions,
 )
+from nuclia.lib.nua_responses import CitationsType
 from nucliadb_models.search import (
     NucliaDBClientType,
 )
@@ -34,6 +35,8 @@ async def create_agentic_response(
     extra_predict_headers: dict[str, str] | None = None,
 ) -> Response:
     ask_request.max_tokens = parse_max_tokens(ask_request.max_tokens)
+    if ask_request.citations is None:
+        ask_request.citations = CitationsType.LLM_FOOTNOTES
     ask_result = AgenticAskResult(
         app=app,
         kbid=kbid,

{nucliadb_agentic_api-1.0.0.post211 → nucliadb_agentic_api-1.0.0.post230}/src/nucliadb_agentic_api/agentic/ask_result.py

@@ -27,8 +27,11 @@ from hyperforge_nucliadb_agentic.ask.model import (
     StatusAskResponseItem,
     TokensDetail,
 )
-from hyperforge_nucliadb_agentic.ask.predict import AnswerStatusCode
-from hyperforge_nucliadb_agentic.ask.search.ask import AskResult, RetrievalMatch
+from hyperforge_nucliadb_agentic.ask.search.ask import (
+    AnswerStatusCode,
+    AskResult,
+    RetrievalMatch,
+)
 from hyperforge_nucliadb_agentic.ask.search.metrics import (
     AskMetrics,
 )

{nucliadb_agentic_api-1.0.0.post211 → nucliadb_agentic_api-1.0.0.post230}/src/nucliadb_agentic_api/app.py

@@ -8,23 +8,21 @@ from hyperforge.api.authentication import RaoAuthenticationBackend
 from hyperforge.broker import Broker
 from hyperforge.broker.redis import RedisBroker
 from hyperforge.driver import Driver
+from hyperforge.manager import Manager
 from hyperforge_nucliadb_agentic.ask.audit import (
     AuditMiddleware,
     start_audit_utility,
     stop_audit_utility,
 )
-from hyperforge_nucliadb_agentic.ask.predict import (
-    start_predict_engine,
-    stop_predict_engine,
-)
 from lru import LRU
 from mcp.server.lowlevel.server import Server as MCPServer
 from mcp.server.streamable_http import (
     StreamableHTTPServerTransport,
 )
+from nuclia.lib.nua import AsyncNuaClient
 from nucliadb_sdk import NucliaDBAsync
 from nucliadb_telemetry.utils import clean_telemetry, setup_telemetry
-from nucliadb_utils.settings import AuditSettings
+from nucliadb_utils.settings import AuditSettings, nuclia_settings
 from prometheus_client import CONTENT_TYPE_LATEST
 from starlette.middleware.authentication import AuthenticationMiddleware
 from starlette.responses import PlainTextResponse
@@ -61,6 +59,7 @@ class HTTPApplication(FastAPI):
     source_manager: Sources
     broker: Broker
     hyperforge_drivers: dict[str, "Driver"]
+    predict_manager: Manager
 
     def __init__(
         self,
@@ -105,9 +104,24 @@ class HTTPApplication(FastAPI):
     async def startup(self) -> None:
         await setup_telemetry(SERVICE_NAME)
 
-        await start_predict_engine()
         await start_audit_utility(SERVICE_NAME, self.audit_settings)
 
+        if nuclia_settings.onprem:
+            nua = AsyncNuaClient.onprem(
+                nuclia_settings.nuclia_public_url,
+                service_account=nuclia_settings.nuclia_service_account,
+                zone=nuclia_settings.nuclia_zone,
+                local_predict=nuclia_settings.local_predict,
+                local_predict_headers=nuclia_settings.local_predict_headers,
+            )
+        else:
+            nua = AsyncNuaClient.internal(nuclia_settings.nuclia_inner_predict_url)
+        self.predict_manager = await Manager.from_config(
+            drivers=[],
+            nua=nua,
+            send_rao_origin=False,
+        )
+
         self.broker = RedisBroker.from_url(
             url=self.settings.valkey_url,
             activate_subject=self.settings.activate_subject,
@@ -163,5 +177,5 @@ class HTTPApplication(FastAPI):
         await self.source_manager.finalize()
         await self.broker.finalize()
         await stop_audit_utility()
-        await stop_predict_engine()
+        await self.predict_manager.aclose()
         await clean_telemetry(SERVICE_NAME)

{nucliadb_agentic_api-1.0.0.post211 → nucliadb_agentic_api-1.0.0.post230}/src/nucliadb_agentic_api/commands.py

@@ -1,3 +1,5 @@
+import asyncio
+
 import uvicorn
 from hyperforge import openapi
 from hyperforge.feature_flag import get_flag_service
@@ -9,6 +11,7 @@ from nucliadb_utils.settings import AuditSettings
 
 from nucliadb_agentic_api import SERVICE_NAME
 from nucliadb_agentic_api.app import HTTPApplication
+from nucliadb_agentic_api.db.agentic_configs import AgenticConfigs
 from nucliadb_agentic_api.db.settings import DataManagerSettings
 from nucliadb_agentic_api.logging import set_sentry
 from nucliadb_agentic_api.settings import Settings
@@ -63,3 +66,15 @@ def extract_openapi():
     openapi.extract_openapi_command(
         "nucliadb_agentic_api", "NucliaDB Agentic API", router
     )
+
+
+def purge_deleted_agentic_configs():
+    async def purge() -> int:
+        manager = await AgenticConfigs.from_settings(DataManagerSettings())  # type: ignore
+        await manager.initialize()
+        try:
+            return await manager.hard_delete_expired_configs()
+        finally:
+            await manager.finalize()
+
+    asyncio.run(purge())

{nucliadb_agentic_api-1.0.0.post211 → nucliadb_agentic_api-1.0.0.post230}/src/nucliadb_agentic_api/db/agentic_configs.py

@@ -1,5 +1,4 @@
 import datetime
-import json
 from time import time
 from typing import Dict
 
@@ -46,6 +45,7 @@ agentic_config_table = sa.Table(
     sa.Column("agentic_id", sa.String, primary_key=True, nullable=False),  # Agentic ID
     sa.Column("created", sa.DateTime, default=sa.func.now()),
     sa.Column("modified", sa.DateTime, onupdate=sa.func.now()),
+    sa.Column("deleted_at", sa.DateTime(timezone=True), nullable=True, index=True),
     sa.Column("title", sa.String, nullable=True),
     sa.Column("config", JSONB, nullable=False),
 )
@@ -120,6 +120,7 @@ class AgenticConfigs:
                 agentic_config_table.c.account == account,
                 agentic_config_table.c.kbid == kbid,
                 agentic_config_table.c.agentic_id == agentic_id,
+                agentic_config_table.c.deleted_at.is_(None),
             )
             .returning(agentic_config_table.c.agentic_id)
         )
@@ -135,14 +136,30 @@ class AgenticConfigs:
         if source_ids:
             await self._validate_sources_exist(account, kbid, source_ids)
 
-        query = sa.select(agentic_config_table.c.agentic_id).where(
+        query = sa.select(agentic_config_table.c.deleted_at).where(
             agentic_config_table.c.account == account,
             agentic_config_table.c.kbid == kbid,
             agentic_config_table.c.agentic_id == agentic_id,
         )
         existing = await self.database.fetch_one(query)
         if existing is not None:
-            raise exceptions.Conflict("Agentic configuration already exists")
+            if existing["deleted_at"] is None:
+                raise exceptions.Conflict("Agentic configuration already exists")
+            await self.database.execute(
+                sa.update(agentic_config_table)
+                .values(
+                    title=config.title,
+                    config=_serialize_config(config),
+                    deleted_at=None,
+                )
+                .where(
+                    agentic_config_table.c.account == account,
+                    agentic_config_table.c.kbid == kbid,
+                    agentic_config_table.c.agentic_id == agentic_id,
+                )
+            )
+            CACHE[_cache_key(account, kbid, agentic_id)] = config
+            return
 
         insert_query = sa.insert(agentic_config_table).values(
             account=account,
@@ -172,35 +189,58 @@ class AgenticConfigs:
                 f"Source(s) not found: {', '.join(missing)}"
             )
 
-    async def delete_configs_referencing_source(
-        self, account: str, kbid: str, source_id: str
-    ) -> int:
-        """Delete every agentic config that references source_id in its smart_agent
-        sources list.  Returns the number of deleted configs.
-
-        Uses the JSONB containment operator (@>) to find matching rows:
-            config->'smart_agent'->'sources' @> '[{"source_id": "<id>"}]'
-        """
+    async def delete_agentic_config(
+        self, account: str, kbid: str, agentic_id: str
+    ) -> None:
         query = (
-            sa.delete(agentic_config_table)
+            sa.update(agentic_config_table)
+            .values(deleted_at=utc_now())
             .where(
                 agentic_config_table.c.account == account,
                 agentic_config_table.c.kbid == kbid,
-                agentic_config_table.c.config["smart_agent"]["sources"].op("@>")(
-                    sa.cast(
-                        json.dumps([{"source_id": source_id}]),
-                        JSONB,
-                    )
-                ),
+                agentic_config_table.c.agentic_id == agentic_id,
+                agentic_config_table.c.deleted_at.is_(None),
             )
             .returning(agentic_config_table.c.agentic_id)
         )
-        deleted_rows = await self.database.fetch_all(query)
-        for row in deleted_rows:
-            key = _cache_key(account, kbid, row["agentic_id"])
-            if key in CACHE:
-                del CACHE[key]
-        return len(deleted_rows)
+        deleted = await self.database.fetch_one(query)
+        if deleted is None:
+            raise exceptions.NotFound("Agentic configuration not found")
+        CACHE.pop(_cache_key(account, kbid, agentic_id), None)
+
+    async def configs_referencing_source(
+        self, account: str, kbid: str, source_id: str
+    ) -> list[str]:
+        query = sa.select(agentic_config_table.c.agentic_id).where(
+            agentic_config_table.c.account == account,
+            agentic_config_table.c.kbid == kbid,
+            agentic_config_table.c.deleted_at.is_(None),
+            sa.func.jsonb_exists(
+                agentic_config_table.c.config["smart_agent"]["sources"], source_id
+            ),
+        )
+        return [row["agentic_id"] for row in await self.database.fetch_all(query)]
+
+    async def hard_delete_expired_configs(self) -> int:
+        cutoff = utc_now() - datetime.timedelta(
+            days=self.settings.agentic_config_deletion_retention_days
+        )
+        conditions = (
+            agentic_config_table.c.deleted_at.is_not(None),
+            agentic_config_table.c.deleted_at < cutoff,
+        )
+        count_query = (
+            sa.select(sa.func.count())
+            .select_from(agentic_config_table)
+            .where(*conditions)
+        )
+        count = await self.database.fetch_val(count_query)
+        if count == 0:
+            return 0
+
+        delete_query = sa.delete(agentic_config_table).where(*conditions)
+        await self.database.execute(delete_query)
+        return count
 
     async def get_agentic_config(
         self, account: str, kbid: str, agentic_id: str
@@ -211,6 +251,7 @@ class AgenticConfigs:
                 agentic_config_table.c.account == account,
                 agentic_config_table.c.kbid == kbid,
                 agentic_config_table.c.agentic_id == agentic_id,
+                agentic_config_table.c.deleted_at.is_(None),
             )
             row = await self.database.fetch_one(query)
             if not row:
@@ -229,6 +270,7 @@ class AgenticConfigs:
         query = sa.select(agentic_config_table).where(
             agentic_config_table.c.account == account,
             agentic_config_table.c.kbid == kbid,
+            agentic_config_table.c.deleted_at.is_(None),
         )
         rows = await self.database.fetch_all(query)
         return {row["agentic_id"]: _config_from_row(row) for row in rows}

{nucliadb_agentic_api-1.0.0.post211 → nucliadb_agentic_api-1.0.0.post230}/src/nucliadb_agentic_api/db/settings.py

@@ -1,8 +1,10 @@
+from pydantic import Field
 from pydantic_settings import BaseSettings
 
 
 class DataManagerSettings(BaseSettings):
     postgresql_dsn: str
+    agentic_config_deletion_retention_days: int = Field(default=30, ge=0)
     export_read_chunk_size: int = 1024 * 1024  # 1 MB
     export_read_max_size: int = 10 * 1024 * 1024  # 10 MB
 

{nucliadb_agentic_api-1.0.0.post211 → nucliadb_agentic_api-1.0.0.post230}/src/nucliadb_agentic_api/db/transform.py

@@ -1,11 +1,14 @@
-from typing import Any, Dict, Tuple
+from typing import Dict, Tuple
 from uuid import uuid4
 
+from hyperforge.agent import AgentConfig
+from hyperforge.context.config import ContextAgentConfig
 from hyperforge.driver import DriverConfig
 from hyperforge.models import MemoryConfig, Rules
 from hyperforge.retrieval.config import RetrievalAgentConfig
 from hyperforge.workflows import WorkflowData
-from hyperforge_mcp.config import Transport
+from hyperforge_google.config import GoogleAgentConfig
+from hyperforge_mcp.config import MCPAgentConfig, Transport
 from hyperforge_mcp.config_driver import (
     MCPHTTPDriverConfig,
     MCPHTTPInnerConfig,
@@ -14,10 +17,15 @@ from hyperforge_nucliadb.driver_config import (
     NucliaDBConfig,
     NucliaDBConnection,
 )
+from hyperforge_nucliadb_agentic.config import NucliaDBAgentConfig
 from hyperforge_nucliadb_agentic.internal_driver import (
     InternalNucliaDBConfig,
     InternalNucliaDBConnection,
 )
+from hyperforge_perplexity.config import PerplexityAgentConfig
+from hyperforge_rephrase.config import RephraseAgentConfig
+from hyperforge_smart.config import SmartAgentConfig
+from hyperforge_summarize.config import SummarizeAgentConfig
 
 from nucliadb_agentic_api.db.sources import Sources
 from nucliadb_agentic_api.models import AgenticConfigSchema
@@ -43,60 +51,35 @@ async def transform_agentic_config(
     global_driver = []
 
     title = agentic_config.title if agentic_config.title else "Default Agentic Config"
+    preprocess: list[AgentConfig] = []
+    context: list[AgentConfig] = []
+    generation: list[AgentConfig] = []
 
     if agentic_config.rephrase:
-        config: Dict[str, Any] = {
-            "title": f"{title} - Retrieval",
-        }
-        if agentic_config.rephrase.model:
-            config["model"] = agentic_config.rephrase.model
-        if agentic_config.rephrase.prompt:
-            config["rules"] = [agentic_config.rephrase.prompt]
-        if agentic_config.rephrase.ask_to:
-            # Same KB with different layers
-            config["kbid"] = agentic_config.rephrase.ask_to
-        if agentic_config.rephrase.history:
-            config["history"] = agentic_config.rephrase.history
-
-        config["module"] = "rephrase"
-        preprocess = [config]
-    else:
-        preprocess = []
+        rephrase = agentic_config.rephrase
+        rephrase_config = RephraseAgentConfig(
+            title=f"{title} - Retrieval",
+            rules=[rephrase.prompt] if rephrase.prompt else None,
+            kb=rephrase.ask_to,
+            history=rephrase.history if rephrase.history is not None else False,
+        )
+        if rephrase.model:
+            rephrase_config.model = rephrase.model
+        preprocess.append(rephrase_config)
 
     if agentic_config.smart_agent:
-        config = {
-            "title": f"{title} - Smart Agent",
-        }
-        if agentic_config.smart_agent.extra_prompt:
-            config["extra_prompt"] = agentic_config.smart_agent.extra_prompt
-        if agentic_config.smart_agent.models:
-            if agentic_config.smart_agent.models.context_validation:
-                config["context_validation_model"] = (
-                    agentic_config.smart_agent.models.context_validation
-                )
-            if agentic_config.smart_agent.models.planner:
-                config["planner_model"] = agentic_config.smart_agent.models.planner
-            if agentic_config.smart_agent.models.executor:
-                config["executor_model"] = agentic_config.smart_agent.models.executor
-            if agentic_config.smart_agent.history:
-                config["history"] = agentic_config.smart_agent.history
-            if agentic_config.smart_agent.extra_prompt:
-                config["extra_prompt"] = agentic_config.smart_agent.extra_prompt
-        registered_agents = []
-        for source in agentic_config.smart_agent.sources:
+        smart_agent = agentic_config.smart_agent
+        registered_agents: list[ContextAgentConfig] = []
+        for source in smart_agent.sources:
             source_obj = await source_manager.get_source(account, kbid, source)
-            source_config: Dict[str, Any] = {
-                "title": f"{title} - Smart Agent - {source_obj.type.capitalize()} Source",
-            }
+            source_title = (
+                f"{title} - Smart Agent - {source_obj.type.capitalize()} Source"
+            )
 
             if source_obj.type == "nucliadb":
                 # Same KB different
                 uid = uuid4().hex
 
-                source_config["id"] = f"nucliadb-agent-{source}"
-                source_config["sources"] = [uid]
-                source_config["module"] = "nucliadb_agent"
-
                 ndb_driver_config: DriverConfig
                 if internal_nucliadb and internal_nucliadb_url:
                     ndb_driver_config = InternalNucliaDBConfig(
@@ -137,15 +120,13 @@ async def transform_agentic_config(
                         "No NucliaDB URL configured for internal or external access"
                     )
                 drivers[uid] = ndb_driver_config
-                registered_agents.append(source_config)
+                registered_agents.append(
+                    NucliaDBAgentConfig(
+                        id=f"nucliadb-agent-{source}", title=source_title, sources=[uid]
+                    )
+                )
             elif source_obj.type == "mcp":
                 uid = uuid4().hex
-                # See the nucliadb branch above for why this must be
-                # deterministic rather than random.
-                source_config["id"] = f"mcp-agent-{source}"
-                source_config["sources"] = [uid]
-                source_config["transport"] = Transport.HTTP
-                source_config["module"] = "mcp"
                 mcp_driver_config = MCPHTTPDriverConfig(
                     identifier=uid,
                     name="MCPHTTP",
@@ -156,46 +137,68 @@ async def transform_agentic_config(
                     ),
                 )  # TODO: pass real config if needed
                 drivers[uid] = mcp_driver_config
-                registered_agents.append(source_config)
+                registered_agents.append(
+                    MCPAgentConfig(
+                        id=f"mcp-agent-{source}",
+                        title=source_title,
+                        source=uid,
+                        transport=Transport.HTTP,
+                        tool_choice_model=source_obj.tool_choice_model or "chatgpt-4.1",
+                        valid_headers=source_obj.valid_headers or [],
+                    )
+                )
 
             elif source_obj.type == "google":
-                source_config["id"] = f"google-agent-{source}"
-                source_config["module"] = "google"
                 global_driver.append("google")
-                registered_agents.append(source_config)
+                registered_agents.append(
+                    GoogleAgentConfig(id=f"google-agent-{source}", title=source_title)
+                )
 
             elif source_obj.type == "perplexity":
-                source_config["id"] = f"perplexity-agent-{source}"
-                source_config["module"] = "perplexity"
                 global_driver.append("perplexity")
-                registered_agents.append(source_config)
+                registered_agents.append(
+                    PerplexityAgentConfig(
+                        id=f"perplexity-agent-{source}",
+                        title=source_title,
+                        domain=source_obj.enabled_domains or [],
+                        prompt=None,
+                    )
+                )
 
-        config["registered_agents"] = registered_agents
-        config["module"] = "smart"
-        context = [config]
-    else:
-        context = []
+        models = smart_agent.models
+        smart_config = SmartAgentConfig(
+            title=f"{title} - Smart Agent",
+            planning_mode=smart_agent.mode.value,
+            extra_prompt=smart_agent.extra_prompt,
+            history=smart_agent.history if smart_agent.history is not None else False,
+            # SmartAgentConfig's before-validator accepts serialized agent configs.
+            registered_agents=[agent.model_dump() for agent in registered_agents],  # type: ignore[misc]
+        )
+        # Only set the models if they are provided; otherwise, leave them as None to use hyperforge's default models.
+        # TODO: Provide nucliadb agentic api level defaults for models
+        if models:
+            if models.context_validation:
+                smart_config.context_validation_model = models.context_validation
+            if models.planner:
+                smart_config.planner_model = models.planner
+            if models.executor:
+                smart_config.executor_model = models.executor
+        context.append(smart_config)
 
     if agentic_config.summarize:
-        config = {
-            "title": f"{title} - Summarize Agent",
-        }
-        if agentic_config.summarize.model:
-            config["model"] = agentic_config.summarize.model
-        if agentic_config.summarize.user_prompt:
-            config["user_prompt"] = agentic_config.summarize.user_prompt
-        if agentic_config.summarize.system_prompt:
-            config["system_prompt"] = agentic_config.summarize.system_prompt
-        if agentic_config.summarize.conversational:
-            config["conversational"] = agentic_config.summarize.conversational
-        if agentic_config.summarize.history:
-            config["history"] = agentic_config.summarize.history
-
-        config["module"] = "summarize"
-
-        generation = [config]
-    else:
-        generation = []
+        summarize = agentic_config.summarize
+        summarize_config = SummarizeAgentConfig(
+            title=f"{title} - Summarize Agent",
+            prompt=summarize.user_prompt,
+            system_prompt=summarize.system_prompt,
+            conversational=summarize.conversational,
+            citations=True,
+            force_chunk_level_citations=False,
+            history=summarize.history if summarize.history is not None else False,
+        )
+        if summarize.model:
+            summarize_config.model = summarize.model
+        generation.append(summarize_config)
 
     return (
         RetrievalAgentConfig(
@@ -208,9 +211,9 @@ async def transform_agentic_config(
                 description="Default workflow for agentic config transformation",
                 parameters=None,
             ),
-            preprocess=preprocess,  # type: ignore
-            context=context,  # type: ignore
-            generation=generation,  # type: ignore
+            preprocess=preprocess,
+            context=context,
+            generation=generation,
             postprocess=[],
         ),
         drivers,

{nucliadb_agentic_api-1.0.0.post211 → nucliadb_agentic_api-1.0.0.post230}/src/nucliadb_agentic_api/exceptions.py

@@ -8,3 +8,7 @@ class NotFound(Exception):
 
 class InvalidReference(Exception):
     """Raised when a referenced resource does not exist."""
+
+
+class InUse(Exception):
+    """Raised when a resource cannot be deleted while it is referenced."""

{nucliadb_agentic_api-1.0.0.post211 → nucliadb_agentic_api-1.0.0.post230}/src/nucliadb_agentic_api/models.py

@@ -133,7 +133,7 @@ class AgenticRephraseConfiguration(BaseModel):
     ask_to: Optional[str] = None
     prompt: Optional[str] = None
     model: Optional[str] = None
-    history: Optional[bool] = None
+    history: Optional[bool] = True
 
 
 class AgenticSmartAgentMode(str, Enum):
@@ -218,15 +218,15 @@ class AgenticSmartAgentConfiguration(BaseModel):
     extra_prompt: Optional[str] = None
     models: Optional[AgenticSmartAgentModels] = None
     sources: List[str] = Field(default_factory=list)
-    history: Optional[bool] = None
+    history: Optional[bool] = True
 
 
 class AgenticSummarizeConfiguration(BaseModel):
     user_prompt: Optional[str] = None
     system_prompt: Optional[str] = None
-    conversational: bool = False
+    conversational: bool = True
     model: Optional[str] = None
-    history: Optional[bool] = None
+    history: Optional[bool] = True
 
 
 class AgenticConfigSchema(BaseModel):

{nucliadb_agentic_api-1.0.0.post211 → nucliadb_agentic_api-1.0.0.post230}/src/nucliadb_agentic_api/server/server.py

@@ -7,7 +7,6 @@ from hyperforge.broker.redis import RedisBroker
 from hyperforge.feature_flag import get_flag_service
 from hyperforge.server.cache import ValkeyCache
 from hyperforge.server.run import run_metrics_server
-from hyperforge_nucliadb_agentic.ask.predict import start_predict_engine
 from nucliadb_telemetry.logs import setup_logging
 from nucliadb_telemetry.settings import LogFormatType, LogLevel, LogSettings
 from nucliadb_telemetry.utils import setup_telemetry
@@ -40,8 +39,6 @@ async def run_server(
     if tracer:
         await setup_telemetry(SERVICE_NAME)
 
-    await start_predict_engine()
-
     audit_settings: AuditSettings = AuditSettings()
     # Connect to Valkey
     broker = RedisBroker.from_url(

{nucliadb_agentic_api-1.0.0.post211 → nucliadb_agentic_api-1.0.0.post230}/src/nucliadb_agentic_api/server/session.py

@@ -255,6 +255,12 @@ class NucliaDBAgenticSessionManager(SessionManager):
             errors.capture_exception(e)
             error = ARAGException(detail=str(e))
             observation.set_status("error")
+        finally:
+            try:
+                await state.manager.aclose()
+            except Exception as e:
+                logger.exception("Error closing Manager")
+                errors.capture_exception(e)
 
         observation.end()
         answer_running.dec()

{nucliadb_agentic_api-1.0.0.post211 → nucliadb_agentic_api-1.0.0.post230}/src/nucliadb_agentic_api/v1/agentic_configs.py

@@ -115,3 +115,28 @@ async def patch_agentic_config_endpoint(
     except exceptions.InvalidReference as exc:
         raise HTTPException(status_code=422, detail=str(exc)) from exc
     return Response(status_code=204)
+
+
+@router.delete(
+    "/api/v1/kb/{kbid}/agentic_configs/{agentic_id}",
+    status_code=204,
+    summary="Delete agentic configuration",
+    tags=["Agentic configs"],
+)
+@requires(NucliaDBRoles.OWNER)
+async def delete_agentic_config_endpoint(
+    request: Request,
+    kbid: str,
+    agentic_id: str,
+    x_nucliadb_account: str = Header(default="", include_in_schema=False),
+) -> Response:
+    app = cast("HTTPApplication", request.app)
+    try:
+        await app.agent_manager.delete_agentic_config(
+            account=x_nucliadb_account,
+            kbid=kbid,
+            agentic_id=agentic_id,
+        )
+    except exceptions.NotFound as exc:
+        raise HTTPException(status_code=404, detail=str(exc)) from exc
+    return Response(status_code=204)

{nucliadb_agentic_api-1.0.0.post211 → nucliadb_agentic_api-1.0.0.post230}/src/nucliadb_agentic_api/v1/ask.py

@@ -2,6 +2,7 @@ import json
 from uuid import UUID
 
 from fastapi import Header, Request, Response
+from hyperforge.manager import Manager
 from hyperforge_nucliadb_agentic.ask.exceptions import (
     AnswerJsonSchemaTooLong,
 )
@@ -108,6 +109,7 @@ async def ask_knowledgebox_endpoint(
         )
 
     return await create_ask_response(
+        predict_manager=request.app.predict_manager,
         kbid=kbid,
         ask_request=item,
         user_id=x_nucliadb_user,
@@ -169,6 +171,7 @@ async def resource_ask_endpoint_by_uuid(
         )
 
     return await create_ask_response(
+        predict_manager=request.app.predict_manager,
         kbid=kbid,
         ask_request=item,
         user_id=x_nucliadb_user,
@@ -238,6 +241,7 @@ async def resource_ask_endpoint_by_slug(
         )
 
     return await create_ask_response(
+        predict_manager=request.app.predict_manager,
         kbid=kbid,
         ask_request=item,
         user_id=x_nucliadb_user,
@@ -251,6 +255,7 @@ async def resource_ask_endpoint_by_slug(
 
 @handled_ask_exceptions
 async def create_ask_response(
+    predict_manager: Manager,
     kbid: str,
     ask_request: AskRequest,
     user_id: str,
@@ -266,6 +271,7 @@ async def create_ask_response(
             search_sdk=rpc.get_sdk("search"),
             reader_sdk=rpc.get_sdk("reader"),
             kbid=kbid,
+            predict_manager=predict_manager,
             ask_request=ask_request,
             user_id=user_id,
             client_type=client_type,

{nucliadb_agentic_api-1.0.0.post211 → nucliadb_agentic_api-1.0.0.post230}/src/nucliadb_agentic_api/v1/mcp_nucliadb.py

@@ -10,6 +10,7 @@ import anyio
 import pydantic_core
 from fastapi import Header
 from hyperforge.api.authentication import requires_one
+from hyperforge.manager import Manager
 from mcp.server.fastmcp.exceptions import ResourceError
 from mcp.server.fastmcp.utilities.types import Image
 from mcp.server.lowlevel.helper_types import ReadResourceContents
@@ -34,7 +35,7 @@ from starlette.responses import Response
 from nucliadb_agentic_api import logger
 
 if TYPE_CHECKING:
-    from hyperforge.api.app import HTTPApplication
+    from nucliadb_agentic_api.app import HTTPApplication
 
 from anyio.abc import TaskStatus
 from hyperforge_nucliadb_agentic.ask.exceptions import (
@@ -80,6 +81,7 @@ BATCH_GET_DOCUMENTS_MAX = 20
 
 @dataclass
 class MCPContext:
+    predict_manager: Manager
     ndb_reader: NucliaDBAsync
     ndb_search: NucliaDBAsync
     kbid: str
@@ -249,6 +251,7 @@ async def _tool_search_documents(
             search_sdk=context.ndb_search,
             reader_sdk=context.ndb_reader,
             kbid=context.kbid,
+            predict_manager=context.predict_manager,
             ask_request=ask_request,
             user_id=context.x_nucliadb_user,
             client_type=context.x_ndb_client,
@@ -469,6 +472,7 @@ async def list_tools(description: str) -> list[Tool]:
 
 
 async def call_tool(
+    predict_manager: Manager,
     x_stf_account: str,
     x_nucliadb_user: str,
     x_ndb_client: NucliaDBClientType,
@@ -492,6 +496,7 @@ async def call_tool(
         )
         raise ResourceError(f"Invalid arguments for '{name}': {error_details}") from e
     context = MCPContext(
+        predict_manager=predict_manager,
         ndb_reader=ndb_reader,
         ndb_search=ndb_search,
         kbid=kbid,
@@ -678,6 +683,7 @@ async def mcp_handler(
         list_resources_partial = partial(list_resources, ndb_reader, kbid)
         call_tool_partial = partial(
             call_tool,
+            app.predict_manager,
             x_stf_account,
             x_nucliadb_user,
             x_ndb_client,

{nucliadb_agentic_api-1.0.0.post211 → nucliadb_agentic_api-1.0.0.post230}/src/nucliadb_agentic_api/v1/sources.py

@@ -141,6 +141,16 @@ async def delete_source_endpoint(
 ) -> Response:
     app = cast("HTTPApplication", request.app)
     try:
+        configs = await app.agent_manager.configs_referencing_source(
+            account=x_nucliadb_account,
+            kbid=kbid,
+            source_id=source_id,
+        )
+        if configs:
+            raise exceptions.InUse(
+                "Source is in use by agentic configuration(s): "
+                + ", ".join(sorted(configs))
+            )
         await app.source_manager.delete_source(
             account=x_nucliadb_account,
             kbid=kbid,
@@ -148,11 +158,6 @@ async def delete_source_endpoint(
         )
     except exceptions.NotFound as exc:
         raise HTTPException(status_code=404, detail=str(exc)) from exc
-
-    # Cascade: remove every agentic config that references this source.
-    await app.agent_manager.delete_configs_referencing_source(
-        account=x_nucliadb_account,
-        kbid=kbid,
-        source_id=source_id,
-    )
+    except exceptions.InUse as exc:
+        raise HTTPException(status_code=409, detail=str(exc)) from exc
     return Response(status_code=204)

nucliadb_agentic_api-1.0.0.post211/VERSION

@@ -1 +0,0 @@
-1.0.0.post211