Add application file

.env

@@ -0,0 +1,3 @@
+IFLYTEK_SPARK_APP_ID=dc6765b2
+IFLYTEK_SPARK_API_SECRET=YWQ4NWUyYWI3NTdjZTMwNjY4YzJjMGJm
+IFLYTEK_SPARK_API_KEY=81232c7c38284a9e1d4e86026ca69739

README.md

@@ -1,8 +1,8 @@
 ---
 title: My Rag App
-emoji: 📈
+emoji: 💻
 colorFrom: yellow
-colorTo: blue
+colorTo: purple
 sdk: gradio
 sdk_version: 5.43.1
 app_file: app.py

app.py

@@ -0,0 +1,59 @@
+import gradio as gr
+from utils import user_asks
+
+# Gradio 界面设置
+with gr.Blocks(title="五险一金规划助手", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("## 🧑‍🏫应届生的第一个五险一金社保规划师")
+
+    with gr.Row():
+        with gr.Column(scale=2):
+            chatbot = gr.Chatbot(label="对话框", type="messages")
+            user_input = gr.Textbox(label="请输入你的问题", placeholder="如：我现在即将入职私企算法工程师岗位，想知道试用期公司会给我交社保和公积金吗？", lines=3)
+            # 按钮可保留，但不需要 click 事件
+            send_button = gr.Button("发送")
+            # stop_button = gr.Button("⬛停止生成", variant="stop")
+
+        # with gr.Column(scale=1):
+        #     gr.Markdown("#### 你的意图")
+        #     user_intent = gr.Radio(["简单科普", "急需帮助", "帮我避坑"], label="当前意图", value="简单科普")
+
+        with gr.Column(scale=1):
+            gr.Markdown("#### 你的基本信息")
+            situation = gr.Dropdown(["正在求职", "即将入职", "还在上学", "实习中", "准备升学", "其他"], label="目前状态", value="即将入职")
+            job_input = gr.Textbox(label="你的工作/岗位", placeholder="如：程序员、教师、自由职业者等")
+            city = gr.Textbox(label="所在城市", placeholder="如：北京、上海")
+            age = gr.Textbox(label="年龄", value="25")
+            user_goal = gr.Textbox(label="你未来的计划是什么？", placeholder="如：我目前打算先工作，未来可能跳槽。", lines=3)
+            other_info = gr.Textbox(label="其他补充信息（可选）")
+            
+            
+    # 设置输入框和按钮
+    click_event = user_input.submit(
+        fn=user_asks,
+        inputs=[user_input, chatbot, user_goal, job_input, situation, 
+                city, age, other_info],
+        outputs=[chatbot, user_input], # user_input 清空输入框
+        queue=True # 启用队列，处理快速输入
+    )
+
+    # 设置发送按钮
+    submit_event = send_button.click(
+        fn=user_asks,
+        inputs=[user_input, chatbot, user_goal, job_input, situation,
+                city,  age, other_info],
+        outputs=[chatbot, user_input],
+        queue=True
+    )
+
+    # 设置取消按钮
+    # stop_button.click(
+    #     fn=None,
+    #     inputs=None,
+    #     outputs=None,
+    #     cancels=[submit_event, click_event],
+    #     queue=False
+    # )
+
+# 运行 Gradio 应用
+demo.launch(share=True)
+

conversation_manager.py

@@ -0,0 +1,170 @@
+import os
+import contextlib
+from typing import Optional, Dict, List
+from langchain_core.runnables.config import RunnableConfig
+from langchain.memory import ConversationBufferMemory
+from langchain.schema import HumanMessage
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+from langchain.retrievers import MultiQueryRetriever
+from rag_chain import build_user_info, build_qa_chain, rerank
+from get_client import get_client
+from langchain.callbacks.base import BaseCallbackHandler
+
+class SilentMultiQueryRetriever(MultiQueryRetriever):
+    def invoke(self, input: str, config: Optional[RunnableConfig] = None, **kwargs):
+        # 静默执行多查询生成，不输出任何内容
+        with disable_stdout():
+            return super().invoke(input, config, **kwargs)
+@contextlib.contextmanager
+def disable_stdout():
+    with open(os.devnull, "w") as f:
+        old_stdout = os.dup(1)
+        os.dup2(f.fileno(), 1)
+        try:
+            yield
+        finally:
+            os.dup2(old_stdout, 1)
+            
+class StreamingHandler(BaseCallbackHandler):
+    def __init__(self):
+        self.tokens = []
+
+    def on_llm_new_token(self, token: str, **kwargs):
+        self.tokens.append(token)
+
+    def get_response(self):
+        return "".join(self.tokens)
+
+class PlannerAgent:
+    def __init__(self, retriever):
+        self.llm = get_client()
+        self.retriever = retriever
+        self.multi_retriever = SilentMultiQueryRetriever.from_llm(
+                            retriever=self.retriever,
+                            llm=self.llm)
+        self.memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)
+        self.tokenizer = AutoTokenizer.from_pretrained("BAAI/bge-reranker-base")
+        self.model = AutoModelForSequenceClassification.from_pretrained("BAAI/bge-reranker-base")
+        # self._should_stop = True # 新增：中断标志
+        # print("PlannerAgent initialized.")
+
+    # def stop_generation(self):
+    #     """设置中断标志，用于停止 stream_reply 的生成"""
+    #     self._should_stop = True
+    #     print("PlannerAgent: 设置中断标志为 True")
+
+    # def reset_stop_flag(self):
+    #     """重置中断标志，以便下次生成能够正常开始"""
+    #     self._should_stop = False
+    #     print("PlannerAgent: 重置中断标志为 False")
+
+    def get_history(self) -> List[Dict[str, str]]:
+        result = []
+        for msg in self.memory.chat_memory.messages:
+            role = "user" if isinstance(msg, HumanMessage) else "assistant"
+            result.append({"role": role, "content": msg.content})
+        return result
+
+    def reply(self, user_question: str, user_info_dict: Dict) -> str:
+        qa_chain, _ = build_qa_chain(self.llm, 
+                self.multi_retriever, 
+                self.tokenizer,
+                self.model)
+
+        user_info_text = build_user_info(user_info_dict)
+        docs = self.retriever.get_relevant_documents(user_question)
+        reranked_docs = rerank(self.tokenizer, self.model, user_question, docs, 5)
+        context = "\n".join([doc.page_content for doc in reranked_docs])
+
+        self.memory.chat_memory.add_user_message(user_question)
+        response = qa_chain.invoke({
+            "user_info": user_info_text,
+            "context": context
+        })
+        self.memory.chat_memory.add_ai_message(response)
+        return response
+
+    def stream_reply(self, user_question: str, user_info_dict: Dict) -> str:
+        # print(f"\n--- Entering stream_reply ---")
+        # print(f"Message received by agent: {user_question}")
+        # print(f"User info received by agent: {user_info_dict}")
+        # self.reset_stop_flag()
+
+        qa_chain, _ = build_qa_chain(llm=self.llm,
+                                    multi_retriever=self.multi_retriever, 
+                                    model=self.model, 
+                                    tokenizer=self.tokenizer)
+
+        user_info_text = build_user_info(user_info_dict)
+        current_chat_history = self.memory.buffer_as_messages
+
+        full_response_content = "" # 用于累积完整响应以便存入 memory
+
+        # 使用 qa_chain.stream() 进行流式处理
+        try:
+            for chunk in qa_chain.stream(
+                {
+                    "chat_history": current_chat_history,
+                    "user_info": user_info_text,
+                    "question": user_question
+                }
+            ):
+                if isinstance(chunk, str):
+                    content_to_yield = chunk
+                elif hasattr(chunk, 'content') and isinstance(chunk.content, str):
+                    content_to_yield = chunk.content
+                else:
+                    continue
+
+                if content_to_yield:
+                    full_response_content += content_to_yield
+                    yield content_to_yield # 每次 yield 实时生成的令牌或小块
+
+                # 只有在没有被中断的情况下才将完整响应添加到内存
+            self.memory.save_context({"question": user_question}, {"answer": full_response_content})
+            print(f"--- 响应已保存到内存: {full_response_content[:50]}... ---")
+
+        except KeyboardInterrupt:
+            print("PlannerAgent: 捕获到 KeyboardInterrupt，停止生成且不保存到内存。")
+            pass 
+        except Exception as e:
+            print(f"错误：流式处理过程中发生异常：{e}")
+            yield f"发生错误：{e}"
+            print("--- 发生错误，不保存到内存。 ---")
+
+        self.memory.chat_memory.add_user_message(user_question)
+        self.memory.chat_memory.add_ai_message(full_response_content)
+
+
+if __name__ == "__main__":
+    from get_client import *
+    from retriever_builder import process_pdfs_to_chunks, save_embeddings
+
+    pdf_paths = "/teamspace/studios/this_studio/pdf_files"
+    all_chunks = process_pdfs_to_chunks(pdf_paths)
+    vectordb = save_embeddings(all_chunks)
+    retriever = vectordb.as_retriever(search_kwargs={"k": 4})
+    tokenizer = AutoTokenizer.from_pretrained("BAAI/bge-reranker-base")
+    model = AutoModelForSequenceClassification.from_pretrained("BAAI/bge-reranker-base")
+    
+    rag_chain, memory = build_qa_chain(
+        llm=get_client(),
+        multi_retriever=retriever,
+        model=model,
+        tokenizer=tokenizer
+    )
+
+    test_user_info = {
+        "job_info": "软件工程师",
+        "situation": "已入职试用期",
+        "city": "上海",
+        "age": 26,
+    }
+    test_question = "试用期公司会给我交社保和公积金吗？"
+    agent = PlannerAgent(retriever=retriever)
+
+    # 流式输出测试（如果启用流式 Spark 回调）
+    print("\n流式输出测试：")
+    for chunk in agent.stream_reply(test_question, test_user_info):
+        # print(chunk, end="", flush=True)
+        pass

