alayaflow 0.1.0__py3-none-any.whl

alayaflow/__init__.py

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

alayaflow/api/__init__.py

@@ -0,0 +1,5 @@
+from .api_singleton import APISingleton as Flow
+
+__all__ = [
+    "Flow",
+]

alayaflow/api/api_singleton.py

@@ -0,0 +1,81 @@
+from typing import Generator, Dict, List, Self
+
+from alayaflow.utils.singleton import SingletonMeta
+from alayaflow.workflow import WorkflowManager
+from alayaflow.execution import ExecutorManager, ExecutorType
+from alayaflow.common.config import settings
+
+
+class APISingleton(metaclass=SingletonMeta):
+    def __init__(self) -> None:
+        self.workflow_manager = WorkflowManager()
+        self.executor_manager = ExecutorManager(
+            workflow_manager=self.workflow_manager
+        )
+        self._inited = False                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
+
+    def is_inited(self) -> bool:
+        return self._inited
+
+    def _check_init(self) -> None:
+        if not self._inited:
+            raise ValueError("Flow APISingleton 未初始化，请先调用 init 方法")
+
+    def init(self, config: dict = {}) -> Self:
+        """初始化 Flow APISingleton"""
+        # Overwrite all for now
+        settings.alayahub_url = config.get("alayahub_url", settings.alayahub_url)
+        settings.langfuse_enabled = config.get("langfuse_enabled", settings.langfuse_enabled)
+        settings.langfuse_public_key = config.get("langfuse_public_key", settings.langfuse_public_key)
+        settings.langfuse_secret_key = config.get("langfuse_secret_key", settings.langfuse_secret_key)
+        settings.langfuse_url = config.get("langfuse_url", settings.langfuse_url)
+        self._inited = True
+        return self
+
+    def list_loaded_workflow_ids(self) -> List[str]:
+        """列举已加载的工作流"""
+        self._check_init()
+        return self.workflow_manager.list_loaded_workflow_ids()
+
+    def list_available_workflows(self) -> Dict[str, List[str]]:
+        """列举工作流，分别返回本地已安装和远程未安装的工作流"""
+        self._check_init()
+        return self.workflow_manager.list_available_workflows()
+
+    def get_workflow_info(self, workflow_id: str) -> dict:
+        """获取工作流信息"""
+        self._check_init()
+        return self.workflow_manager.get_workflow_info(workflow_id)
+
+    def install_workflow(self, workflow_id: str) -> bool:
+        """安装工作流"""
+        self._check_init()
+        return self.workflow_manager.install_workflow(workflow_id)
+
+    def uninstall_workflow(self, workflow_id: str) -> bool:
+        """卸载工作流"""
+        self._check_init()
+        return self.workflow_manager.uninstall_workflow(workflow_id)
+
+    def load_workflow(self, workflow_id: str, version: str, init_args: dict = {}):
+        """加载工作流"""
+        self._check_init()
+        return self.workflow_manager.load_workflow(workflow_id, version, init_args)
+
+    def exec_workflow(
+        self,
+        workflow_id: str,
+        version: str,
+        input_data: dict,
+        user_config: dict,
+        executor_type: str | ExecutorType = ExecutorType.NAIVE
+    ) -> Generator[dict, None, None]:
+        """执行工作流"""
+        self._check_init()
+        yield from self.executor_manager.exec_workflow(
+            workflow_id=workflow_id,
+            version=version,
+            input_data=input_data,
+            user_config=user_config,
+            executor_type=executor_type
+        )

alayaflow/clients/alayamem/base_client.py

@@ -0,0 +1,19 @@
+from abc import ABC, abstractmethod
+from typing import Dict, List, Any
+
+class BaseAlayaMemClient(ABC):
+    @abstractmethod
+    def init_session(self, user_id: str, session_id: str) -> Dict:
+        pass
+
+    @abstractmethod
+    def vdb_query(self, messages: List[Any], limit: int) -> Dict:
+        pass
+
+    @abstractmethod
+    def add_session_messages(self, user_id: str, session_id: str, messages: List[Any]) -> None:
+        pass
+
+    @abstractmethod
+    def query(self, user_id: str, session_id: str, message: Any) -> Dict:
+        pass

alayaflow/clients/alayamem/http_client.py

