add files

.gitignore

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

app.py

@@ -0,0 +1,881 @@
+# 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 base64
+from collections import namedtuple
+from functools import partial
+import hashlib
+import json
+import logging
+import faiss
+import os
+from argparse import ArgumentParser
+import textwrap
+
+import gradio as gr
+import numpy as np
+
+from bot_requests import BotClient
+# from faiss_text_database import FaissTextDatabase
+
+os.environ["NO_PROXY"] = "localhost,127.0.0.1"  # Disable proxy
+
+logging.root.setLevel(logging.INFO)
+
+FILE_URL_DEFAULT = "data/coffee.txt"
+RELEVANT_PASSAGE_DEFAULT = textwrap.dedent("""\
+    1675年时，英格兰就有3000多家咖啡馆；启蒙运动时期，咖啡馆成为民众深入讨论宗教和政治的聚集地，
+    1670年代的英国国王查理二世就曾试图取缔咖啡馆。这一时期的英国人认为咖啡具有药用价值，
+    甚至名医也会推荐将咖啡用于医疗。"""
+)
+
+QUERY_REWRITE_PROMPT = textwrap.dedent("""\
+    你是一个擅长问答系统和信息检索的大模型助手。
+
+    请根据用户提出的问题，判断是否需要调用文档检索系统来获取答案：
+    - 若问题属于常识性、定义性或答案明确，不依赖外部资料，请标记为 "is_search": false；
+    - 若问题涉及事实查证、具体数据、文档内容等，必须依赖资料检索，请标记为 "is_search": true，并将问题拆解成多个可用于检索的子问题。
+
+    要求：
+    1. 子问题应语义清晰、独立，适合用于检索；
+    2. 只在**确有必要**的情况下拆解，最多不超过 5 个，不要为了凑满数量而输出冗余子问题；
+    3. 输出为严格的 JSON 格式，无多余注释。
+
+    【用户当前问题】：
+    {query}
+
+    【输出格式】：
+    请仅输出如下格式的内容（符合 JSON 规范，无多余注释）：
+    ```
+    {{
+        "is_search": true 或 false,
+        "sub_query_list": ["子问题1","子问题2","..."]
+    }}
+    ```"""
+)
+
+ANSWER_PROMPT = textwrap.dedent(
+    """\
+    你是一个乐于助人且信息丰富的机器人，使用下面提供的参考段落中的文本来回答问题。
+    请务必用完整的句子回答，内容要全面，包括所有相关的背景信息。
+
+    然而，你的对话对象是非技术人员，所以请务必分解复杂的概念，并使用友好和对话式的语气。
+    如果段落与答案无关，你可以忽略它。
+
+    问题：'{query}'
+    段落：'{relevant_passage}'
+
+    答案："""
+)
+QUERY_DEFAULT = "1675 年时，英格兰有多少家咖啡馆？"
+
+
+def get_args() -> argparse.Namespace:
+    """
+    Parse and return command line arguments for the ERNIE models web chat demo.
+    Configures server settings, model endpoints, and document processing parameters.
+
+    Returns:
+        argparse.Namespace: Parsed command line arguments containing:
+        - server_port: Demo server port (default: 8333)
+        - server_name: Demo server host (default: "0.0.0.0")
+        - model_urls: Endpoints for ERNIE and Qianfan models
+        - document_processing: Chunk size, FAISS index and text DB paths
+    """
+    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(
+        "--qianfan_url", 
+        type=str, 
+        default="https://qianfan.baidubce.com/v2", 
+        help="Qianfan URL."
+    )
+    parser.add_argument(
+        "--qianfan_api_key", 
+        type=str, 
+        default=os.environ.get("API_KEY"),
+        help="Qianfan API key."
+    )
+    parser.add_argument(
+        "--embedding_model", 
+        type=str, 
+        default="embedding-v1", 
+        help="Embedding model name."
+    )
+    parser.add_argument(
+        "--chunk_size", 
+        type=int, 
+        default=512, 
+        help="Chunk size for splitting long documents."
+    )
+    parser.add_argument(
+        "--faiss_index_path", 
+        type=str, 
+        default="data/faiss_index", 
+        help="Faiss index path."
+    )
+    parser.add_argument(
+        "--text_db_path", 
+        type=str, 
+        default="data/text_db.jsonl", 
+        help="Text database path."
+    )
+
+    args = parser.parse_args()
+    return args
+
+
+class FaissTextDatabase:
+    """
+    A vector database for text retrieval using FAISS (Facebook AI Similarity Search).
+    Provides efficient similarity search and document management capabilities.
+    """
+    def __init__(self, args, bot_client: BotClient, embedding_dim: int=384):
+        """
+        Initialize the FaissTextDatabase.
+
+        Args:
+            args: arguments for initialization
+            bot_client: instance of BotClient
+            embedding_dim: dimension of the embedding vector
+        """
+        self.logger = logging.getLogger(__name__)
+        
+        self.bot_client = bot_client
+        self.faiss_index_path = getattr(args, "faiss_index_path", "data/faiss_index")
+        self.text_db_path = getattr(args, "text_db_path", "data/text_db.jsonl")
+        self.embedding_dim = embedding_dim
+        
+        # If faiss_index_path exists, load it and text_db_path
+        if os.path.exists(self.faiss_index_path) and os.path.exists(self.text_db_path):
+            self.index = faiss.read_index(self.faiss_index_path)
+            with open(self.text_db_path, 'r', encoding='utf-8') as f:
+                self.text_db = json.load(f)
+        else:
+            self.index = faiss.IndexFlatIP(self.embedding_dim)
+            self.text_db = {
+                "file_md5s": [],  # Save file_md5s to avoid duplicates
+                "chunks": []      # Save chunks
+            }
+    
+    def calculate_md5(self, file_path: str) -> str:
+        """
+        Calculate the MD5 hash of a file
+
+        Args:
+            file_path: the path of the source file
+
+        Returns:
+            str: the MD5 hash
+        """
+        with open(file_path, "rb") as f:
+            return hashlib.md5(f.read()).hexdigest()
+
+    def is_file_processed(self, file_path: str) -> bool:
+        """
+        Check if the file has been processed before
+
+        Args:
+            file_path: the path of the source file
+
+        Returns:
+            bool: whether the file has been processed
+        """
+        file_md5 = self.calculate_md5(file_path)
+        return file_md5 in self.text_db["file_md5s"]
+    
+    def add_embeddings(self, file_path: str, segments: list[str], progress_bar: gr.Progress=None) -> bool:
+        """
+        Stores document embeddings in FAISS database after checking for duplicates.
+        Generates embeddings for each text segment, updates the FAISS index and metadata database,
+        and persists changes to disk. Includes optional progress tracking for Gradio interfaces.
+        
+        Args:
+            file_path: the path of the source file
+            segments: the list of segments
+            progress_bar: the progress bar object
+        
+        Returns:
+            bool: whether the operation was successful
+        """
+        file_md5 = self.calculate_md5(file_path)
+        if file_md5 in self.text_db["file_md5s"]:
+            self.logger.info("File already processed: {file_path} (MD5: {file_md5})".format(
+                file_path=file_path, 
+                file_md5=file_md5
+            ))
+            return False
+        
+        # Generate embeddings
+        vectors = []
+        file_name = os.path.basename(file_path)
+        for i, segment in  enumerate(segments):
+            vectors.append(self.bot_client.embed_fn(segment))
+            if progress_bar is not None:
+                progress_bar((i + 1) / len(segments), desc=file_name + " Processing...")
+        vectors = np.array(vectors)
+        self.index.add(vectors.astype('float32'))
+        
+        start_id = len(self.text_db["chunks"])
+        for i, text in enumerate(segments):
+            self.text_db["chunks"].append({
+                "file_md5": file_md5,
+                "text": text,
+                "vector_id": start_id + i
+            })
+        
+        self.text_db["file_md5s"].append(file_md5)
+        self.save()
+        return True
+
+    def search_with_context(self, query: str, context_size: int=2) -> str:
+        """
+        Finds the most relevant text chunk for a query and includes surrounding context.
+        Uses FAISS to find the closest matching embedding, then retrieves adjacent chunks
+        from the same source document to provide better context understanding.
+
+        Args:
+            query: the input query string
+            context_size: the number of surrounding chunks to include
+        
+        Returns:
+            str: the relevant chunk with context
+        """
+        query_vector = np.array([self.bot_client.embed_fn(query)]).astype('float32')
+        distances, indices = self.index.search(query_vector, 1)
+        
+        target_idx = indices[0][0]
+        target_chunk = self.text_db["chunks"][target_idx]
+        target_file_md5 = target_chunk["file_md5"]
+        self.logger.info("Similarity: {}".format(distances[0][0]))
+        self.logger.info("Target Chunk: {}".format(self.text_db["chunks"][target_idx]["text"]))
+        
+        # Get the context 
+        start = max(0, target_idx - context_size)
+        end = min(len(self.text_db["chunks"]) - 1, target_idx + context_size)
+        result = ""
+        for pos in range(start, end + 1):
+            if self.text_db["chunks"][pos]["file_md5"] == target_file_md5:
+                result += self.text_db["chunks"][pos]["text"] + "\n"
+        
+        return result
+    
+    def save(self) -> None:
+        """Save the database to disk."""
+        faiss.write_index(self.index, self.faiss_index_path)
+        
+        with open(self.text_db_path, 'w', encoding='utf-8') as f:
+            json.dump(self.text_db, f, ensure_ascii=False, indent=2)
+
+
+class GradioEvents(object):
+    """
+    Manages event handling and UI interactions for Gradio applications.
+    Provides methods to process user inputs, trigger callbacks, and update interface components.
+    """
+    @staticmethod
+    def chat_stream(
+        query: str, 
+        task_history: list, 
+        model: str, 
+        bot_client: BotClient, 
+        faiss_db: FaissTextDatabase,
+    ) -> dict:
+        """
+        Streams chatbot responses by processing queries with context from history and FAISS database.
+        Integrates language model generation with knowledge retrieval to produce dynamic responses.
+        Yields response events in real-time for interactive conversation experiences.
+
+        Args:
+            query (str): The query string.
+            task_history (list): The task history record list.
+            model (Model): The model used to generate responses.
+            bot_client (BotClient): The chatbot client object.
+            faiss_db (FaissTextDatabase): The FAISS database object.
+
+        Yields:
+            dict: A dictionary containing the event type and its corresponding content.
+        """
+        search_info_result = GradioEvents.get_sub_query(query, model, bot_client)
+        if search_info_result.get("is_search", False) and search_info_result.get("sub_query_list", []):
+            relevant_passage = GradioEvents.get_relevant_passage(
+                search_info_result["sub_query_list"], 
+                faiss_db
+            )
+            yield {"type": "relevant_passage", "content": relevant_passage}
+            input = ANSWER_PROMPT.format(query=query, relevant_passage=relevant_passage)
+        else:
+            input = query
+
+        conversation = []
+        for query_h, response_h in task_history:
+            conversation.append({"role": "user", "content": query_h})
+            conversation.append({"role": "assistant", "content": response_h})
+        conversation.append({"role": "user", "content": input})
+        
+        try:
+            req_data = {"messages": conversation}
+            for chunk in bot_client.process_stream(model, req_data):
+                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,
+        model: str, 
+        bot_client: BotClient,
+        faiss_db: FaissTextDatabase
+    ) -> tuple:
+        """
+        Generates streaming responses by combining model predictions with knowledge retrieval.
+        Processes user queries using conversation history and FAISS database context,
+        yielding updated chat messages and relevant passages in real-time.
+
+        Args:
+            query (str): The content of the user's input query.
+            chatbot (list): The chatbot's historical message list.
+            task_history (list): The task history record list. 
+            model (Model): The model used to generate responses.
+            bot_client (object): The chatbot client object.
+            faiss_db (FaissTextDatabase): The FAISS database instance.
+
+        Yields:
+            tuple: A tuple containing the updated chatbot's message list and the relevant passage.
+        """
+        query = query if query else QUERY_DEFAULT
+
+        logging.info("User: {}".format(query))
+        chatbot.append({"role": "user", "content": query})  
+        
+        # First yield the chatbot with user message
+        yield chatbot, None
+
+        new_texts = GradioEvents.chat_stream(
+            query, 
+            task_history, 
+            model, 
+            bot_client,
+            faiss_db,
+        )
+        reasoning_content = ""
+        response = ""
+        has_thinking = False
+        current_relevant_passage = None
+        for new_text in new_texts:
+            if not isinstance(new_text, dict):
+                continue
+                
+            if new_text.get("type") == "embedding":
+                current_relevant_passage = new_text["content"]
+                yield chatbot, current_relevant_passage
+                continue
+            elif new_text.get("type") == "relevant_passage":
+                current_relevant_passage = new_text["content"]
+                yield chatbot, current_relevant_passage
+                continue
+            elif 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, current_relevant_passage
+
+        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, 
+        model: str, 
+        bot_client: BotClient,
+        faiss_db: FaissTextDatabase
+    ) -> tuple:
+        """
+        Regenerate the chatbot's response based on the latest user query
+
+        Args:
+            chatbot (list): Chat history list
+            task_history (list): Task history
+            model (str): Model name to use
+            bot_client (BotClient): Bot request client instance
+            faiss_db (FaissTextDatabase): Faiss database instance
+
+        Yields:
+            tuple: Updated chatbot and relevant_passage
+        """
+        if not task_history:
+            yield chatbot, None
+            return
+        # Pop the last user query and bot response from task_history
+        item = task_history.pop(-1)
+        while len(chatbot) != 0 and chatbot[-1].get("role") == "assistant":
+            chatbot.pop(-1)
+        chatbot.pop(-1)
+
+        for chunk, relevant_passage in GradioEvents.predict_stream(
+            item[0], 
+            chatbot, 
+            task_history, 
+            model, 
+            bot_client,
+            faiss_db
+        ):
+            yield chunk, relevant_passage
+
+    @staticmethod
+    def reset_user_input() -> gr.update:
+        """
+        Reset user input box content.
+
+        Returns:
+            gr.update: An update object representing the cleared value
+        """
+        return gr.update(value="")
+
+    @staticmethod
+    def reset_state() -> namedtuple:
+        """
+        Reset chat state and clear all history.
+
+        Returns:
+            tuple: A named tuple containing the updated values for chatbot, task_history, file_btn, and relevant_passage
+        """
+        GradioEvents.gc()
+        
+        reset_result = namedtuple("reset_result", 
+                           ["chatbot", 
+                            "task_history", 
+                            "file_btn", 
+                            "relevant_passage"])
+        return reset_result(
+            [],  # clear chatbot
+            [],  # clear task_history
+            gr.update(value=None),  # clear file_btn
+            gr.update(value=None)  # reset relevant_passage
+        )
+    
+    @staticmethod
+    def gc():
+        """
+        Force garbage collection to free memory.
+        """
+        import gc
+
+        gc.collect()
+
+    @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): Path to the image file. Must be a valid file path.
+
+        Returns:
+            str: Data URL string in format "data:image/{ext};base64,{encoded_data}"
+        """
+        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_relevant_passage(
+        sub_query_list: list,
+        faiss_db: FaissTextDatabase
+    ) -> str:
+        """
+        Retrieve the relevant passage from the database based on the query.
+
+        Args:
+            sub_query_list (list): List of sub-queries.
+            faiss_db (FaissTextDatabase): The FAISS database instance.
+
+        Returns:
+            str: The relevant passage.
+        """
+        relevant_passages = ""
+        for idx, query_item in enumerate(sub_query_list):
+            relevant_passage = faiss_db.search_with_context(query_item)
+            relevant_passages += "\n段落{idx}:\n{relevant_passage}".format(idx=idx + 1, relevant_passage=relevant_passage)
+
+        return relevant_passages
+
+    @staticmethod
+    def get_sub_query(query: str, model_name: str, bot_client: BotClient) -> dict:
+        """
+        Enhances user queries by generating alternative phrasings using language models.
+        Creates semantically similar variations of the original query to improve retrieval accuracy.
+        Returns structured dictionary containing both original and rephrased queries.
+
+        Args:
+            query (str): The query to rephrase.
+            model_name (str): The name of the model to use for rephrasing.
+            bot_client (BotClient): The bot client instance.
+
+        Returns:
+            dict: The rephrased query.
+        """
+        query = QUERY_REWRITE_PROMPT.format(query=query)
+        conversation = [{"role": "user", "content": query}]
+        req_data = {"messages": conversation}
+        try:
+            response = bot_client.process(model_name, req_data)
+            search_info_res = response["choices"][0]["message"]["content"]
+            start = search_info_res.find("{")
+            end = search_info_res.rfind("}") + 1
+            if start >= 0 and end > start:
+                search_info_res = search_info_res[start:end]
+            search_info_res = json.loads(search_info_res)
+            if search_info_res.get("sub_query_list", []):
+                unique_list = list(set(search_info_res["sub_query_list"]))
+                search_info_res["sub_query_list"] = unique_list
+            return search_info_res
+        except Exception:
+            raise gr.Error("Error: Model output is not a valid JSON")
+
+    @staticmethod
+    def split_oversized_line(line: str, chunk_size: int) -> tuple:
+        """
+        Split a line into two parts based on punctuation marks or whitespace while preserving
+        natural language boundaries and maintaining the original content structure.
+
+        Args:
+            line (str): The line to split.
+            chunk_size (int): The maximum length of each chunk.
+
+        Returns:
+            tuple: Two strings, the first part of the original line and the rest of the line.
+        """
+        PUNCTUATIONS = [".", "。", "!", "！", "?", "？", ",", "，", ";", "；", ":", "："]
+
+        if len(line) <= chunk_size:
+            return line, ""
+        
+        # Search from chunk_size position backwards
+        split_pos = chunk_size
+        for i in range(chunk_size, 0, -1):
+            if line[i] in PUNCTUATIONS:
+                split_pos = i + 1  # Include punctuation
+                break
+        
+        # Fallback to whitespace if no punctuation found
+        if split_pos == chunk_size:
+            split_pos = line.rfind(" ", 0, chunk_size)
+            if split_pos == -1:
+                split_pos = chunk_size  # Hard split
+        
+        return line[:split_pos], line[split_pos:]
+
+    @staticmethod
+    def split_text_into_chunks(text: str, chunk_size: int) -> list:
+        """
+        Split text into chunks of a specified size while respecting natural language boundaries
+        and avoiding mid-word splits whenever possible.
+
+        Args:
+            text (str): The text to split.
+            chunk_size (int): The maximum length of each chunk.
+
+        Returns:
+            list: A list of strings, where each element represents a chunk of the original text.
+        """
+        lines = [line.strip() for line in text.split('\n') if line.strip()]
+        chunks = []
+        current_chunk = []
+        current_length = 0
+        
+        for line in lines:
+            
+            # If adding this line would exceed chunk size (and we have content)
+            if current_length + len(line) > chunk_size and current_chunk:
+                chunks.append(" ".join(current_chunk))
+                current_chunk = []
+                current_length = 0
+
+            # Process oversized lines first
+            while len(line) > chunk_size:
+                head, line = GradioEvents.split_oversized_line(line, chunk_size)
+                chunks.append(head)
+            
+            # Add remaining line content
+            if line:
+                current_chunk.append(line)
+                current_length += len(line) + 1
+        
+        if current_chunk:
+            chunks.append(" ".join(current_chunk))
+        return chunks
+
+    @staticmethod
+    def file_upload(
+        files_url: list, 
+        chunk_size: int, 
+        faiss_db: FaissTextDatabase, 
+        progress_bar: gr.Progress = gr.Progress()
+    ) -> str:
+        """
+        Uploads and processes multiple files by splitting them into semantically meaningful chunks,
+        then indexes them in the FAISS database with progress tracking.
+
+        Args:
+            files_url (list): List of file URLs.
+            chunk_size (int): Maximum chunk size.
+            faiss_db (FaissTextDatabase): FAISS database instance.
+            progress_bar (gr.Progress): Progress bar instance.
+
+        Returns:
+            str: Message indicating successful completion.
+        """
+        if not files_url:
+            return
+        yield gr.update(visible=True)
+        for file_url in files_url:
+            if not GradioEvents.save_file_to_db(file_url, chunk_size, faiss_db, progress_bar):
+                file_name = os.path.basename(file_url)
+                gr.Info("{} already processed.".format(file_name))
+
+        yield gr.update(visible=False)
+
+    @staticmethod
+    def save_file_to_db(file_url: str, chunk_size: int, faiss_db: FaissTextDatabase, progress_bar: gr.Progress=None):
+        """
+        Processes and indexes document content into FAISS database with semantic-aware chunking.
+        Handles file validation, text segmentation, embedding generation and storage operations.
+
+        Args:
+            file_url (str): File URL.
+            chunk_size (int): Chunk size.
+            faiss_db (FaissTextDatabase): FAISS database instance.
+            progress_bar (gr.Progress): Progress bar instance.
+
+        Returns:
+            bool: True if the file was saved successfully, otherwise False.
+        """
+        file_name = os.path.basename(file_url)
+        if not faiss_db.is_file_processed(file_url):
+            logging.info("{} not processed yet, processing now...".format(file_url))
+            try:
+                with open(file_url, "r", encoding="utf-8") as f:
+                    text = f.read()
+                segments = GradioEvents.split_text_into_chunks(text, chunk_size)
+                faiss_db.add_embeddings(file_url, segments, progress_bar)
+
+                logging.info("{} processed successfully.".format(file_url))
+                return True
+            except Exception as e:
+                logging.error("Error processing {}: {}".format(file_url, str(e)))
+                gr.Error("Error processing file: {}".format(file_name))
+                raise
+        else:
+            logging.info("{} already processed.".format(file_url))          
+            return False
+
+
+def launch_demo(args: argparse.Namespace, bot_client: BotClient, faiss_db: FaissTextDatabase):
+    """
+    Launch demo program
+    
+    Args:
+        args (argparse.Namespace): argparse Namespace object containing parsed command line arguments
+        bot_client (BotClient): Bot client instance
+        faiss_db (FaissTextDatabase): FAISS database 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;
+    }
+    """
+    with gr.Blocks(css=css) as demo:
+        model_name = gr.State("eb-45t")
+
+        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", 
+            type="messages"
+        )
+
+        with gr.Row(equal_height=True):
+            file_btn = gr.File(
+                label="Knowledge Base Upload (System default will be used if none provided. Accepted formats: TXT, MD)", 
+                height="150px", 
+                file_types=[".txt", ".md"],
+                elem_id="file-upload",
+                file_count="multiple"
+            )
+            relevant_passage = gr.Textbox(
+                label="Relevant Passage",
+                lines=5,
+                max_lines=5,
+                placeholder=RELEVANT_PASSAGE_DEFAULT,
+                interactive=False
+            )
+        with gr.Row():
+            progress_bar = gr.Textbox(label="Progress", visible=False)
+
+        query = gr.Textbox(label="Query", elem_id="text_input", value=QUERY_DEFAULT)
+
+        with gr.Row():
+            empty_btn = gr.Button("🧹 Clear History(清除历史)")
+            submit_btn = gr.Button("🚀 Submit(发送)", elem_id="submit-button")
+            regen_btn = gr.Button("🤔️ Regenerate(重试)")
+        
+        task_history = gr.State([])
+        
+        predict_with_clients = partial(
+            GradioEvents.predict_stream,
+            bot_client=bot_client,
+            faiss_db=faiss_db
+        )
+        regenerate_with_clients = partial(
+            GradioEvents.regenerate,
+            bot_client=bot_client,
+            faiss_db=faiss_db
+        )
+        file_upload_with_clients = partial(
+            GradioEvents.file_upload,
+            faiss_db=faiss_db
+        )
+        
+        chunk_size = gr.State(args.chunk_size)
+        file_btn.change(
+            fn=file_upload_with_clients,
+            inputs=[file_btn, chunk_size],
+            outputs=[progress_bar],
+        )
+        query.submit(
+            predict_with_clients, 
+            inputs=[query, chatbot, task_history, model_name], 
+            outputs=[chatbot, relevant_passage],
+            show_progress=True
+        )
+        query.submit(GradioEvents.reset_user_input, [], [query])
+        submit_btn.click(
+            predict_with_clients, 
+            inputs=[query, chatbot, task_history, model_name],
+            outputs=[chatbot, relevant_passage],
+            show_progress=True,
+        )
+        submit_btn.click(GradioEvents.reset_user_input, [], [query])
+        empty_btn.click(
+            GradioEvents.reset_state,
+            outputs=[chatbot, task_history, file_btn, relevant_passage], show_progress=True
+        )
+        regen_btn.click(
+            regenerate_with_clients, 
+            inputs=[chatbot, task_history, model_name],
+            outputs=[chatbot, relevant_passage],
+            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)
+    faiss_db = FaissTextDatabase(args, bot_client)
+
+    # Run file upload function to save default knowledge base.
+    GradioEvents.save_file_to_db(FILE_URL_DEFAULT, args.chunk_size, faiss_db)
+
+    launch_demo(args, bot_client, faiss_db)
+
+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-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-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

data/coffee.txt

@@ -0,0 +1,63 @@
+咖啡（英语：coffee）是指咖啡植物的种子即咖啡豆在经过烘焙磨粉后通过冲泡制成的饮料，是世界上流行范围最为广泛的饮料之一。咖啡在人类饮食中一般为日常的饮品，人们通常会为了提振精神，或在用餐和社交、阅读时饮用。咖啡原产于非洲东岸的埃塞俄比亚，咖啡起源于15-16世纪，从也门被传播至穆斯林世界，16世纪的威尼斯商人将咖啡引入意大利，随后17-18世纪由于欧洲对咖啡的需求，促使殖民者将咖啡树传播并栽种到美洲、东南亚和印度等热带地区，现今有超过70个国家种植咖啡树。未经烘焙的 咖啡生豆作为世界上最大的出口农产品，以及世界上交易量为广泛的热带农产品之一，也是发展中国家出口中最有价值的商品之一。采收的成熟咖啡果会经过剥离果肉的初步加工，再经过烘焙的工序，而成为能制作咖啡的咖啡豆。透过不同的冲泡方式与成分比例，咖啡有浓缩咖啡、卡布奇诺和拿铁咖啡等变化。咖啡豆的品种可大致分为两种：最为普遍的小果咖啡（阿拉比卡），以及颗粒较粗且酸味较低而苦味较浓的中果咖啡（罗布斯塔）。一些争议指咖啡的种植与它环境影响有关，例如肯亚咖啡豆在移植种植后失去了独有的肯亚酸，而肯亚的原种地土壤含有较高浓度的磷酸。因此，公平贸易咖啡与有机咖啡是一个不断扩大的市场。
+
+传说9世纪的埃塞俄比亚的牧羊人发现并咀嚼了咖啡果实，随后将咖啡果实带给了附近修道院的僧侣，但僧侣起初不愿食用果实，并把果实扔进火里，经过火烤的咖啡果中冒出香气引来僧侣前来查看，僧侣从余烬中捞出咖啡豆，并将其磨碎溶解在热水中，这才制成了世界上第一杯咖啡。但此故事截至1671年并没有得到任何记载，因此可能是杜撰的。亦有研究认为最初栽培的咖啡源自埃塞俄比亚的哈勒尔。埃塞俄比亚的阿克苏姆王国兴盛时曾一度占据也门南部，6世纪中期，萨珊帝国攻占也门后将阿克苏姆赶出南阿拉伯半岛，可以肯定的是咖啡是从埃塞俄比亚传播到也门的。
+
+咖啡传播到穆斯林世界后伊斯兰医学认可了咖啡的好处，认为其可以提振精神并防止酒和大麻对穆斯林的诱惑，15世纪的也门苏菲派修道院在祈祷时使用咖啡来帮助集中注意力。 16世纪初咖啡从也门的摩卡港传播到埃及，随后咖啡馆还出现在叙利亚阿勒颇，并于1554年在奥斯曼帝国首都伊斯坦布尔开业。1511年，由于也门麦加的宗教领袖认为咖啡具有刺激作用，便开始禁止穆斯林饮用咖啡，造成其余阿拉伯世界的苏丹和宗教领袖也相继效仿；其中两位奥斯曼帝国苏丹更是同样出于政治考量，而在1517年和1623年两度禁止咖啡。
+
+同样在16世纪，与阿拉伯世界的贸易令威尼斯获得了包括咖啡在内的非洲商品，威尼斯商人则向威尼斯的上流阶级高价推销咖啡。起初意大利的宗教人士对咖啡这种穆斯林饮料持怀疑态度，并称咖啡为“撒旦的苦涩发明（bitter invention of Satan）”或是“阿拉伯酒（wine of Araby）”，1600年，教宗克莱孟八世对咖啡的争议作出裁决，在教宗品尝咖啡后认为可以饮用，并祝福了咖啡。 1616年，荷兰商人彼得·范登布罗克从也门摩卡获得了一些阿拉比卡咖啡树苗并带回了阿姆斯特丹，还在当地植物园种植成功。1658年，荷兰人首先在其殖民地锡兰和印度南部开始种植咖啡，但出于避免供应过剩而降低价格的考量，最终放弃了在锡兰种植，专注于爪哇和苏里南的种植园。
+
+1675年时，英格兰就有3000多家咖啡馆；启蒙运动时期，咖啡馆成为民众深入讨论宗教和政治的聚集地，1670年代的英国国王查理二世就曾试图取缔咖啡馆。这一时期的英国人认为咖啡具有药用价值，甚至名医也会推荐将咖啡用于医疗。
+
+1773年，波士顿倾茶事件后约翰·亚当斯和许多美国人认为喝茶是不爱国的，令大量美国人在美国独立战争期间改喝咖啡。
+
+18世纪，葡萄牙人首先在巴西里约热内卢附近，后来则是圣保罗种植咖啡并建设种植园。1852-1950年，巴西主导了世界咖啡生产，其出口的咖啡比世界其他地区的总和还多。1950年以来，由于哥伦比亚和越南等主要生产国相继出现，而越南在1999年超过哥伦比亚成为世界第二大咖啡生产国，并在2011年达到15%的市场份额，而同年巴西的市场份额仅占33%。
+
+在咖啡的原产地埃塞俄比亚，18世纪前咖啡曾被埃塞俄比亚正教会所禁止，直至19世纪后期叶埃塞俄比亚皇帝孟尼利克二世的统治时期才有所开放。
+
+咖啡在19世纪中已经引入中国上海，1843年—44年上海对外贸易文献就有记载“枷榧豆5��，每包70斤”，表明当时上海已经从外国进口咖啡豆。
+
+香港英文报章在1866年刊登关于coffee shop的报导。1885年香港中文报章以“咖啡”为中文名，此后逐渐成为华语地区普及使用的中文译名。香港在1840年代起有英国人聚居，由于饮食文化的差异，最初被输入到香港的咖啡豆是主要供应西方人饮用，而一般本地华人则不喜欢咖啡苦涩的味道，在早年的香港常有大量从事搬运工作的苦力在码头聚集，为来港的货轮搬运货物，从事体力劳动的苦力比一般华人更容易接触到刚循海路进口的咖啡豆，所以在华人社会中最早有饮用咖啡习惯的群体，却是社会地位低下的码头搬运工。
+
+不同地区和民族之间的口味偏好，令咖啡冲泡方式以及调味品的使用多种多样，通常热咖啡添加砂糖、牛奶、奶油、奶精等调味，冷饮咖啡则有更多选择，如酒、薄荷、丁香、柠檬汁等。而不同冲泡和调味方式亦产生出了许多咖啡品类：
+
+土耳其咖啡：是种具有古老历史的咖啡饮品和冲泡方式，而土耳其以外的中东国家以及东南欧皆有流行过此种冲泡方式。土耳其咖啡冲泡好后未经过滤即可直接饮用，土耳其传统上会将土耳其咖啡倒入小瓷杯中慢慢啜饮，而处于悬浊状的咖啡残留有少量咖啡渣亦成为土耳其咖啡独特风味与口感的来源。冲泡土耳其咖啡的方法为将咖啡豆研磨成粉末后装入土耳其壶中，倒入热水并与咖啡末搅拌均匀，再加人豆蔻粉充分搅拌，对土耳其壶加热并充分搅拌。咖啡煮至冒泡后停止加热，待泡沫消失，此时可短暂重复加热2次；或是将三分之一的咖啡先倒入到各个杯子中，壶中剩余的咖啡则再度加热，直到沸腾后倒入之前的杯子里。
+
+浓缩咖啡：是一种通过迫使接近沸腾的高压水流通过咖啡末制作而成的咖啡，拿铁咖啡和卡布奇诺、玛琪雅朵等皆是以浓缩咖啡为基本制成的。
+
+拿铁咖啡：拿铁咖啡是由浓缩咖啡和热牛奶以1:2的比例冲泡，并加入些许奶泡制成的。也可依需求加上两份浓缩咖啡，意大利语称之为“Double”。
+
+卡布奇诺：卡布奇诺是一种意大利咖啡，是由在浓缩咖啡上倒入奶泡制成，由于咖啡的颜色就像方济嘉布遣会修士深褐色外衣上覆的头巾一样，卡布奇诺也因此得名。其与拿铁咖啡类似，区别仅是卡布奇诺在咖啡、牛奶、奶泡的比例为1:1:1。卡布奇诺咖啡奶泡多，而拿铁咖啡的奶泡少。口味上卡布奇诺咖啡的咖啡味重，而拿铁较为清淡一些，这是因为拿铁的牛奶更多。
+
+摩卡咖啡：通常是由三分之一的意式浓缩咖啡和三分之二的奶泡配成，并加入少量巧克力糖浆或速溶巧克力粉。拉夫咖啡是在单杯浓缩咖啡中添加带有少量泡沫（0.5 厘米）的奶油而制成的咖啡。通常与香草糖一起喝用但通常使用糖浆代替香草糖。
+
+玛琪雅朵咖啡：在冲泡好的浓缩咖啡上加入鲜奶并倒入一层较薄的奶泡的意大利咖啡。
+
+焦糖玛琪雅朵：是一种在浓缩咖啡加入热牛奶和香草，最后淋上焦糖制成的玛琪雅朵咖啡。
+
+欧蕾咖啡：是一种咖啡和牛奶的比例为1:1的牛奶咖啡，在冲泡时，需要牛奶壶和咖啡壶从两旁同时注入到咖啡杯。在星巴克则被称为Caffè Misto，以1:1比例的法式压滤咖啡搭配奶泡而成。
+
+美式咖啡：是一种浓缩咖啡以1:5比例加入热水稀释制成的咖啡饮料。冲泡美式咖啡亦可使用意式咖啡机萃取浓缩咖啡，而在咖啡萃取完成后，继续使用咖啡机向浓缩咖啡加入热水稀释到合适比例即可。其浓度随浓缩咖啡的冲泡次数和添加的水量而变化，美式咖啡具有浓缩咖啡风味但却更为柔和。
+
+长黑咖啡：是澳大利亚和新西兰常见的一种咖啡，是将双份浓缩咖啡倒入热水中制成的，其恰好与美式咖啡截然相反。长黑咖啡通常使用约100–120毫升的水，但水量可根据个人口味灵活调整。
+
+维也纳咖啡：其制作方式为将糖或粗砂糖放入杯内再倒入热咖啡，杯上挤入鲜奶油以及巧克力膏，最终撒上彩色糖粒装饰即可。此种制法可追溯至1683年，当时乌克兰裔波兰军官耶日·弗朗西泽克·库奇茨基开设了奥地利首家咖啡馆并在维也纳开业，其普及了在咖啡中加糖和牛奶的制作和饮用方式。而维也纳咖啡传说是由奥地利马车夫爱因·舒伯纳发明。
+
+爱尔兰咖啡：在咖啡中加入威士忌后在其顶部放上奶油。而加入威士忌的爱尔兰咖啡能将咖啡的酸甜味衬托出来。
+
+调味咖啡：依据口味的不同在咖啡中加入巧克力、糖浆、果汁、肉桂、肉豆蔻、橘子花等不同调味料。
+
+康宝蓝：康宝蓝是一种在意大利浓缩咖啡上倒入适量奶油的咖啡，并用玻璃咖啡杯盛装，由于鲜奶油具有甜味因此通常无需加糖。
+
+白咖啡：起源于马来西亚怡保，其使用经过人造黄油烘培的咖啡豆，冲泡好后加入甜炼乳的饮品。19世纪和20世纪初英国锡矿公司在怡保设立锡矿，而中国移民则在怡保锡矿工作，白咖啡是19世纪中后期移民马来亚的海南人出于华人不习惯咖啡味道而发明。从本质上是一种拿铁咖啡。在美国，白咖啡也指轻度烘培的咖啡豆，使用意式冲煮，具有较强酸味的咖啡。
+
+越南咖啡：是一种滴漏咖啡，冲泡时先在盛装咖啡的杯子中倒入炼乳，将滴漏壶置于盛装的杯上，并向滴漏壶加入咖啡末，再以压板压住咖啡末，倒入热水后等待滴漏。越南常用的咖啡豆品种为罗布斯塔，因其带有较重的酸味与苦味以及烘焙时间较长，使得风味较重，因此需要加入炼乳饮用。
+
+印度滴漏咖啡：其通常是阿拉比卡咖啡或咖啡公豆制作的；咖啡豆经过深度烘焙、研磨并与菊苣混合，咖啡占混合物的80-90%，其余的为菊苣。菊苣的轻微苦味有助于产生印度滴漏咖啡的风味，传统上使用粗糖或蜂蜜作为甜味剂，但自1900年代中期改为白糖。
+
+皇家咖啡：据说拿破仑在俄法战争时，因遭遇俄国酷寒的冬天，于是命令下属在咖啡里倒入白兰地取暖而发明。其制作方式为，在预热好的咖啡杯中倒入热咖啡，将咖啡匙架在杯缘上，在咖啡匙上放置方糖后淋上白兰地并点火燃烧，火焰熄灭后将咖啡匙放入咖啡搅拌至方糖溶解即可饮用。
+
+黑咖啡：是使用滴滤法、渗滤法、虹吸法或加法冲泡的咖啡，在饮用时不添加牛奶、糖等调味品。速溶咖啡是不属于黑咖啡的范围的。
+
+希腊法拉沛咖啡：通常由速溶咖啡、糖和牛奶制成的冰咖啡，咖啡中也会倒入奶泡；其口感微甜凉爽，适宜在夏季饮用。
+
+阿芙佳朵：是种近乎甜点的冰咖啡，由冰淇淋上加入意大利浓缩咖啡制成。会加入焦糖来增加甜味和促进口感，或加入巧克力酱、可可粉、肉桂粉等。

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