add files

.gitignore

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

app.py

@@ -0,0 +1,541 @@
+# 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 file contains the code for the chatbot demo using Gradio."""
+
+import argparse
+from collections import namedtuple
+from functools import partial
+import logging
+import os
+import base64
+from argparse import ArgumentParser
+
+import gradio as gr
+
+from bot_requests import BotClient
+
+os.environ["NO_PROXY"] = "localhost,127.0.0.1"  # Disable proxy
+
+logging.root.setLevel(logging.INFO)
+
+
+def get_args() -> argparse.Namespace:
+    """
+    Parses and returns command line arguments for configuring the chatbot demo.
+    Sets up argument parser with default values for server configuration and model endpoints.
+    The arguments include:
+    - Server port and name for the Gradio interface
+    - Character limits and retry settings for conversation handling
+    - Model endpoints for different AI services
+    - API keys and other service configurations
+
+    Returns:
+        argparse.Namespace: Parsed command line arguments containing:
+            - server_port (int): Port number for the demo server (default: 8232)
+            - server_name (str): Hostname/IP for the server (default: "0.0.0.0")
+            - max_char (int): Maximum character limit for messages (default: 8000)
+            - max_retry_num (int): Maximum retry attempts for API calls (default: 3)
+            - eb45t_model_url (str): Endpoint URL for the multimodal model
+            - x1_model_url (str): Endpoint URL for the text inference model
+    """
+    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=8000, 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(
+        "--eb45t_model_url", 
+        type=str, 
+        default="https://qianfan.baidubce.com/v2",
+        help="Model URL for multimodal model."
+    )
+    parser.add_argument(
+        "--x1_model_url", 
+        type=str, 
+        default="https://qianfan.baidubce.com/v2",
+        help="Model URL for text inference model."
+    )
+
+    args = parser.parse_args()
+    return args
+
+
+class GradioEvents(object):
+    """
+    Central handler for all Gradio interface events in the chatbot demo. Provides static methods
+    for processing user interactions including:
+    - Streaming chat predictions with reasoning steps
+    - Response regeneration
+    - Conversation state management
+    - Image handling and URL conversion
+    - Component visibility control
+    
+    Coordinates with BotClient to interface with backend models while maintaining 
+    conversation history and handling multimodal inputs.
+    """
+    @staticmethod
+    def get_image_url(image_path: str) -> str:
+        """
+        Converts an image file at the given path to a base64 encoded data URL 
+        that can be used directly in HTML or Gradio interfaces. 
+        Reads the image file, encodes it in base64 format, and constructs 
+        a data URL with the appropriate image MIME type.
+
+        Args:
+            image_path (str): Path to the image file.
+
+        Returns:
+            str: Image URL.
+        """
+        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 chat_stream(
+        query: str, 
+        task_history: list, 
+        image_history: dict, 
+        model_name: str, 
+        file_url: str, 
+        system_msg: str, 
+        max_tokens: int, 
+        temperature: float, 
+        top_p: float, 
+        bot_client: BotClient
+    ) -> dict:
+        """
+        Handles streaming chat interactions by processing user queries and 
+        generating real-time responses from the bot client. Constructs conversation 
+        history including system messages, text inputs and image attachments, then 
+        streams back model responses with reasoning steps and final answers.
+
+        Args:
+            query (str): User input.
+            task_history (list): Task history.
+            image_history (dict): Image history.
+            model_name (str): Model name.
+            file_url (str): File URL.
+            system_msg (str): System message.
+            max_tokens (int): Maximum tokens.
+            temperature (float): Temperature.
+            top_p (float): Top p.
+            bot_client (BotClient): Bot client.
+
+        Yields:
+            dict: A dictionary containing the event type and its corresponding content.
+        """
+        conversation = []
+        if system_msg:
+            conversation.append({"role": "system", "content": system_msg})
+        for idx, (query_h, response_h) in enumerate(task_history):
+            if idx in image_history:
+                content = []
+                content.append({
+                    "type": "image_url", 
+                    "image_url": {"url": GradioEvents.get_image_url(image_history[idx])}
+                })
+                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})
+
+        content = []
+        if file_url and (len(image_history) == 0 or file_url != list(image_history.values())[-1]):
+            image_history[len(task_history)] = file_url
+            content.append({"type": "image_url", "image_url": {"url": GradioEvents.get_image_url(file_url)}})
+            content.append({"type": "text", "text": query})
+            conversation.append({"role": "user", "content": content})
+        else:
+            conversation.append({"role": "user", "content": query})
+
+        
+        try:
+            req_data = {"messages": conversation}
+            for chunk in bot_client.process_stream(model_name, req_data, max_tokens, temperature, top_p):
+                if "error" in chunk:
+                    raise Exception(chunk["error"])
+                
+                message = chunk.get("choices", [{}])[0].get("delta", {})
+                content = message.get("content", "")
+                reasoning_content = message.get("reasoning_content", "")
+                
+                if reasoning_content:
+                    yield {"type": "thinking", "content": reasoning_content}
+                if content:
+                    yield {"type": "answer", "content": content}
+                    
+        except Exception as e:
+            raise gr.Error("Exception: " + repr(e))
+
+    @staticmethod
+    def predict_stream(
+        query: str, 
+        chatbot: list, 
+        task_history: list, 
+        image_history: dict, 
+        model: str, 
+        file_url: str, 
+        system_msg: str, 
+        max_tokens: int, 
+        temperature: float, 
+        top_p: float, 
+        bot_client: BotClient
+    ) -> list:
+        """
+        Processes user queries in a streaming manner by coordinating with the chat stream handler,
+        progressively updates the chatbot state with intermediate reasoning steps and final responses,
+        and maintains conversation history. Handles both text and multimodal inputs while preserving
+        the interactive chat experience with real-time updates.
+
+        Args:
+            query (str): The user's query.
+            chatbot (list): The current chatbot state.
+            task_history (list): The task history.
+            image_history (dict): The image history.
+            model (str): The model name.
+            file_url (str): The file URL.
+            system_msg (str): The system message.
+            max_tokens (int): The maximum token length of the generated response.
+            temperature (float): The temperature parameter used by the model.
+            top_p (float): The top_p parameter used by the model.
+            bot_client (BotClient): The bot client.
+
+        Returns:
+            list: A list containing the updated chatbot state after processing the user's query.
+        """
+
+        logging.info("User: {}".format(query))
+        chatbot.append({"role": "user", "content": query})  
+        
+        # First yield the chatbot with user message
+        yield chatbot
+
+        new_texts = GradioEvents.chat_stream(
+            query, 
+            task_history, 
+            image_history, 
+            model, 
+            file_url, 
+            system_msg, 
+            max_tokens, 
+            temperature, 
+            top_p, 
+            bot_client
+        )
+
+        reasoning_content = ""
+        response = ""
+        has_thinking = False
+        for new_text in new_texts:
+            if not isinstance(new_text, dict):
+                continue
+                
+            if new_text.get("type") == "thinking":
+                has_thinking = True
+                reasoning_content += new_text["content"]
+                
+            elif new_text.get("type") == "answer":
+                response += new_text["content"]
+            
+            # Remove previous thinking message if exists
+            if chatbot[-1].get("role") == "assistant":
+                chatbot.pop(-1)
+            
+            content = ""
+            if has_thinking:
+                content = "**思考过程：**<br>{}<br>".format(reasoning_content)
+            if response:
+                if has_thinking:
+                    content += "<br><br>**最终回答：**<br>{}".format(response)
+                else:
+                    content = response
+            
+            if content:
+                chatbot.append({"role": "assistant", "content": content})
+                yield chatbot
+
+        logging.info("History: {}".format(task_history))
+        task_history.append((query, response))    
+        logging.info("ERNIE models: {}".format(response))
+
+    @staticmethod
+    def regenerate(
+        chatbot: list, 
+        task_history: list, 
+        image_history: dict, 
+        model: str, 
+        file_url: str, 
+        system_msg: str, 
+        max_tokens: int, 
+        temperature: float, 
+        top_p: float, 
+        bot_client: BotClient
+    ) -> list:
+        """
+        Reconstructs the conversation context by removing the last interaction and 
+        reprocesses the user's previous query to generate a fresh response. Maintains 
+        consistency in conversation flow while allowing response regeneration.
+
+        Args:
+            chatbot (list): The current chatbot state.
+            task_history (list): The task history.
+            image_history (dict): The image history.
+            model (str): The model name.
+            file_url (str): The file URL.
+            system_msg (str): The system message.
+            max_tokens (int): The maximum token length of the generated response.
+            temperature (float): The temperature parameter used by the model.
+            top_p (float): The top_p parameter used by the model.
+            bot_client (BotClient): The bot client.
+
+        Yields:
+            list: A list containing the updated chatbot state after processing the user's query.
+        """
+        if not task_history:
+            yield chatbot
+            return
+        # Pop the last user query and bot response from task_history
+        item = task_history.pop(-1)
+        if (len(task_history)) in image_history:
+            del image_history[len(task_history)]
+        while len(chatbot) != 0 and chatbot[-1].get("role") == "assistant":
+            chatbot.pop(-1)
+        chatbot.pop(-1)
+
+        for chunk in GradioEvents.predict_stream(
+            item[0], 
+            chatbot, 
+            task_history, 
+            image_history,
+            model, 
+            file_url,
+            system_msg, 
+            max_tokens, 
+            temperature, 
+            top_p,
+            bot_client
+        ):
+            yield chunk
+
+    @staticmethod
+    def reset_user_input() -> gr.update:
+        """
+        Reset user input field value to empty string.
+        
+        Returns:
+            gr.update: Update object representing the new value of the user input field.
+        """
+        return gr.update(value="")
+
+    @staticmethod
+    def reset_state() -> tuple:
+        """
+        Reset all states including chatbot, task_history, image_history, and file_btn.
+        
+        Returns:
+            tuple: A tuple containing the following values:
+                - chatbot (list): An empty list that represents the cleared chatbot state.
+                - task_history (list): An empty list that represents the cleared task history.
+                - image_history (dict): An empty dictionary that represents the cleared image history.
+                - file_btn (gr.update): An update object that sets the value of the file button to None.
+        """
+        GradioEvents.gc()
+                
+        reset_result = namedtuple("reset_result", 
+                           ["chatbot", 
+                            "task_history", 
+                            "image_history",
+                            "file_btn"])
+        return reset_result(
+            [],  # clear chatbot
+            [],  # clear task_history
+            {},  # clear image_history
+            gr.update(value=None),  # clear file_btn
+        )
+    
+    @staticmethod
+    def gc():
+        """Run garbage collection to free up memory resources."""
+        import gc
+
+        gc.collect()
+
+    @staticmethod
+    def toggle_components_visibility(model_name: str) -> tuple:
+        """
+        Toggle visibility of components depending on the selected model name.
+        
+        Args:
+            model_name (str): Name of the selected model.
+        
+        Returns:
+            tuple: A tuple containing two updates: one for the file button and another for the system message.
+        """
+        is_eb45t = (model_name == "eb-45t")
+        return (
+            gr.update(visible=is_eb45t),  # file_btn
+            gr.update(visible=is_eb45t)  # system_message
+        )
+
+
+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 = """
+    /* 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;
+    }
+    """
+    model_names = ["eb-45t", "eb-x1"]
+
+    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>"""
+        )
+        gr.Markdown("""\
+<center><font size=4>
+<a href="https://yiyan.baidu.com/">eb-45t</a> | 
+&nbsp<a href="https://yiyan.baidu.com/">eb-x1</a></center>""")
+
+        chatbot = gr.Chatbot(
+            label="ERNIE", 
+            elem_classes="control-height", 
+            type="messages"
+        )
+        with gr.Row():
+            model_name = gr.Dropdown(label="Select Model", choices=model_names, value="eb-45t", allow_custom_value=True)
+            file_btn = gr.File(
+                label="Image upload (Active only for multimodal models. Accepted formats: PNG, JPEG, JPG)", 
+                height="80px", 
+                visible=True, 
+                file_types=[".png", ".jpeg", "jpg"],
+                elem_id="file-upload"
+            )
+        query = gr.Textbox(label="Input", elem_id="text_input")
+
+        with gr.Row():
+            empty_btn = gr.Button("🧹 Clear History(清除历史)")
+            submit_btn = gr.Button("🚀 Submit(发送)", elem_id="submit-button")
+            regen_btn = gr.Button("🤔️ Regenerate(重试)")
+
+        with gr.Accordion("⚙️ Advanced Config", open=False):  # open=False means collapsed by default
+            system_message = gr.Textbox(value="", label="System message", visible=True)
+            additional_inputs = [
+                system_message,
+                gr.Slider(minimum=1, maximum=4096, value=2048, step=1, label="Max new tokens"),
+                gr.Slider(minimum=0.1, maximum=1.0, value=1.0, step=0.05, label="Temperature"),
+                gr.Slider(minimum=0.1, maximum=1.0, value=0.7, step=0.05, label="Top-p (nucleus sampling)")
+            ]
+        
+        task_history = gr.State([])
+        image_history = gr.State({})
+        
+        model_name.change(
+            GradioEvents.toggle_components_visibility, 
+            inputs=model_name, 
+            outputs=[file_btn, system_message]
+        )
+        model_name.change(
+            GradioEvents.reset_state, 
+            outputs=[chatbot, task_history, image_history, file_btn], 
+            show_progress=True
+        )
+        predict_with_clients = partial(
+            GradioEvents.predict_stream,
+            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, model_name, file_btn] + additional_inputs, 
+            outputs=[chatbot], 
+            show_progress=True
+        )
+        query.submit(GradioEvents.reset_user_input, [], [query])
+        submit_btn.click(
+            predict_with_clients, 
+            inputs=[query, chatbot, task_history, image_history, model_name, file_btn] + additional_inputs, 
+            outputs=[chatbot], 
+            show_progress=True,
+        )
+        submit_btn.click(GradioEvents.reset_user_input, [], [query])
+        empty_btn.click(
+            GradioEvents.reset_state, 
+            outputs=[chatbot, task_history, image_history, file_btn], 
+            show_progress=True
+        )
+        regen_btn.click(
+            regenerate_with_clients, 
+            inputs=[chatbot, task_history, image_history, model_name, file_btn] + additional_inputs, 
+            outputs=[chatbot], 
+            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,388 @@
+# 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
+
+from appbuilder.mcp_server.client import MCPClient
+
+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.eb45t_model_url = getattr(args, 'eb45t_model_url', 'eb45t_model_url')
+        self.x1_model_url = getattr(args, 'x1_model_url', 'x1_model_url')
+        self.api_key = os.environ.get("API_KEY")
+
+        self.qianfan_url = getattr(args, 'qianfan_url', 'qianfan_url')
+        self.qianfan_api_key = getattr(args, 'qianfan_api_key', 'qianfan_api_key')
+        self.embedding_model = getattr(args, 'embedding_model', 'embedding_model')
+
+        self.ai_search_service_url = getattr(args, 'ai_search_service_url', 'ai_search_service_url')
+
+    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_map = {
+            "eb-45t": self.eb45t_model_url,
+            "eb-x1": self.x1_model_url
+        }
+
+        model_url = model_map[model_name]
+
+        req_data["model"] = "ernie-4.5-turbo-vl-32k" if "eb-45t" == model_name else "ernie-x1-turbo-32k"
+        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
+        self.logger.info(json.dumps(res, ensure_ascii=False))
+        
+        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_map = {
+            "eb-45t": self.eb45t_model_url,
+            "eb-x1": self.x1_model_url
+        }
+
+        model_url = model_map[model_name]
+        req_data["model"] = "ernie-4.5-turbo-vl-32k" if "eb-45t" == model_name else "ernie-x1-turbo-32k"
+        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(1, len(processed) - 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.qianfan_url, api_key=self.qianfan_api_key)
+        response = client.embeddings.create(input=[text], model=self.embedding_model)
+        return response.data[0].embedding
+
+    async def get_ai_search_res(self, query_list: list) -> list:
+        """
+        Get AI search results for the given queries using the MCPClient.
+        
+        Args:
+            query_list (list): List of queries to search for.
+
+        Returns:
+            list: List of search results as strings.
+        """
+        try:
+            client = MCPClient()
+            await client.connect_to_server(service_url=self.ai_search_service_url)
+            result = []
+            for query in query_list:
+                response = await client.call_tool("AIsearch", {"query": query})
+                result.append(response.content[0].text)
+        finally:
+            await client.cleanup()
+        return result

requirements.txt

@@ -0,0 +1,14 @@
+# Requires Python 3.10-3.12
+appbuilder_sdk==1.0.6
+crawl4ai==0.6.3
+docx==0.2.4
+faiss-cpu==1.9.0
+gradio==5.27.1
+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