nv-ingest-api 2025.7.15.dev20250715__py3-none-any.whl → 2025.7.17.dev20250717__py3-none-any.whl

nv_ingest_api/interface/extract.py

@@ -781,9 +781,9 @@ def extract_chart_data_from_image(
     *,
     df_ledger: pd.DataFrame,
     yolox_endpoints: Tuple[str, str],
-    paddle_endpoints: Tuple[str, str],
+    ocr_endpoints: Tuple[str, str],
     yolox_protocol: str = "grpc",
-    paddle_protocol: str = "grpc",
+    ocr_protocol: str = "grpc",
     auth_token: str = "",
 ) -> DataFrame:
     """
@@ -795,11 +795,11 @@ def extract_chart_data_from_image(
         DataFrame containing metadata required for chart extraction.
     yolox_endpoints : Tuple[str, str]
         YOLOX inference server endpoints.
-    paddle_endpoints : Tuple[str, str]
+    ocr_endpoints : Tuple[str, str]
         PaddleOCR inference server endpoints.
     yolox_protocol : str, optional
         Protocol for YOLOX inference (default "grpc").
-    paddle_protocol : str, optional
+    ocr_protocol : str, optional
         Protocol for PaddleOCR inference (default "grpc").
     auth_token : str, optional
         Authentication token for inference services.
@@ -821,9 +821,9 @@ def extract_chart_data_from_image(
         **{
             "endpoint_config": {
                 "yolox_endpoints": yolox_endpoints,
-                "paddle_endpoints": paddle_endpoints,
+                "ocr_endpoints": ocr_endpoints,
                 "yolox_infer_protocol": yolox_protocol,
-                "paddle_infer_protocol": paddle_protocol,
+                "ocr_infer_protocol": ocr_protocol,
                 "auth_token": auth_token,
             }
         }
@@ -844,9 +844,9 @@ def extract_table_data_from_image(
     *,
     df_ledger: pd.DataFrame,
     yolox_endpoints: Optional[Tuple[str, str]] = None,
-    paddle_endpoints: Optional[Tuple[str, str]] = None,
+    ocr_endpoints: Optional[Tuple[str, str]] = None,
     yolox_protocol: Optional[str] = None,
-    paddle_protocol: Optional[str] = None,
+    ocr_protocol: Optional[str] = None,
     auth_token: Optional[str] = None,
 ) -> pd.DataFrame:
     """
