add files

.gitignore

@@ -0,0 +1 @@
+.idea

Dockerfile

@@ -0,0 +1,68 @@
+FROM python:3.10-slim
+
+# 1) Install dependencies for Dev Mode + Playwright
+RUN apt-get update && \
+    apt-get install -y \
+      bash \
+      curl \
+      wget \
+      procps \
+      git \
+      git-lfs \
+      libnss3 \
+      libatk1.0-0 \
+      libatk-bridge2.0-0 \
+      libx11-6 \
+      libx11-xcb1 \
+      libxcomposite1 \
+      libxcursor1 \
+      libxdamage1 \
+      libxext6 \
+      libxfixes3 \
+      libxi6 \
+      libxrandr2 \
+      libxrender1 \
+      libxss1 \
+      libxtst6 \
+      libappindicator1 \
+      libsecret-1-0 \
+      fonts-ipafont-gothic && \
+    rm -rf /var/lib/apt/lists/*
+
+# 2) Copy code into /app
+WORKDIR /app
+COPY . /app
+ENV HOME=/app
+
+# 3) Install Python dependencies
+RUN pip install --upgrade pip
+RUN pip install gradio==5.27.1
+RUN pip install -U crawl4ai==0.6.3
+
+# 4) Install Playwright browser(s)
+RUN pip install playwright==1.53.0
+RUN python -m playwright install --with-deps chromium
+
+RUN pip install appbuilder_sdk==1.0.6 \
+    docx==0.2.4 \
+    faiss-cpu==1.9.0 \
+    jieba==0.42.1 \
+    mcp==1.9.4 \
+    numpy==2.2.6 \
+    openai==1.88.0 \
+    pdfplumber==0.11.7 \
+    python_docx==1.1.2 \
+    Requests==2.32.4 \
+    sse-starlette==2.3.6
+
+# 5) Make /app owned by user 1000 (Dev Mode requirement)
+RUN chown -R 1000 /app
+
+# 6) Switch to user 1000
+USER 1000
+
+# 7) Expose port for Gradio
+EXPOSE 7860
+
+# 8) Start your Gradio app
+CMD ["python", "app.py"]

app.py

@@ -0,0 +1,882 @@
+# Copyright (c) 2025 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.
+
+"""This script provides a simple web interface that allows users to interact with."""
+
+import argparse
+import asyncio
+from collections import namedtuple
+from datetime import datetime
+from functools import partial
+import json
+import logging
+import os
+import base64
+from argparse import ArgumentParser
+import textwrap
+from docx import Document
+
+import gradio as gr
+import pdfplumber
+
+from bot_requests import BotClient
+from crawl_utils import CrawlUtils
+
+os.environ["NO_PROXY"] = "localhost,127.0.0.1"  # Disable proxy
+
+logging.root.setLevel(logging.INFO)
+
+IMAGE_FILE_TYPE = [".png", ".jpeg", ".jpg"]
+TEXT_FILE_TYPE = [".pdf", ".txt", ".md", ".docx"]
+
+SEARCH_INFO_PROMPT = textwrap.dedent(
+    """\
+    ## 当前时间
+    {date}
+
+    ## 对话
+    {context}
+    问题：{query}
+
+    根据当前时间和对话完成以下任务：
+    1. 查询判断：是否需要借助搜索引擎查询外部知识回答用户当前问题。
+    2. 问题改写：改写用户当前问题，使其更适合在搜索引擎查询到相关知识。
+    注意：只在**确有必要**的情况下改写，输出不超过 5 个改写结果，不要为了凑满数量而输出冗余问题。
+
+    ## 输出如下格式的内容（只输出 JSON ，不要给出多余内容）：
+    ```json
+    {{
+        "is_search":true/false,
+        "query_list":["改写问题1"，"改写问题2"...]
+    }}```
+    """
+)
+ANSWER_PROMPT = textwrap.dedent(
+    """\
+    下面你会收到多段参考资料和一个问题。你的任务是阅读参考资料，并根据参考资料中的信息回答对话中的问题。
+    以下是当前时间和参考资料：
+    ---------
+    ## 当前时间
+    {date}
+
+    ## 参考资料
+    {reference}
+
+    请严格遵守以下规则：
+    1. 回答必须结合问题需求和当前时间，对参考资料的可用性进行判断，避免在回答中使用错误或过时的信息。
+    2. 当参考资料中的信息无法准确地回答问题时，你需要在回答中提供获取相应信息的建议，或承认无法提供相应信息。
+    3. 你需要优先根据百度高权威信息、百科、官网、权威机构、专业网站等高权威性来源的信息来回答问题，
+       但务必不要用“（来源：xx）”这类格式给出来源，
+       不要暴露来源网站中的“_百度高权威信息”，
+       也不要出现'根据参考资料'，'根据当前时间'等表述。
+    4. 更多地使用参考文章中的相关数字、案例、法律条文、公式等信息，让你的答案更专业。
+    5. 只要使用了参考资料中的任何内容，必须在句末或段末加上资料编号，如 "[1]" 或 "[2][4]"。不要遗漏编号，也不要随意编造编号。编号必须来源于参考资料中已有的标注。
+    ---------
+    下面请结合以上信息，回答问题，补全对话:
+    ## 对话
+    {context}
+    问题：{query}
+
+    直接输出回复内容即可。
+    """
+)
+
+
+def get_args() -> argparse.Namespace:
+    """
+    Parse and return command line arguments for the ERNIE chatbot demo.
+    Configures server settings, model endpoints, and operational parameters.
+
+    Returns:
+        argparse.Namespace: Parsed command line arguments containing all the above settings.
+    """
+    parser = ArgumentParser(description="ERNIE models web chat demo.")
+
+    parser.add_argument(
+        "--server-port", type=int, default=7860, help="Demo server port."
+    )
+    parser.add_argument(
+        "--server-name", type=str, default="0.0.0.0", help="Demo server name."
+    )
+    parser.add_argument(
+        "--max_char", type=int, default=20000, help="Maximum character limit for messages."
+    )
+    parser.add_argument(
+        "--max_retry_num", type=int, default=3, help="Maximum retry number for request."
+    )
+    parser.add_argument(
+        "--model_map", 
+        type=str, 
+        default="{\"ernie-4.5-turbo-vl-32k\": \"https://qianfan.baidubce.com/v2\"}",
+        help="""JSON string defining model name to endpoint mappings.
+            Required Format:
+            {"ERNIE-4.5-VL": "http://localhost:port/v1"}
+
+            Note:
+            - Endpoint must be valid HTTP URL
+            - Specify ONE model endpoint in JSON format.
+            - Prefix determines model capabilities:
+            * ERNIE-4.5-VL: Multimodal models (image+text)
+            """
+    )
+    parser.add_argument(
+        "--web_search_service_url",
+        type=str, 
+        default="https://qianfan.baidubce.com/v2/ai_search/chat/completions",
+        help="Web Search Service URL."
+    )
+    parser.add_argument(
+        "--qianfan_api_key", 
+        type=str, 
+        default=os.environ.get('API_SEARCH_KEY'),
+        help="Web Search Service API key.",
+    )
+
+    args = parser.parse_args()
+    try:
+        args.model_map = json.loads(args.model_map)
+
+        # Validation: Check at least one model exists
+        if len(args.model_map) < 1:
+            raise ValueError("model_map must contain at least one model configuration")
+    except json.JSONDecodeError as e:
+        raise ValueError("Invalid JSON format for --model-map") from e
+    return args
+
+
+class GradioEvents(object):
+    """
+    Handles Gradio UI events and manages chatbot interactions including conversation flow and file processing. 
+    
+    Provides methods for maintaining chat history, extracting text from files, and generating image URLs. 
+    Supports both text and multimodal interactions with web search integration when needed. 
+    
+    Manages chatbot state including conversation history, file attachments and UI updates. 
+    Includes utilities for reading various file formats and handling streaming AI responses.
+    """
+    @staticmethod
+    def get_history_conversation(task_history: list, image_history: dict, file_history: dict) -> tuple:
+        """
+        Constructs complete conversation history from stored components including text messages,
+        attached files and images. Processes each dialogue turn by combining the raw query/response
+        pairs with any associated multimedia attachments. For multimodal models, image URLs are
+        formatted with base64 encoding while text files have their content extracted inline.
+
+        Args:
+            task_history (list): List of tuples containing user queries and responses.
+            image_history (dict): Dictionary mapping indices to lists of image urls.
+            file_history (dict): Dictionary mapping indices to lists of file urls.
+
+        Returns:
+            tuple: Tuple containing two elements:
+                - conversation (list): List of dictionaries representing the conversation history.
+                - conversation_str (str): String representation of the conversation history.
+        """
+        conversation = []
+        conversation_str = ""
+        for idx, (query_h, response_h) in enumerate(task_history):
+            conversation_str += "user:\n{query}\nassistant:\n{response}\n".format(query=query_h, response=response_h)
+            if idx in file_history:
+                for file_url in file_history[idx]:
+                    query_h += "参考资料[{idx}]:\n资料来源：用户上传\n{file_text}\n".format(
+                        idx=idx + 1, 
+                        file_text=GradioEvents.get_file_text(file_url)
+                    )
+            if idx in image_history:
+                content = []
+                for image_url in image_history[idx]:
+                    content.append({
+                        "type": "image_url", 
+                        "image_url": {"url": GradioEvents.get_image_url(image_url)}
+                    })
+                content.append({"type": "text", "text": query_h})
+                conversation.append({"role": "user", "content": content})
+            else:
+                conversation.append({"role": "user", "content": query_h})
+            conversation.append({"role": "assistant", "content": response_h})
+        return conversation, conversation_str
+
+    @staticmethod
+    def get_search_query(conversation: list, model_name: str, bot_client: BotClient) -> list:
+        """
+        Processes conversation history to generate search queries by sending the conversation context
+        to the model and parsing its JSON response. Handles model output validation and extracts
+        structured search queries containing query lists. Raises Gradio errors for
+        invalid JSON responses from the model.
+
+        Args:
+            conversation (list): List of dictionaries representing the conversation history.
+            model_name (str): Name of the model being used.
+            bot_client (BotClient): An instance of BotClient.
+
+        Returns:
+            list: List of strings representing the search query.
+        """
+        req_data = {"messages": conversation}
+        try:
+            response = bot_client.process(model_name, req_data)
+            search_query = response["choices"][0]["message"]["content"]
+            start = search_query.find("{")
+            end = search_query.rfind("}") + 1
+            if start >= 0 and end > start:
+                search_query = search_query[start:end]
+            search_query = json.loads(search_query)
+            return search_query
+        except json.JSONDecodeError:
+            logging.error("error: model output is not valid JSON format ")
+            return None
+
+    @staticmethod
+    def process_files(
+        diologue_turn: int, 
+        files_url: list, 
+        file_history: dict, 
+        image_history: dict, 
+        bot_client: BotClient, 
+        max_file_char: int
+    ):
+        """
+        Processes file URLs and generates input content for the model.
+        Handles both text and image files by:
+        1. For text files (PDF, TXT, MD, DOCX): extracts content and adds to file history with reference numbering
+        2. For image files (PNG, JPEG, JPG): generates base64 encoded URLs for model input
+        Maintains character limits for text references and ensures no duplicate file processing.
+
+        Args:
+            diologue_turn (int): Index of the current dialogue turn.
+            files_url (list): List of uploaded file urls.
+            file_history (dict): Dictionary mapping indices to lists of file urls.
+            image_history (dict): Dictionary mapping indices to lists of image urls.
+            bot_client (BotClient): An instance of BotClient.
+            max_file_char (int): Maximum number of characters allowed for references.
+
+        Returns:
+            tuple: A tuple containing three elements:
+                - input_content (list): List of dictionaries representing the input content.
+                - file_contents (str): String representation of the file contents.
+                - ref_file_num (int): Number of reference files added.
+        """
+        input_content = []
+        file_contents = ""
+        ref_file_num = 0
+        if not files_url:
+            return input_content, file_contents, ref_file_num
+
+        for file_url in files_url:
+            extionsion = "." + file_url.split(".")[-1]
+            if extionsion in TEXT_FILE_TYPE and (len(file_history) == 0 
+                or file_url not in list(file_history.values())[-1]):
+                file_history[diologue_turn] = file_history.get(diologue_turn, []) + [file_url]
+                file_name = file_url.split("/")[-1]
+                file_contents_words = bot_client.cut_chinese_english(file_contents)
+                
+                if len(file_contents_words) < max_file_char - 20:
+                    ref_file_num += 1
+                    file_content = "\n参考资料[{idx}]:\n资料来源：用户上传\n{file_name}\n{file_text}\n".format(
+                                idx=len(file_history[diologue_turn]), 
+                                file_name=file_name, 
+                                file_text=GradioEvents.get_file_text(file_url)
+                            )
+                    file_content_words = bot_client.cut_chinese_english(file_content)
+                    max_char = min(len(file_content_words), max_file_char - len(file_contents_words))
+                    file_content_words = file_content_words[: max_char]
+                    file_contents += "".join(file_content_words) + "\n"
+            elif extionsion in IMAGE_FILE_TYPE and (len(image_history) == 0 
+                or file_url not in list(image_history.values())[-1]):
+                image_history[diologue_turn] = image_history.get(diologue_turn, []) + [file_url]
+                input_content.append({"type": "image_url", "image_url": {"url": GradioEvents.get_image_url(file_url)}})
+        return input_content, file_contents, ref_file_num
+
+    @staticmethod
+    async def chat_stream(
+        query: str, 
+        task_history: list, 
+        image_history: dict, 
+        file_history: dict, 
+        model_name: str, 
+        files_url: list, 
+        search_state: bool,
+        bot_client: BotClient,
+        max_ref_char: int=18000
+    ) -> dict:
+        """
+        Handles streaming chat queries with text and multimodal inputs. 
+        Builds conversation history with attachments, checks if web search 
+        is needed, and streams responses.
+
+        Args:
+            query (str): User input query string.
+            task_history (list): List of tuples containing user queries and responses.
+            image_history (dict): Dictionary mapping indices to lists of image urls.
+            file_history (dict): Dictionary mapping indices to lists of file urls.
+            model_name (str): Name of the model being used.
+            files_url (list): List of uploaded file urls.
+            search_state (bool): Whether to perform a search.
+            bot_client (BotClient): An instance of BotClient.
+            max_ref_char (int): Maximum number of characters allowed for references.
+
+        Returns:
+            dict: Dictionary containing the following keys:
+                - "type": The message type.
+                - "content": The content of the message.
+        """
+        conversation, conversation_str = GradioEvents.get_history_conversation(
+            task_history, 
+            image_history, 
+            file_history
+        )
+
+        # Step 1: Determine whether a search is needed and obtain the corresponding query list
+        search_info_res = {}
+        if search_state:
+            search_info_message = SEARCH_INFO_PROMPT.format(
+                date=datetime.now().strftime("%Y-%m-%d %H:%M:%S"), 
+                context=conversation_str, 
+                query=query
+            )
+            search_conversation = [{"role": "user", "content": search_info_message}]
+            search_info_res = GradioEvents.get_search_query(search_conversation, model_name, bot_client)
+            if search_info_res is None:
+                search_info_res = {"is_search": True, "query_list": [query]}
+
+        # Process files
+        diologue_turn = len(task_history)
+        if search_info_res.get("is_search", False) and search_info_res.get("query_list", []):
+            max_file_char = max_ref_char // 2
+        else:
+            max_file_char = max_ref_char
+        input_content, file_contents, ref_file_num = GradioEvents.process_files(
+            diologue_turn, files_url, file_history, image_history, bot_client, max_file_char
+        )
+        
+        # Step 2: If a search is needed, obtain the corresponding query results
+        if search_info_res.get("is_search", False) and search_info_res.get("query_list", []):
+            search_result = bot_client.get_web_search_res(search_info_res["query_list"])
+            
+            max_search_result_char = max_ref_char - len(bot_client.cut_chinese_english(file_contents))
+            complete_search_result = await GradioEvents.get_complete_search_content(
+                ref_file_num, search_result, bot_client, max_search_result_char
+            )
+            complete_ref = file_contents + "\n" + complete_search_result
+            
+            query = ANSWER_PROMPT.format(
+                date=datetime.now().strftime("%Y-%m-%d %H:%M:%S"), 
+                reference=complete_ref,
+                context=conversation_str, 
+                query=query
+            )
+            yield {"type": "search_result", "content": complete_ref}
+        else:
+            query += "\n" + file_contents
+
+        # Step 3: Answer the user's query
+        if image_history.get(diologue_turn, []):
+            input_content.append({"type": "text", "text": query})
+            conversation.append({"role": "user", "content": input_content})
+        else:
+            conversation.append({"role": "user", "content": query})
+
+        try:
+            req_data = {"messages": conversation}
+            for chunk in bot_client.process_stream(model_name, req_data):
+                if "error" in chunk:
+                    raise Exception(chunk["error"])
+                
+                message = chunk.get("choices", [{}])[0].get("delta", {})
+                content = message.get("content", "")
+
+                if content:
+                    yield {"type": "answer", "content": content}
+                    
+        except Exception as e:
+            raise gr.Error("Exception: " + repr(e))
+
+    @staticmethod
+    async def predict(
+        query: str, 
+        chatbot: list, 
+        task_history: list, 
+        image_history: dict, 
+        file_history: dict, 
+        model: str, 
+        file_url: list, 
+        search_state: bool,
+        bot_client: BotClient
+    ) -> tuple:
+        """
+        Processes user queries and generates responses through streaming interaction.
+        Handles both text and file inputs, manages conversation history updates,
+        and optionally performs web searches when enabled. Yields intermediate
+        answers as they become available.
+
+        Args:
+            query (str): User input query string.
+            chatbot (list): List of dictionaries representing the chatbot history.
+            task_history (list): List of tuples containing user queries and responses.
+            image_history (dict): Dictionary mapping indices to lists of image urls.
+            file_history (dict): Dictionary mapping indices to lists of file urls.
+            model (str): Name of the model being used.
+            file_url (list): List of uploaded file urls.
+            search_state (bool): Whether to perform a search.
+            bot_client (BotClient): An instance of BotClient.
+
+        Returns:
+            tuple: Tuple containing two elements:
+                - chatbot (list): Updated chatbot history after adding the user's query.
+                - search_result (str): Search result obtained from the AI search service.
+        """
+
+        logging.info("User: {}".format(query))
+        # First yield the chatbot with user message
+        chatbot.append({"role": "user", "content": query})  
+        yield chatbot, None
+
+        response = ""
+        search_result = None
+        async for new_text in GradioEvents.chat_stream(
+            query, 
+            task_history, 
+            image_history, 
+            file_history, 
+            model, 
+            file_url, 
+            search_state,
+            bot_client
+        ):
+            if not isinstance(new_text, dict):
+                continue
+                
+            if new_text.get("type") == "search_result":
+                search_result = new_text["content"]
+                yield chatbot, search_result
+                continue
+            elif new_text.get("type") == "answer":
+                response += new_text["content"]
+            
+            # Remove previous message if exists
+            if chatbot[-1].get("role") == "assistant":
+                chatbot.pop(-1)
+
+            if response:
+                chatbot.append({"role": "assistant", "content": response})
+                yield chatbot, search_result
+                await asyncio.sleep(0)  # Wait to refresh
+
+        logging.info("History: {}".format(task_history))
+        task_history.append((query, response))    
+        logging.info("ERNIE models: {}".format(response))
+
+    @staticmethod
+    async def regenerate(
+        chatbot: list, 
+        task_history: list, 
+        image_history: dict, 
+        file_history: dict,
+        model: str, 
+        file_url: list, 
+        search_state: bool,
+        bot_client: BotClient
+    ) -> tuple:
+        """
+        Regenerates the chatbot's last response by reprocessing the previous user query with current context.
+        Maintains conversation continuity by preserving history while removing the last interaction,
+        then reinvokes the prediction pipeline with identical parameters to generate a fresh response.
+
+        Args:
+            chatbot (list): List of dictionaries representing the chatbot history.
+            task_history (list): List of tuples containing user queries and responses.
+            image_history (dict): Dictionary mapping indices to lists of image urls.
+            file_history (dict): Dictionary mapping indices to lists of file urls.
+            model (str): Name of the model being used.
+            file_url (list): List of uploaded file urls.
+            search_state (bool): Whether to perform a search.
+            bot_client (Botclient): An instance of BotClient.
+
+        Returns:
+            tuple: Tuple containing two elements:
+                - chatbot (list): Updated chatbot history after removing the last user query and response.
+                - search_result (str): Search result obtained from the AI search service.
+        """
+        if not task_history:
+            yield chatbot, None
+            return
+        # Pop the last user query and bot response from task_history
+        item = task_history.pop(-1)
+        dialogue_turn = len(task_history)
+        if (dialogue_turn) in image_history:
+            del image_history[dialogue_turn]
+        if (dialogue_turn) in file_history:
+            del file_history[dialogue_turn]
+        while len(chatbot) != 0 and chatbot[-1].get("role") == "assistant":
+            chatbot.pop(-1)
+        chatbot.pop(-1)
+
+        async for chunk, search_result in GradioEvents.predict(
+            item[0], 
+            chatbot, 
+            task_history, 
+            image_history,
+            file_history,
+            model, 
+            file_url,
+            search_state,
+            bot_client
+        ):
+            yield chunk, search_result
+
+    @staticmethod
+    def reset_user_input() -> gr.update:
+        """
+        Reset user input box content.
+
+        Returns:
+            gr.update: Update object indicating that the value should be set to an empty string
+        """
+        return gr.update(value="")
+
+    @staticmethod
+    def reset_state() -> namedtuple:
+        """
+        Reset the state of the chatbot.
+
+        Returns:
+            namedtuple: A namedtuple containing the following fields:
+                - chatbot (list): Empty list
+                - task_history (list): Empty list
+                - image_history (dict): Empty dictionary
+                - file_history (dict): Empty dictionary
+                - file_btn (gr.update): Value set to None
+                - search_result (gr.update): Value set to None
+        """
+        GradioEvents.gc()
+
+        reset_result = namedtuple("reset_result", 
+                    ["chatbot", 
+                    "task_history", 
+                    "image_history",
+                    "file_history", 
+                    "file_btn", 
+                    "search_result"])
+        return reset_result(
+            [],  # clear chatbot
+            [],  # clear task_history
+            {},  # clear image_history
+            {},  # clear file_history
+            gr.update(value=None),  # clear file_btn
+            gr.update(value=None)  # reset search_result
+        )
+    
+    @staticmethod
+    def gc():
+        """Run garbage collection."""
+        import gc
+
+        gc.collect()
+
+    @staticmethod
+    def search_toggle_state(search_state: bool) -> bool:
+        """
+        Toggle search state between enabled and disabled.
+
+        Args:
+            search_state (bool): Current search state
+
+        Returns:
+            bool: New search result visible state   
+        """
+        return gr.update(visible=search_state)
+
+    @staticmethod
+    def get_image_url(image_path: str) -> str:
+        """
+        Encode image file to Base64 format and generate data URL.
+        Reads an image file from disk, encodes it as Base64, and formats it
+        as a data URL that can be used directly in HTML or API requests.
+
+        Args:
+            image_path (str): The path to the image file.
+
+        Returns:
+            str: The URL of the image file.
+        """
+        base64_image = ""
+        extension = image_path.split(".")[-1]
+        with open(image_path, "rb") as image_file:
+            base64_image = base64.b64encode(image_file.read()).decode("utf-8")
+        url = "data:image/{ext};base64,{img}".format(ext=extension, img=base64_image)
+        return url
+    
+    @staticmethod
+    def get_file_text(file_path: str) -> str:
+        """
+        Get the contents of a file as plain text.
+
+        Args:
+            file_path (str): The path to the file to read.
+
+        Returns:
+            str: The contents of the file as plain text.
+        """
+        if file_path is None:
+            return ""
+        if file_path.endswith(".pdf"):
+            return GradioEvents.read_pdf(file_path)
+        elif file_path.endswith(".docx"):
+            return GradioEvents.read_docx(file_path)
+        elif file_path.endswith(".txt") or file_path.endswith(".md"):
+            return GradioEvents.read_txt_md(file_path)
+        else:
+            return ""
+
+    @staticmethod
+    def read_pdf(pdf_path: str) -> str:
+        """
+        Extracts text content from a PDF file using pdfplumber library. Processes each page sequentially
+        and concatenates all extracted text. Handles potential extraction errors gracefully by returning
+        an empty string and logging the error.
+
+        Args:
+            pdf_path (str): Path to the PDF file.
+
+        Returns:
+            str: Text extracted from the PDF file.
+        """
+        try:
+            text = ""
+            with pdfplumber.open(pdf_path) as pdf:
+                for page in pdf.pages:
+                    text += page.extract_text()
+            return text
+        except Exception as e:
+            logging.info("Error reading PDF file: {}".format(e))
+            return ""
+
+    @staticmethod
+    def read_docx(file_path: str) -> str:
+        """
+        Extracts text content from a DOCX file using python-docx library. Processes all paragraphs
+        sequentially and joins them with newline characters. Handles potential file reading errors
+        gracefully by returning an empty string and logging the error.
+
+        Args:
+            file_path (str): Path to the DOCX file.
+
+        Returns:
+            str: Text extracted from the DOCX file.
+        """
+        try:
+            doc = Document(file_path)
+            full_text = []
+            for paragraph in doc.paragraphs:
+                full_text.append(paragraph.text)
+            return "\n".join(full_text)
+        except Exception as e:
+            logging.info("Error reading DOCX file: {}".format(e))
+            return ""
+
+    @staticmethod
+    def read_txt_md(file_path: str) -> str:
+        """
+        Read a TXT or MD file and extract its text content.
+
+        Args:
+            file_path (str): Path to the TXT or MD file.
+
+        Returns:
+            str: Text extracted from the TXT or MD file.
+        """
+        try:
+            with open(file_path, "r", encoding="utf-8") as f:
+                return f.read()
+        except Exception as e:
+            logging.info("Error reading TXT or MD file: {}".format(e))
+            return ""
+
+    @staticmethod
+    async def get_complete_search_content(
+        ref_file_num: int,
+        search_results: list, 
+        bot_client: BotClient, 
+        max_search_results_char
+    ) -> str:
+        """
+        Combines and formats multiple search results into a single string.
+        Processes each result, extracts URLs, crawls content, and enforces length limits.
+
+        Args:
+            ref_file_num (int): Reference file number
+            search_results (list): List of search results
+            bot_client (BotClient): Chatbot client instance
+            max_search_results_char (int): Maximum character length of each search result
+
+        Returns:
+            str: Complete search content string
+        """
+        results = [] 
+        crawl_utils = CrawlUtils()
+        for search_res in search_results:
+            for item in search_res:
+                new_content = await crawl_utils.get_webpage_text(item["url"])
+                if not new_content:
+                    continue
+                item_text = "Title: {title} \nURL: {url} \nContent:\n{content}\n".format(
+                    title=item["title"], url=item["url"], content=new_content
+                )
+
+                # Truncate the search result to max_search_results_char characters
+                search_res_words = bot_client.cut_chinese_english(item_text)
+                res_words = bot_client.cut_chinese_english("".join(results))
+                if len(search_res_words) + len(res_words) > max_search_results_char:
+                    break
+
+                results.append("参考资料[{idx}]:\n资料来源：素材检索\n{item_text}\n".format(
+                    idx=len(results) + 1 + ref_file_num, item_text=item_text
+                    ))
+
+        return "".join(results)
+
+
+def launch_demo(args: argparse.Namespace, bot_client: BotClient):
+    """
+    Launch demo program
+    
+    Args:
+        args (argparse.Namespace): argparse Namespace object containing parsed command line arguments
+        bot_client (BotClient): Bot client instance
+    """
+    css = """
+    .input-textbox textarea {
+        height: 200px !important;
+    }
+    #file-upload {
+        height: 247px !important;
+        min-height: 247px !important;
+        max-height: 247px !important;
+    }
+    /* Hide original Chinese text */
+    #file-upload .wrap {
+        font-size: 0 !important;
+        position: relative;
+        display: flex;
+        flex-direction: column;
+        align-items: center;
+        justify-content: center;
+    }
+
+    /* Insert English prompt text below the SVG icon */
+    #file-upload .wrap::after {
+        content: "Drag and drop files here or click to upload";
+        font-size: 18px;
+        color: #555;
+        margin-top: 8px;
+        white-space: nowrap;
+    }
+    """
+
+    with gr.Blocks(css=css) as demo:
+        logo_url = GradioEvents.get_image_url("assets/logo.png")
+        gr.Markdown("""\
+                <p align="center"><img src="{}" \
+                style="height: 60px"/><p>""".format(logo_url))
+        gr.Markdown(
+            """\
+<center><font size=3>This demo is based on ERNIE models. \
+(本演示基于文心大模型实现。)</center>"""
+        )
+
+        chatbot = gr.Chatbot(
+            label="ERNIE", 
+            elem_classes="control-height", 
+            type="messages"
+        )
+
+        search_result = gr.Textbox(label="Search Result", lines=10, max_lines=10, visible=False)
+
+        with gr.Row():
+            search_check = gr.Checkbox(label="🌐 Search the web(联网搜索)")
+
+        with gr.Row():
+            query = gr.Textbox(label="Input", lines=1, scale=6, elem_classes="input-textbox")
+            file_btn = gr.File(
+                label="File upload (Accepted formats: PNG, JPEG, JPG, PDF, TXT, MD, DOC, DOCX)", 
+                scale=4,
+                elem_id="file-upload",
+                file_types=IMAGE_FILE_TYPE + TEXT_FILE_TYPE,
+                file_count="multiple"
+            )
+
+        with gr.Row():
+            empty_btn = gr.Button("🧹 Clear History(清除历史)")
+            submit_btn = gr.Button("🚀 Submit(发送)")
+            regen_btn = gr.Button("🤔️ Regenerate(重试)")
+        
+        task_history = gr.State([])
+        image_history = gr.State({})
+        file_history = gr.State({})
+        model_name = gr.State(list(args.model_map.keys())[0])
+
+        search_check.change(
+            fn=GradioEvents.search_toggle_state,
+            inputs=search_check,
+            outputs=search_result
+        )
+        
+        predict_with_clients = partial(
+            GradioEvents.predict,
+            bot_client=bot_client
+        )
+        regenerate_with_clients = partial(
+            GradioEvents.regenerate,
+            bot_client=bot_client
+        )
+        query.submit(
+            predict_with_clients, 
+            inputs=[query, chatbot, task_history, image_history, file_history, model_name, file_btn, search_check], 
+            outputs=[chatbot, search_result], 
+            show_progress=True
+        )
+        query.submit(GradioEvents.reset_user_input, [], [query])
+        submit_btn.click(
+            predict_with_clients, 
+            inputs=[query, chatbot, task_history, image_history, file_history, model_name, file_btn, search_check], 
+            outputs=[chatbot, search_result], 
+            show_progress=True,
+        )
+        submit_btn.click(GradioEvents.reset_user_input, [], [query])
+        empty_btn.click(
+            GradioEvents.reset_state, 
+            outputs=[chatbot, task_history, image_history, file_history, file_btn, search_result], 
+            show_progress=True
+        )
+        regen_btn.click(
+            regenerate_with_clients, 
+            inputs=[chatbot, task_history, image_history, file_history, model_name, file_btn, search_check], 
+            outputs=[chatbot, search_result], 
+            show_progress=True
+        )
+
+    demo.queue().launch(
+        server_port=args.server_port,
+        server_name=args.server_name
+    )
+
+
+def main():
+    """Main function that runs when this script is executed."""
+    args = get_args()
+    bot_client = BotClient(args)
+    launch_demo(args, bot_client)
+
+if __name__ == "__main__":
+    main()

bot_requests.py

@@ -0,0 +1,390 @@
+# Copyright (c) 2025 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.
+
+"""BotClient class for interacting with bot models."""
+
+import os
+import argparse
+import logging
+import traceback
+import json
+import jieba
+from openai import OpenAI
+
+import requests
+
+class BotClient(object):
+    """Client for interacting with various AI models."""
+    def __init__(self, args: argparse.Namespace):
+        """
+        Initializes the BotClient instance by configuring essential parameters from command line arguments 
+        including retry limits, character constraints, model endpoints and API credentials while setting up 
+        default values for missing arguments to ensure robust operation.
+
+        Args:
+            args (argparse.Namespace): Command line arguments containing configuration parameters.
+                                      Uses getattr() to safely retrieve values with fallback defaults.
+        """
+        self.logger = logging.getLogger(__name__)
+        
+        self.max_retry_num = getattr(args, 'max_retry_num', 3)
+        self.max_char = getattr(args, 'max_char', 8000)
+
+        self.model_map = getattr(args, 'model_map', {})
+        self.api_key = os.environ.get('API_KEY')
+
+        self.embedding_service_url = getattr(args, 'embedding_service_url', 'embedding_service_url')
+        self.embedding_model = getattr(args, 'embedding_model', 'embedding_model')
+
+        self.web_search_service_url = getattr(args, 'web_search_service_url', 'web_search_service_url')
+        self.max_search_results_num = getattr(args, 'max_search_results_num', 15)
+
+        self.qianfan_api_key = os.environ.get('API_SEARCH_KEY')
+
+    def call_back(self, host_url: str, req_data: dict) -> dict:
+        """
+        Executes an HTTP request to the specified endpoint using the OpenAI client, handles the response 
+        conversion to a compatible dictionary format, and manages any exceptions that may occur during 
+        the request process while logging errors appropriately.
+
+        Args:
+            host_url (str): The URL to send the request to.
+            req_data (dict): The data to send in the request body.
+
+        Returns:
+            dict: Parsed JSON response from the server. Returns empty dict
+                if request fails or response is invalid.
+        """
+        try:
+            client = OpenAI(base_url=host_url, api_key=self.api_key)
+            response = client.chat.completions.create(
+                **req_data
+            )
+                
+            # Convert OpenAI response to compatible format
+            return response.model_dump()
+
+        except Exception as e:
+            self.logger.error("Stream request failed: {}".format(e))
+            raise
+
+    def call_back_stream(self, host_url: str, req_data: dict) -> dict:
+        """
+        Makes a streaming HTTP request to the specified host URL using the OpenAI client and yields response chunks 
+        in real-time while handling any exceptions that may occur during the streaming process.
+
+        Args:
+            host_url (str): The URL to send the request to.
+            req_data (dict): The data to send in the request body.
+
+        Returns:
+            generator: Generator that yields parsed JSON responses from the server.
+        """
+        try:
+            client = OpenAI(base_url=host_url, api_key=self.api_key)
+            response = client.chat.completions.create(
+                **req_data,
+                stream=True,
+            )
+            for chunk in response:
+                if not chunk.choices:
+                    continue
+                
+                # Convert OpenAI response to compatible format
+                yield chunk.model_dump()
+
+        except Exception as e:
+            self.logger.error("Stream request failed: {}".format(e))
+            raise
+
+    def process(
+        self, 
+        model_name: str, 
+        req_data: dict, 
+        max_tokens: int=2048, 
+        temperature: float=1.0, 
+        top_p: float=0.7
+    ) -> dict:
+        """
+        Handles chat completion requests by mapping the model name to its endpoint, preparing request parameters 
+        including token limits and sampling settings, truncating messages to fit character limits, making API calls 
+        with built-in retry mechanism, and logging the full request/response cycle for debugging purposes.
+
+        Args:
+            model_name (str): Name of the model, used to look up the model URL from model_map.
+            req_data (dict): Dictionary containing request data, including information to be processed.
+            max_tokens (int): Maximum number of tokens to generate.
+            temperature (float): Sampling temperature to control the diversity of generated text.
+            top_p (float): Cumulative probability threshold to control the diversity of generated text.
+
+        Returns:
+            dict: Dictionary containing the model's processing results.
+        """
+        model_url = self.model_map[model_name]
+
+        req_data["model"] = model_name
+        req_data["max_tokens"] = max_tokens
+        req_data["temperature"] = temperature
+        req_data["top_p"] = top_p
+        req_data["messages"] = self.truncate_messages(req_data["messages"])
+        for _ in range(self.max_retry_num):
+            try:
+                self.logger.info("[MODEL] {}".format(model_url))
+                self.logger.info("[req_data]====>")
+                self.logger.info(json.dumps(req_data, ensure_ascii=False))
+                res = self.call_back(model_url, req_data)
+                self.logger.info("model response")
+                self.logger.info(res)
+                self.logger.info("-" * 30)
+            except Exception as e:
+                self.logger.info(e)
+                self.logger.info(traceback.format_exc())
+                res = {}
+            if len(res) != 0 and "error" not in res:
+                break
+        
+        return res
+
+    def process_stream(
+        self, model_name: str, 
+        req_data: dict, 
+        max_tokens: int=2048, 
+        temperature: float=1.0, 
+        top_p: float=0.7
+    ) -> dict:
+        """
+        Processes streaming requests by mapping the model name to its endpoint, configuring request parameters,
+        implementing a retry mechanism with logging, and streaming back response chunks in real-time while
+        handling any errors that may occur during the streaming session.
+
+        Args:
+            model_name (str): Name of the model, used to look up the model URL from model_map.
+            req_data (dict): Dictionary containing request data, including information to be processed.
+            max_tokens (int): Maximum number of tokens to generate.
+            temperature (float): Sampling temperature to control the diversity of generated text.
+            top_p (float): Cumulative probability threshold to control the diversity of generated text.
+
+        Yields:
+            dict: Dictionary containing the model's processing results.
+        """
+        model_url = self.model_map[model_name]
+        req_data["model"] = model_name
+        req_data["max_tokens"] = max_tokens
+        req_data["temperature"] = temperature
+        req_data["top_p"] = top_p
+        req_data["messages"] = self.truncate_messages(req_data["messages"])
+            
+        last_error = None
+        for _ in range(self.max_retry_num):
+            try:
+                self.logger.info("[MODEL] {}".format(model_url))
+                self.logger.info("[req_data]====>")
+                self.logger.info(json.dumps(req_data, ensure_ascii=False))
+                
+                for chunk in self.call_back_stream(model_url, req_data):
+                    yield chunk
+                return
+                
+            except Exception as e:
+                last_error = e
+                self.logger.error("Stream request failed (attempt {}/{}): {}".format(_ + 1, self.max_retry_num, e))
+        
+        self.logger.error("All retry attempts failed for stream request")
+        yield {"error": str(last_error)}
+
+    def cut_chinese_english(self, text: str) -> list:
+        """
+        Segments mixed Chinese and English text into individual components using Jieba for Chinese words 
+        while preserving English words as whole units, with special handling for Unicode character ranges 
+        to distinguish between the two languages.
+
+        Args:
+            text (str): Input string to be segmented.
+
+        Returns:
+            list: A list of segments, where each segment is either a letter or a word.
+        """
+        words = jieba.lcut(text)
+        en_ch_words = []
+
+        for word in words:
+            if word.isalpha() and not any("\u4e00" <= char <= "\u9fff" for char in word):
+                en_ch_words.append(word)
+            else:
+                en_ch_words.extend(list(word))
+        return en_ch_words
+
+    def truncate_messages(self, messages: list[dict]) -> list:
+        """
+        Truncates conversation messages to fit within the maximum character limit (self.max_char)
+        by intelligently removing content while preserving message structure. The truncation follows
+        a prioritized order: historical messages first, then system message, and finally the last message.
+
+        Args:
+            messages (list[dict]): List of messages to be truncated.
+
+        Returns:
+            list[dict]: Modified list of messages after truncation.
+        """
+        if not messages:
+            return messages
+    
+        processed = []
+        total_units = 0
+        
+        for msg in messages:
+            # Handle two different content formats
+            if isinstance(msg["content"], str):
+                text_content = msg["content"]
+            elif isinstance(msg["content"], list):
+                text_content = msg["content"][1]["text"]
+            else:
+                text_content = ""
+            
+            # Calculate unit count after tokenization
+            units = self.cut_chinese_english(text_content)
+            unit_count = len(units)
+            
+            processed.append({
+                "role": msg["role"],
+                "original_content": msg["content"],  # Preserve original content
+                "text_content": text_content,        # Extracted plain text
+                "units": units,
+                "unit_count": unit_count
+            })
+            total_units += unit_count
+        
+        if total_units <= self.max_char:
+            return messages
+        
+        # Number of units to remove
+        to_remove = total_units - self.max_char
+        
+        # 1. Truncate historical messages
+        for i in range(len(processed) - 1, 1):
+            if to_remove <= 0:
+                break
+            
+            # current = processed[i]
+            if processed[i]["unit_count"] <= to_remove:
+                processed[i]["text_content"] = ""
+                to_remove -= processed[i]["unit_count"]
+                if isinstance(processed[i]["original_content"], str):
+                    processed[i]["original_content"] = ""
+                elif isinstance(processed[i]["original_content"], list):
+                    processed[i]["original_content"][1]["text"] = ""
+            else:
+                kept_units = processed[i]["units"][:-to_remove]
+                new_text = "".join(kept_units)
+                processed[i]["text_content"] = new_text
+                if isinstance(processed[i]["original_content"], str):
+                    processed[i]["original_content"] = new_text
+                elif isinstance(processed[i]["original_content"], list):
+                    processed[i]["original_content"][1]["text"] = new_text
+                to_remove = 0
+        
+        # 2. Truncate system message
+        if to_remove > 0:
+            system_msg = processed[0]
+            if system_msg["unit_count"] <= to_remove:
+                processed[0]["text_content"] = ""
+                to_remove -= system_msg["unit_count"]
+                if isinstance(processed[0]["original_content"], str):
+                    processed[0]["original_content"] = ""
+                elif isinstance(processed[0]["original_content"], list):
+                    processed[0]["original_content"][1]["text"] = ""
+            else:
+                kept_units = system_msg["units"][:-to_remove]
+                new_text = "".join(kept_units)
+                processed[0]["text_content"] = new_text
+                if isinstance(processed[0]["original_content"], str):
+                    processed[0]["original_content"] = new_text
+                elif isinstance(processed[0]["original_content"], list):
+                    processed[0]["original_content"][1]["text"] = new_text
+                to_remove = 0
+        
+        # 3. Truncate last message
+        if to_remove > 0 and len(processed) > 1:
+            last_msg = processed[-1]
+            if last_msg["unit_count"] > to_remove:
+                kept_units = last_msg["units"][:-to_remove]
+                new_text = "".join(kept_units)
+                last_msg["text_content"] = new_text
+                if isinstance(last_msg["original_content"], str):
+                    last_msg["original_content"] = new_text
+                elif isinstance(last_msg["original_content"], list):
+                    last_msg["original_content"][1]["text"] = new_text
+            else:
+                last_msg["text_content"] = ""
+                if isinstance(last_msg["original_content"], str):
+                    last_msg["original_content"] = ""
+                elif isinstance(last_msg["original_content"], list):
+                    last_msg["original_content"][1]["text"] = ""
+        
+        result = []
+        for msg in processed:
+            if msg["text_content"]:
+                result.append({
+                    "role": msg["role"],
+                    "content": msg["original_content"]
+                })
+        
+        return result
+
+    def embed_fn(self, text: str) -> list:
+        """
+        Generate an embedding for the given text using the QianFan API.
+
+        Args:
+            text (str): The input text to be embedded.
+
+        Returns:
+            list: A list of floats representing the embedding.
+        """
+        client = OpenAI(base_url=self.embedding_service_url, api_key=self.qianfan_api_key)
+        response = client.embeddings.create(input=[text], model=self.embedding_model)
+        return response.data[0].embedding
+
+    def get_web_search_res(self, query_list: list) -> list:
+        """
+        Send a request to the AI Search service using the provided API key and service URL.
+
+        Args:
+            query_list (list): List of queries to send to the AI Search service.
+
+        Returns:
+            list: List of responses from the AI Search service.
+        """
+        headers = {
+            "Authorization": "Bearer " + self.qianfan_api_key,
+            "Content-Type": "application/json"
+        }
+
+        results = []
+        top_k = self.max_search_results_num // len(query_list)
+        for query in query_list:
+            payload = {
+                "messages": [{"role": "user", "content": query}],
+                "resource_type_filter": [{"type": "web", "top_k": top_k}]
+            }
+            response = requests.post(self.web_search_service_url, headers=headers, json=payload)
+
+            if response.status_code == 200:
+                response = response.json()
+                self.logger.info(response)
+                results.append(response["references"])
+            else:
+                self.logger.info(f"请求失败，状态码: {response.status_code}")
+                self.logger.info(response.text)
+        return results

crawl_utils.py

@@ -0,0 +1,96 @@
+# Copyright (c) 2025 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.
+
+"""
+CrawlUtils is a class that provides utility methods for web crawling and processing.
+"""
+
+import logging
+import re
+from crawl4ai import AsyncWebCrawler, CacheMode, CrawlerRunConfig, DefaultMarkdownGenerator, PruningContentFilter
+
+
+class CrawlUtils(object):
+    """
+    Provides web crawling and content extraction utilities with intelligent filtering.
+    Features include asynchronous crawling, content pruning, markdown generation,
+    and configurable link/media filtering. Uses crawl4ai library for core functionality.
+    """
+    def __init__(self):
+        """Initialize the CrawlUtils instance."""
+        self.logger = logging.getLogger(__name__)
+
+        # Configure content filter - uses pruning algorithm to filter page content
+        content_filter = PruningContentFilter(  
+            threshold=0.48,  
+            threshold_type="fixed"
+        )  
+        # Configure markdown generator, apply the above content filter to generate "fit_markdown"
+        md_generator = DefaultMarkdownGenerator(  
+            content_filter=content_filter  
+        )
+        # Configure crawler run parameters
+        self.run_config = CrawlerRunConfig(  
+            # 20 seconds page timeout
+            page_timeout=20000, 
+
+            # Filtering
+            word_count_threshold=10,
+            excluded_tags=["nav", "footer", "aside", "header", "script", "style", "iframe", "meta"],
+            exclude_external_links=True, 
+            exclude_internal_links=True, 
+            exclude_social_media_links=True, 
+            exclude_external_images=True,
+            only_text=True,
+
+            # Markdown generation
+            markdown_generator=md_generator,
+            
+            # Cache
+            cache_mode=CacheMode.BYPASS
+        )  
+
+    async def get_webpage_text(self, url: str) -> str:
+        """
+        Asynchronously fetches and cleans webpage content from given URL using configured crawler.
+        Applies content filtering, markdown conversion, and text cleaning (removing undefined,
+        excess whitespace, tabs). Returns None if error occurs.
+
+        Args:
+            url (str): The URL to retrieve the text from.
+            
+        Returns:
+            str: The plain text retrieved from the specified URL.
+        """
+        try:
+            async with AsyncWebCrawler() as crawler:
+                result = await crawler.arun(
+                    url=url,
+                    config=self.run_config
+                )
+            
+            webpage_text = result.markdown.fit_markdown
+            self.logger.info("Webpage Text: \n{}".format(webpage_text))
+
+            # Clean up the text
+            cleaned_text = webpage_text.replace("undefined", "")
+            cleaned_text = re.sub(r'(\n\s*){3,}', '\n\n', cleaned_text)
+            cleaned_text = re.sub(r'[\r\t]', '', cleaned_text)
+            cleaned_text = re.sub(r' +', ' ', cleaned_text)
+            cleaned_text = re.sub(r'^\s+|\s+$', '', cleaned_text, flags=re.MULTILINE)
+            return cleaned_text.strip()
+        
+        except Exception as e:
+            self.logger.info("Error: {}".format(e))
+            return None