alayaflow 0.1.1__tar.gz → 0.1.3__tar.gz

alayaflow-0.1.3/.alaya.ai/alayaflow/workflows/autotable/1.0.0/metadata.json

@@ -0,0 +1,9 @@
+{
+    "id": "autotable",
+    "name": "Auto Table Filler",
+    "description": "基于知识库的智能表格自动填写工作流",
+    "version": "1.0.0",
+    "tags": ["extraction", "table", "rag"],
+    "entry_file": "workflow.py",
+    "entry_point": "create_graph"
+}

alayaflow-0.1.3/.alaya.ai/alayaflow/workflows/autotable/1.0.0/metadata.py

@@ -0,0 +1,17 @@
+from pathlib import Path
+
+from alayaflow.workflow import WorkflowInfo
+
+def get_metadata():
+    meta = {
+        "id": "autotable",
+        "name": "Auto Table Filler",
+        "description": "基于知识库的智能表格自动填写工作流",
+        "version": "1.0.0",
+        "tags": ["extraction", "table", "rag"],
+        "entry_file": "workflow.py",
+        "entry_point": "create_graph",
+        "wf_dir": Path(__file__).parent
+    }
+    return WorkflowInfo(**meta)
+

{alayaflow-0.1.1/.alaya.ai/alayaflow/workflows/simple_chat → alayaflow-0.1.3/.alaya.ai/alayaflow/workflows/autotable}/1.0.0/requirements.txt

@@ -1,11 +1,14 @@
 # LangGraph 核心依赖
 langgraph>=0.2.0
 
+# LangChain Core
+langchain-core>=0.3.0
+
 # LangChain Community (用于 ChatOpenAI)
 langchain-community>=0.3.0
 
 # OpenAI SDK (DeepSeek API 兼容 OpenAI 格式)
 openai>=1.0.0
 
-# Langfuse
-langfuse>=3.0.0,<4.0.0
+# Langfuse (可选，用于追踪)
+langfuse>=3.0.0,<4.0.0

alayaflow-0.1.3/.alaya.ai/alayaflow/workflows/autotable/1.0.0/schemas.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+from typing import Dict, List, Any, Union, TypeAlias, TypedDict, Annotated
+from dataclasses import dataclass
+from pydantic import BaseModel, Field
+from .utils import merge_dicts, deep_merge
+
+FieldSpec: TypeAlias = Union[str, Dict[str, List[Any]]]
+
+@dataclass(frozen=True)
+class GroupTask:
+    path: tuple[str, ...]
+    keys: tuple[str, ...]
+
+
+class WorkflowInitArgs(BaseModel):
+    alayamem_url: str = Field(..., description="AlayaMem 服务地址")
+
+
+class Input(BaseModel):
+    fields: List[FieldSpec] = Field(..., description="要填写的表格字段模板（支持嵌套结构）")
+
+
+class WorkflowContext(BaseModel):
+    collection_name: str = Field(default="file_watcher_collection", description="检索的集合名称")
+
+
+class Output(BaseModel):
+    final_result: Dict[str, Any] = Field(..., description="填写完成的表格数据（嵌套结构）")
+    context_by_task: Dict[str, List[str]] = Field(default_factory=dict, description="每个任务检索到的文档片段（调试用）")
+    errors: Dict[str, str] = Field(default_factory=dict, description="错误信息")
+    tasks: List[GroupTask] = Field(default_factory=list, description="规划的任务列表")
+
+
+class OverallState(TypedDict):
+    fields: List[FieldSpec]
+    final_result: Annotated[Dict[str, Any], deep_merge]
+    context_by_task: Annotated[Dict[str, List[str]], merge_dicts]
+    errors: Annotated[Dict[str, str], merge_dicts]
+    tasks: List[GroupTask]
+
+
+class TaskState(TypedDict):
+    task: GroupTask

alayaflow-0.1.3/.alaya.ai/alayaflow/workflows/autotable/1.0.0/utils.py