get_client.py

@@ -0,0 +1,42 @@
+import os
+from dotenv import find_dotenv, load_dotenv
+from typing import Optional, Any
+from langchain_community.chat_models import ChatSparkLLM
+from langchain.callbacks.base import BaseCallbackHandler
+
+load_dotenv(find_dotenv())
+
+class ChunkPrintHandler(BaseCallbackHandler):
+    def on_llm_new_token(self, token: str, *, chunk: Optional[Any] = None, **kwargs: Any):
+        print(token, end="", flush=True)
+        debug = False
+        if debug:
+            print("\n", kwargs)
+
+def get_client():
+    app_id = os.getenv("IFLYTEK_SPARK_APP_ID")
+    api_key = os.getenv("IFLYTEK_SPARK_API_KEY")
+    api_secret = os.getenv("IFLYTEK_SPARK_API_SECRET")
+
+    if not all([app_id, api_key, api_secret]):
+        raise ValueError("请确保环境变量已设置。")
+
+    llm = ChatSparkLLM(
+            model='Spark4.0 Ultra',
+            app_id=app_id,
+            api_key=api_key,
+            api_secret=api_secret,
+            spark_api_url="wss://spark-api.xf-yun.com/v4.0/chat",
+            spark_llm_domain="4.0Ultra",
+            streaming=True,
+            callbacks=[ChunkPrintHandler()]
+        )
+    
+    return llm
+
+if __name__ == "__main__":
+    client = get_client()
+    print("Client initialized successfully.")
+    # 测试模型
+    response = client.invoke("你好，介绍一下你自己。")
+    print("\nResponse:", response)

