alayaflow 0.1.2__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.2/.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.2 → alayaflow-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alayaflow
-Version: 0.1.2
+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.2 → 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.2 → 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.2 → alayaflow-0.1.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "alayaflow"
-version = "0.1.2"
+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.2 → 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.2"
+__version__ = "0.1.3"
 

{alayaflow-0.1.2 → 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]

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

@@ -1,9 +0,0 @@
-{
-    "id": "autotable",
-    "name": "RAG 并发信息抽取工作流",
-    "description": "基于 LangGraph Map-Reduce 架构的高性能抽取流程。集成信号量限流(Semaphore)、JSON 结构化校验、文档截断及错误兜底机制。",
-    "version": "1.0.0",
-    "tags": ["rag", "extraction", "langgraph", "json-mode"],
-    "entry_file": "workflow.py",
-    "entry_point": "create_graph"
-}

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

@@ -1,400 +0,0 @@
-import json
-from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, TypedDict, Annotated, Union, TypeAlias, 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
-
-
-FieldSpec: TypeAlias = Union[str, Dict[str, List["FieldSpec"]]]  # 递归：dict -> list[FieldSpec]
-
-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
-
-
-@dataclass(frozen=True)
-class GroupTask:
-    path: Tuple[str, ...]   # 父路径，如 ("个人信息","联系方式")；根为 ()
-    keys: Tuple[str, ...]   # 该路径下需要抽取的叶子字段名
-
-
-class OverallState(TypedDict):
-    fields: List[FieldSpec]  # 输入模板（递归）
-    tasks: List[GroupTask]   # 规划出的任务列表
-
-    # 调试信息：每个任务的检索片段
-    context_by_task: Annotated[Dict[str, List[str]], merge_dicts]
-
-    # 最终值树：通过 deep_merge reducer 并发合并 patch
-    final_result: Annotated[Dict[str, Any], deep_merge]
-
-    errors: Annotated[Dict[str, str], merge_dicts]
-
-
-class TaskState(TypedDict):
-    task: GroupTask
-
-
-
-def _as_list(x: Any) -> List[Any]:
-    if x is None:
-        return []
-    if isinstance(x, list):
-        return x
-    return [x]
-
-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]] = []
-
-    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 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}
-
-
-def map_tasks(state: OverallState):
-    return [Send("extract_task", {"task": t}) for t in state["tasks"]]
-
-
-
-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 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 create_extract_task_node(
-    client: HttpAlayaMemClient,
-    *,
-    max_concurrency: int = 10,
-    top_k: int = 5,
-    max_doc_chars: int = 400,
-):
-    limiter = Semaphore(max_concurrency)
-
-    def slim_docs(docs: List[str]) -> 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 node(state: TaskState, config: RunnableConfig):
-        task = state["task"]
-        path = task.path
-        keys = list(task.keys)
-
-        task_id = f"{'/'.join(path) or '<root>'}:{','.join(keys)}"
-
-        # 默认 patch：保证结构稳定（缺失也填空）
-        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
-                # path 越深，越应该把上层标题带进去提升命中
-                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)
-
-                # 没 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_name="deepseek-chat",
-                    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 validate_node(state: OverallState, config: RunnableConfig):
-    # 简单缺失检查：把 tasks 展开期望字段，看看 final_result 是否为空
-    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 {}
-
-
-# -------------------------
-# Build graph
-# -------------------------
-def create_graph(init_args: Dict[str, Any]):
-    client = HttpAlayaMemClient(init_args["alayamem_url"])
-    g = StateGraph(OverallState)
-
-    g.add_node("plan", plan_node)
-    g.add_node("extract_task", create_extract_task_node(client, max_concurrency=10, top_k=3))
-    g.add_node("validate", 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()
-
-
-if __name__ == "__main__":
-    app = create_graph({"alayamem_url": "http://10.16.70.46:5555"})
-
-    input_data: OverallState = {
-        "fields": [
-            {
-                "申请人信息": [
-                "姓名",
-                "性别",
-                "出生年月",
-                "民族",
-                "学位",
-                "职称",
-                "是否在站博士后",
-                "电子邮箱",
-                "办公电话",
-                "国别或地区",
-                "申请人类别",
-                "工作单位",
-                "主要研究领域"
-                ]
-            },
-            {
-                "依托单位信息": [
-                "名称",
-                "联系人",
-                "电子邮箱",
-                "电话",
-                "网站地址"
-                ]
-            },
-            {
-                "合作研究单位信息": [
-                "单位名称"
-                ]
-            },
-            {
-                "项目基本信息": [
-                "项目名称",
-                "英文名称",
-                "资助类别",
-                "亚类说明",
-                "附注说明",
-                "申请代码",
-                "研究期限",
-                "研究方向",
-                "申请资助经费",
-                "研究属性",
-                "中文关键词",
-                "英文关键词"
-                ]
-            },
-            "中文摘要",
-            "英文摘要"
-            ],
-        "tasks": [],
-        "context_by_task": {},
-        "final_result": {},
-        "errors": {},
-    }
-
-    config = {
-        "configurable": {
-            "collection_name": "file_watcher_collection",
-        }
-    }
-    out = app.invoke(input_data, config=config)
-    print("final_result:")
-    print(json.dumps(out["final_result"], ensure_ascii=False, indent=2))
-    print("\nerrors:")
-    print(json.dumps(out["errors"], ensure_ascii=False, indent=2))

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

@@ -1,11 +0,0 @@
-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 []