@@ -0,0 +1,35 @@
+from typing import Any, Dict, List, Tuple
+
+
+def make_patch(path: Tuple[str, ...], kv: Dict[str, str]) -> Dict[str, Any]:
+    """
+    path=("个人信息","联系方式"), kv={"电话":"..","邮箱":".."} =>
+    {"个人信息":{"联系方式":{"电话":"..","邮箱":".."}}}
+    """
+    node: Dict[str, Any] = dict(kv)
+    for p in reversed(path):
+        node = {p: node}
+    return node
+
+
+def slim_docs(docs: List[str], max_doc_chars: int) -> List[str]:
+        out = []
+        for d in docs or []:
+            s = str(d)
+            if len(s) > max_doc_chars:
+                s = s[:max_doc_chars] + "…"
+            out.append(s)
+        return out
+
+
+def merge_dicts(a: Dict, b: Dict) -> Dict:
+    return {**a, **b}
+
+def deep_merge(a: Dict[str, Any], b: Dict[str, Any]) -> Dict[str, Any]:
+    out = dict(a or {})
+    for k, v in (b or {}).items():
+        if k in out and isinstance(out[k], dict) and isinstance(v, dict):
+            out[k] = deep_merge(out[k], v)
+        else:
+            out[k] = v
+    return out

alayaflow-0.1.3/.alaya.ai/alayaflow/workflows/autotable/1.0.0/workflow.py