@@ -0,0 +1,64 @@
+import requests
+from typing import List, Any
+
+from alayaflow.clients.alayamem.base_client import BaseAlayaMemClient
+
+
+class HttpAlayaMemClient(BaseAlayaMemClient):
+    def __init__(self, base_url: str):
+        self.base_url = base_url.rstrip("/")
+
+    def init_session(self, user_id, user_name, agent_name):
+        return self._post("/init", {
+            "user_id": user_id,
+            "user_name": "unknown",
+            "agent_name": "unknown",
+        })
+
+    def vdb_query(self, messages: List[Any], limit: int,  collection_name: str):
+        query_text = self._extract_query(messages)
+        return self._post("/vdb/query", {
+            "collection_name": collection_name,
+            "query_text": query_text,
+            "limit": limit,
+        })
+
+    def query(self, user_id, message):
+        return self._post("/query", {
+            "user_id": user_id,
+            "question": self._msg_content(message),
+        })
+
+    def add_session_messages(self, user_id, messages):
+        for msg in messages:
+            return self._post("/add_message", {
+                                "user_id": user_id,
+                                "message": self._msg_content(msg),
+                                "is_user": self._is_user(msg),
+                                "speaker_name": "unknown",
+                            })
+
+    # ---------- private helpers ----------
+
+    def _post(self, path: str, payload: dict):
+        resp = requests.post(f"{self.base_url}{path}", json=payload)
+        resp.raise_for_status()
+        return resp.json()
+
+    def _msg_content(self, msg):
+        # 支持字典格式
+        if isinstance(msg, dict):
+            return msg.get("content", str(msg))
+        # 支持对象格式
+        return msg.content if hasattr(msg, "content") else str(msg)
+
+    def _extract_query(self, messages):
+        if not messages:
+            return ""
+        last_msg = messages[-1]
+        return self._msg_content(last_msg)
+
+    def _is_user(self, msg):
+        if isinstance(msg, dict):
+            return msg.get("role", "").lower() == "user"
+        return "Human" in msg.__class__.__name__ or "User" in msg.__class__.__name__

alayaflow/common/config.py

@@ -0,0 +1,106 @@
+from pathlib import Path
+from typing import Literal, Optional
+from pydantic import model_validator
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+class Settings(BaseSettings):
+    """支持.env改写所有路径的配置类"""
+    # 开发模式配置:
+    # - "dev": pip install -e 可编辑安装，包安装到 <project>/.alaya.ai/...，可直接修改源码
+    # - "dev-uneditable": pip install . 标准安装，包会安装到 site-package
+    # - "prod":pip install alayaflow 部署模式，使用 ~/.alaya.ai/alayaflow
+    dev_mode: Literal["dev", "dev-uneditable", "prod"] = "dev"
+
+    def is_dev(self) -> bool:
+        return self.dev_mode == "dev"
+
+    def is_uneditable_dev(self) -> bool:
+        return self.dev_mode == "dev-uneditable"
+
+    def is_prod(self) -> bool:
+        return self.dev_mode == "prod"
+    
+    alayaflow_root: Optional[Path] = None
+    workspace_root: Optional[Path] = None
+    resources_root: Optional[Path] = None
+    workflow_storage_path: Optional[Path] = None
+    agent_storage_path: Optional[Path] = None
+    app_storage_path: Optional[Path] = None
+    
+    alayahub_url: str = "http://localhost:8000"
+
+    # Langfuse 配置
+    langfuse_enabled: bool = False
+    langfuse_public_key: Optional[str] = ""
+    langfuse_secret_key: Optional[str] = ""
+    langfuse_url: Optional[str] = "http://100.64.0.34:4000/"
+    
+    model_config = SettingsConfigDict(
+        env_file=".env",
+        env_file_encoding="utf-8",
+        extra="ignore" 
+    )
+
+    @property
+    def cache_dir(self) -> Path:
+        return self.workspace_root / "cache"
+
+    @property
+    def envs_dir(self) -> Path:
+        return self.workspace_root / "envs"
+
+    @model_validator(mode="after")
+    def set_default_paths(self):
+        
+        current_file = Path(__file__).absolute()
+        project_root = current_file.parent.parent.parent.parent
+
+        is_editable_install = (project_root / "pyproject.toml").exists() or (project_root / "setup.py").exists()
+
+        if self.alayaflow_root is None:
+            if self.is_dev() and is_editable_install:
+                self.alayaflow_root = project_root
+            else:
+                self.alayaflow_root = current_file.parent.parent.parent
+        else:
+            # 将相对路径转换为绝对路径
+            alayaflow_root_path = Path(self.alayaflow_root)
+            if not alayaflow_root_path.is_absolute():
+                # 如果是相对路径，相对于当前工作目录解析
+                self.alayaflow_root = alayaflow_root_path.resolve()
+            else:
+                self.alayaflow_root = alayaflow_root_path
+
+        if self.workspace_root is None:
+            if self.is_dev() and is_editable_install:
+                self.workspace_root = project_root / ".alaya.ai" / "alayaflow"
+            else:
+                self.workspace_root = Path.home() / ".alaya.ai" / "alayaflow"
+        else:
+            self.workspace_root = Path(self.workspace_root)
+
+        if self.workflow_storage_path is None:
+            self.workflow_storage_path = self.workspace_root / "workflows"
+        else:
+            self.workflow_storage_path = Path(self.workflow_storage_path)
+
+        return self
+
+    @model_validator(mode='after')
+    def create_directories(self):
+        """
+        在配置加载（实例化）完成后，自动检查并创建必要的目录结构
+        """
+        self.workspace_root.mkdir(parents=True, exist_ok=True)
+        self.cache_dir.mkdir(parents=True, exist_ok=True)
+        self.envs_dir.mkdir(parents=True, exist_ok=True)
+        self.workflow_storage_path.mkdir(parents=True, exist_ok=True)
+        
+        return self
+
+    @model_validator(mode='after')
+    def print_config(self):
+        print(self.model_dump())
+        return self
+
+settings = Settings()

