hyperforge-nucliadb-agentic 1.0.0.post64__py3-none-any.whl

hyperforge_nucliadb_agentic/ask/search/rpc.py

@@ -0,0 +1,192 @@
+import base64
+from typing import Literal
+
+from nucliadb_models.augment import AugmentRequest, AugmentResponse
+from nucliadb_models.configuration import SearchConfiguration
+from nucliadb_models.graph.requests import GraphNodesSearchRequest, GraphSearchRequest
+from nucliadb_models.graph.responses import (
+    GraphNodesSearchResponse,
+    GraphSearchResponse,
+)
+from nucliadb_models.labels import KnowledgeBoxLabels
+from nucliadb_models.retrieval import RetrievalRequest, RetrievalResponse
+from nucliadb_models.search import (
+    FindRequest,
+    KnowledgeboxFindResults,
+    NucliaDBClientType,
+)
+from nucliadb_sdk import NucliaDBAsync
+from nucliadb_sdk.v2.exceptions import NotFoundError, UnknownError
+from pydantic import TypeAdapter
+from typing_extensions import assert_never
+
+from hyperforge_nucliadb_agentic.ask import logger
+from hyperforge_nucliadb_agentic.ask.exceptions import (
+    KnowledgeBoxNotFound,
+    NucliaDBError,
+)
+from hyperforge_nucliadb_agentic.ask.model import Image
+from hyperforge_nucliadb_agentic.ask.settings import settings
+from hyperforge_nucliadb_agentic.ask.utils.ids import FieldId
+
+
+async def get_resource_uuid_from_slug(
+    reader_sdk: NucliaDBAsync, kbid: str, slug: str
+) -> str | None:
+    try:
+        resource = await reader_sdk.get_resource_by_slug(kbid=kbid, slug=slug)
+    except NotFoundError:
+        return None
+    else:
+        return resource.id
+
+
+async def get_search_configuration(
+    reader_sdk: NucliaDBAsync, kbid: str, name: str
+) -> SearchConfiguration | None:
+    resp = await reader_sdk.session.get(f"/v1/kb/{kbid}/search_configurations/{name}")
+
+    if resp.status_code == 404:
+        return None
+
+    if resp.status_code != 200:
+        raise Exception(
+            f"/search_configurations/{name} call failed: {resp.status_code} {resp.content.decode()}"
+        )
+
+    config: SearchConfiguration = TypeAdapter(SearchConfiguration).validate_json(
+        resp.content
+    )
+    return config
+
+
+async def find(
+    search_sdk: NucliaDBAsync,
+    kbid: str,
+    item: FindRequest,
+    x_ndb_client: NucliaDBClientType,
+    x_nucliadb_user: str,
+    x_forwarded_for: str,
+) -> tuple[KnowledgeboxFindResults, bool]:
+    """RPC to /find endpoint making it look as an internal call."""
+
+    resp = await search_sdk.session.post(
+        f"/v1/kb/{kbid}/find",
+        headers={
+            "x-ndb-client": x_ndb_client,
+            "x-nucliadb-user": x_nucliadb_user,
+            "x-forwarded-for": x_forwarded_for,
+        },
+        json=item.model_dump(),
+    )
+    if resp.status_code == 200:
+        incomplete = False
+    elif resp.status_code == 206:
+        incomplete = True
+    elif resp.status_code == 404:
+        raise KnowledgeBoxNotFound()
+    else:
+        raise Exception(
+            f"/find call failed: {resp.status_code} {resp.content.decode()}"
+        )
+
+    find_results = KnowledgeboxFindResults.model_validate(resp.json())
+
+    return find_results, incomplete
+
+
+async def retrieve(
+    search_sdk: NucliaDBAsync,
+    kbid: str,
+    item: RetrievalRequest,
+) -> RetrievalResponse:
+    try:
+        retrieved = await search_sdk.retrieve(kbid=kbid, content=item)
+    except NotFoundError as exc:
+        raise KnowledgeBoxNotFound() from exc
+    except UnknownError as exc:
+        logger.warning(
+            "/retrieve RPC to NucliaDB failed", extra={"kbid": kbid}, exc_info=True
+        )
+        raise NucliaDBError() from exc
+    return retrieved
+
+
+async def augment(
+    search_sdk: NucliaDBAsync, kbid: str, item: AugmentRequest
+) -> AugmentResponse:
+    try:
+        augmented = await search_sdk.augment(kbid=kbid, content=item)
+    except NotFoundError as exc:
+        raise KnowledgeBoxNotFound() from exc
+    except UnknownError as exc:
+        logger.warning(
+            "/augment RPC to NucliaDB failed", extra={"kbid": kbid}, exc_info=True
+        )
+        raise NucliaDBError() from exc
+    return augmented
+
+
+async def graph_paths(
+    search_sdk: NucliaDBAsync, kbid: str, item: GraphSearchRequest
+) -> GraphSearchResponse:
+    paths = await search_sdk.graph_search(kbid=kbid, content=item)
+    return paths
+
+
+async def graph_nodes(
+    search_sdk: NucliaDBAsync, kbid: str, item: GraphNodesSearchRequest
+) -> GraphNodesSearchResponse:
+    nodes = await search_sdk.graph_nodes(kbid=kbid, content=item)
+    return nodes
+
+
+async def labelsets(reader_sdk: NucliaDBAsync, kbid: str) -> KnowledgeBoxLabels:
+    labelsets = await reader_sdk.get_labelsets(kbid=kbid)
+    return labelsets
+
+
+async def download_image(
+    reader_sdk: NucliaDBAsync,
+    kbid: str,
+    field_id: FieldId,
+    path: str,
+    *,
+    mime_type: str,
+) -> Image | None:
+    async with (
+        reader_sdk.session.stream(
+            "GET",
+            f"/v1/kb/{kbid}/resource/{field_id.rid}/{field_id.type_name.value}/{field_id.key}/download/extracted/{path}",
+        ) as resp,
+    ):
+        if resp.status_code == 404:
+            return None
+
+        data = await resp.aread()
+        return Image(
+            b64encoded=base64.b64encode(data).decode(),
+            content_type=mime_type,
+        )
+
+
+__SDK: dict[Literal["reader"] | Literal["search"], NucliaDBAsync] = {}
+
+
+def get_sdk(service: Literal["reader"] | Literal["search"]) -> NucliaDBAsync:
+    if service in __SDK:
+        return __SDK[service]
+
+    if service == "reader":
+        service_address = settings.nucliadb_reader_address
+    elif service == "search":
+        service_address = settings.nucliadb_search_address
+    else:
+        assert_never(service)
+
+    sdk = NucliaDBAsync(
+        url=service_address,
+        headers={"x-nucliadb-roles": "READER"},
+    )
+    __SDK[service] = sdk
+    return sdk