@@ -0,0 +1,267 @@
+import json
+from typing import Any, Dict, List, Optional, Tuple
+from collections import defaultdict
+from threading import Semaphore
+
+from langgraph.graph import StateGraph, START, END
+from langgraph.types import Send
+from langchain_core.runnables import RunnableConfig
+
+from alayaflow.component.llm_node import LLMComponent, ResponseFormat
+from alayaflow.clients.alayamem.http_client import HttpAlayaMemClient
+from alayaflow.component.retrieve_node import RetrieveComponent
+
+from .schemas import (
+    FieldSpec, GroupTask, WorkflowInitArgs, 
+    OverallState, TaskState, WorkflowContext, Input, Output
+)
+from .utils import make_patch, slim_docs
+
+
+def flatten_leaf_tasks(specs: List[FieldSpec], base_path: Optional[List[str]] = None) -> List[Tuple[Tuple[str, ...], str]]:
+    """
+    返回：[(path_tuple, leaf_key), ...]
+    """
+    base_path = base_path or []
+    out: List[Tuple[Tuple[str, ...], str]] = []
+
+    def _as_list(x: Any) -> List[Any]:
+        if x is None:
+            return []
+        if isinstance(x, list):
+            return x
+        return [x]
+
+    for item in specs or []:
+        if isinstance(item, str):
+            out.append((tuple(base_path), item))
+            continue
+
+        if isinstance(item, dict):
+            for parent, children in item.items():
+                for child in _as_list(children):
+                    if isinstance(child, str):
+                        out.append((tuple(base_path + [parent]), child))
+                    elif isinstance(child, dict):
+                        out.extend(flatten_leaf_tasks([child], base_path + [parent]))
+                    else:
+                        pass
+            continue
+
+    return out
+
+
+def create_plan_node():
+    """创建规划节点：将输入的字段模板规划为多个独立的抽取任务"""
+    def plan_node(state: OverallState, config: RunnableConfig):
+        leaf = flatten_leaf_tasks(state["fields"])
+        grouped: Dict[Tuple[str, ...], List[str]] = defaultdict(list)
+        for path, key in leaf:
+            grouped[path].append(key)
+
+        tasks: List[GroupTask] = []
+        for path, keys in grouped.items():
+            # 去重保持顺序
+            seen = set()
+            uniq = []
+            for k in keys:
+                if k not in seen:
+                    seen.add(k)
+                    uniq.append(k)
+            tasks.append(GroupTask(path=path, keys=tuple(uniq)))
+
+        tasks.sort(key=lambda t: (len(t.path), t.path))
+        return {"tasks": tasks}
+    
+    return plan_node
+
+
+def create_extract_task_node(client: HttpAlayaMemClient):
+    TOP_K: int = 5
+    MAX_DOC_CHARS: int = 400
+    MODEL_ID: str = "deepseek-chat"
+    MAX_CONCURRENCY: int = 10
+
+    limiter = Semaphore(MAX_CONCURRENCY)
+
+    def _build_system_prompt(keys: list[str]) -> str:
+        keys_str = ", ".join(keys)
+
+        return f"""
+            你是一个严谨的“局部字段抽取器”（table patch extractor）。
+
+            你的任务是：**只为指定字段抽取值**，严格依据提供的知识片段，不得猜测或编造。
+
+            通用规则：
+            1. 输出必须是严格合法 JSON，不允许包含解释、Markdown、代码块或多余文本。
+            2. **只允许输出以下字段（不多不少）**：{keys_str}
+            3. 所有字段值必须是字符串。
+            4. 找不到 / 不确定 / 空值 / 占位符 → 必须输出空字符串 ""。
+            5. 字段名可能存在空格或轻微变体（如“姓 名”≈“姓名”），允许智能匹配，但不得扩展到未指定字段。
+            
+            长文本字段格式规则（必须遵守）：
+            - 当字段内容包含**多个条目、多个时间段或多段经历**时：
+            - 必须使用序号列表格式。
+            - **每个条目占一行，条目之间必须使用 "\n" 换行符分隔。**
+            - 不允许使用分号、顿号、逗号等方式合并多个条目到同一行。
+            - 示例正确格式：
+            "1.第一条内容\n2.第二条内容\n3.第三条内容"
+
+            表格单元格理解规则（重要）：
+            - 知识片段可能来自表格，每行使用 " | " 分隔单元格。
+            - "<空>" 表示空单元格，对应值为 ""。
+            - 字段名后不一定是值：
+            - 若字段名后是 "<空>" → 值为 ""。
+            - 若字段名后是另一个字段名 → 继续向后寻找第一个“非字段名 / 非占位符”的单元格作为值。
+            - 示例："字段A | 字段B | 值" → 字段A="", 字段B="值"。
+
+            占位符识别：
+            - 若候选值是模板占位符或签字日期类文本
+            （如“签字： 年 月 日”“学院盖章： 年 月 日”等），必须返回 ""。
+            """.strip()
+
+    def _build_user_prompt(content_text: str, path: list[str], keys: list[str],) -> str:
+        path_str = " / ".join(path) if path else "<root>"
+        keys_str = ", ".join(keys)
+
+        json_skeleton = "{\n" + ",\n".join([f'  "{k}": ""' for k in keys]) + "\n}"
+
+        return f"""
+            【本次任务定位】
+            字段路径（仅用于语义定位，不要输出）：{path_str}
+            需要抽取的字段：{keys_str}
+
+            【知识库片段】
+            {content_text}
+
+            【输出要求】
+            - 只输出一个 JSON 对象
+            - key 必须严格为：{keys_str}
+            - 无法确定 / 空值 / 占位符 → 输出 ""
+
+            【JSON 输出模板】
+            {json_skeleton}
+            """.strip()
+
+    def node(state: TaskState, config: RunnableConfig):
+        task = state["task"]
+        path = task.path
+        keys = list(task.keys)
+
+        task_id = f"{'/'.join(path) or '<root>'}:{','.join(keys)}"
+
+        default_kv = {k: "" for k in keys}
+        default_patch = make_patch(path, default_kv)
+
+        try:
+            with limiter:
+                # 从 config 中获取 collection_name（运行时参数）
+                config_dict = config.get("configurable", {}) if isinstance(config, dict) else {}
+                collection_name = config_dict.get("collection_name", "file_watcher_collection")
+                
+                # 1) 检索 query：路径信息 + keys
+                # 把上层标题带进去提升命中
+                query_parts = list(path) + keys
+                query = "；".join([p for p in query_parts if p])
+
+                retrieve_component = RetrieveComponent(client=client)
+                docs = retrieve_component(query=query, collection_name=collection_name, limit=TOP_K)
+                docs = slim_docs(docs, MAX_DOC_CHARS)
+
+                # 没 docs：直接返回默认
+                if not docs:
+                    return {
+                        "context_by_task": {task_id: []},
+                        "final_result": default_patch,
+                    }
+
+                formatted_context = "\n\n".join(
+                    [f"片段 {i+1}: {doc}" for i, doc in enumerate(docs)]
+                )
+
+                # 2) 一次性抽取 keys（严格 JSON object）
+                json_skeleton = "{\n" + ",\n".join([f'  "{k}": ""' for k in keys]) + "\n}"
+
+                system_prompt = _build_system_prompt(keys)
+                user_prompt = _build_user_prompt(formatted_context, path, keys)
+
+                llm = LLMComponent(
+                    model_id=MODEL_ID,
+                    system_prompt=system_prompt,
+                    prompt=user_prompt,
+                    response_format=ResponseFormat.JSON,
+                    temperature=0.0,
+                )
+
+                msg = llm()
+                obj = json.loads(msg.content)
+
+                extracted = {}
+                for k in keys:
+                    v = obj.get(k, "")
+                    extracted[k] = (str(v).strip() if v is not None else "")
+
+                patch = make_patch(path, extracted)
+
+                return {
+                    "context_by_task": {task_id: docs},
+                    "final_result": patch,
+                }
+
+        except Exception as e:
+            return {
+                "context_by_task": {task_id: []},
+                "final_result": default_patch,
+                "errors": {task_id: f"{type(e).__name__}: {e}"},
+            }
+
+    return node
+
+
+def create_validate_node():
+    def validate_node(state: OverallState):
+        res = state.get("final_result", {}) or {}
+        missing = []
+
+        def get_in(d: Dict[str, Any], path: Tuple[str, ...]) -> Dict[str, Any]:
+            cur = d
+            for p in path:
+                if not isinstance(cur, dict):
+                    return {}
+                cur = cur.get(p, {})
+            return cur if isinstance(cur, dict) else {}
+
+        for t in state["tasks"]:
+            scope = get_in(res, t.path)
+            for k in t.keys:
+                if not str(scope.get(k, "")).strip():
+                    missing.append((".".join(t.path + (k,))) if t.path else k)
+
+        if missing:
+            return {"errors": {"missing": "；".join(missing)}}
+        return {}
+    
+    return validate_node
+
+
+def map_tasks(state: OverallState):
+    return [Send("extract_task", {"task": t}) for t in state["tasks"]]
+
+
+def create_graph(init_args: WorkflowInitArgs | Dict[str, Any]):
+    if isinstance(init_args, dict):
+        init_args = WorkflowInitArgs(**init_args)
+    client = HttpAlayaMemClient(init_args.alayamem_url)
+    
+    g = StateGraph(OverallState, WorkflowContext, input_type=Input, output_type=Output)
+    g.add_node("plan", create_plan_node())
+    g.add_node("extract_task", create_extract_task_node(client))
+    g.add_node("validate", create_validate_node())
+    
+    g.add_edge(START, "plan")
+    g.add_conditional_edges("plan", map_tasks, ["extract_task"])
+    g.add_edge("extract_task", "validate")
+    g.add_edge("validate", END)
+
+    return g.compile()
+

