paddlex 3.0.2__py3-none-any.whl → 3.1.0__py3-none-any.whl

paddlex/inference/pipelines/pp_doctranslation/utils.py

@@ -0,0 +1,260 @@
+# Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import re
+
+
+def _find_split_pos(text, chunk_size):
+    """
+    Find the position to split the text into two chunks.
+
+    Args:
+        text (str): The original text to be split.
+        chunk_size (int): The maximum size of each chunk.
+
+    Returns:
+        int: The index where the text should be split.
+    """
+    center = len(text) // 2
+    # Search forward
+    for i in range(center, len(text)):
+        if text[i] in ["\n", ".", "。", ";", "；", "!", "！", "?", "？"]:
+            if i + 1 < len(text) and len(text[: i + 1]) <= chunk_size:
+                return i + 1
+    # Search backward
+    for i in range(center, 0, -1):
+        if text[i] in ["\n", ".", "。", ";", "；", "!", "！", "?", "？"]:
+            if len(text[: i + 1]) <= chunk_size:
+                return i + 1
+    # If no suitable position is found, split directly
+    return min(chunk_size, len(text))
+
+
+def split_text_recursive(text, chunk_size, translate_func, results):
+    """
+    Split the text recursively and translate each chunk.
+
+    Args:
+        text (str): The original text to be split.
+        chunk_size (int): The maximum size of each chunk.
+        translate_func (callable): A function that translates a single chunk of text.
+        results (list): A list to store the translated chunks.
+
+    Returns:
+        None
+    """
+    text = text.strip()
+    if len(text) <= chunk_size:
+        results.append(translate_func(text))
+    else:
+        split_pos = _find_split_pos(text, chunk_size)
+        left = text[:split_pos].strip()
+        right = text[split_pos:].strip()
+        if left:
+            split_text_recursive(left, chunk_size, translate_func, results)
+        if right:
+            split_text_recursive(right, chunk_size, translate_func, results)
+
+
+def translate_code_block(code_block, chunk_size, translate_func, results):
+    """
+    Translate a code block and append the result to the results list.
+
+    Args:
+        code_block (str): The code block to be translated.
+        chunk_size (int): The maximum size of each chunk.
+        translate_func (callable): A function that translates a single chunk of text.
+        results (list): A list to store the translated chunks.
+
+    Returns:
+        None
+    """
+    lines = code_block.strip().split("\n")
+    if lines[0].startswith("```") or lines[0].startswith("~~~"):
+        header = lines[0]
+        footer = (
+            lines[-1]
+            if (lines[-1].startswith("```") or lines[-1].startswith("~~~"))
+            else ""
+        )
+        code_content = "\n".join(lines[1:-1]) if footer else "\n".join(lines[1:])
+    else:
+        header = ""
+        footer = ""
+        code_content = code_block
+
+    translated_code_lines = []
+    split_text_recursive(
+        code_content, chunk_size, translate_func, translated_code_lines
+    )
+
+    # drop ``` or ~~~
+    filtered_code_lines = [
+        line
+        for line in translated_code_lines
+        if not (line.strip().startswith("```") or line.strip().startswith("~~~"))
+    ]
+    translated_code = "\n".join(filtered_code_lines)
+
+    result = f"{header}\n{translated_code}\n{footer}" if header else translated_code
+    results.append(result)
+
+
+def translate_html_block(html_block, chunk_size, translate_func, results):
+    """
+    Translate a HTML block and append the result to the results list.
+
+    Args:
+        html_block (str): The HTML block to be translated.
+        chunk_size (int): The maximum size of each chunk.
+        translate_func (callable): A function that translates a single chunk of text.
+        results (list): A list to store the translated chunks.
+
+    Returns:
+        None
+    """
+    from bs4 import BeautifulSoup
+
+    soup = BeautifulSoup(html_block, "html.parser")
+
+    # collect text nodes
+    text_nodes = []
+    for node in soup.find_all(string=True, recursive=True):
+        text = node.strip()
+        if text:
+            text_nodes.append(node)
+
+    idx = 0
+    total = len(text_nodes)
+    while idx < total:
+        batch_nodes = []
+        li_texts = []
+        current_length = len("<ol></ol>")
+        while idx < total:
+            node_text = text_nodes[idx].strip()
+            if len(node_text) > chunk_size:
+                # if node_text is too long, split it
+                translated_lines = []
+                split_text_recursive(
+                    node_text, chunk_size, translate_func, translated_lines
+                )
+                # concatenate translated lines with \n
+                text_nodes[idx].replace_with("\n".join(translated_lines))
+                idx += 1
+                continue
+            li_str = f"<li>{node_text}</li>"
+            if current_length + len(li_str) > chunk_size:
+                break
+            batch_nodes.append(text_nodes[idx])
+            li_texts.append(li_str)
+            current_length += len(li_str)
+            idx += 1
+        if not batch_nodes:
+            # if all individual nodes are longer than chunk_size, translate it alone
+            node_text = text_nodes[idx - 1].strip()
+            li_str = f"<li>{node_text}</li>"
+            batch_nodes = [text_nodes[idx - 1]]
+            li_texts = [li_str]
+
+        if batch_nodes:
+            batch_text = "<ol>" + "".join(li_texts) + "</ol>"
+            translated = translate_func(batch_text)
+            trans_soup = BeautifulSoup(translated, "html.parser")
+            translated_lis = trans_soup.find_all("li")
+            for orig_node, li_tag in zip(batch_nodes, translated_lis):
+                orig_node.replace_with(li_tag.decode_contents())
+
+    results.append(str(soup))
+
+
+def split_original_texts(text):
+    """
+    Split the original text into chunks.
+    """
+    from bs4 import BeautifulSoup
+
+    # find all html blocks and replace them with placeholders
+    soup = BeautifulSoup(text, "html.parser")
+    html_blocks = []
+    html_placeholders = []
+    placeholder_fmt = "<<HTML_BLOCK_{}>>"
+    text_after_placeholder = ""
+
+    index = 0
+    for elem in soup.contents:
+        if hasattr(elem, "name") and elem.name is not None:
+            html_str = str(elem)
+            placeholder = placeholder_fmt.format(index)
+            html_blocks.append(html_str)
+            html_placeholders.append(placeholder)
+            text_after_placeholder += placeholder
+            index += 1
+        else:
+            text_after_placeholder += str(elem)
+
+    # split text into paragraphs
+    splited_block = []
+    splited_block = split_and_append_text(splited_block, text_after_placeholder)
+
+    # replace placeholders with html blocks
+    current_index = 0
+    for idx, block in enumerate(splited_block):
+        _, content = block
+        while (
+            current_index < len(html_placeholders)
+            and html_placeholders[current_index] in content
+        ):
+            content = content.replace(
+                html_placeholders[current_index], html_blocks[current_index]
+            )
+            current_index += 1
+            splited_block[idx] = ("html", content)
+
+    return splited_block
+
+
+def split_and_append_text(result, text_content):
+    """
+    Split the text and append the result to the result list.
+
+    Args:
+        result (list): The current result list.
+        text_content (str): The text content to be processed.
+
+    Returns:
+        list: The updated result list after processing the text content.
+    """
+    if text_content.strip():
+        # match all code block interval
+        code_pattern = re.compile(r"(```.*?\n.*?```|~~~.*?\n.*?~~~)", re.DOTALL)
+        last_pos = 0
+        for m in code_pattern.finditer(text_content):
+            # process text before code block
+            if m.start() > last_pos:
+                non_code = text_content[last_pos : m.start()]
+                paragraphs = re.split(r"\n{2,}", non_code)
+                for p in paragraphs:
+                    if p.strip():
+                        result.append(("text", p.strip()))
+            # process code block
+            result.append(("code", m.group()))
+            last_pos = m.end()
+        # process remaining text
+        if last_pos < len(text_content):
+            non_code = text_content[last_pos:]
+            paragraphs = re.split(r"\n{2,}", non_code)
+            for p in paragraphs:
+                if p.strip():
+                    result.append(("text", p.strip()))
+    return result