hyperforge_nucliadb_agentic/ask/settings.py

@@ -0,0 +1,9 @@
+from pydantic_settings import BaseSettings
+
+
+class Settings(BaseSettings):
+    nucliadb_reader_address: str = "http://reader.nucliadb.svc.cluster.local:8080/api"
+    nucliadb_search_address: str = "http://search.nucliadb.svc.cluster.local:8080/api"
+
+
+settings = Settings()

hyperforge_nucliadb_agentic/ask/utils/ids.py

@@ -0,0 +1,188 @@
+from dataclasses import dataclass
+
+from nucliadb_models.common import FieldTypeName
+from nucliadb_protos.resources_pb2 import FieldType
+
+FIELD_TYPE_STR_TO_PB: dict[str, FieldType.ValueType] = {
+    "t": FieldType.TEXT,
+    "f": FieldType.FILE,
+    "u": FieldType.LINK,
+    "a": FieldType.GENERIC,
+    "c": FieldType.CONVERSATION,
+}
+
+FIELD_TYPE_PB_TO_STR = {v: k for k, v in FIELD_TYPE_STR_TO_PB.items()}
+
+FIELD_TYPE_NAME_TO_STR = {
+    FieldTypeName.TEXT: "t",
+    FieldTypeName.FILE: "f",
+    FieldTypeName.LINK: "u",
+    FieldTypeName.GENERIC: "a",
+    FieldTypeName.CONVERSATION: "c",
+}
+
+FIELD_TYPE_STR_TO_NAME = {v: k for k, v in FIELD_TYPE_NAME_TO_STR.items()}
+
+
+@dataclass
+class FieldId:
+    """
+    Field ids are used to identify fields in resources. They usually have the following format:
+
+        `rid/field_type/field_key`
+
+    where field type is one of: `t`, `f`, `u`, `a`, `c` (text, file, link, generic, conversation)
+    and field_key is an identifier for that field type on the resource, usually chosen by the user.
+
+    In some cases, fields can have subfields, for example, in conversations, where each part of the
+    conversation is a subfield. In those cases, the id has the following format:
+
+        `rid/field_type/field_key/subfield_id`
+
+    Examples:
+
+    >>> FieldId(rid="rid", type="u", key="my-link")
+    FieldID("rid/u/my-link")
+    >>> FieldId.from_string("rid/u/my-link")
+    FieldID("rid/u/my-link")
+    """
+
+    rid: str
+    type: str
+    key: str
+    # also knwon as `split`, this indicates a part of a field in, for example, conversations
+    subfield_id: str | None = None
+
+    @classmethod
+    def from_string(cls, value: str) -> "FieldId":
+        """
+        Parse a FieldId from a string
+        Example:
+        >>> fid = FieldId.from_string("rid/u/foo")
+        >>> fid
+        FieldId("rid/u/foo")
+        >>> fid.type
+        'u'
+        >>> fid.key
+        'foo'
+        >>> FieldId.from_string("rid/u/foo/subfield_id").subfield_id
+        'subfield_id'
+        """
+        parts = value.split("/")
+        if len(parts) == 3:
+            rid, _type, key = parts
+            _type = cls._parse_field_type(_type)
+            return cls(rid=rid, type=_type, key=key)
+        elif len(parts) == 4:
+            rid, _type, key, subfield_id = parts
+            _type = cls._parse_field_type(_type)
+            return cls(
+                rid=rid,
+                type=_type,
+                key=key,
+                subfield_id=subfield_id,
+            )
+        else:
+            raise ValueError(f"Invalid FieldId: {value}")
+
+    @classmethod
+    def from_pb(
+        cls,
+        rid: str,
+        field_type: FieldType.ValueType,
+        key: str,
+        subfield_id: str | None = None,
+    ) -> "FieldId":
+        return cls(
+            rid=rid,
+            type=FIELD_TYPE_PB_TO_STR[field_type],
+            key=key,
+            subfield_id=subfield_id,
+        )
+
+    @property
+    def pb_type(self) -> FieldType.ValueType:
+        return FIELD_TYPE_STR_TO_PB[self.type]
+
+    @property
+    def type_name(self) -> FieldTypeName:
+        return FIELD_TYPE_STR_TO_NAME[self.type]
+
+    def full(self) -> str:
+        if self.subfield_id is None:
+            return f"{self.rid}/{self.type}/{self.key}"
+        else:
+            return f"{self.rid}/{self.type}/{self.key}/{self.subfield_id}"
+
+    def full_without_subfield(self) -> str:
+        return f"{self.rid}/{self.type}/{self.key}"
+
+    def short_without_subfield(self) -> str:
+        return f"/{self.type}/{self.key}"
+
+    def paragraph_id(self, paragraph_start: int, paragraph_end: int) -> "ParagraphId":
+        """Generate a ParagraphId from the current field given its start and
+        end.
+
+        """
+        return ParagraphId(
+            field_id=self,
+            paragraph_start=paragraph_start,
+            paragraph_end=paragraph_end,
+        )
+
+    def __str__(self) -> str:
+        return self.full()
+
+    def __repr__(self) -> str:
+        return f"FieldId({self.full()})"
+
+    def __hash__(self) -> int:
+        return hash(self.full())
+
+    @staticmethod
+    def _parse_field_type(_type: str) -> str:
+        if _type not in FIELD_TYPE_STR_TO_PB:
+            # Try to parse the enum value
+            # XXX: This is to support field types that are integer values of FieldType
+            # Which is how legacy processor relations reported the paragraph_id
+            try:
+                type_pb = FieldType.ValueType(int(_type))
+            except ValueError:
+                raise ValueError(f"Invalid FieldId: {_type}")
+            if type_pb in FIELD_TYPE_PB_TO_STR:
+                return FIELD_TYPE_PB_TO_STR[type_pb]
+            else:
+                raise ValueError(f"Invalid FieldId: {_type}")
+        return _type
+
+
+@dataclass
+class ParagraphId:
+    field_id: FieldId
+    paragraph_start: int
+    paragraph_end: int
+
+    @classmethod
+    def from_string(cls, value: str) -> "ParagraphId":
+        parts = value.split("/")
+        paragraph_range = parts[-1]
+        start, end = map(int, paragraph_range.split("-"))
+        field_id = FieldId.from_string("/".join(parts[:-1]))
+        return cls(field_id=field_id, paragraph_start=start, paragraph_end=end)
+
+    @property
+    def rid(self) -> str:
+        return self.field_id.rid
+
+    def full(self) -> str:
+        return f"{self.field_id.full()}/{self.paragraph_start}-{self.paragraph_end}"
+
+    def __str__(self) -> str:
+        return self.full()
+
+    def __repr__(self) -> str:
+        return f"ParagraphId({self.full()})"
+
+    def __hash__(self) -> int:
+        return hash(self.full())