alayaflow-0.1.3/.alaya.ai/alayaflow/workflows/simple_chat/1.0.0/metadata.py

@@ -0,0 +1,16 @@
+from pathlib import Path
+
+from alayaflow.workflow import WorkflowInfo
+
+def get_metadata():
+    meta = {
+        "id": "simple_chat",
+        "name": "Simple Chatbot",
+        "description": "一个简单的 LLM 对话工作流示例",
+        "version": "1.0.0",
+        "tags": ["chat", "basic"],
+        "entry_file": "workflow.py",
+        "entry_point": "create_graph",
+        "wf_dir": Path(__file__).parent
+    }
+    return WorkflowInfo(**meta)

{alayaflow-0.1.1 → alayaflow-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alayaflow
-Version: 0.1.1
+Version: 0.1.3
 Summary: A desktop platform for executing LangGraph workflows with uv-managed sandboxes.
 Author-email: alayaflow group <dev@example.com>
 License: MIT

{alayaflow-0.1.1 → alayaflow-0.1.3}/examples/autotable_demo.py

@@ -1,6 +1,9 @@
 import json
+import os
 
 from alayaflow.api import Flow
+from dotenv import load_dotenv
+load_dotenv()
 
 def main():
     # Initialize flow api singleton
@@ -10,6 +13,23 @@ def main():
         "alayahub_url": "http://your-alayahub-url",
     })
 
