nucliadb 2.46.1.post382__py3-none-any.whl → 6.2.1.post2777__py3-none-any.whl

nucliadb/search/api/v1/find.py

@@ -18,33 +18,37 @@
 # along with this program. If not, see <http://www.gnu.org/licenses/>.
 #
 import json
-from datetime import datetime
 from typing import Optional, Union
 
 from fastapi import Body, Header, Query, Request, Response
 from fastapi.openapi.models import Example
 from fastapi_versioning import version
-from pydantic.error_wrappers import ValidationError
+from pydantic import ValidationError
 
 from nucliadb.common.datamanagers.exceptions import KnowledgeBoxNotFound
 from nucliadb.models.responses import HTTPClientError
 from nucliadb.search import predict
 from nucliadb.search.api.v1.router import KB_PREFIX, api
 from nucliadb.search.api.v1.utils import fastapi_query
+from nucliadb.search.search import cache
 from nucliadb.search.search.exceptions import InvalidQueryError
 from nucliadb.search.search.find import find
-from nucliadb.search.search.utils import min_score_from_query_params
+from nucliadb.search.search.utils import maybe_log_request_payload, min_score_from_query_params
 from nucliadb_models.common import FieldTypeName
 from nucliadb_models.resource import ExtractedDataTypeName, NucliaDBRoles
 from nucliadb_models.search import (
     FindRequest,
     KnowledgeboxFindResults,
     NucliaDBClientType,
+    RankFusionName,
+    Reranker,
+    RerankerName,
     ResourceProperties,
     SearchOptions,
     SearchParamDefaults,
 )
 from nucliadb_models.security import RequestSecurity
+from nucliadb_models.utils import DateTime
 from nucliadb_utils.authentication import requires
 from nucliadb_utils.exceptions import LimitsExceededError
 
@@ -54,7 +58,7 @@ FIND_EXAMPLES = {
         description="Perform a hybrid search that will return text and semantic results matching the query",
         value={
             "query": "How can I be an effective product manager?",
-            "features": [SearchOptions.PARAGRAPH, SearchOptions.VECTOR],
+            "features": [SearchOptions.KEYWORD, SearchOptions.SEMANTIC],
         },
     )
 }