hyperforge_nucliadb_agentic/ask/utils/proto.py

@@ -0,0 +1,6 @@
+from nucliadb_models.search import NucliaDBClientType
+from nucliadb_protos.audit_pb2 import ClientType
+
+
+def client_type(obj: NucliaDBClientType) -> ClientType.ValueType:
+    return ClientType.Value(obj.name)

hyperforge_nucliadb_agentic/ask/utils/responses.py

@@ -0,0 +1,6 @@
+from fastapi.responses import JSONResponse
+
+
+class HTTPClientError(JSONResponse):
+    def __init__(self, status_code: int, detail: str):
+        super().__init__(status_code=status_code, content={"detail": detail})

hyperforge_nucliadb_agentic/ask/utils/text_blocks.py

@@ -0,0 +1,51 @@
+from hyperforge_nucliadb_agentic.ask.utils.ids import ParagraphId
+from nucliadb_models.retrieval import Score
+from nucliadb_models.search import SCORE_TYPE, Relations, TextPosition
+from nucliadb_protos import resources_pb2
+from pydantic import BaseModel
+
+# /k/ocr
+_OCR_LABEL = f"/k/{resources_pb2.Paragraph.TypeParagraph.Name(resources_pb2.Paragraph.TypeParagraph.OCR).lower()}"
+# /k/inception
+_INCEPTION_LABEL = f"/k/{resources_pb2.Paragraph.TypeParagraph.Name(resources_pb2.Paragraph.TypeParagraph.OCR).lower()}"
+
+
+class ScoredTextBlock(BaseModel):
+    paragraph_id: ParagraphId
+    score_type: SCORE_TYPE
+
+    scores: list[Score]
+
+    @property
+    def score(self) -> float:
+        return self.current_score.score
+
+    @property
+    def current_score(self) -> Score:
+        assert len(self.scores) > 0, "text block matches must be scored"
+        return self.scores[-1]
+
+
+class TextBlockMatch(ScoredTextBlock):
+    """
+    Model a text block/paragraph retrieved from an external index with all the information
+    needed in order to later hydrate retrieval results.
+    """
+
+    position: TextPosition
+    order: int
+    page_with_visual: bool = False
+    fuzzy_search: bool
+    is_a_table: bool = False
+    representation_file: str | None = None
+    paragraph_labels: list[str] = []
+    field_labels: list[str] = []
+    text: str | None = None
+    relevant_relations: Relations | None = None
+
+    @property
+    def is_an_image(self) -> bool:
+        return (
+            _OCR_LABEL in self.paragraph_labels
+            or _INCEPTION_LABEL in self.paragraph_labels
+        )