paddlex/inference/pipelines/pp_shitu_v2/result.py

@@ -17,7 +17,7 @@ import copy
 import PIL
 from PIL import Image, ImageDraw, ImageFont
 
-from ....utils.fonts import PINGFANG_FONT_FILE_PATH
+from ....utils.fonts import PINGFANG_FONT
 from ...common.result import BaseCVResult, JsonMixin
 from ...utils.color_map import font_colormap, get_colormap
 
@@ -32,7 +32,7 @@ def draw_box(img, boxes):
     """
     img = Image.fromarray(img)
     font_size = int(0.018 * int(img.width)) + 2
-    font = ImageFont.truetype(PINGFANG_FONT_FILE_PATH, font_size, encoding="utf-8")
+    font = ImageFont.truetype(PINGFANG_FONT.path, font_size, encoding="utf-8")
 
     draw_thickness = int(max(img.size) * 0.002)
     draw = ImageDraw.Draw(img)

paddlex/inference/serving/basic_serving/_app.py

@@ -114,6 +114,7 @@ class PipelineWrapper(Generic[PipelineT]):
         if not self._closed:
             self._queue.put(None)
             await call_async(self._thread.join)
+            self._closed = True
 
     def _worker(self):
         while not self._closed:

paddlex/inference/serving/basic_serving/_pipeline_apps/anomaly_detection.py

@@ -39,7 +39,9 @@ def create_pipeline_app(pipeline: Any, app_config: AppConfig) -> "FastAPI":
     async def _infer(request: InferRequest) -> AIStudioResultResponse[InferResult]:
         pipeline = ctx.pipeline
         aiohttp_session = ctx.aiohttp_session
-
+        visualize_enabled = (
+            request.visualize if request.visualize is not None else ctx.config.visualize
+        )
         file_bytes = await serving_utils.get_raw_bytes_async(
             request.image, aiohttp_session
         )
@@ -50,7 +52,7 @@ def create_pipeline_app(pipeline: Any, app_config: AppConfig) -> "FastAPI":
         pred = result["pred"][0].tolist()
         size = [len(pred), len(pred[0])]
         label_map = [item for sublist in pred for item in sublist]
-        if ctx.config.visualize:
+        if visualize_enabled:
             output_image_base64 = serving_utils.base64_encode(
                 serving_utils.image_to_bytes(result.img["res"].convert("RGB"))
             )

paddlex/inference/serving/basic_serving/_pipeline_apps/doc_preprocessor.py

@@ -45,6 +45,10 @@ def create_pipeline_app(pipeline: Any, app_config: AppConfig) -> "FastAPI":
 
         log_id = serving_utils.generate_log_id()
 
+        visualize_enabled = (
+            request.visualize if request.visualize is not None else ctx.config.visualize
+        )
+
         images, data_info = await ocr_common.get_images(request, ctx)
 
         result = await pipeline.infer(
@@ -64,7 +68,7 @@ def create_pipeline_app(pipeline: Any, app_config: AppConfig) -> "FastAPI":
                 return_url=ctx.extra["return_img_urls"],
                 max_img_size=ctx.extra["max_output_img_size"],
             )
-            if ctx.config.visualize:
+            if visualize_enabled:
                 vis_imgs = {
                     "input_img": img,
                     "doc_preprocessing_img": item.img["preprocessed_img"],

paddlex/inference/serving/basic_serving/_pipeline_apps/face_recognition.py

@@ -166,7 +166,9 @@ def create_pipeline_app(pipeline: Any, app_config: AppConfig) -> "FastAPI":
     ) -> AIStudioResultResponse[schema.InferResult]:
         pipeline = ctx.pipeline
         aiohttp_session = ctx.aiohttp_session
-
+        visualize_enabled = (
+            request.visualize if request.visualize is not None else ctx.config.visualize
+        )
         image_bytes = await serving_utils.get_raw_bytes_async(
             request.image, aiohttp_session
         )
@@ -211,7 +213,7 @@ def create_pipeline_app(pipeline: Any, app_config: AppConfig) -> "FastAPI":
                     score=obj["det_score"],
                 )
             )
-        if ctx.config.visualize:
+        if visualize_enabled:
             output_image_base64 = serving_utils.base64_encode(
                 serving_utils.image_to_bytes(result.img["res"])
             )

paddlex/inference/serving/basic_serving/_pipeline_apps/formula_recognition.py

@@ -44,7 +44,9 @@ def create_pipeline_app(pipeline: Any, app_config: AppConfig) -> "FastAPI":
         pipeline = ctx.pipeline
 
         log_id = serving_utils.generate_log_id()
-
+        visualize_enabled = (
+            request.visualize if request.visualize is not None else ctx.config.visualize
+        )
         images, data_info = await ocr_common.get_images(request, ctx)
 
         result = await pipeline.infer(
@@ -61,7 +63,7 @@ def create_pipeline_app(pipeline: Any, app_config: AppConfig) -> "FastAPI":
         formula_rec_results: List[Dict[str, Any]] = []
         for i, (img, item) in enumerate(zip(images, result)):
             pruned_res = common.prune_result(item.json["res"])
-            if ctx.config.visualize:
+            if visualize_enabled:
                 imgs = {
                     "input_img": img,
                     **item.img,

paddlex/inference/serving/basic_serving/_pipeline_apps/human_keypoint_detection.py

@@ -43,7 +43,9 @@ def create_pipeline_app(pipeline: Any, app_config: AppConfig) -> "FastAPI":
     async def _infer(request: InferRequest) -> AIStudioResultResponse[InferResult]:
         pipeline = ctx.pipeline
         aiohttp_session = ctx.aiohttp_session
-
+        visualize_enabled = (
+            request.visualize if request.visualize is not None else ctx.config.visualize
+        )
         file_bytes = await serving_utils.get_raw_bytes_async(
             request.image, aiohttp_session
         )
@@ -66,7 +68,7 @@ def create_pipeline_app(pipeline: Any, app_config: AppConfig) -> "FastAPI":
                     kptScore=obj["kpt_score"],
                 )
             )
-        if ctx.config.visualize:
+        if visualize_enabled:
             output_image_base64 = serving_utils.base64_encode(
                 serving_utils.image_to_bytes(result.img["res"])
             )

paddlex/inference/serving/basic_serving/_pipeline_apps/image_classification.py

@@ -39,7 +39,9 @@ def create_pipeline_app(pipeline: Any, app_config: AppConfig) -> "FastAPI":
     async def _infer(request: InferRequest) -> AIStudioResultResponse[InferResult]:
         pipeline = ctx.pipeline
         aiohttp_session = ctx.aiohttp_session
-
+        visualize_enabled = (
+            request.visualize if request.visualize is not None else ctx.config.visualize
+        )
         file_bytes = await serving_utils.get_raw_bytes_async(
             request.image, aiohttp_session
         )
@@ -54,7 +56,7 @@ def create_pipeline_app(pipeline: Any, app_config: AppConfig) -> "FastAPI":
         categories: List[Dict[str, Any]] = []
         for id_, name, score in zip(result["class_ids"], cat_names, result["scores"]):
             categories.append(dict(id=id_, name=name, score=score))
-        if ctx.config.visualize:
+        if visualize_enabled:
             output_image_base64 = serving_utils.base64_encode(
                 serving_utils.image_to_bytes(result.img["res"])
             )

paddlex/inference/serving/basic_serving/_pipeline_apps/image_multilabel_classification.py

@@ -43,7 +43,9 @@ def create_pipeline_app(pipeline: Any, app_config: AppConfig) -> "FastAPI":
     async def _infer(request: InferRequest) -> AIStudioResultResponse[InferResult]:
         pipeline = ctx.pipeline
         aiohttp_session = ctx.aiohttp_session
-
+        visualize_enabled = (
+            request.visualize if request.visualize is not None else ctx.config.visualize
+        )
         file_bytes = await serving_utils.get_raw_bytes_async(
             request.image, aiohttp_session
         )
@@ -58,7 +60,7 @@ def create_pipeline_app(pipeline: Any, app_config: AppConfig) -> "FastAPI":
         categories: List[Dict[str, Any]] = []
         for id_, name, score in zip(result["class_ids"], cat_names, result["scores"]):
             categories.append(dict(id=id_, name=name, score=score))
-        if ctx.config.visualize:
+        if visualize_enabled:
             output_image_base64 = serving_utils.base64_encode(
                 serving_utils.image_to_bytes(result.img["res"])
             )

paddlex/inference/serving/basic_serving/_pipeline_apps/instance_segmentation.py

@@ -51,7 +51,9 @@ def create_pipeline_app(pipeline: Any, app_config: AppConfig) -> "FastAPI":
     async def _infer(request: InferRequest) -> AIStudioResultResponse[InferResult]:
         pipeline = ctx.pipeline
         aiohttp_session = ctx.aiohttp_session
-
+        visualize_enabled = (
+            request.visualize if request.visualize is not None else ctx.config.visualize
+        )
         file_bytes = await serving_utils.get_raw_bytes_async(
             request.image, aiohttp_session
         )
@@ -72,7 +74,7 @@ def create_pipeline_app(pipeline: Any, app_config: AppConfig) -> "FastAPI":
                     mask=mask,
                 )
             )
-        if ctx.config.visualize:
+        if visualize_enabled:
             output_image_base64 = serving_utils.base64_encode(
                 serving_utils.image_to_bytes(result.img["res"])
             )

paddlex/inference/serving/basic_serving/_pipeline_apps/layout_parsing.py

@@ -46,7 +46,9 @@ def create_pipeline_app(pipeline: Any, app_config: AppConfig) -> "FastAPI":
         pipeline = ctx.pipeline
 
         log_id = serving_utils.generate_log_id()
-
+        visualize_enabled = (
+            request.visualize if request.visualize is not None else ctx.config.visualize
+        )
         images, data_info = await ocr_common.get_images(request, ctx)
 
         result = await pipeline.infer(
@@ -78,7 +80,7 @@ def create_pipeline_app(pipeline: Any, app_config: AppConfig) -> "FastAPI":
         layout_parsing_results: List[Dict[str, Any]] = []
         for i, (img, item) in enumerate(zip(images, result)):
             pruned_res = common.prune_result(item.json["res"])
-            if ctx.config.visualize:
+            if visualize_enabled:
                 imgs = {
                     "input_img": img,
                     **item.img,

paddlex/inference/serving/basic_serving/_pipeline_apps/object_detection.py

@@ -39,7 +39,9 @@ def create_pipeline_app(pipeline: Any, app_config: AppConfig) -> "FastAPI":
     async def _infer(request: InferRequest) -> AIStudioResultResponse[InferResult]:
         pipeline = ctx.pipeline
         aiohttp_session = ctx.aiohttp_session
-
+        visualize_enabled = (
+            request.visualize if request.visualize is not None else ctx.config.visualize
+        )
         file_bytes = await serving_utils.get_raw_bytes_async(
             request.image, aiohttp_session
         )
@@ -62,7 +64,7 @@ def create_pipeline_app(pipeline: Any, app_config: AppConfig) -> "FastAPI":
                     score=obj["score"],
                 )
             )
-        if ctx.config.visualize:
+        if visualize_enabled:
             output_image_base64 = serving_utils.base64_encode(
                 serving_utils.image_to_bytes(result.img["res"])
             )

paddlex/inference/serving/basic_serving/_pipeline_apps/ocr.py

@@ -44,7 +44,9 @@ def create_pipeline_app(pipeline: Any, app_config: AppConfig) -> "FastAPI":
         pipeline = ctx.pipeline
 
         log_id = serving_utils.generate_log_id()
-
+        visualize_enabled = (
+            request.visualize if request.visualize is not None else ctx.config.visualize
+        )
         images, data_info = await ocr_common.get_images(request, ctx)
 
         result = await pipeline.infer(
@@ -63,7 +65,7 @@ def create_pipeline_app(pipeline: Any, app_config: AppConfig) -> "FastAPI":
         ocr_results: List[Dict[str, Any]] = []
         for i, (img, item) in enumerate(zip(images, result)):
             pruned_res = common.prune_result(item.json["res"])
-            if ctx.config.visualize:
+            if visualize_enabled:
                 output_imgs = item.img
                 imgs = {
                     "input_img": img,

paddlex/inference/serving/basic_serving/_pipeline_apps/open_vocabulary_detection.py

@@ -43,7 +43,9 @@ def create_pipeline_app(pipeline: Any, app_config: AppConfig) -> "FastAPI":
     async def _infer(request: InferRequest) -> AIStudioResultResponse[InferResult]:
         pipeline = ctx.pipeline
         aiohttp_session = ctx.aiohttp_session
-
+        visualize_enabled = (
+            request.visualize if request.visualize is not None else ctx.config.visualize
+        )
         file_bytes = await serving_utils.get_raw_bytes_async(
             request.image, aiohttp_session
         )
@@ -66,7 +68,7 @@ def create_pipeline_app(pipeline: Any, app_config: AppConfig) -> "FastAPI":
                     score=obj["score"],
                 )
             )
-        if ctx.config.visualize:
+        if visualize_enabled:
             output_image_base64 = serving_utils.base64_encode(
                 serving_utils.image_to_bytes(result.img["res"])
             )

paddlex/inference/serving/basic_serving/_pipeline_apps/open_vocabulary_segmentation.py

@@ -55,7 +55,9 @@ def create_pipeline_app(pipeline: Any, app_config: AppConfig) -> "FastAPI":
     async def _infer(request: InferRequest) -> AIStudioResultResponse[InferResult]:
         pipeline = ctx.pipeline
         aiohttp_session = ctx.aiohttp_session
-
+        visualize_enabled = (
+            request.visualize if request.visualize is not None else ctx.config.visualize
+        )
         file_bytes = await serving_utils.get_raw_bytes_async(
             request.image, aiohttp_session
         )
@@ -74,7 +76,7 @@ def create_pipeline_app(pipeline: Any, app_config: AppConfig) -> "FastAPI":
         ]
         mask_infos = result["mask_infos"]
 
-        if ctx.config.visualize:
+        if visualize_enabled:
             output_image_base64 = serving_utils.base64_encode(
                 serving_utils.image_to_bytes(result.img["res"])
             )

paddlex/inference/serving/basic_serving/_pipeline_apps/pedestrian_attribute_recognition.py

@@ -43,7 +43,9 @@ def create_pipeline_app(pipeline: Any, app_config: AppConfig) -> "FastAPI":
     async def _infer(request: InferRequest) -> AIStudioResultResponse[InferResult]:
         pipeline = ctx.pipeline
         aiohttp_session = ctx.aiohttp_session
-
+        visualize_enabled = (
+            request.visualize if request.visualize is not None else ctx.config.visualize
+        )
         file_bytes = await serving_utils.get_raw_bytes_async(
             request.image, aiohttp_session
         )
@@ -69,7 +71,7 @@ def create_pipeline_app(pipeline: Any, app_config: AppConfig) -> "FastAPI":
                     score=obj["det_score"],
                 )
             )
-        if ctx.config.visualize:
+        if visualize_enabled:
             output_image_base64 = serving_utils.base64_encode(
                 serving_utils.image_to_bytes(result.img["res"])
             )

paddlex/inference/serving/basic_serving/_pipeline_apps/pp_chatocrv3_doc.py

@@ -46,7 +46,9 @@ def create_pipeline_app(pipeline: Any, app_config: AppConfig) -> "FastAPI":
         pipeline = ctx.pipeline
 
         log_id = serving_utils.generate_log_id()
-
+        visualize_enabled = (
+            request.visualize if request.visualize is not None else ctx.config.visualize
+        )
         images, data_info = await ocr_common.get_images(request, ctx)
 
         result = await pipeline.call(
@@ -78,7 +80,7 @@ def create_pipeline_app(pipeline: Any, app_config: AppConfig) -> "FastAPI":
         visual_info: List[dict] = []
         for i, (img, item) in enumerate(zip(images, result)):
             pruned_res = common.prune_result(item["layout_parsing_result"].json["res"])
-            if ctx.config.visualize:
+            if visualize_enabled:
                 imgs = {
                     "input_img": img,
                     **item["layout_parsing_result"].img,
@@ -126,19 +128,13 @@ def create_pipeline_app(pipeline: Any, app_config: AppConfig) -> "FastAPI":
     ) -> AIStudioResultResponse[schema.BuildVectorStoreResult]:
         pipeline = ctx.pipeline
 
-        kwargs: Dict[str, Any] = {
-            "flag_save_bytes_vector": True,
-            "retriever_config": request.retrieverConfig,
-        }
-        if request.minCharacters is not None:
-            kwargs["min_characters"] = request.minCharacters
-        if request.blockSize is not None:
-            kwargs["block_size"] = request.blockSize
-
         vector_info = await serving_utils.call_async(
             pipeline.pipeline.build_vector,
             request.visualInfo,
-            **kwargs,
+            min_characters=request.minCharacters,
+            block_size=request.blockSize,
+            flag_save_bytes_vector=True,
+            retriever_config=request.retrieverConfig,
         )
 
         return AIStudioResultResponse[schema.BuildVectorStoreResult](
@@ -156,8 +152,13 @@ def create_pipeline_app(pipeline: Any, app_config: AppConfig) -> "FastAPI":
     ) -> AIStudioResultResponse[schema.ChatResult]:
         pipeline = ctx.pipeline
 
-        kwargs: Dict[str, Any] = dict(
+        result = await serving_utils.call_async(
+            pipeline.pipeline.chat,
+            request.keyList,
+            request.visualInfo,
+            use_vector_retrieval=request.useVectorRetrieval,
             vector_info=request.vectorInfo,
+            min_characters=request.minCharacters,
             text_task_description=request.textTaskDescription,
             text_output_format=request.textOutputFormat,
             text_rules_str=request.textRulesStr,
@@ -171,17 +172,6 @@ def create_pipeline_app(pipeline: Any, app_config: AppConfig) -> "FastAPI":
             chat_bot_config=request.chatBotConfig,
             retriever_config=request.retrieverConfig,
         )
-        if request.useVectorRetrieval is not None:
-            kwargs["use_vector_retrieval"] = request.useVectorRetrieval
-        if request.minCharacters is not None:
-            kwargs["min_characters"] = request.minCharacters
-
-        result = await serving_utils.call_async(
-            pipeline.pipeline.chat,
-            request.keyList,
-            request.visualInfo,
-            **kwargs,
-        )
 
         return AIStudioResultResponse[schema.ChatResult](
             logId=serving_utils.generate_log_id(),