@@ -63,7 +67,7 @@ FIND_EXAMPLES = {
 @api.get(
     f"/{KB_PREFIX}/{{kbid}}/find",
     status_code=200,
-    name="Find Knowledge Box",
+    summary="Find Knowledge Box",
     description="Find on a Knowledge Box",
     response_model=KnowledgeboxFindResults,
     response_model_exclude_unset=True,
@@ -78,39 +82,35 @@ async def find_knowledgebox(
     query: str = fastapi_query(SearchParamDefaults.query),
     fields: list[str] = fastapi_query(SearchParamDefaults.fields),
     filters: list[str] = fastapi_query(SearchParamDefaults.filters),
-    page_number: int = fastapi_query(SearchParamDefaults.page_number),
-    page_size: int = fastapi_query(SearchParamDefaults.page_size),
+    top_k: Optional[int] = fastapi_query(SearchParamDefaults.top_k),
     min_score: Optional[float] = Query(
         default=None,
-        description="Minimum similarity score to filter vector index results. If not specified, the default minimum score of the semantic model associated to the Knowledge Box will be used. Check out the documentation for more information on how to use this parameter: https://docs.nuclia.dev/docs/docs/using/search/#minimum-score",  # noqa: E501
+        description="Minimum similarity score to filter vector index results. If not specified, the default minimum score of the semantic model associated to the Knowledge Box will be used. Check out the documentation for more information on how to use this parameter: https://docs.nuclia.dev/docs/rag/advanced/search#minimum-score",  # noqa: E501
         deprecated=True,
     ),
     min_score_semantic: Optional[float] = Query(
         default=None,
-        description="Minimum semantic similarity score to filter vector index results. If not specified, the default minimum score of the semantic model associated to the Knowledge Box will be used. Check out the documentation for more information on how to use this parameter: https://docs.nuclia.dev/docs/docs/using/search/#minimum-score",  # noqa: E501
+        description="Minimum semantic similarity score to filter vector index results. If not specified, the default minimum score of the semantic model associated to the Knowledge Box will be used. Check out the documentation for more information on how to use this parameter: https://docs.nuclia.dev/docs/rag/advanced/search#minimum-score",  # noqa: E501
     ),
     min_score_bm25: float = Query(
         default=0,
         description="Minimum bm25 score to filter paragraph and document index results",
         ge=0,
     ),
-    range_creation_start: Optional[datetime] = fastapi_query(
-        SearchParamDefaults.range_creation_start
-    ),
-    range_creation_end: Optional[datetime] = fastapi_query(
-        SearchParamDefaults.range_creation_end
-    ),
-    range_modification_start: Optional[datetime] = fastapi_query(
+    vectorset: Optional[str] = fastapi_query(SearchParamDefaults.vectorset),
+    range_creation_start: Optional[DateTime] = fastapi_query(SearchParamDefaults.range_creation_start),
+    range_creation_end: Optional[DateTime] = fastapi_query(SearchParamDefaults.range_creation_end),
+    range_modification_start: Optional[DateTime] = fastapi_query(
         SearchParamDefaults.range_modification_start
     ),
-    range_modification_end: Optional[datetime] = fastapi_query(
+    range_modification_end: Optional[DateTime] = fastapi_query(
         SearchParamDefaults.range_modification_end
     ),
     features: list[SearchOptions] = fastapi_query(
         SearchParamDefaults.search_features,
         default=[
-            SearchOptions.PARAGRAPH,
-            SearchOptions.VECTOR,
+            SearchOptions.KEYWORD,
+            SearchOptions.SEMANTIC,
         ],
     ),
     debug: bool = fastapi_query(SearchParamDefaults.debug),
@@ -119,13 +119,14 @@ async def find_knowledgebox(
     field_type_filter: list[FieldTypeName] = fastapi_query(
         SearchParamDefaults.field_type_filter, alias="field_type"
     ),
-    extracted: list[ExtractedDataTypeName] = fastapi_query(
-        SearchParamDefaults.extracted
-    ),
+    extracted: list[ExtractedDataTypeName] = fastapi_query(SearchParamDefaults.extracted),
     with_duplicates: bool = fastapi_query(SearchParamDefaults.with_duplicates),
     with_synonyms: bool = fastapi_query(SearchParamDefaults.with_synonyms),
     autofilter: bool = fastapi_query(SearchParamDefaults.autofilter),
     security_groups: list[str] = fastapi_query(SearchParamDefaults.security_groups),
+    show_hidden: bool = fastapi_query(SearchParamDefaults.show_hidden),
+    rank_fusion: RankFusionName = fastapi_query(SearchParamDefaults.rank_fusion),
+    reranker: Union[RerankerName, Reranker] = fastapi_query(SearchParamDefaults.reranker),
     x_ndb_client: NucliaDBClientType = Header(NucliaDBClientType.API),
     x_nucliadb_user: str = Header(""),
     x_forwarded_for: str = Header(""),
@@ -138,11 +139,9 @@ async def find_knowledgebox(
             query=query,
             fields=fields,
             filters=filters,
-            page_number=page_number,
-            page_size=page_size,
-            min_score=min_score_from_query_params(
-                min_score_bm25, min_score_semantic, min_score
-            ),
+            top_k=top_k,  # type: ignore
+            min_score=min_score_from_query_params(min_score_bm25, min_score_semantic, min_score),
+            vectorset=vectorset,
             range_creation_end=range_creation_end,
             range_creation_start=range_creation_start,
             range_modification_end=range_modification_end,
@@ -157,20 +156,21 @@ async def find_knowledgebox(
             with_synonyms=with_synonyms,
             autofilter=autofilter,
             security=security,
+            show_hidden=show_hidden,
+            rank_fusion=rank_fusion,
+            reranker=reranker,
         )
     except ValidationError as exc:
         detail = json.loads(exc.json())
         return HTTPClientError(status_code=422, detail=detail)
 
-    return await _find_endpoint(
-        response, kbid, item, x_ndb_client, x_nucliadb_user, x_forwarded_for
-    )
+    return await _find_endpoint(response, kbid, item, x_ndb_client, x_nucliadb_user, x_forwarded_for)
 
 
 @api.post(
     f"/{KB_PREFIX}/{{kbid}}/find",
     status_code=200,
-    name="Find Knowledge Box",
+    summary="Find Knowledge Box",
     description="Find on a Knowledge Box",
     response_model=KnowledgeboxFindResults,
     response_model_exclude_unset=True,
@@ -187,9 +187,7 @@ async def find_post_knowledgebox(
     x_nucliadb_user: str = Header(""),
     x_forwarded_for: str = Header(""),
 ) -> Union[KnowledgeboxFindResults, HTTPClientError]:
-    return await _find_endpoint(
-        response, kbid, item, x_ndb_client, x_nucliadb_user, x_forwarded_for
-    )
+    return await _find_endpoint(response, kbid, item, x_ndb_client, x_nucliadb_user, x_forwarded_for)
 
 
 async def _find_endpoint(
@@ -201,11 +199,13 @@ async def _find_endpoint(
     x_forwarded_for: str,
 ) -> Union[KnowledgeboxFindResults, HTTPClientError]:
     try:
-        results, incomplete, _ = await find(
-            kbid, item, x_ndb_client, x_nucliadb_user, x_forwarded_for
-        )
-        response.status_code = 206 if incomplete else 200
-        return results
+        maybe_log_request_payload(kbid, "/find", item)
+        with cache.request_caches():
+            results, incomplete, _ = await find(
+                kbid, item, x_ndb_client, x_nucliadb_user, x_forwarded_for
+            )
+            response.status_code = 206 if incomplete else 200
+            return results
     except KnowledgeBoxNotFound:
         return HTTPClientError(status_code=404, detail="Knowledge Box not found")
     except LimitsExceededError as exc:
@@ -214,6 +214,6 @@ async def _find_endpoint(
         return HTTPClientError(status_code=412, detail=str(exc))
     except predict.ProxiedPredictAPIError as err:
         return HTTPClientError(
-            status_code=503,
-            detail=f"Inference service unavailable. {err.status}: {err.detail}",
+            status_code=err.status,
+            detail=err.detail,
         )

nucliadb/search/api/v1/knowledgebox.py

@@ -24,29 +24,35 @@ from fastapi import HTTPException, Request
 from fastapi_versioning import version
 from grpc import StatusCode as GrpcStatusCode
 from grpc.aio import AioRpcError
-from nucliadb_protos.noderesources_pb2 import Shard
-from nucliadb_protos.writer_pb2 import ShardObject as PBShardObject
-from nucliadb_protos.writer_pb2 import Shards
 
 from nucliadb.common import datamanagers
 from nucliadb.common.cluster.exceptions import ShardsNotFound
 from nucliadb.common.cluster.manager import choose_node
 from nucliadb.common.cluster.utils import get_shard_manager
+from nucliadb.common.constants import AVG_PARAGRAPH_SIZE_BYTES
+from nucliadb.common.counters import IndexCounts
+from nucliadb.common.external_index_providers.manager import get_external_index_manager
+from nucliadb.common.models_utils import from_proto
 from nucliadb.search import logger
 from nucliadb.search.api.v1.router import KB_PREFIX, api
 from nucliadb.search.api.v1.utils import fastapi_query
 from nucliadb.search.search.shards import get_shard
 from nucliadb.search.settings import settings
+from nucliadb_models.internal.shards import KnowledgeboxShards
 from nucliadb_models.resource import NucliaDBRoles
 from nucliadb_models.search import (
     KnowledgeboxCounters,
-    KnowledgeboxShards,
     SearchParamDefaults,
 )
+from nucliadb_protos.noderesources_pb2 import Shard
+from nucliadb_protos.writer_pb2 import ShardObject as PBShardObject
+from nucliadb_protos.writer_pb2 import Shards
 from nucliadb_telemetry import errors
+from nucliadb_utils import const
 from nucliadb_utils.authentication import requires, requires_one
+from nucliadb_utils.utilities import has_feature
 
-AVG_PARAGRAPH_SIZE_BYTES = 10_000
+MAX_PARAGRAPHS_FOR_SMALL_KB = 250_000
 
 
 @api.get(
@@ -68,7 +74,7 @@ async def knowledgebox_shards(request: Request, kbid: str) -> KnowledgeboxShards
             status_code=404,
             detail="The knowledgebox or its shards configuration is missing",
         )
-    return KnowledgeboxShards.from_message(shards)
+    return from_proto.kb_shards(shards)
 
 
 @api.get(
@@ -84,24 +90,85 @@ async def knowledgebox_shards(request: Request, kbid: str) -> KnowledgeboxShards
 async def knowledgebox_counters(
     request: Request,
     kbid: str,
-    vectorset: str = fastapi_query(SearchParamDefaults.vectorset),
     debug: bool = fastapi_query(SearchParamDefaults.debug),
 ) -> KnowledgeboxCounters:
-    shard_manager = get_shard_manager()
-
     try:
-        shard_groups: list[PBShardObject] = await shard_manager.get_shards_by_kbid(kbid)
+        return await _kb_counters(kbid, debug=debug)
     except ShardsNotFound:
         raise HTTPException(
             status_code=404,
             detail="The knowledgebox or its shards configuration is missing",
         )
 
+
+async def _kb_counters(
+    kbid: str,
+    debug: bool = False,
+) -> KnowledgeboxCounters:
+    """
+    Resources count is calculated from maindb and cached
+    Field count is calculated from the index node cluster
+    Paragraphs and Sentences count is calculated from the index node cluster or the external index provider.
+    Index size is estimated from the paragraphs count.
+    """
+    counters = KnowledgeboxCounters(
+        resources=0,
+        paragraphs=0,
+        fields=0,
+        sentences=0,
+        index_size=0,
+    )
+    external_index_manager = await get_external_index_manager(kbid)
+    if external_index_manager is not None:
+        index_counts = await external_index_manager.get_index_counts()
+        counters.paragraphs = index_counts.paragraphs
+        counters.sentences = index_counts.sentences
+        is_small_kb = index_counts.paragraphs < MAX_PARAGRAPHS_FOR_SMALL_KB
+        resource_count = await get_resources_count(kbid, force_calculate=is_small_kb)
+        # TODO: Find a way to query the fields count from the external index provider or use the catalog
+        counters.resources = counters.fields = resource_count
+    else:
+        node_index_counts, queried_shards = await get_node_index_counts(kbid)
+        counters.fields = node_index_counts.fields
+        counters.paragraphs = node_index_counts.paragraphs
+        counters.sentences = node_index_counts.sentences
+        is_small_kb = node_index_counts.paragraphs < MAX_PARAGRAPHS_FOR_SMALL_KB
+        resource_count = await get_resources_count(kbid, force_calculate=is_small_kb)
+        counters.resources = resource_count
+    counters.index_size = counters.paragraphs * AVG_PARAGRAPH_SIZE_BYTES
+    if debug and queried_shards is not None:
+        counters.shards = queried_shards
+    return counters
+
+
+async def get_resources_count(kbid: str, force_calculate: bool = False) -> int:
+    async with datamanagers.with_ro_transaction() as txn:
+        if force_calculate:
+            # For small kbs, this is faster and more up to date
+            resource_count = await datamanagers.resources.calculate_number_of_resources(txn, kbid=kbid)
+        else:
+            resource_count = await datamanagers.resources.get_number_of_resources(txn, kbid=kbid)
+            if resource_count == -1:
+                # WARNING: standalone, this value will never be cached
+                resource_count = await datamanagers.resources.calculate_number_of_resources(
+                    txn, kbid=kbid
+                )
+    return resource_count
+
+
+async def get_node_index_counts(kbid: str) -> tuple[IndexCounts, list[str]]:
+    """
+    Get the index counts for a knowledgebox that has an index in the index node cluster.
+    """
+    shard_manager = get_shard_manager()
+    shard_groups: list[PBShardObject] = await shard_manager.get_shards_by_kbid(kbid)
     ops = []
     queried_shards = []
     for shard_object in shard_groups:
         try:
-            node, shard_id = choose_node(shard_object)
+            node, shard_id = choose_node(
+                shard_object, use_nidx=has_feature(const.Features.NIDX_READS, context={"kbid": kbid})
+            )
         except KeyError:
             raise HTTPException(
                 status_code=500,
@@ -111,7 +178,7 @@ async def knowledgebox_counters(
             if shard_id is not None:
                 # At least one node is alive for this shard group
                 # let's add it ot the query list if has a valid value
-                ops.append(get_shard(node, shard_id, vectorset=vectorset))
+                ops.append(get_shard(node, shard_id))
                 queried_shards.append(shard_id)
 
     if not ops:
@@ -122,7 +189,7 @@ async def knowledgebox_counters(
         )
 
     try:
-        results: Optional[list[Shard]] = await asyncio.wait_for(  # type: ignore
+        results: Optional[list[Shard]] = await asyncio.wait_for(
             asyncio.gather(*ops, return_exceptions=True),  # type: ignore
             timeout=settings.search_timeout,
         )
@@ -139,56 +206,17 @@ async def knowledgebox_counters(
     if results is None:
         raise HTTPException(status_code=503, detail=f"No shards found")
 
-    field_count = 0
-    paragraph_count = 0
-    sentence_count = 0
-
+    counts = IndexCounts(
+        fields=0,
+        paragraphs=0,
+        sentences=0,
+    )
     for shard in results:
         if isinstance(shard, Exception):
             logger.error("Error getting shard info", exc_info=shard)
             errors.capture_exception(shard)
-            raise HTTPException(
-                status_code=500, detail=f"Error while geting shard data"
-            )
-
-        field_count += shard.fields
-        paragraph_count += shard.paragraphs
-        sentence_count += shard.sentences
-
-    async with datamanagers.with_transaction() as txn:
-        try:
-            if len(shard_groups) <= 1:
-                # for smaller kbs, this is faster and more up to date
-                resource_count = (
-                    await datamanagers.resources.calculate_number_of_resources(
-                        txn, kbid=kbid
-                    )
-                )
-            else:
-                resource_count = await datamanagers.resources.get_number_of_resources(
-                    txn, kbid=kbid
-                )
-                if resource_count == -1:
-                    # WARNING: standalone, this value will never be cached
-                    resource_count = (
-                        await datamanagers.resources.calculate_number_of_resources(
-                            txn, kbid=kbid
-                        )
-                    )
-        except Exception as exc:
-            errors.capture_exception(exc)
-            raise HTTPException(
-                status_code=500, detail="Couldn't retrieve counters right now"
-            )
-
-    counters = KnowledgeboxCounters(
-        resources=resource_count,
-        paragraphs=paragraph_count,
-        fields=field_count,
-        sentences=sentence_count,
-        index_size=paragraph_count * AVG_PARAGRAPH_SIZE_BYTES,
-    )
-
-    if debug:
-        counters.shards = queried_shards
-    return counters
+            raise HTTPException(status_code=500, detail=f"Error while geting shard data")
+        counts.fields += shard.fields
+        counts.paragraphs += shard.paragraphs
+        counts.sentences += shard.sentences
+    return counts, queried_shards

nucliadb/search/api/v1/predict_proxy.py

@@ -39,7 +39,7 @@ DESCRIPTION = "Convenience endpoint that proxies requests to the Predict API. It
 @api.get(
     path=f"/{KB_PREFIX}/{{kbid}}/predict/{{endpoint}}",
     status_code=200,
-    name="Predict API Proxy",
+    summary="Predict API Proxy",
     description=DESCRIPTION,
     response_model=None,
     tags=["Search"],
@@ -47,7 +47,7 @@ DESCRIPTION = "Convenience endpoint that proxies requests to the Predict API. It
 @api.post(
     path=f"/{KB_PREFIX}/{{kbid}}/predict/{{endpoint}}",
     status_code=200,
-    name="Predict API Proxy",
+    summary="Predict API Proxy",
     description=DESCRIPTION,
     response_model=None,
     tags=["Search"],

nucliadb/search/api/v1/resource/ask.py

@@ -17,146 +17,95 @@
 # You should have received a copy of the GNU Affero General Public License
 # along with this program. If not, see <http://www.gnu.org/licenses/>.
 #
-from typing import Union
+from typing import Optional, Union
 
-from fastapi import Body, Header, Request, Response
-from fastapi.openapi.models import Example
+from fastapi import Header, Request, Response
 from fastapi_versioning import version
-from nucliadb_protos.resources_pb2 import FieldComputedMetadata
-from nucliadb_protos.utils_pb2 import ExtractedText
+from starlette.responses import StreamingResponse
 
-from nucliadb.common.maindb.utils import get_driver
-from nucliadb.ingest.orm.knowledgebox import KnowledgeBox
+from nucliadb.common import datamanagers
 from nucliadb.models.responses import HTTPClientError
-from nucliadb.search import SERVICE_NAME, logger
-from nucliadb.search.api.v1.router import KB_PREFIX, api
-from nucliadb.search.predict import SendToPredictError
-from nucliadb.search.search.exceptions import InvalidQueryError, ResourceNotFoundError
-from nucliadb.search.utilities import get_predict
+from nucliadb.search.api.v1.router import KB_PREFIX, RESOURCE_SLUG_PREFIX, api
 from nucliadb_models.resource import NucliaDBRoles
-from nucliadb_models.search import AskRequest, AskResponse, TextBlocks
-from nucliadb_utils import const
+from nucliadb_models.search import AskRequest, NucliaDBClientType, SyncAskResponse
 from nucliadb_utils.authentication import requires
-from nucliadb_utils.exceptions import LimitsExceededError
-from nucliadb_utils.utilities import get_storage, has_feature
 
-ASK_EXAMPLES = {
-    "Ask a Resource": Example(
-        summary="Ask a question to the document",
-        description="Ask a question to the document. The whole document is sent as context to the generative AI",
-        value={
-            "question": "Does this document contain personal information?",
-        },
-    )
-}
+from ..ask import create_ask_response
 
 
 @api.post(
     f"/{KB_PREFIX}/{{kbid}}/resource/{{rid}}/ask",
     status_code=200,
-    name="Ask a Resource",
-    summary="Ask a question to a resource",
-    description="Ask to the complete content of the resource",
+    summary="Ask a resource (by id)",
+    description="Ask questions to a resource",
     tags=["Search"],
-    response_model=None,
-    # TODO: set to True once feature is fully enabled
-    include_in_schema=False,
+    response_model=SyncAskResponse,
 )
 @requires(NucliaDBRoles.READER)
 @version(1)
-async def resource_ask_endpoint(
+async def resource_ask_endpoint_by_uuid(
     request: Request,
-    response: Response,
     kbid: str,
     rid: str,
-    item: AskRequest = Body(
-        openapi_examples=ASK_EXAMPLES, description="Ask a question payload"
+    item: AskRequest,
+    x_ndb_client: NucliaDBClientType = Header(NucliaDBClientType.API),
+    x_nucliadb_user: str = Header(""),
+    x_forwarded_for: str = Header(""),
+    x_synchronous: bool = Header(
+        False,
+        description="When set to true, outputs response as JSON in a non-streaming way. "
+        "This is slower and requires waiting for entire answer to be ready.",
     ),
-    x_nucliadb_user: str = Header("", description="User Id", include_in_schema=False),
-) -> Union[AskResponse, HTTPClientError]:
-    if not has_feature(const.Features.ASK_YOUR_DOCUMENTS):
-        return HTTPClientError(status_code=404, detail="Feature not yet available")
-
-    try:
-        return await resource_ask(kbid, rid, item, user_id=x_nucliadb_user)
-    except ResourceNotFoundError:
-        return HTTPClientError(status_code=404, detail="Resource not found")
-    except LimitsExceededError as exc:
-        return HTTPClientError(status_code=exc.status_code, detail=exc.detail)
-    except SendToPredictError:
-        return HTTPClientError(status_code=503, detail="Ask service not available")
-    except InvalidQueryError as exc:
-        return HTTPClientError(status_code=412, detail=str(exc))
+) -> Union[StreamingResponse, HTTPClientError, Response]:
+    return await create_ask_response(
+        kbid,
+        item,
+        x_nucliadb_user,
+        x_ndb_client,
+        x_forwarded_for,
+        x_synchronous,
+        resource=rid,
+    )
 
 
-async def resource_ask(
+@api.post(
+    f"/{KB_PREFIX}/{{kbid}}/{RESOURCE_SLUG_PREFIX}/{{slug}}/ask",
+    status_code=200,
+    summary="Ask a resource (by slug)",
+    description="Ask questions to a resource",
+    tags=["Search"],
+    response_model=SyncAskResponse,
+)
+@requires(NucliaDBRoles.READER)
+@version(1)
+async def resource_ask_endpoint_by_slug(
+    request: Request,
     kbid: str,
-    rid: str,
+    slug: str,
     item: AskRequest,
-    user_id: str,
-) -> AskResponse:
-    blocks = await get_resource_text_blocks(kbid, rid)
-
-    predict = get_predict()
-    answer = await predict.ask_document(kbid, item.question, blocks, user_id)
-
-    return AskResponse(answer=answer)
-
-
-async def get_resource_text_blocks(kbid: str, rid: str) -> TextBlocks:
-    """
-    Iterate over all fields of the resource and get its extracted text.
-    Slice file extracted texts by paragraphs.
-    """
-    blocks = []
-    driver = get_driver()
-    storage = await get_storage(service_name=SERVICE_NAME)
-    async with driver.transaction() as txn:
-        kb = KnowledgeBox(txn, storage, kbid)
-        orm_resource = await kb.get(rid)
-        if orm_resource is None:
-            raise ResourceNotFoundError()
-
-        for field_type, field_id in await orm_resource.get_fields_ids():
-            field_obj = await orm_resource.get_field(field_id, field_type, load=False)
-            etxt = await field_obj.get_extracted_text()
-            if etxt is None:
-                logger.warning(
-                    f"Skipping field {field_id}, as it does not have extracted text yet!"
-                )
-                continue
-
-            fcm = await field_obj.get_field_metadata()
-            if fcm is None:
-                logger.warning(f"Field metadata not found for {field_id}")
-                blocks.append(get_field_blocks(etxt))
-            else:
-                blocks.append(get_field_blocks_split_by_paragraphs(etxt, fcm))
-    return blocks
-
-
-def get_field_blocks_split_by_paragraphs(
-    etxt: ExtractedText, fcm: FieldComputedMetadata
-) -> list[str]:
-    block = []
-    for paragraph in fcm.metadata.paragraphs:
-        block.append(etxt.text[paragraph.start : paragraph.end])
-
-    for split, metadata in fcm.split_metadata.items():
-        for split_paragraph in metadata.paragraphs:
-            split_text = etxt.split_text.get(split)
-            if split_text is None:
-                logger.warning(f"Split {split} not found in extracted text")
-                continue
-            block.append(split_text[split_paragraph.start : split_paragraph.end])
-    return block
+    x_ndb_client: NucliaDBClientType = Header(NucliaDBClientType.API),
+    x_nucliadb_user: str = Header(""),
+    x_forwarded_for: str = Header(""),
+    x_synchronous: bool = Header(
+        False,
+        description="When set to true, outputs response as JSON in a non-streaming way. "
+        "This is slower and requires waiting for entire answer to be ready.",
+    ),
+) -> Union[StreamingResponse, HTTPClientError, Response]:
+    resource_id = await get_resource_uuid_by_slug(kbid, slug)
+    if resource_id is None:
+        return HTTPClientError(status_code=404, detail="Resource not found")
+    return await create_ask_response(
+        kbid,
+        item,
+        x_nucliadb_user,
+        x_ndb_client,
+        x_forwarded_for,
+        x_synchronous,
+        resource=resource_id,
+    )
 
 
-def get_field_blocks(etxt: ExtractedText) -> list[str]:
-    blocks = []
-    if etxt.text:
-        blocks.append(etxt.text)
-    for split_etxt in etxt.split_text.values():
-        if split_etxt:
-            blocks.append(split_etxt)
-    return blocks
+async def get_resource_uuid_by_slug(kbid: str, slug: str) -> Optional[str]:
+    async with datamanagers.with_ro_transaction() as txn:
+        return await datamanagers.resources.get_resource_uuid_from_slug(txn, kbid=kbid, slug=slug)