hyperforge_nucliadb_agentic/config.py

@@ -0,0 +1,47 @@
+from typing import List, Literal, Optional, Tuple
+
+from hyperforge.context.agent import ContextAgentConfig
+from hyperforge.utils import WidgetType
+from pydantic import Field
+from pydantic.config import ConfigDict
+
+
+class NucliaDBAgentConfig(ContextAgentConfig):
+    model_config = ConfigDict(title="Knowledge Box Agent")
+    module: Literal["nucliadb_agent"] = "nucliadb_agent"
+    sources: List[str] = Field(
+        default_factory=list,
+        json_schema_extra={
+            "show_in_node": True,
+        },
+    )
+    generative_model: str = Field(
+        default="chatgpt-azure-4o-mini",
+        title="Generative model",
+        description="Model used to generate answers",
+        json_schema_extra={"widget": WidgetType.MODEL_SELECT},
+    )
+    published_functions: Optional[Tuple[str, ...]] = Field(
+        default=(
+            "search_by_title",
+            "ask_labels_list",
+            "ask_by_title",
+            "ask_agent",
+            "ask_labels",
+            "facets_count",
+            "facets_search",
+            "catalog_search",
+            "all_images_by_title",
+            "search_images",
+        ),
+        title="Published functions",
+        description="List of functions published by this agent to be used by other agents in the chain",
+        json_schema_extra={
+            "widget": WidgetType.NOT_SHOWN,
+        },
+    )
+    generate_inner_answer: bool = Field(
+        default=True,
+        title="Generate inner answer",
+        description="If true, the agent will generate an inner answer to be used by other agents in the chain. If false, the agent will only generate a reasoning and a list of resources.",
+    )