pdf_files.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:03ec065bb7dd6500e7be3226ca160664039ede192958405ff653c0c05cb8d750
+size 44264675

rag_chain.py

@@ -0,0 +1,174 @@
+import torch
+from langchain_core.runnables import RunnablePassthrough, RunnableParallel, RunnableMap
+from langchain.memory import ConversationBufferMemory
+from langchain.chains import RetrievalQA
+from langchain_core.output_parsers import StrOutputParser
+from langchain.prompts import ChatPromptTemplate
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+
+
+def rerank(tokenizer, model, query, docs, top_k=5):
+    pairs = [(query, doc.page_content) for doc in docs]
+    inputs = tokenizer([f"{q} [SEP] {d}" for q, d in pairs], return_tensors='pt', padding=True, truncation=True)
+    scores = model(**inputs).logits.view(-1)
+    scored_docs = list(zip(scores, docs))
+    sorted_scored_docs = sorted(scored_docs, key=lambda item: item[0], reverse=True)
+    # ranked_docs = [doc for _, doc in sorted(zip(scores, docs), reverse=True)]
+    ranked_docs = [doc for score, doc in sorted_scored_docs]
+    return ranked_docs[:top_k]
+
+# 获取用户信息
+def build_user_info(user_info: dict) -> str:
+    user_text = "用户相关信息如下："
+
+    if user_info.get("goal", "未知"):
+        user_text += f"\n未来计划：{user_info['goal']}"
+    if user_info.get("job_info", "未知"):
+        user_text += f"\n从事工作：{user_info['job_info']}"
+    if user_info.get("job_type", "未知"):
+        user_text += f"\n工作类型：{user_info['job_type']}"
+    if user_info.get("age", "未知"):
+        user_text += f"\n年龄：{user_info['age']}"
+    if user_info.get("situation", "未知"):
+        user_text += f"\n目前状态：{user_info['situation']}"
+    if user_info.get("city", "未知"):
+        user_text += f"\n所在城市：{user_info['city']}"
+    if user_info.get("other_info", "无"):
+        user_text += f"\n其他补充信息：{user_info['other_info']}"
+
+    return user_text
+
+# 构建支持流式输出的 stuff QA chain
+def build_qa_chain(llm, multi_retriever, model, tokenizer):
+    prompt = ChatPromptTemplate.from_messages([
+        ("system", 
+        """
+        你是一个专业的、富有同理心的“应届生社保规划小助手”。
+        你的核心任务是为即将或刚刚踏入社会的中国大学应届毕业生提供清晰、易懂、可执行的“五险一金”规划和建议。
+        你的回答必须始终围绕应届毕业生的视角、需求和痛点展开,将“帮助新人顺利了解、入门、避免踩坑”作为你的第一原则
+        请牢记以下内容：
+        - 你的沟通对象是对社保和公积金几乎一无所知的“小白”，比起冗长的政策细节，他们更关心哪些因素会影响到自己的未来之路。。  
+        - 回答要围绕“帮助新人顺利了解、入门、避免踩坑”，以安心和实用为首要目标。  
+        - 必须保证回答直接、准确，不要回避用户问题。  
+        
+        【多轮对话规则】  
+        1. 如果这是**第一次提问**，可以进行简短的入门科普（“是什么”“有什么用”）。  
+        2. 如果用户是**多轮追问**，请避免重复基础科普内容，直接进入个性化回答，围绕新问题展开。  
+        3. 在多轮提问时，回答要紧扣用户新的关注点，并在需要时结合之前提供过的信息进行延伸，而不是重复。  
+        4. 如果用户的问题只是闲聊或模糊（如“你好”），请不要执行规划步骤，而是礼貌介绍自己，并引导用户提出与社保相关的具体问题。  
+        """),
+        ("placeholder", "{chat_history}"),
+        ("human", 
+        "用户信息（包含了用户的工作、现状、城市和年龄等）：\n{user_info}\n\n"
+        "相关政策资料：\n{context}\n\n"
+        "我的问题是：'{question}'\n\n"
+     
+        "请严格按照以下步骤，为我提供一份专属的社保规划建议：\n\n"
+     
+        "**首先：关于你的问题（必须优先）**\n"
+        "- 先用清晰、简洁的语言直接回答用户问题。"
+        "- 如果有明确的结论，就直说，不要绕。"
+        "- 如果资料不足，要说明限制，并给出下一步可行的方向。\n\n"
+        
+        "**（仅限首次提问时）简明入门科普**\n"
+        "- 在第一次提问时，可以补充简短的背景知识，让用户理解“五险一金是什么、有什么用”。"  
+        "- 在后续多轮追问时，省略科普，只聚焦新问题。\n\n"  
+        
+        "**个性化规划与预测**\n"
+        "- 根据用户的个人信息和相关政策，提供操作指南：用户需要做什么、准备哪些材料、可能遇到什么情况。"  
+        "- 回答要明确到步骤和要点。\n\n"  
+        
+        "**避坑提醒（重点）**\n"
+        "- 主动提示用户在当前情境下可能遇到的常见陷阱，并说明危害 + 对策。" 
+        "- 避坑要简洁醒目，不要过度展开和重复。\n\n"
+        
+        "**特殊情况处理**\n"
+        "- 如果问题涉及实习期、试用期、空窗期、自由职业、考研/考公，请额外提供换位思考后的建议。\n\n"
+
+        "--- 回答要求 ---\n"
+        "- **同理心与易懂性：** 语言必须平和、友好，充满鼓励，让刚毕业的大学生感到安心。\n"
+        "- **结构化：** 使用清晰的标题和项目符号，让内容一目了然。\n"
+        "- **准确性：** 严格基于提供的“相关政策资料”作答，若资料不足，可以联网搜索，但请诚实说明，并提供信息来源。\n"
+        "- **去冗余: ** 请确保回答内容简洁明了，避免重复相同的信息。如果多个文档包含相似内容，请整合这些信息，不要重复表述。\n"
+        "- **特殊情况处理：** 如果我的问题只是闲聊或不明确（例如“你好”），请不要执行以上规划步骤，而是礼貌地介绍你自己（应届生社保规划小助手），并引导我提出与社保规划相关的具体问题。\n"
+        )
+    ])
+
+
+    memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)
+
+    retrieval_pipeline = RunnableMap(
+    {
+        "question": lambda x: x["question"],
+        "user_info": lambda x: x["user_info"],
+        "chat_history": lambda x: x["chat_history"],
+    }
+)
+    debug_step = RunnablePassthrough.assign(
+    debug_info=lambda x: print(f"Question type: {type(x['question'])}, content: {x}")
+)
+
+    retrieval_step = RunnablePassthrough.assign(
+        docs=lambda x: multi_retriever.invoke(x["question"])
+    )
+    rerank_step = RunnablePassthrough.assign(
+        reranked_docs=lambda x: rerank(tokenizer, model, x["question"], x["docs"], 5)
+)
+    context_step = RunnablePassthrough.assign(
+        context=lambda x: "\n".join([doc.page_content for doc in x["reranked_docs"]])
+    )
+
+    chain = (
+        retrieval_pipeline
+        | retrieval_step
+        | rerank_step
+        | context_step
+        | prompt
+        | llm
+        | StrOutputParser()
+)
+
+    return chain, memory
+
+
+if __name__ == "__main__":
+    from rag_chain import build_user_info, build_qa_chain, rerank
+    from get_client import get_client
+    from retriever_builder import process_pdfs_to_chunks, save_embeddings
+    from transformers import AutoTokenizer, AutoModelForSequenceClassification
+
+    llm = get_client()
+    pdf_paths = "../pdf_files"
+    all_chunks = process_pdfs_to_chunks(pdf_paths)
+    vectordb = save_embeddings(all_chunks,
+                    persist_directory='../data_base/vector_db/chroma',
+                    overwrite=False)
+    retriever = vectordb.as_retriever(search_kwargs={"k": 4})
+    tokenizer = AutoTokenizer.from_pretrained("BAAI/bge-reranker-base")
+    model = AutoModelForSequenceClassification.from_pretrained("BAAI/bge-reranker-base")
+    
+    rag_chain, memory = build_qa_chain(
+        llm=llm,
+        multi_retriever=retriever,
+        model=model,
+        tokenizer=tokenizer
+    )
+
+    test_user_info = {
+        "job_info": "软件工程师",
+        "situation": "已入职试用期",
+        "city": "上海",
+        "age": 26,
+    }
+    test_question = "试用期公司会给我交社保和公积金吗？"
+    
+    print("\n--- 正在执行 RAG 链 ---")
+
+    result = rag_chain.invoke({
+        "question": test_question,
+        "user_info": build_user_info(test_user_info),
+        "chat_history": []  # 假设是首次提问，聊天记录为空
+    })
+
+    print("\n--- 成功执行！链的最终输出如下 ---")
+    print(result)