@@ -858,11 +858,11 @@ def extract_table_data_from_image(
         DataFrame containing metadata required for chart extraction.
     yolox_endpoints : Optional[Tuple[str, str]], default=None
         YOLOX inference server endpoints. If None, the default defined in ChartExtractorConfigSchema is used.
-    paddle_endpoints : Optional[Tuple[str, str]], default=None
+    ocr_endpoints : Optional[Tuple[str, str]], default=None
         PaddleOCR inference server endpoints. If None, the default defined in ChartExtractorConfigSchema is used.
     yolox_protocol : Optional[str], default=None
         Protocol for YOLOX inference. If None, the default defined in ChartExtractorConfigSchema is used.
-    paddle_protocol : Optional[str], default=None
+    ocr_protocol : Optional[str], default=None
         Protocol for PaddleOCR inference. If None, the default defined in ChartExtractorConfigSchema is used.
     auth_token : Optional[str], default=None
         Authentication token for inference services. If None, the default defined in ChartExtractorConfigSchema is used.
@@ -882,9 +882,9 @@ def extract_table_data_from_image(
     config_kwargs = {
         "endpoint_config": {
             "yolox_endpoints": yolox_endpoints,
-            "paddle_endpoints": paddle_endpoints,
+            "ocr_endpoints": ocr_endpoints,
             "yolox_infer_protocol": yolox_protocol,
-            "paddle_infer_protocol": paddle_protocol,
+            "ocr_infer_protocol": ocr_protocol,
             "auth_token": auth_token,
         }
     }
@@ -907,8 +907,8 @@ def extract_table_data_from_image(
 def extract_infographic_data_from_image(
     *,
     df_ledger: pd.DataFrame,
-    paddle_endpoints: Optional[Tuple[str, str]] = None,
-    paddle_protocol: Optional[str] = None,
+    ocr_endpoints: Optional[Tuple[str, str]] = None,
+    ocr_protocol: Optional[str] = None,
     auth_token: Optional[str] = None,
 ) -> pd.DataFrame:
     """
@@ -924,10 +924,10 @@ def extract_infographic_data_from_image(
     ----------
     df_extraction_ledger : pd.DataFrame
         DataFrame containing the images and associated metadata from which infographic data is to be extracted.
-    paddle_endpoints : Optional[Tuple[str, str]], default=None
+    ocr_endpoints : Optional[Tuple[str, str]], default=None
         A tuple of PaddleOCR endpoint addresses (e.g., (gRPC_endpoint, HTTP_endpoint)) used for inference.
         If None, the default endpoints from InfographicExtractorConfigSchema are used.
-    paddle_protocol : Optional[str], default=None
+    ocr_protocol : Optional[str], default=None
         The protocol (e.g., "grpc" or "http") for PaddleOCR inference.
         If None, the default protocol from InfographicExtractorConfigSchema is used.
     auth_token : Optional[str], default=None
@@ -951,8 +951,8 @@ def extract_infographic_data_from_image(
     extractor_config_kwargs = {
         "endpoint_config": InfographicExtractorConfigSchema(
             **{
-                "paddle_endpoints": paddle_endpoints,
-                "paddle_infer_protocol": paddle_protocol,
+                "ocr_endpoints": ocr_endpoints,
+                "ocr_infer_protocol": ocr_protocol,
                 "auth_token": auth_token,
             }
         )

nv_ingest_api/internal/enums/common.py

@@ -52,6 +52,8 @@ class ContentDescriptionEnum(str, Enum):
         Description for image extracted from PDF document.
     PDF_INFOGRAPHIC : str
         Description for structured infographic extracted from PDF document.
+    PDF_PAGE_IMAGE : str
+        Description for a full-page image rendered from a PDF document.
     PDF_TABLE : str
         Description for structured table extracted from PDF document.
     PDF_TEXT : str
@@ -70,6 +72,7 @@ class ContentDescriptionEnum(str, Enum):
     PDF_CHART: str = "Structured chart extracted from PDF document."
     PDF_IMAGE: str = "Image extracted from PDF document."
     PDF_INFOGRAPHIC: str = "Structured infographic extracted from PDF document."
+    PDF_PAGE_IMAGE: str = "Full-page image rendered from a PDF document."
     PDF_TABLE: str = "Structured table extracted from PDF document."
     PDF_TEXT: str = "Unstructured text from PDF document."
     PPTX_IMAGE: str = "Image extracted from PPTX presentation."
@@ -94,6 +97,8 @@ class ContentTypeEnum(str, Enum):
         Represents image content.
     INFO_MSG : str
         Represents an informational message.
+    PAGE_IMAGE : str
+        Represents a full-page image rendered from a document.
     STRUCTURED : str
         Represents structured content.
     TEXT : str
@@ -111,6 +116,7 @@ class ContentTypeEnum(str, Enum):
     INFOGRAPHIC: str = "infographic"
     INFO_MSG: str = "info_message"
     NONE: str = "none"
+    PAGE_IMAGE: str = "page_image"
     STRUCTURED: str = "structured"
     TABLE: str = "table"
     TEXT: str = "text"

nv_ingest_api/internal/extract/image/chart_extractor.py

@@ -16,9 +16,10 @@ import pandas as pd
 from nv_ingest_api.internal.primitives.nim.model_interface.helpers import get_version
 from nv_ingest_api.internal.schemas.extract.extract_chart_schema import ChartExtractorSchema
 from nv_ingest_api.internal.schemas.meta.ingest_job_schema import IngestTaskChartExtraction
-from nv_ingest_api.util.image_processing.table_and_chart import join_yolox_graphic_elements_and_paddle_output
+from nv_ingest_api.util.image_processing.table_and_chart import join_yolox_graphic_elements_and_ocr_output
 from nv_ingest_api.util.image_processing.table_and_chart import process_yolox_graphic_elements
-from nv_ingest_api.internal.primitives.nim.model_interface.paddle import PaddleOCRModelInterface
+from nv_ingest_api.internal.primitives.nim.model_interface.ocr import OCRModelInterface
+from nv_ingest_api.internal.primitives.nim.model_interface.ocr import get_ocr_model_name
 from nv_ingest_api.internal.primitives.nim import NimClient
 from nv_ingest_api.internal.primitives.nim.model_interface.yolox import YoloxGraphicElementsModelInterface
 from nv_ingest_api.util.image_processing.transforms import base64_to_numpy
@@ -62,7 +63,8 @@ def _filter_valid_chart_images(
 
 def _run_chart_inference(
     yolox_client: Any,
-    paddle_client: Any,
+    ocr_client: Any,
+    ocr_model_name: str,
     valid_arrays: List[np.ndarray],
     valid_images: List[str],
     trace_info: Dict,
@@ -70,29 +72,40 @@ def _run_chart_inference(
     """
     Run concurrent inference for chart extraction using YOLOX and Paddle.
 
-    Returns a tuple of (yolox_results, paddle_results).
+    Returns a tuple of (yolox_results, ocr_results).
     """
     data_yolox = {"images": valid_arrays}
-    data_paddle = {"base64_images": valid_images}
+    data_ocr = {"base64_images": valid_images}
 
-    with ThreadPoolExecutor(max_workers=2) as executor:
-        future_yolox = executor.submit(
-            yolox_client.infer,
-            data=data_yolox,
-            model_name="yolox",
-            stage_name="chart_extraction",
-            max_batch_size=8,
-            trace_info=trace_info,
-        )
-        future_paddle = executor.submit(
-            paddle_client.infer,
-            data=data_paddle,
+    future_yolox_kwargs = dict(
+        data=data_yolox,
+        model_name="yolox",
+        stage_name="chart_extraction",
+        max_batch_size=8,
+        trace_info=trace_info,
+    )
+    future_ocr_kwargs = dict(
+        data=data_ocr,
+        stage_name="chart_extraction",
+        max_batch_size=1 if ocr_client.protocol == "grpc" else 2,
+        trace_info=trace_info,
+    )
+    if ocr_model_name == "paddle":
+        future_ocr_kwargs.update(
             model_name="paddle",
-            stage_name="chart_extraction",
-            max_batch_size=1 if paddle_client.protocol == "grpc" else 2,
-            trace_info=trace_info,
+        )
+    else:
+        future_ocr_kwargs.update(
+            model_name="scene_text",
+            input_names=["input", "merge_levels"],
+            dtypes=["FP32", "BYTES"],
+            merge_level="paragraph",
         )
 
+    with ThreadPoolExecutor(max_workers=2) as executor:
+        future_yolox = executor.submit(yolox_client.infer, **future_yolox_kwargs)
+        future_ocr = executor.submit(ocr_client.infer, **future_ocr_kwargs)
+
         try:
             yolox_results = future_yolox.result()
         except Exception as e:
@@ -100,16 +113,16 @@ def _run_chart_inference(
             raise
 
         try:
-            paddle_results = future_paddle.result()
+            ocr_results = future_ocr.result()
         except Exception as e:
-            logger.error(f"Error calling paddle_client.infer: {e}", exc_info=True)
+            logger.error(f"Error calling ocr_client.infer: {e}", exc_info=True)
             raise
 
-    return yolox_results, paddle_results
+    return yolox_results, ocr_results
 
 
 def _validate_chart_inference_results(
-    yolox_results: Any, paddle_results: Any, valid_arrays: List[Any], valid_images: List[str]
+    yolox_results: Any, ocr_results: Any, valid_arrays: List[Any], valid_images: List[str]
 ) -> Tuple[List[Any], List[Any]]:
     """
     Ensure inference results are lists and have expected lengths.
@@ -117,21 +130,21 @@ def _validate_chart_inference_results(
     Raises:
       ValueError if results do not match expected types or lengths.
     """
-    if not (isinstance(yolox_results, list) and isinstance(paddle_results, list)):
-        raise ValueError("Expected list results from both yolox_client and paddle_client infer calls.")
+    if not (isinstance(yolox_results, list) and isinstance(ocr_results, list)):
+        raise ValueError("Expected list results from both yolox_client and ocr_client infer calls.")
 
     if len(yolox_results) != len(valid_arrays):
         raise ValueError(f"Expected {len(valid_arrays)} yolox results, got {len(yolox_results)}")
-    if len(paddle_results) != len(valid_images):
-        raise ValueError(f"Expected {len(valid_images)} paddle results, got {len(paddle_results)}")
-    return yolox_results, paddle_results
+    if len(ocr_results) != len(valid_images):
+        raise ValueError(f"Expected {len(valid_images)} ocr results, got {len(ocr_results)}")
+    return yolox_results, ocr_results
 
 
 def _merge_chart_results(
     base64_images: List[str],
     valid_indices: List[int],
     yolox_results: List[Any],
-    paddle_results: List[Any],
+    ocr_results: List[Any],
     initial_results: List[Tuple[str, Optional[Dict]]],
 ) -> List[Tuple[str, Optional[Dict]]]:
     """
@@ -140,10 +153,10 @@ def _merge_chart_results(
     For each valid image, processes the results from both inference calls and updates the
     corresponding entry in the results list.
     """
-    for idx, (yolox_res, paddle_res) in enumerate(zip(yolox_results, paddle_results)):
-        # Unpack paddle result into bounding boxes and text predictions.
-        bounding_boxes, text_predictions = paddle_res
-        yolox_elements = join_yolox_graphic_elements_and_paddle_output(yolox_res, bounding_boxes, text_predictions)
+    for idx, (yolox_res, ocr_res) in enumerate(zip(yolox_results, ocr_results)):
+        # Unpack ocr result into bounding boxes and text predictions.
+        bounding_boxes, text_predictions, _ = ocr_res
+        yolox_elements = join_yolox_graphic_elements_and_ocr_output(yolox_res, bounding_boxes, text_predictions)
         chart_content = process_yolox_graphic_elements(yolox_elements)
         original_index = valid_indices[idx]
         initial_results[original_index] = (base64_images[original_index], chart_content)
@@ -153,7 +166,8 @@ def _merge_chart_results(
 def _update_chart_metadata(
     base64_images: List[str],
     yolox_client: Any,
-    paddle_client: Any,
+    ocr_client: Any,
+    ocr_model_name: str,
     trace_info: Dict,
     worker_pool_size: int = 8,  # Not currently used.
 ) -> List[Tuple[str, Optional[Dict]]]:
@@ -172,28 +186,29 @@ def _update_chart_metadata(
     valid_images, valid_arrays, valid_indices, results = _filter_valid_chart_images(base64_images)
 
     # Run concurrent inference only for valid images.
-    yolox_results, paddle_results = _run_chart_inference(
+    yolox_results, ocr_results = _run_chart_inference(
         yolox_client=yolox_client,
-        paddle_client=paddle_client,
+        ocr_client=ocr_client,
+        ocr_model_name=ocr_model_name,
         valid_arrays=valid_arrays,
         valid_images=valid_images,
         trace_info=trace_info,
     )
 
     # Validate that the returned inference results are lists of the expected length.
-    yolox_results, paddle_results = _validate_chart_inference_results(
-        yolox_results, paddle_results, valid_arrays, valid_images
+    yolox_results, ocr_results = _validate_chart_inference_results(
+        yolox_results, ocr_results, valid_arrays, valid_images
     )
 
     # Merge the inference results into the results list.
-    return _merge_chart_results(base64_images, valid_indices, yolox_results, paddle_results, results)
+    return _merge_chart_results(base64_images, valid_indices, yolox_results, ocr_results, results)
 
 
 def _create_clients(
     yolox_endpoints: Tuple[str, str],
     yolox_protocol: str,
-    paddle_endpoints: Tuple[str, str],
-    paddle_protocol: str,
+    ocr_endpoints: Tuple[str, str],
+    ocr_protocol: str,
     auth_token: str,
 ) -> Tuple[NimClient, NimClient]:
     # Obtain yolox_version
@@ -214,9 +229,9 @@ def _create_clients(
         yolox_version = None  # Default to the latest version
 
     yolox_model_interface = YoloxGraphicElementsModelInterface(yolox_version=yolox_version)
-    paddle_model_interface = PaddleOCRModelInterface()
+    ocr_model_interface = OCRModelInterface()
 
-    logger.debug(f"Inference protocols: yolox={yolox_protocol}, paddle={paddle_protocol}")
+    logger.debug(f"Inference protocols: yolox={yolox_protocol}, ocr={ocr_protocol}")
 
     yolox_client = create_inference_client(
         endpoints=yolox_endpoints,
@@ -225,14 +240,14 @@ def _create_clients(
         infer_protocol=yolox_protocol,
     )
 
-    paddle_client = create_inference_client(
-        endpoints=paddle_endpoints,
-        model_interface=paddle_model_interface,
+    ocr_client = create_inference_client(
+        endpoints=ocr_endpoints,
+        model_interface=ocr_model_interface,
         auth_token=auth_token,
-        infer_protocol=paddle_protocol,
+        infer_protocol=ocr_protocol,
     )
 
-    return yolox_client, paddle_client
+    return yolox_client, ocr_client
 
 
 def extract_chart_data_from_image_internal(
@@ -275,14 +290,18 @@ def extract_chart_data_from_image_internal(
         return df_extraction_ledger, execution_trace_log
 
     endpoint_config = extraction_config.endpoint_config
-    yolox_client, paddle_client = _create_clients(
+    yolox_client, ocr_client = _create_clients(
         endpoint_config.yolox_endpoints,
         endpoint_config.yolox_infer_protocol,
-        endpoint_config.paddle_endpoints,
-        endpoint_config.paddle_infer_protocol,
+        endpoint_config.ocr_endpoints,
+        endpoint_config.ocr_infer_protocol,
         endpoint_config.auth_token,
     )
 
+    # Get the grpc endpoint to determine the model if needed
+    ocr_grpc_endpoint = endpoint_config.ocr_endpoints[0]
+    ocr_model_name = get_ocr_model_name(ocr_grpc_endpoint)
+
     try:
         # 1) Identify rows that meet criteria in a single pass
         #    - metadata exists
@@ -323,7 +342,8 @@ def extract_chart_data_from_image_internal(
         bulk_results = _update_chart_metadata(
             base64_images=base64_images,
             yolox_client=yolox_client,
-            paddle_client=paddle_client,
+            ocr_client=ocr_client,
+            ocr_model_name=ocr_model_name,
             worker_pool_size=endpoint_config.workers_per_progress_engine,
             trace_info=execution_trace_log,
         )
@@ -344,8 +364,8 @@ def extract_chart_data_from_image_internal(
 
     finally:
         try:
-            if paddle_client is not None:
-                paddle_client.close()
+            if ocr_client is not None:
+                ocr_client.close()
             if yolox_client is not None:
                 yolox_client.close()
 

nv_ingest_api/internal/extract/image/infographic_extractor.py

@@ -12,12 +12,14 @@ from typing import Tuple
 import pandas as pd
 
 from nv_ingest_api.internal.primitives.nim import NimClient
-from nv_ingest_api.internal.primitives.nim.model_interface.paddle import PaddleOCRModelInterface
+from nv_ingest_api.internal.primitives.nim.model_interface.ocr import OCRModelInterface
+from nv_ingest_api.internal.primitives.nim.model_interface.ocr import get_ocr_model_name
 from nv_ingest_api.internal.schemas.extract.extract_infographic_schema import (
     InfographicExtractorSchema,
 )
 from nv_ingest_api.util.image_processing.transforms import base64_to_numpy
 from nv_ingest_api.util.nim import create_inference_client
+from nv_ingest_api.util.image_processing.table_and_chart import reorder_boxes
 
 logger = logging.getLogger(__name__)
 
@@ -61,22 +63,23 @@ def _filter_infographic_images(
 
 def _update_infographic_metadata(
     base64_images: List[str],
-    paddle_client: NimClient,
+    ocr_client: NimClient,
+    ocr_model_name: str,
     worker_pool_size: int = 8,  # Not currently used
     trace_info: Optional[Dict] = None,
 ) -> List[Tuple[str, Optional[Any], Optional[Any]]]:
     """
-    Filters base64-encoded images and uses PaddleOCR to extract infographic data.
+    Filters base64-encoded images and uses OCR to extract infographic data.
 
-    For each image that meets the minimum size, calls paddle_client.infer to obtain
+    For each image that meets the minimum size, calls ocr_client.infer to obtain
     (text_predictions, bounding_boxes). Invalid images are marked as skipped.
 
     Parameters
     ----------
     base64_images : List[str]
         List of base64-encoded images.
-    paddle_client : NimClient
-        Client instance for PaddleOCR inference.
+    ocr_client : NimClient
+        Client instance for OCR inference.
     worker_pool_size : int, optional
         Worker pool size (currently not used), by default 8.
     trace_info : Optional[Dict], optional
@@ -88,54 +91,70 @@ def _update_infographic_metadata(
         List of tuples in the same order as base64_images, where each tuple contains:
         (base64_image, text_predictions, bounding_boxes).
     """
-    logger.debug(f"Running infographic extraction using protocol {paddle_client.protocol}")
+    logger.debug(f"Running infographic extraction using protocol {ocr_client.protocol}")
 
     valid_images, valid_indices, results = _filter_infographic_images(base64_images)
-    data_paddle = {"base64_images": valid_images}
+    data_ocr = {"base64_images": valid_images}
 
     # worker_pool_size is not used in current implementation.
     _ = worker_pool_size
 
-    try:
-        paddle_results = paddle_client.infer(
-            data=data_paddle,
+    infer_kwargs = dict(
+        stage_name="infographic_extraction",
+        max_batch_size=1 if ocr_client.protocol == "grpc" else 2,
+        trace_info=trace_info,
+    )
+    if ocr_model_name == "paddle":
+        infer_kwargs.update(
             model_name="paddle",
-            stage_name="infographic_extraction",
-            max_batch_size=1 if paddle_client.protocol == "grpc" else 2,
-            trace_info=trace_info,
         )
+    else:
+        infer_kwargs.update(
+            model_name="scene_text",
+            input_names=["input", "merge_levels"],
+            dtypes=["FP32", "BYTES"],
+            merge_level="paragraph",
+        )
+    try:
+        ocr_results = ocr_client.infer(data_ocr, **infer_kwargs)
     except Exception as e:
-        logger.error(f"Error calling paddle_client.infer: {e}", exc_info=True)
+        logger.error(f"Error calling ocr_client.infer: {e}", exc_info=True)
         raise
 
-    if len(paddle_results) != len(valid_images):
-        raise ValueError(f"Expected {len(valid_images)} paddle results, got {len(paddle_results)}")
+    if len(ocr_results) != len(valid_images):
+        raise ValueError(f"Expected {len(valid_images)} ocr results, got {len(ocr_results)}")
 
-    for idx, paddle_res in enumerate(paddle_results):
+    for idx, ocr_res in enumerate(ocr_results):
         original_index = valid_indices[idx]
-        # Each paddle_res is expected to be a tuple (text_predictions, bounding_boxes)
-        results[original_index] = (base64_images[original_index], paddle_res[0], paddle_res[1])
+
+        if ocr_model_name == "paddle":
+            logger.debug(f"OCR results for image {base64_images[original_index]}: {ocr_res}")
+        else:
+            # Each ocr_res is expected to be a tuple (text_predictions, bounding_boxes, conf_scores).
+            ocr_res = reorder_boxes(*ocr_res)
+
+        results[original_index] = (base64_images[original_index], ocr_res[0], ocr_res[1])
 
     return results
 
 
 def _create_clients(
-    paddle_endpoints: Tuple[str, str],
-    paddle_protocol: str,
+    ocr_endpoints: Tuple[str, str],
+    ocr_protocol: str,
     auth_token: str,
 ) -> NimClient:
-    paddle_model_interface = PaddleOCRModelInterface()
+    ocr_model_interface = OCRModelInterface()
 
-    logger.debug(f"Inference protocols: paddle={paddle_protocol}")
+    logger.debug(f"Inference protocols: ocr={ocr_protocol}")
 
-    paddle_client = create_inference_client(
-        endpoints=paddle_endpoints,
-        model_interface=paddle_model_interface,
+    ocr_client = create_inference_client(
+        endpoints=ocr_endpoints,
+        model_interface=ocr_model_interface,
         auth_token=auth_token,
-        infer_protocol=paddle_protocol,
+        infer_protocol=ocr_protocol,
     )
 
-    return paddle_client
+    return ocr_client
 
 
 def _meets_infographic_criteria(row: pd.Series) -> bool:
@@ -209,12 +228,16 @@ def extract_infographic_data_from_image_internal(
         return df_extraction_ledger, execution_trace_log
 
     endpoint_config = extraction_config.endpoint_config
-    paddle_client = _create_clients(
-        endpoint_config.paddle_endpoints,
-        endpoint_config.paddle_infer_protocol,
+    ocr_client = _create_clients(
+        endpoint_config.ocr_endpoints,
+        endpoint_config.ocr_infer_protocol,
         endpoint_config.auth_token,
     )
 
+    # Get the grpc endpoint to determine the model if needed
+    ocr_grpc_endpoint = endpoint_config.ocr_endpoints[0]
+    ocr_model_name = get_ocr_model_name(ocr_grpc_endpoint)
+
     try:
         # Identify rows that meet the infographic criteria.
         mask = df_extraction_ledger.apply(_meets_infographic_criteria, axis=1)
@@ -230,14 +253,15 @@ def extract_infographic_data_from_image_internal(
         # Call bulk update to extract infographic data.
         bulk_results = _update_infographic_metadata(
             base64_images=base64_images,
-            paddle_client=paddle_client,
+            ocr_client=ocr_client,
+            ocr_model_name=ocr_model_name,
             worker_pool_size=endpoint_config.workers_per_progress_engine,
             trace_info=execution_trace_log,
         )
 
         # Write the extracted results back into the DataFrame.
         for result_idx, df_idx in enumerate(valid_indices):
-            # Unpack result: (base64_image, paddle_bounding_boxes, paddle_text_predictions)
+            # Unpack result: (base64_image, ocr_bounding_boxes, ocr_text_predictions)
             _, _, text_predictions = bulk_results[result_idx]
             table_content = " ".join(text_predictions) if text_predictions else None
             df_extraction_ledger.at[df_idx, "metadata"]["table_metadata"]["table_content"] = table_content
@@ -250,4 +274,4 @@ def extract_infographic_data_from_image_internal(
         raise
 
     finally:
-        paddle_client.close()
+        ocr_client.close()