alayaflow/component/chat_model.py

@@ -0,0 +1,20 @@
+import requests
+
+from langchain_openai import ChatOpenAI
+
+from alayaflow.common.config import settings
+
+def mk_chat_model_deepseek():
+    return ChatOpenAI(
+        model="deepseek-chat",
+        api_key="sk-4fe7cd96f5e948c79168025372e2327c",
+        base_url="https://api.deepseek.com/v1",
+    )
+
+def mk_chat_model_jet(base_url: str, model_name: str):
+    return ChatOpenAI(
+        model=model_name,
+        api_key="EMPTY",
+        base_url=base_url,
+    )
+

alayaflow/component/intent_classifier.py

@@ -0,0 +1,94 @@
+from typing import List
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.output_parsers import JsonOutputParser
+from langchain_core.exceptions import OutputParserException
+
+from typing import List, Dict, Any, TypedDict, Annotated, Optional
+from langchain_core.language_models import BaseChatModel
+from pydantic import BaseModel, Field
+
+
+class IntentionResult(BaseModel):
+    """
+    意图分类结果模型，标准化返回意图索引和分类原因
+    适配 LangChain 结构化输出、JSON 解析器，支持自动类型校验
+    """
+    # 意图分类索引ID：对应intents列表的下标，兜底时为fallback_index（默认-1）
+    classification_id: int = Field(
+        ...,
+        description="意图分类的索引ID，匹配输入intents列表的下标，兜底值通常为-1",
+        gt=-2  # 简单校验：索引ID最小为-1（避免无效负数，可根据业务调整）
+    )
+
+    reason: str = Field(
+        ...,
+        description="意图分类的依据说明，异常场景下为具体错误信息",
+        min_length=1  # 简单校验：不可为空字符串
+    )
+
+DEFAULT_INTENT_PROMPT_TEMPLATE = """
+你是专业的意图分类助手，需严格按照以下规则处理：
+1. 从给定的选项中为用户输入匹配唯一的意图，返回对应的索引ID（fallback_index={fallback_index} 为兜底选项，仅当无匹配时使用）
+2. 必须以 **纯JSON格式** 输出，字段为 classification_id（int类型）和 reason（str类型），无其他多余文本、注释
+3. reason 需简洁说明分类依据，不超过50字
+
+可用意图选项：
+{intents}
+"""
+
+def execute_intent_classification(
+    query: str, 
+    intents: List[str], 
+    model: BaseChatModel,
+    fallback_index: int = -1
+) -> IntentionResult:
+    """
+    核心业务逻辑：执行意图分类（适配所有支持JSON输出的大模型）。
+    """
+    if not intents:
+        return IntentionResult(classification_id=fallback_index, reason='input intent list is empty')
+
+    parser = JsonOutputParser(pydantic_object=IntentionResult)
+
+    formatted_intents = "\n".join([f"选项{i}: {intent}" for i, intent in enumerate(intents)])
+    prompt = ChatPromptTemplate.from_template(DEFAULT_INTENT_PROMPT_TEMPLATE)
+    full_prompt = prompt.format_prompt(
+        fallback_index=fallback_index,
+        intents=formatted_intents
+    )
+
+    user_prompt = f"### 用户输入\n{query}\n\n{parser.get_format_instructions()}"
+
+    try:
+        # 显式指定 response_format={"type": "json_object"}，强制模型返回JSON
+        response = model.invoke(
+            [
+                ("system", full_prompt.to_string()),
+                ("user", user_prompt)
+            ],
+            response_format={"type": "json_object"}
+        )
+        result_dict = parser.parse(response.content)
+        return IntentionResult(**result_dict)
+    except OutputParserException as e:
+        error_msg = f"JSON解析失败，模型输出非标准格式：{str(e)}"
+        import sys
+        sys.stderr.write(f"Error during classification: {error_msg}\n")
+        return IntentionResult(classification_id=fallback_index, reason=error_msg)
+    except Exception as e:
+        error_msg = f"分类过程中发生错误：{str(e)}"
+        import sys
+        sys.stderr.write(f"Error during classification: {error_msg}\n")
+        return IntentionResult(classification_id=fallback_index, reason=error_msg)
+
+
+# def inner_test():
+#     from alayaflow.component.chat_model import mk_chat_model_deepseek
+#     model = mk_chat_model_deepseek()
+#     query = "你好"
+#     intents = ["问候", "查询"]
+#     result = execute_intent_classification(query, intents, model)
+#     print(result)
+
+# if __name__ == "__main__":
+#     inner_test()