requirements.txt

@@ -0,0 +1,7 @@
+gradio
+langchain
+langchain-community
+langchain-core
+transformers
+torch
+pypdf

retriever_builder.py

@@ -0,0 +1,142 @@
+import os
+import re
+from typing import List
+from langchain.docstore.document import Document
+from langchain_community.document_loaders import PyPDFLoader
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_community.embeddings import HuggingFaceEmbeddings
+from langchain_community.vectorstores import Chroma
+from langchain_community.embeddings import SentenceTransformerEmbeddings
+from langchain_community.retrievers import BM25Retriever
+from langchain.retrievers import EnsembleRetriever
+
+def build_or_load_vectorstore(paths: list[str], embedding_model, persist_directory):
+    all_docs = []
+    pdf_paths = [
+        os.path.join(paths, fname)
+        for fname in os.listdir(paths)
+        if fname.lower().endswith(".pdf")
+    ]
+
+    for path in pdf_paths:
+        loader = PyPDFLoader(path)
+        docs = loader.load()
+        all_docs.extend(docs)
+
+    splitter = RecursiveCharacterTextSplitter(chunk_size=200, 
+                                              chunk_overlap=50,
+                                              separators=["\n\n", "(?<=\。 )", "\n", " ", ""],
+                                              strip_whitespace=True
+                                              )
+    split_docs = splitter.split_documents(all_docs)
+
+    vectordb = Chroma.from_documents(documents=split_docs, embedding=embedding_model, persist_directory=persist_directory)
+    vectordb.persist()
+    return vectordb
+
+
+def process_pdfs_to_chunks(paths: List[str],
+                           chunk_size: int = 200,
+                           chunk_overlap: int = 50) -> List[Document]:
+    # 初始化分割器
+    splitter = RecursiveCharacterTextSplitter(
+        chunk_size=chunk_size,
+        chunk_overlap=chunk_overlap,
+        separators=["\n\n", "(?<=\。 )", "\n", " ", ""],
+        strip_whitespace=True
+    )
+
+    all_chunks = []
+    pdf_paths = [
+        os.path.join(paths, fname)
+        for fname in os.listdir(paths)
+        if fname.lower().endswith(".pdf")
+    ]
+
+    for pdf_path in pdf_paths:
+        loader = PyPDFLoader(pdf_path)
+        pages = loader.load()
+
+        for page in pages:
+            chunks = splitter.split_text(page.page_content)
+
+            for chunk in chunks:
+                # 清洗：按行 strip，然后再合并为一段文本
+                cleaned_chunk_text = re.sub(r'\n\s+', '\n', chunk)
+                lines = cleaned_chunk_text.split('\n')
+                cleaned_chunk = [line.strip() for line in lines]
+                final_page_content = ' '.join(cleaned_chunk)
+
+                if final_page_content.strip():  # 非空才添加
+                    all_chunks.append(Document(
+                        page_content=final_page_content,
+                        metadata={
+                            "source": pdf_path,
+                            "page": page.metadata.get("page", None)
+                        }
+                    ))
+
+    return all_chunks
+
+
+def save_embeddings(all_chunks: List[Document] | None = None,
+                    persist_directory: str = './data_base/vector_db/chroma',
+                    overwrite=False):
+ 
+    embedding_model = SentenceTransformerEmbeddings(model_name="BAAI/bge-base-zh")
+
+    if os.path.exists(persist_directory) and not overwrite:
+        print("===已存在向量库，跳过保存===")
+        return Chroma(persist_directory=persist_directory, embedding_function=embedding_model)
+
+    vectorstore = Chroma.from_documents(
+        documents=all_chunks,
+        embedding=embedding_model,
+        persist_directory=persist_directory
+    )
+
+    vectorstore.persist()
+    print(f"===向量数据库已保存到：{persist_directory}===")
+
+    return vectorstore
+
+
+def get_hybrid_retriever(all_chunks: List[Document],
+                         persist_directory: str = './data_base/vector_db/chroma',
+                         k: int = 4) -> EnsembleRetriever:
+    # 稠密 embedding
+    embedding_model = SentenceTransformerEmbeddings(model_name="BAAI/bge-base-zh")
+    
+    # 构建/加载 Chroma
+    vectorstore = Chroma.from_documents(
+        documents=all_chunks,
+        embedding=embedding_model,
+        persist_directory=persist_directory
+    )
+    vectorstore.persist()
+
+    dense_retriever = vectorstore.as_retriever(search_kwargs={"k": k})
+
+    # 构建稀疏 BM25
+    bm25_retriever = BM25Retriever.from_documents(all_chunks)
+    bm25_retriever.k = k
+
+    # 融合
+    hybrid_retriever = EnsembleRetriever(
+        retrievers=[dense_retriever, bm25_retriever],
+        weights=[0.4, 0.6]
+    )
+    return hybrid_retriever
+
+
+if __name__ == "__main__":
+    embedding_model = HuggingFaceEmbeddings(model_name="BAAI/bge-base-zh")
+    VECTORDB_DIR = "./data_base/vector_db/chroma/"
+
+    pdf_paths = "./pdf_files/"
+    all_chunks = process_pdfs_to_chunks(pdf_paths)
+    vectorstore = save_embeddings(all_chunks)
+    
+    # 获取混合检索器
+    hybrid_retriever = get_hybrid_retriever(all_chunks)
+    print("===混合检索器已准备就绪===")