hyperforge_nucliadb_agentic/internal_driver.py

@@ -0,0 +1,87 @@
+"""
+Internal NucliaDB driver for nucliadb_agentic_api.
+
+Registered as provider 'nucliadb_internal'. Creates two NucliaDBAsync clients
+(reader + search) and exposes a proxy that delegates to the correct one.
+"""
+
+import os
+from typing import Literal
+
+from hyperforge.configure import driver
+from hyperforge.driver import DriverConfig
+from hyperforge_nucliadb.driver import NucliaDBDriver, manager_connect
+from hyperforge_nucliadb.driver_config import NucliaDBConnection
+from nucliadb_sdk.v2 import NucliaDBAsync
+from pydantic.config import ConfigDict
+
+# Methods served by the search component; everything else goes to reader.
+_SEARCH_METHODS = {
+    "ask",
+    "find",
+    "search",
+    "catalog",
+    "catalog_facets",
+    "graph_nodes",
+    "graph_relations",
+    "graph_search",
+    "summarize",
+    "retrieve",
+    "augment",
+}
+
+
+class NucliaDBProxy:
+    """Holds two NucliaDBAsync clients and dispatches method calls to the correct one."""
+
+    def __init__(self, reader: NucliaDBAsync, search: NucliaDBAsync):
+        self._reader = reader
+        self._search = search
+
+    def __getattr__(self, name: str):
+        if name in _SEARCH_METHODS:
+            return getattr(self._search, name)
+        return getattr(self._reader, name)
+
+
+class InternalNucliaDBConnection(NucliaDBConnection):
+    """Connection config for internal cluster access. Provider is nucliadb_internal."""
+
+    pass
+
+
+class InternalNucliaDBConfig(DriverConfig[InternalNucliaDBConnection]):
+    model_config = ConfigDict(title="Internal Knowledge Box")
+    provider: Literal["nucliadb_internal"]
+    config: InternalNucliaDBConnection
+
+
+@driver(
+    id="nucliadb_internal",
+    title="Internal KnowledgeBox Source",
+    description="Internal cluster source for KnowledgeBox. Routes to reader/search components.",
+    config_schema=InternalNucliaDBConfig,
+)
+class InternalNucliaDBDriver(NucliaDBDriver):
+    driver: NucliaDBProxy
+
+    @classmethod
+    async def init(cls, driver: InternalNucliaDBConfig):
+        base_url = os.environ.get("INTERNAL_NUCLIADB_URL")
+        if not base_url:
+            raise RuntimeError(
+                "INTERNAL_NUCLIADB_URL must be set to use the nucliadb_internal driver"
+            )
+        reader_url = base_url.format(component="reader")
+        search_url = base_url.format(component="search")
+        headers = {"X-NUCLIADB-ROLES": "READER"}
+        reader_ndb = NucliaDBAsync(url=reader_url, headers=headers)
+        search_ndb = NucliaDBAsync(url=search_url, headers=headers)
+        return cls(
+            provider=driver.provider,
+            name=driver.name,
+            config=driver.config,
+            driver=NucliaDBProxy(reader_ndb, search_ndb),
+            manager=await manager_connect(driver.config),
+            _synonyms=None,
+        )