alayaflow/component/langflow/intent_classifier.py

@@ -0,0 +1,83 @@
+from langflow.custom import Component
+from langflow.io import MessageTextInput, IntInput, Output, MultilineInput
+from langflow.schema import Data, Message
+
+from alayaflow.component.intent_classifier import execute_intent_classification
+from alayaflow.component.chat_model import mk_chat_model_deepseek
+
+class IntentClassifierComponent(Component):
+    display_name = "Intent Classifier"
+    description = "基于 LLM 的意图分类器，输出分类 ID 和原因。"
+    icon = "Split"
+    name = "IntentClassifier"
+
+    inputs = [
+        # Input(
+        #     name="llm",
+        #     display_name="Language Model",
+        #     info="请连接一个支持 Structured Output 的模型 (如 OpenAI)。",
+        #     input_types=["LanguageModel"], # 允许连接 LLM 节点
+        #     required=True,
+        # ),
+        MessageTextInput(
+            name="query",
+            display_name="User Query",
+            info="用户的输入文本",
+            required=True,
+        ),
+        MultilineInput(
+            name="intents_text",
+            display_name="Intents List",
+            info="每行输入一个意图描述。",
+            value="查询订单状态\n取消订阅服务\n转人工客服",
+        ),
+        IntInput(
+            name="fallback_index",
+            display_name="Fallback Index",
+            value=-1,
+            advanced=True,
+        ),
+    ]
+
+    outputs = [
+        Output(
+            name="result_data",
+            display_name="Result (Data)",
+            method="classify_to_data",
+        ),
+        Output(
+            name="result_message",
+            display_name="Result (Message)",
+            method="classify_to_message",
+        ),
+    ]
+
+    def classify_to_data(self) -> Data:
+        """输出结构化数据，方便后续逻辑判断"""
+        # 1. 处理输入
+        query = self.query
+        # 将多行文本转换为列表，去除空行
+        intents = [line.strip() for line in self.intents_text.split('\n') if line.strip()]
+        # model = self.llm
+        model = mk_chat_model_deepseek()
+        fallback = self.fallback_index
+
+        # 2. 调用你的业务逻辑
+        result = execute_intent_classification(query, intents, model, fallback)
+        
+        # 更新节点状态显示
+        self.status = f"Classified as ID: {result.classification_id}"
+
+        # 3. 返回 Data 对象
+        return Data(data=result.model_dump())
+
+    def classify_to_message(self) -> Message:
+        """输出文本消息，方便调试查看"""
+        data_output = self.classify_to_data()
+        result = data_output.data
+        
+        text_output = (
+            f"分类结果 ID: {result.get('classification_id', 'N/A')}\n"
+            f"原因: {result.get('reason', 'N/A')}"
+        )
+        return Message(text=text_output)