utils.py

@@ -0,0 +1,95 @@
+import os
+import sys
+from retriever_builder import process_pdfs_to_chunks, save_embeddings
+from conversation_manager import PlannerAgent
+
+# 部署时解压pdf文件
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+os.system(f"tar -xzvf /home/user/app/pdf_files.tar.gz")
+
+# 初始化向量数据库
+pdf_paths = "./pdf_files"
+all_chunks = process_pdfs_to_chunks(pdf_paths)
+vectordb = save_embeddings(all_chunks,
+                persist_directory='./data_base/vector_db/chroma',
+                overwrite=True)  # 是否需要复写（是否有新增）
+retriever = vectordb.as_retriever(search_kwargs={"k": 4})
+
+# 用于缓存 agent 实例（支持多轮）
+agent = PlannerAgent(retriever=retriever)
+
+def classify_job_type(job_name: str) -> str:
+    job_name = job_name.lower()
+    job_name = job_name.split('(')[0]
+
+    # 新业态关键词
+    new_economy_jobs = ["外卖", "快递", "网约车", "主播", "骑手", "平台", "直播", "自媒体"]
+    # 灵活就业关键词
+    flexible_jobs = ["自由", "个体户", "兼职", "临时工", "接单", "顾问", "自由职业者"]
+    # 城镇职工关键词（白领/技术类等）
+    urban_jobs = ["公司", "企业", "工程师", "职员", "护士", "程序员"]
+    # 城乡居民关键词
+    rural_jobs = ["农民", "养殖户", "渔民", "果农", "农业工人", "林业工人", "乡村医生"]
+
+    for kw in new_economy_jobs:
+        if kw in job_name:
+            return "新业态就业"
+    for kw in flexible_jobs:
+        if kw in job_name:
+            return "灵活就业"
+    for kw in urban_jobs:
+        if kw in job_name:
+            return "城镇职工"
+    for kw in rural_jobs:
+        if kw in job_name:
+            return "城乡居民"
+    if job_name not in new_economy_jobs and job_name not in flexible_jobs and job_name not in urban_jobs:
+        return "其他"
+    # 默认值
+    return "其他"
+
+def user_asks(message, history, *args):
+
+    user_goal   = args[0] if len(args) > 0 else "未知"
+    job_input   = args[1] if len(args) > 1 else "未知"
+    situation   = args[2] if len(args) > 2 else "未知"
+    city        = args[3] if len(args) > 3 else "未知"
+    age         = args[4] if len(args) > 4 else "未知"
+    other_info  = args[5] if len(args) > 5 else "未知"
+
+    # 自动分类
+    job_type = classify_job_type(job_input)
+
+    user_info = {
+        "goal": user_goal,
+        "job_info": job_input,
+        "job_type": job_type,
+        "city": city,
+        "age": age,
+        "situation": situation,
+        "other_info": other_info,
+    }
+
+    current_history = history + [{"role": "user", "content": message}, {"role": "assistant", "content": ""}]
+
+    # 显示用户消息，同时清空输入框
+    yield current_history, ""
+
+    full_response = ""
+    
+    try:
+        for chunk in agent.stream_reply(message, user_info):
+
+            print(f"--- Received chunk from agent: '{chunk}' ---")
+            full_response += chunk
+            current_history[-1]["content"] = full_response
+            yield current_history, ""
+        print("--- Agent streaming loop finished ---")
+    except Exception as e:
+        print(f"!!! ERROR: An exception occurred during agent.stream_reply or its iteration: {e}")
+        import traceback
+        traceback.print_exc()
+        current_history[-1]["content"] = f"抱歉，系统内部发生错误，无法生成回复。错误详情：{e}"
+        yield current_history, ""
+    print("--- Exiting user_asks ---")
+