hyperforge_nucliadb_agentic-1.0.0.post64.dist-info/METADATA

@@ -0,0 +1,24 @@
+Metadata-Version: 2.4
+Name: hyperforge_nucliadb_agentic
+Version: 1.0.0.post64
+Summary: NucliaDB Hyperforge agent
+Author: Nuclia
+Author-email: Nuclia <nucliadb@nuclia.com>
+License-Expression: Apache-2.0
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Dist: hyperforge>=1.0.0.post76
+Requires-Dist: lingua-language-detector
+Requires-Dist: nucliadb-sdk
+Requires-Python: >=3.10, <4
+Project-URL: Homepage, https://progress.com
+Project-URL: Repository, https://github.com/nuclia/nucliadb_agentic_api
+Project-URL: Changelog, https://github.com/nuclia/nucliadb_agentic_api/blob/main/agents/nucliadb/CHANGELOG.md
+Description-Content-Type: text/markdown
+
+# NucliaDB Agentic Hyperforge agents
+

hyperforge_nucliadb_agentic-1.0.0.post64.dist-info/RECORD

@@ -0,0 +1,35 @@
+hyperforge_nucliadb_agentic/__init__.py,sha256=78Naois_RaK3UZ_g9M_tAke18pWA-CiTSaO8ZPHiDSo,62
+hyperforge_nucliadb_agentic/agent.py,sha256=8_3Xmb3qEdnI8tzvGBqcmONSWB34rBLGmH1MTZGXOh8,65404
+hyperforge_nucliadb_agentic/ask/__init__.py,sha256=LFMSFtFFoLQMCLkeYgwXap8gQTGDkMpRDdMbUdobx1o,104
+hyperforge_nucliadb_agentic/ask/audit.py,sha256=NeBk9zpTwxtE3bQIq1UM6VBrebkZNofawyLzaaUDoaA,15670
+hyperforge_nucliadb_agentic/ask/exceptions.py,sha256=MGd8zIB0z9OIQOWVzfUuHWyp4BYGcUG2TiV-4L6aZOI,1171
+hyperforge_nucliadb_agentic/ask/lifespan.py,sha256=RMEtoO_1Stjo7bLgPUA0sBA0IF_UsO6_mCB36SfItUc,521
+hyperforge_nucliadb_agentic/ask/model.py,sha256=FqoYMsEg2elpYY7TTYlp9ONAhxdytfjOQIZhu0gRkWs,52131
+hyperforge_nucliadb_agentic/ask/predict.py,sha256=tfJPC0WLkSwJCfvEHg-VvGQa0dt6zmP33kO5wjKL2YA,14864
+hyperforge_nucliadb_agentic/ask/predict_models.py,sha256=QPOWZ579ShKo4pCIqBtkB8tjYosHl7usTVeAQPUGNvs,3041
+hyperforge_nucliadb_agentic/ask/search/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hyperforge_nucliadb_agentic/ask/search/ask.py,sha256=Mn1rbFTnmOtkD9-nGYrC-m_nUMhYeKP9y07vSNlSzqU,43260
+hyperforge_nucliadb_agentic/ask/search/graph_strategy.py,sha256=OP2aHVjL_BlD1zC-usUbZ7TdUfb71DARJuD75r6Ys4g,39968
+hyperforge_nucliadb_agentic/ask/search/highlight.py,sha256=09PmwrScPusa8Ar26-yilnhFX-ibAw3wpjqCTkBEpJI,2775
+hyperforge_nucliadb_agentic/ask/search/hydrator.py,sha256=tyX4VmJ7N8eG0EbgId96D3ITf-3TcA5fiZwpxOccJcE,851
+hyperforge_nucliadb_agentic/ask/search/metrics.py,sha256=mtJO8v_Dfk-j1r1dwcDpUzPwLHcP7oc1z5A1HJwGov4,2954
+hyperforge_nucliadb_agentic/ask/search/parsers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hyperforge_nucliadb_agentic/ask/search/parsers/ask.py,sha256=CfXd-mbOjm-Llf_hz1SghTrUqmhTXmKYIzsyY53YQWU,2056
+hyperforge_nucliadb_agentic/ask/search/parsers/fetcher.py,sha256=ZO4DvmXdNZdzeqv-4Pw0ORuUSHUSaoisAs8y0Am1NDs,7377
+hyperforge_nucliadb_agentic/ask/search/parsers/find.py,sha256=u-s7akTC1890WyNfCj4jBVI68ncDMyGrz0hx7SYUEho,25726
+hyperforge_nucliadb_agentic/ask/search/prompt.py,sha256=ADa1AwQqVKJ4oDBE1xWtulHl4VjhyGRpbEhvqqy6SHU,49051
+hyperforge_nucliadb_agentic/ask/search/rank_fusion.py,sha256=XJgflFgnmtHxtRG1xQMcobiFkPWce6J8yS4iKTHsa8M,5065
+hyperforge_nucliadb_agentic/ask/search/rerankers.py,sha256=9mRPHaR_Ki3mK7hTMJzxsyG8TUgoMa9csvZtbakI1dg,4435
+hyperforge_nucliadb_agentic/ask/search/retrieval.py,sha256=vjgdjahRUr3G9qH2pp9csJT6vOOyLsbXdUvyWxSyv30,26498
+hyperforge_nucliadb_agentic/ask/search/rpc.py,sha256=x82OJPpghQIgTk3CW0lpLEWix-09vYSqPUJAv9BfRwI,5653
+hyperforge_nucliadb_agentic/ask/settings.py,sha256=0UiZKc6OiLwZbKaf9fYvujy5nng9Lr5cAej6m50Sh68,273
+hyperforge_nucliadb_agentic/ask/utils/ids.py,sha256=LiC78oQ4BE7TlF7sK_45a2Tc0899qEWRdJWE2Zi6lfE,5581
+hyperforge_nucliadb_agentic/ask/utils/proto.py,sha256=l245LXONx9elbppnbo7sHgaevOefPUUe1DAdh_GU1dg,209
+hyperforge_nucliadb_agentic/ask/utils/responses.py,sha256=5-mbQuWIYUSRmMqDuDZaW83vtpOKce9J_Yq-knzy-JE,215
+hyperforge_nucliadb_agentic/ask/utils/text_blocks.py,sha256=WGXFo4qL0L_ZS2CMU_6m8kASnLrBB7wC8i_mHfvzq0U,1580
+hyperforge_nucliadb_agentic/config.py,sha256=UkLnvA8_GbQAtpIqCC8t-UIy6v_zoKI6UL6oaEnLgJ0,1661
+hyperforge_nucliadb_agentic/internal_driver.py,sha256=uDValbgHE9U2z46UObce5gVXT2u8ITerimNRXt0q6kM,2774
+hyperforge_nucliadb_agentic/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hyperforge_nucliadb_agentic-1.0.0.post64.dist-info/WHEEL,sha256=YR4QUxGCbsyoOnWBVTv-p1I4yc3seKGPev46mvmc8Cg,81
+hyperforge_nucliadb_agentic-1.0.0.post64.dist-info/METADATA,sha256=IjxiIF8ccYsga1IIE-FC-NDr_nZEH8zLARf9HsKnDLQ,968
+hyperforge_nucliadb_agentic-1.0.0.post64.dist-info/RECORD,,

hyperforge_nucliadb_agentic-1.0.0.post64.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.11.29
+Root-Is-Purelib: true
+Tag: py3-none-any