alayaflow/component/llm_node.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+import json
+from enum import IntEnum
+from functools import cached_property
+from typing import Any, Dict, Optional
+
+from langchain_openai import ChatOpenAI
+from langchain_core.messages import SystemMessage, HumanMessage, AIMessage, BaseMessage
+from langchain_core.runnables import Runnable
+
+
+class ResponseFormat(IntEnum):
+    TEXT = 0
+    JSON = 1
+
+class LLMComponent:
+    def __init__(
+        self,
+        *,
+        # ===== 模型 & prompt =====
+        model_name: 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,
+        retry_json_once: bool = True,
+    ):
+        # —— 配置即成员变量（= Spec）——
+        self.model_name = model_name
+        self.system_prompt = system_prompt
+        self.prompt = prompt
+
+        self.temperature = temperature
+        self.top_p = top_p
+        self.max_tokens = max_tokens
+
+        self.response_format = response_format
+        self.json_schema = json_schema
+        self.outputs = outputs or {}
+        self.retry_json_once = retry_json_once
+
+
+    @cached_property
+    def llm(self) -> Runnable:
+        return ChatOpenAI(model=self.model_name, api_key="sk-4fe7cd96f5e948c79168025372e2327c", base_url="https://api.deepseek.com/v1")
+    
+    def _get_llm(self) -> Runnable:
+        llm = self.llm
+        bind_kwargs: Dict[str, Any] = {}
+
+        if self.temperature is not None:
+            bind_kwargs["temperature"] = self.temperature
+        if self.top_p is not None:
+            bind_kwargs["top_p"] = self.top_p
+        if self.max_tokens is not None:
+            bind_kwargs["max_tokens"] = self.max_tokens
+
+        if bind_kwargs:
+            try:
+                llm = llm.bind(**bind_kwargs)
+            except Exception:
+                pass
+
+        return llm
+    
+    def _invoke(self, system_prompt: str) -> AIMessage:
+        llm = self._get_llm()
+        resp = llm.invoke(
+            [
+                SystemMessage(content=system_prompt),
+                HumanMessage(content=self.prompt),
+            ]
+        )
+
+        if isinstance(resp, AIMessage):
+            return resp
+
+        if isinstance(resp, BaseMessage):
+            return AIMessage(
+                content=getattr(resp, "content", str(resp)),
+                additional_kwargs=getattr(resp, "additional_kwargs", {}) or {},
+                response_metadata=getattr(resp, "response_metadata", {}) or {},
+            )
+
+        return AIMessage(content=str(resp))
+
+    def __call__(self) -> AIMessage:
+        if self.response_format == ResponseFormat.TEXT:
+            return self._invoke(self.system_prompt)
+
+        json_system = (
+            self.system_prompt
+            + "\n\n【输出格式要求】\n"
+              "你必须只输出严格合法的 JSON。\n"
+              "不要输出任何解释、前后缀、Markdown 代码块或多余文本。\n"
+        )
+
+        msg = self._invoke(json_system)
+
+        try:
+            json.loads(msg.content)
+            return msg
+        except Exception:
+            if not self.retry_json_once:
+                return msg
+
+            strict_system = (
+                self.system_prompt
+                + "\n\n【严格输出格式要求】\n"
+                  "只输出严格合法的 JSON（json.loads 必须可解析）。\n"
+                  "禁止输出任何非 JSON 字符。\n"
+            )
+            return self._invoke(strict_system)
+

alayaflow/component/memory.py

@@ -0,0 +1,50 @@
+from alayaflow.clients.alayamem.http_client import HttpAlayaMemClient
+
+
+def query_vdb_message(alayamem_url: str, messages, limit, collection_name = "file_watcher_collection"):
+    mem_client = HttpAlayaMemClient(alayamem_url)
+    try:
+        result = mem_client.vdb_query(messages, limit, collection_name)
+        return {"vdb_results": result.get("results", []), "vdb_response": result}
+    except Exception as e:
+        return {"vdb_results": [], "error": str(e)}
+
+
+def init_memory(alayamem_url: str, user_id, user_name="unknown", agent_name="unknown"):
+    mem_client = HttpAlayaMemClient(alayamem_url)
+    try:
+        return mem_client.init_session(user_id, user_name, agent_name)
+    except Exception as e:
+        return {"memory_initialized": False}
+
+
+def query_message(alayamem_url: str, user_id, messages):
+    mem_client = HttpAlayaMemClient(alayamem_url)
+
+    if not messages:
+        return
+
+    last_message = messages[-1]
+    
+    try:
+        resp = mem_client.query(user_id, last_message)
+    except Exception as e:
+        print(f"[Query User Message] Error: {e}")
+        return []
+
+    return resp
+
+
+def add_message(alayamem_url: str, user_id, session_id, messages):
+    mem_client = HttpAlayaMemClient(alayamem_url)
+
+    if not messages:
+        return
+
+    try:
+        return mem_client.add_session_messages(user_id, messages)
+    except Exception as e:
+        print(f"[Add Messages] Error: {e}")
+        pass
+
+    return