+    api_key = os.getenv("DEEPSEEK_API_KEY")
+    if not api_key:
+        raise ValueError("请设置环境变量 DEEPSEEK_API_KEY")
+    
+    flow.register_models([
+        {
+            # Local used fields
+            "name": "DeepSeek Chat",
+            "model_id": "deepseek-chat",
+            "provider_name": "DeepSeek",
+            # Connection credentials
+            "model_name": "deepseek-chat",
+            "base_url": "https://api.deepseek.com/v1",
+            "api_key": api_key,
+        }
+    ])
+
     workflow_id = 'autotable'
     workflow_version = '1.0.0'
     init_args = {
@@ -55,6 +75,12 @@ def main():
     if final_result:
         print("\n最终结果：")
         print(json.dumps(final_result.get("final_result", {}), indent=2, ensure_ascii=False))
+        
+        # 打印错误信息（如果有）
+        errors = final_result.get("errors", {})
+        if errors:
+            print("\n错误信息：")
+            print(json.dumps(errors, indent=2, ensure_ascii=False))
 
 if __name__ == '__main__':
     main()

{alayaflow-0.1.1 → alayaflow-0.1.3}/examples/chat_demo.py

@@ -2,6 +2,8 @@ import os
 import sys
 
 from alayaflow.api import Flow
+from dotenv import load_dotenv
+load_dotenv()
 
 
 def init_flow():
@@ -15,6 +17,11 @@ def init_flow():
     flow.init({
         "alayahub_url": "http://your-alayahub-url",
     })
+    
+    api_key = os.getenv("DEEPSEEK_API_KEY")
+    if not api_key:
+        raise ValueError("请设置环境变量 DEEPSEEK_API_KEY")
+    
     flow.register_models([
         {
             # Local used fields
@@ -24,7 +31,7 @@ def init_flow():
             # Connection credentials
             "model_name": "deepseek-chat",
             "base_url": "https://api.deepseek.com/v1",
-            "api_key": os.getenv("DEEPSEEK_API_KEY"),
+            "api_key": api_key,
         }
     ])
 

{alayaflow-0.1.1 → alayaflow-0.1.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "alayaflow"
-version = "0.1.1"
+version = "0.1.3"
 description = "A desktop platform for executing LangGraph workflows with uv-managed sandboxes."
 readme = "README.md"
 requires-python = ">=3.10"

{alayaflow-0.1.1 → alayaflow-0.1.3}/src/alayaflow/__init__.py

@@ -1,5 +1,5 @@
 """AlayaFlow - A desktop platform for executing LangGraph workflows with multiple executors."""
 
 
-__version__ = "0.1.1"
+__version__ = "0.1.3"
 

{alayaflow-0.1.1 → alayaflow-0.1.3}/src/alayaflow/api/api_singleton.py

@@ -1,10 +1,11 @@
-from typing import Generator, Dict, List, Self
+from typing import Generator, Dict, List, Self, Optional
 
 from alayaflow.utils.singleton import SingletonMeta
 from alayaflow.workflow import WorkflowManager
 from alayaflow.execution import ExecutorManager, ExecutorType
 from alayaflow.common.config import settings
 from alayaflow.component.model import ModelManager, ModelProfile
+from alayaflow.workflow.runnable import BaseRunnableWorkflow
 
 
 class APISingleton(metaclass=SingletonMeta):
@@ -23,8 +24,10 @@ class APISingleton(metaclass=SingletonMeta):
         if not self._inited:
             raise ValueError("Flow APISingleton 未初始化，请先调用 init 方法")
 
-    def init(self, config: dict = {}) -> Self:
+    def init(self, config: dict = None) -> Self:
         """初始化 Flow APISingleton"""
+        if config is None:
+            config = {}
         # Overwrite all for now
         settings.alayahub_url = config.get("alayahub_url", settings.alayahub_url)
         settings.langfuse_enabled = config.get("langfuse_enabled", settings.langfuse_enabled)
@@ -66,10 +69,15 @@ class APISingleton(metaclass=SingletonMeta):
         self._check_init()
         return self.workflow_manager.uninstall_workflow(workflow_id)
 
-    def load_workflow(self, workflow_id: str, version: str, init_args: dict = {}):
-        """加载工作流"""
+    def load_workflow(self, workflow_id: str, version: str, init_args: Optional[Dict] = None, storage_path: str = settings.workflow_storage_path) -> None:
+        """加载本地工作流"""
         self._check_init()
-        return self.workflow_manager.load_workflow(workflow_id, version, init_args)
+        return self.workflow_manager.load_workflow(workflow_id, version, init_args or {}, storage_path)
+
+    def register_workflow(self, runnable: BaseRunnableWorkflow, requirements: List[str] = None) -> None:
+        """加载Python项目中的工作流"""
+        self._check_init()
+        self.workflow_manager.register_workflow(runnable, requirements or [])
 
     def exec_workflow(
         self,

{alayaflow-0.1.1 → alayaflow-0.1.3}/src/alayaflow/component/llm_node.py

@@ -18,17 +18,14 @@ class LLMComponent:
     def __init__(
         self,
         *,
-        # ===== 模型 & prompt =====
         model_id: str,
         system_prompt: str,
         prompt: str,
 
-        # ===== 采样参数 =====
         temperature: Optional[float] = None,
         top_p: Optional[float] = None,
         max_tokens: Optional[int] = None,
 
-        # ===== 输出控制 =====
         response_format: ResponseFormat = ResponseFormat.TEXT,
         json_schema: Optional[Dict[str, Any]] = None,
         outputs: Optional[Dict[str, str]] = None,
@@ -47,6 +44,9 @@ class LLMComponent:
         self.json_schema = json_schema
         self.outputs = outputs or {}
         self.retry_json_once = retry_json_once
+        
+        # —— 依赖注入（获取全局单例 ModelManager）——
+        self._model_manager = ModelManager()
     
     def _get_llm(self) -> Runnable:
         bind_kwargs: Dict[str, Any] = {}
@@ -58,8 +58,7 @@ class LLMComponent:
         if self.max_tokens is not None:
             bind_kwargs["max_tokens"] = self.max_tokens
 
-        model_manager = ModelManager()
-        llm = model_manager.get_model(self.model_id, runtime_config=bind_kwargs)
+        llm = self._model_manager.get_model(self.model_id, runtime_config=bind_kwargs)
 
         return llm
     

alayaflow-0.1.3/src/alayaflow/component/retrieve_node.py

@@ -0,0 +1,77 @@
+from urllib import request
+from alayaflow.clients.alayamem.http_client import HttpAlayaMemClient
+
+
+class RetrieveComponent:
+    def __init__(self, client: HttpAlayaMemClient):
+        self.client = client
+    
+    def __call__(self, query: str, collection_name: str, limit: int = 3) -> list[str]:
+        # result = self.client.vdb_query([query], limit, collection_name)
+        # return result.get('documents', [[]])[0] if result.get('documents') else []
+        docs: list[str] = []
+
+        # -------- 基础个人信息 --------
+        if "姓名" in query:
+            docs.extend([
+                "用户姓名是张三。",
+                "张三，男，1989年出生。",
+            ])
+
+        if "性别" in query:
+            docs.append("张三，男，工程师。")
+
+        if "年龄" in query:
+            docs.append("张三，1989年出生，今年34岁。")
+
+        # -------- 联系方式 --------
+        if "电话" in query:
+            docs.extend([
+                "联系电话：15643431212。",
+                "手机号为15643431212，可随时联系。",
+            ])
+
+        if "邮箱" in query or "Email" in query:
+            docs.extend([
+                "电子邮箱：273230101@qq.com。",
+                "邮箱地址为 27223221@qq.com。",
+            ])
+
+        # -------- 工作单位 / 职务 --------
+        if "工作单位" in query or "公司" in query:
+            docs.extend([
+                "现就职于 Google 中国。",
+                "工作单位为 Google。",
+            ])
+
+        if "职务" in query or "职位" in query:
+            docs.append("现任高级软件工程师。")
+
+        # -------- 教育背景 --------
+        if "学历" in query or "教育" in query:
+            docs.extend([
+                "2016年本科毕业于清华大学计算机科学与技术专业。",
+                "2020年博士毕业于北京大学。",
+            ])
+
+        # -------- 工作 / 学习经历 --------
+        if "学习工作经历" in query or "经历" in query:
+            docs.extend([
+                "2010.09-2014.07 就读于清华大学计算机科学与技术专业。",
+                "2014.07-2016.08 在百度公司担任软件开发工程师。",
+                "2016.09 至今在 Google 担任高级软件工程师。",
+            ])
+
+        # -------- 路径/父字段增强（模拟更真实检索）--------
+        if "个人信息" in query and not docs:
+            docs.append("张三，男，1989年出生，工程师，现居北京。")
+
+        if "联系方式" in query and not docs:
+            docs.append("联系方式：电话 15643431212，邮箱 272040101@qq.com。")
+
+        # -------- 兜底：模拟找不到 --------
+        if not docs:
+            return []
+
+        # limit 截断
+        return docs[:limit]