add files

app.py

@@ -17,6 +17,7 @@
 import argparse
 from collections import namedtuple
 from functools import partial
+import json
 import logging
 import os
 import base64
@@ -30,6 +31,8 @@ os.environ["NO_PROXY"] = "localhost,127.0.0.1"  # Disable proxy
 
 logging.root.setLevel(logging.INFO)
 
+MULTI_MODEL_PREFIX = "ernie-4.5-turbo-vl"
+
 
 def get_args() -> argparse.Namespace:
     """
@@ -38,17 +41,10 @@ def get_args() -> argparse.Namespace:
     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
+    - Model name to endpoint mappings for the chatbot
 
     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
+        argparse.Namespace: Parsed command line arguments containing all the above settings
     """
     parser = ArgumentParser(description="ERNIE models web chat demo.")
 
@@ -65,19 +61,38 @@ def get_args() -> argparse.Namespace:
         "--max_retry_num", type=int, default=3, help="Maximum retry number for request."
     )
     parser.add_argument(
-        "--eb45t_model_url", 
+        "--model_map", 
         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."
+        default="""{
+            "ernie-4.5-turbo-128k": "https://qianfan.baidubce.com/v2",
+            "ernie-4.5-turbo-32k": "https://qianfan.baidubce.com/v2", 
+            "ernie-4.5-8k-preview": "https://qianfan.baidubce.com/v2",
+            "ernie-4.5-turbo-vl-32k": "https://qianfan.baidubce.com/v2",
+            "ernie-4.5-turbo-vl-32k-preview": "https://qianfan.baidubce.com/v2"
+        }""",
+        help="""JSON string defining model name to endpoint mappings.
+            Required Format:
+            {"model_name": "http://localhost:port/v1", ...}
+
+            Note:
+            - All endpoints must be valid HTTP URLs
+            - At least one model must be specified
+            - Prefix determines model capabilities:
+            * ERNIE-4.5[-*]: Text-only model
+            * ERNIE-4.5-VL[-*]: Multimodal models (image+text)
+            """
     )
 
     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
 
 
@@ -85,7 +100,6 @@ 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
@@ -127,12 +141,12 @@ class GradioEvents(object):
         temperature: float, 
         top_p: float, 
         bot_client: BotClient
-    ) -> dict:
+    ) -> str:
         """
         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.
+        streams back model responses.
 
         Args:
             query (str): User input.
@@ -147,7 +161,7 @@ class GradioEvents(object):
             bot_client (BotClient): Bot client.
 
         Yields:
-            dict: A dictionary containing the event type and its corresponding content.
+            str: Model response.
         """
         conversation = []
         if system_msg:
@@ -174,7 +188,6 @@ class GradioEvents(object):
         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):
@@ -183,12 +196,9 @@ class GradioEvents(object):
                 
                 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}
+                    yield content
                     
         except Exception as e:
             raise gr.Error("Exception: " + repr(e))
@@ -209,7 +219,7 @@ class GradioEvents(object):
     ) -> 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,
+        progressively updates the chatbot state with responses,
         and maintains conversation history. Handles both text and multimodal inputs while preserving
         the interactive chat experience with real-time updates.
 
@@ -249,35 +259,16 @@ class GradioEvents(object):
             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"]
+        for new_text in new_texts:                
+            response += new_text
             
-            # Remove previous thinking message if exists
+            # Remove previous 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})
+                chatbot.append({"role": "assistant", "content": response})
                 yield chatbot
 
         logging.info("History: {}".format(task_history))
@@ -387,7 +378,7 @@ class GradioEvents(object):
         gc.collect()
 
     @staticmethod
-    def toggle_components_visibility(model_name: str) -> tuple:
+    def toggle_components_visibility(model_name: str) -> gr.update:
         """
         Toggle visibility of components depending on the selected model name.
         
@@ -395,13 +386,9 @@ class GradioEvents(object):
             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.
+            gr.update: An update object representing the visibility of the file button.
         """
-        is_eb45t = (model_name == "eb-45t")
-        return (
-            gr.update(visible=is_eb45t),  # file_btn
-            gr.update(visible=is_eb45t)  # system_message
-        )
+        return gr.update(visible=model_name.startswith(MULTI_MODEL_PREFIX))  # file_btn
 
 
 def launch_demo(args: argparse.Namespace, bot_client: BotClient):
@@ -426,14 +413,11 @@ def launch_demo(args: argparse.Namespace, bot_client: BotClient):
     /* 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;
+        font-size: 15px;
         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("""\
@@ -444,18 +428,20 @@ def launch_demo(args: argparse.Namespace, bot_client: BotClient):
 <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"
         )
+        model_names = list(args.model_map.keys())
         with gr.Row():
-            model_name = gr.Dropdown(label="Select Model", choices=model_names, value="eb-45t", allow_custom_value=True)
+            model_name = gr.Dropdown(
+                label="Select Model", 
+                choices=model_names, 
+                value=model_names[0], 
+                allow_custom_value=True
+            )
             file_btn = gr.File(
                 label="Image upload (Active only for multimodal models. Accepted formats: PNG, JPEG, JPG)", 
                 height="80px", 
@@ -485,7 +471,7 @@ def launch_demo(args: argparse.Namespace, bot_client: BotClient):
         model_name.change(
             GradioEvents.toggle_components_visibility, 
             inputs=model_name, 
-            outputs=[file_btn, system_message]
+            outputs=file_btn
         )
         model_name.change(
             GradioEvents.reset_state, 
@@ -526,6 +512,12 @@ def launch_demo(args: argparse.Namespace, bot_client: BotClient):
             show_progress=True
         )
 
+        demo.load(
+            GradioEvents.toggle_components_visibility, 
+            inputs=gr.State(model_names[0]), 
+            outputs=file_btn
+        )
+
     demo.queue().launch(
         server_port=args.server_port,
         server_name=args.server_name

bot_requests.py

@@ -22,7 +22,7 @@ import json
 import jieba
 from openai import OpenAI
 
-from appbuilder.mcp_server.client import MCPClient
+import requests
 
 class BotClient(object):
     """Client for interacting with various AI models."""
@@ -41,15 +41,16 @@ class BotClient(object):
         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.model_map = getattr(args, 'model_map', {})
         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_service_url = getattr(args, 'embedding_service_url', 'embedding_service_url')
         self.embedding_model = getattr(args, 'embedding_model', 'embedding_model')
 
-        self.ai_search_service_url = getattr(args, 'ai_search_service_url', 'ai_search_service_url')
+        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_KEY")
 
     def call_back(self, host_url: str, req_data: dict) -> dict:
         """
@@ -130,14 +131,9 @@ class BotClient(object):
         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]
+        model_url = self.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["model"] = model_name
         req_data["max_tokens"] = max_tokens
         req_data["temperature"] = temperature
         req_data["top_p"] = top_p
@@ -157,7 +153,6 @@ class BotClient(object):
                 res = {}
             if len(res) != 0 and "error" not in res:
                 break
-        self.logger.info(json.dumps(res, ensure_ascii=False))
         
         return res
 
@@ -183,13 +178,8 @@ class BotClient(object):
         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"
+        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
@@ -282,7 +272,7 @@ class BotClient(object):
         to_remove = total_units - self.max_char
         
         # 1. Truncate historical messages
-        for i in range(1, len(processed) - 1):
+        for i in range(len(processed) - 1, 1):
             if to_remove <= 0:
                 break
             
@@ -362,27 +352,39 @@ class BotClient(object):
         Returns:
             list: A list of floats representing the embedding.
         """
-        client = OpenAI(base_url=self.qianfan_url, api_key=self.qianfan_api_key)
+        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
 
-    async def get_ai_search_res(self, query_list: list) -> list:
+    def get_web_search_res(self, query_list: list) -> list:
         """
-        Get AI search results for the given queries using the MCPClient.
-        
+        Send a request to the AI Search service using the provided API key and service URL.
+
         Args:
-            query_list (list): List of queries to search for.
+            query_list (list): List of queries to send to the AI Search service.
 
         Returns:
-            list: List of search results as strings.
+            list: List of responses from the AI Search service.
         """
-        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
+        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