flowllm 0.1.0__py3-none-any.whl → 0.1.1__py3-none-any.whl

flowllm/__init__.py

@@ -0,0 +1,12 @@
+from flowllm import embedding_model
+from flowllm import flow_engine
+from flowllm import llm
+from flowllm import op
+from flowllm import service
+from flowllm import storage
+
+from .app import main
+
+__version__ = "0.1.1"
+
+__all__ = ["main"]

flowllm/app.py

@@ -0,0 +1,25 @@
+import sys
+
+from flowllm.service.base_service import BaseService
+from flowllm.utils.common_utils import load_env
+
+load_env()
+
+from flowllm.config.pydantic_config_parser import PydanticConfigParser
+from flowllm.schema.service_config import ServiceConfig
+from flowllm.context.service_context import C
+
+
+def main():
+    config_parser = PydanticConfigParser(ServiceConfig)
+    service_config: ServiceConfig = config_parser.parse_args(*sys.argv[1:])
+    service_cls = C.resolve_service(service_config.backend)
+    service: BaseService = service_cls(service_config)
+    service()
+
+if __name__ == "__main__":
+    main()
+
+
+# python -m build
+# twine upload dist/*

flowllm/config/default_config.yaml

@@ -0,0 +1,82 @@
+# default config.yaml
+backend: mcp
+language: ""
+thread_pool_max_workers: 32
+ray_max_workers: 8
+
+mcp:
+  transport: sse
+  host: "0.0.0.0"
+  port: 8001
+
+http:
+  host: "0.0.0.0"
+  port: 8001
+  timeout_keep_alive: 600
+  limit_concurrency: 64
+
+
+flow_engine:
+  backend: simple
+
+
+flow:
+  get_a_stock_infos:
+    flow_content: get_ak_a_code_op >> get_ak_a_info_op >> get_ak_a_spot_op >> get_ak_a_money_flow_op >> get_ak_a_financial_info_op >> merge_ak_a_info_op
+    description: "Retrieve the A-share stock codes from the query, and fetch information about these stocks, including company basic information, current stock price and its change percentage, capital inflow and outflow data for the most recent day, and financial information from the latest quarter."
+    input_schema:
+      query:
+        type: "str"
+        description: "user question"
+
+  get_a_stock_news:
+    flow_content: get_ak_a_code_op >> get_ak_a_news_op >> merge_ak_a_info_op
+    description: "Retrieve the A-share stock codes from the query, and obtain the latest news information about these stocks."
+    input_schema:
+      query:
+        type: "str"
+        description: "user question"
+
+  mock_flow:
+    flow_content: mock1_op>>((mock4_op>>mock2_op)|mock5_op)>>(mock3_op|mock6_op)
+    description: "mock flow"
+    input_schema:
+      a:
+        type: "str"
+        description: "mock attr a"
+        required: true
+      b:
+        type: "str"
+        description: "mock attr b"
+        required: true
+
+op:
+  mock1_op:
+    backend: mock1_op
+    llm: default
+    vector_store: default
+
+llm:
+  default:
+    backend: openai_compatible
+    model_name: qwen3-30b-a3b-thinking-2507
+    params:
+      temperature: 0.6
+  qwen3_30b_instruct:
+    backend: openai_compatible
+    model_name: qwen3-30b-a3b-instruct-2507
+
+embedding_model:
+  default:
+    backend: openai_compatible
+    model_name: text-embedding-v4
+    params:
+      dimensions: 1024
+
+vector_store:
+  default:
+    backend: elasticsearch
+    embedding_model: default
+    params:
+      hosts: "http://localhost:9200"
+

flowllm/config/pydantic_config_parser.py

@@ -0,0 +1,242 @@
+import copy
+import json
+from pathlib import Path
+from typing import Any, Generic, List, Type, TypeVar
+
+import yaml
+from loguru import logger
+from pydantic import BaseModel
+
+T = TypeVar('T', bound=BaseModel)
+
+
+class PydanticConfigParser(Generic[T]):
+    """
+    Pydantic Configuration Parser
+    
+    Supported configuration sources (priority from low to high):
+    1. Default configuration (Pydantic model default values)
+    2. YAML configuration file
+    3. Command line arguments (dot notation format)
+    4. Runtime parameters
+    """
+
+    def __init__(self, config_class: Type[T]):
+        """
+        Initialize configuration parser
+        
+        Args:
+            config_class: Pydantic configuration model class
+        """
+        self.config_class = config_class
+        self.config_dict: dict = {}
+
+    def parse_dot_notation(self, dot_list: List[str]) -> dict:
+        """
+        Parse dot notation format configuration list
+        
+        Args:
+            dot_list: Configuration list in format ['a.b.c=value', 'x.y=123']
+            
+        Returns:
+            Parsed nested dictionary
+        """
+        config_dict = {}
+
+        for item in dot_list:
+            if '=' not in item:
+                continue
+
+            key_path, value_str = item.split('=', 1)
+            keys = key_path.split('.')
+
+            # Automatic type conversion
+            value = self._convert_value(value_str)
+
+            # Build nested dictionary
+            current_dict = config_dict
+            for key in keys[:-1]:
+                if key not in current_dict:
+                    current_dict[key] = {}
+                current_dict = current_dict[key]
+
+            current_dict[keys[-1]] = value
+
+        return config_dict
+
+    @staticmethod
+    def _convert_value(value_str: str) -> Any:
+        """
+        Automatically convert string values to appropriate Python types
+        
+        Args:
+            value_str: String value
+            
+        Returns:
+            Converted value
+        """
+        value_str = value_str.strip()
+
+        if value_str.lower() in ("true", "false"):
+            return value_str.lower() == "true"
+
+        if value_str.lower() in ("none", "null"):
+            return None
+
+        try:
+            if "." not in value_str and "e" not in value_str.lower():
+                return int(value_str)
+
+            return float(value_str)
+
+        except ValueError:
+            pass
+
+        try:
+            return json.loads(value_str)
+        except (json.JSONDecodeError, ValueError):
+            pass
+
+        return value_str
+
+    @staticmethod
+    def load_from_yaml(yaml_path: str | Path) -> dict:
+        """
+        Load configuration from YAML file
+        
+        Args:
+            yaml_path: YAML file path
+            
+        Returns:
+            Configuration dictionary
+        """
+        if isinstance(yaml_path, str):
+            yaml_path = Path(yaml_path)
+
+        if not yaml_path.exists():
+            raise FileNotFoundError(f"Configuration file does not exist: {yaml_path}")
+
+        with yaml_path.open() as f:
+            return yaml.safe_load(f)
+
+    def merge_configs(self, *config_dicts: dict) -> dict:
+        """
+        Deep merge multiple configuration dictionaries
+        
+        Args:
+            *config_dicts: Multiple configuration dictionaries
+            
+        Returns:
+            Merged configuration dictionary
+        """
+        result = {}
+
+        for config_dict in config_dicts:
+            result = self._deep_merge(result, config_dict)
+
+        return result
+
+    def _deep_merge(self, base_dict: dict, update_dict: dict) -> dict:
+        """
+        Deep merge two dictionaries
+        
+        Args:
+            base_dict: Base dictionary
+            update_dict: Update dictionary
+            
+        Returns:
+            Merged dictionary
+        """
+        result = base_dict.copy()
+
+        for key, value in update_dict.items():
+            if key in result and isinstance(result[key], dict) and isinstance(value, dict):
+                result[key] = self._deep_merge(result[key], value)
+            else:
+                result[key] = value
+
+        return result
+
+    def parse_args(self, *args) -> T:
+        """
+        Parse command line arguments and return configuration object
+        
+        Args:
+            args: Command line arguments.
+            
+        Returns:
+            Parsed configuration object
+        """
+        configs_to_merge = []
+
+        # 1. Default configuration (from Pydantic model)
+        default_config = self.config_class().model_dump()
+        configs_to_merge.append(default_config)
+
+        # 2. YAML configuration file
+        config = ""
+        filter_args = []
+        for arg in args:
+            if "=" not in arg:
+                continue
+
+            arg = arg.lstrip("--").lstrip("-")
+
+            if "c=" in arg or "config=" in arg:
+                config = arg.split("=")[-1]
+            else:
+                filter_args.append(arg)
+
+        if config:
+            if not config.endswith(".yaml"):
+                config += ".yaml"
+
+            # load pre-built configs
+            config_path = Path(__file__).parent / config
+            if not config_path.exists():
+                config_path = Path(config)
+
+            yaml_config = self.load_from_yaml(config_path)
+            logger.info(f"flowllm using config={config_path}")
+            configs_to_merge.append(yaml_config)
+
+        # 3. Command line override configuration
+        if args:
+            cli_config = self.parse_dot_notation(filter_args)
+            configs_to_merge.append(cli_config)
+
+        # Merge all configurations
+        self.config_dict = self.merge_configs(*configs_to_merge)
+
+        # Create and validate final configuration object
+        return self.config_class.model_validate(self.config_dict)
+
+    def update_config(self, **kwargs) -> T:
+        """
+        Update configuration object using keyword arguments
+        
+        Args:
+            **kwargs: Configuration items to update, supports dot notation, e.g. server__host='localhost'
+            
+        Returns:
+            Updated configuration object
+        """
+        # Convert kwargs to dot notation format
+        dot_list = []
+        for key, value in kwargs.items():
+            # support double underscore as dot replacement (server__host -> server.host)
+            dot_key = key.replace("__", ".")
+            dot_list.append(f"{dot_key}={value}")
+
+        # Parse and merge configuration
+        override_config = self.parse_dot_notation(dot_list)
+        final_config = self.merge_configs(copy.deepcopy(self.config_dict), override_config)
+
+        return self.config_class.model_validate(final_config)
+
+
+def get_default_config():
+    from flowllm.schema.service_config import ServiceConfig
+
+    config_parser = PydanticConfigParser(ServiceConfig)
+    return config_parser.parse_args("config=default_config")

flowllm/context/base_context.py

@@ -0,0 +1,59 @@
+from typing import List
+
+
+class BaseContext:
+    def __init__(self, **kwargs):
+        self._data = {**kwargs}
+
+    def __getattr__(self, name: str):
+        if name in self._data:
+            return self._data[name]
+
+        raise AttributeError(f"'{self.__class__.__name__}' has no attribute '{name}'")
+
+    def __setattr__(self, name: str, value):
+        if name == "_data":
+            super().__setattr__(name, value)
+        else:
+            self._data[name] = value
+
+    def __getitem__(self, name: str):
+        if name not in self._data:
+            raise AttributeError(f"'{self.__class__.__name__}' has no attribute '{name}'")
+        return self._data[name]
+
+    def __setitem__(self, name: str, value):
+        self._data[name] = value
+
+    def __contains__(self, name: str):
+        return name in self._data
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}({self._data!r})"
+
+    def dump(self) -> dict:
+        return self._data
+
+    @property
+    def keys(self) -> List[str]:
+        return sorted(self._data.keys())
+
+    def update(self, **kwargs):
+        self._data.update(kwargs)
+
+
+if __name__ == "__main__":
+    ctx = BaseContext(**{"name": "Alice", "age": 30, "city": "New York"})
+
+    print(ctx.name)
+    print(ctx.age)
+    print(ctx.city)
+
+    ctx.email = "alice@example.com"
+    ctx["email"] = "alice@example.com"
+    print(ctx.email)
+
+    print(ctx.keys)
+    print(ctx)
+
+    # print(ctx.city2)

flowllm/context/flow_context.py

@@ -0,0 +1,28 @@
+import uuid
+
+from flowllm.context.base_context import BaseContext
+from flowllm.schema.flow_response import FlowResponse
+from flowllm.schema.service_config import ServiceConfig
+
+
+class FlowContext(BaseContext):
+
+    def __init__(self, flow_id: str = uuid.uuid4().hex, **kwargs):
+        super().__init__(**kwargs)
+        self.flow_id: str = flow_id
+
+    @property
+    def service_config(self) -> ServiceConfig:
+        return self._data.get("service_config")
+
+    @service_config.setter
+    def service_config(self, service_config: ServiceConfig):
+        self._data["service_config"] = service_config
+
+    @property
+    def response(self) -> FlowResponse:
+        return self._data.get("response")
+
+    @response.setter
+    def response(self, response: FlowResponse):
+        self._data["response"] = response

llmflow/op/prompt_mixin.py → flowllm/context/prompt_handler.py

@@ -3,42 +3,56 @@ from pathlib import Path
 import yaml
 from loguru import logger
 
+from flowllm.context.base_context import BaseContext
+from flowllm.context.service_context import C
 
-class PromptMixin:
 
-    def __init__(self):
-        self._prompt_dict: dict = {}
+class PromptHandler(BaseContext):
+
+    def __init__(self, language: str = "", **kwargs):
+        super().__init__(**kwargs)
+        self.language: str = language or C.language
 
     def load_prompt_by_file(self, prompt_file_path: Path | str = None):
         if prompt_file_path is None:
-            return
+            return self
 
         if isinstance(prompt_file_path, str):
             prompt_file_path = Path(prompt_file_path)
 
         if not prompt_file_path.exists():
-            return
+            return self
 
         with prompt_file_path.open() as f:
             prompt_dict = yaml.load(f, yaml.FullLoader)
             self.load_prompt_dict(prompt_dict)
+        return self
 
     def load_prompt_dict(self, prompt_dict: dict = None):
         if not prompt_dict:
-            return
+            return self
 
         for key, value in prompt_dict.items():
             if isinstance(value, str):
-                if key in self._prompt_dict:
-                    self._prompt_dict[key] = value
+                if key in self._data:
+                    self._data[key] = value
                     logger.warning(f"prompt_dict key={key} overwrite!")
 
                 else:
-                    self._prompt_dict[key] = value
+                    self._data[key] = value
                     logger.info(f"add prompt_dict key={key}")
+        return self
+
+    def get_prompt(self, prompt_name: str):
+        key: str = prompt_name
+        if self.language and not key.endswith(self.language.strip()):
+            key += "_" + self.language.strip()
 
-    def prompt_format(self, prompt_name: str, **kwargs):
-        prompt = self._prompt_dict[prompt_name]
+        assert key in self._data, f"prompt_name={key} not found."
+        return self._data[key]
+
+    def prompt_format(self, prompt_name: str, **kwargs) -> str:
+        prompt = self.get_prompt(prompt_name)
 
         flag_kwargs = {k: v for k, v in kwargs.items() if isinstance(v, bool)}
         other_kwargs = {k: v for k, v in kwargs.items() if not isinstance(v, bool)}
@@ -69,6 +83,3 @@ class PromptMixin:
             prompt = prompt.format(**other_kwargs)
 
         return prompt
-
-    def get_prompt(self, key: str):
-        return self._prompt_dict[key]

flowllm/context/registry.py

@@ -0,0 +1,26 @@
+from loguru import logger
+
+from flowllm.context.base_context import BaseContext
+from flowllm.utils.common_utils import camel_to_snake
+
+
+class Registry(BaseContext):
+
+    def __init__(self, registry_name: str, enable_log: bool = True, **kwargs):
+        super().__init__(**kwargs)
+        self.registry_name: str = registry_name
+        self.enable_log: bool = enable_log
+
+    def register(self, name: str = ""):
+        def decorator(cls):
+            class_name = name if name else camel_to_snake(cls.__name__)
+            if self.enable_log:
+                if class_name in self._data:
+                    logger.warning(f"{self.registry_name}.class({class_name}) is already registered!")
+                else:
+                    logger.info(f"{self.registry_name}.class({class_name}) is registered.")
+
+            self._data[class_name] = cls
+            return cls
+
+        return decorator

flowllm/context/service_context.py

@@ -0,0 +1,103 @@
+import uuid
+from concurrent.futures import ThreadPoolExecutor
+from typing import Dict
+
+from flowllm.context.base_context import BaseContext
+from flowllm.context.registry import Registry
+from flowllm.utils.singleton import singleton
+
+
+@singleton
+class ServiceContext(BaseContext):
+
+    def __init__(self, service_id: str = uuid.uuid4().hex, **kwargs):
+        super().__init__(**kwargs)
+        self.service_id: str = service_id
+        self.registry_dict: Dict[str, Registry] = \
+            {k: Registry(k) for k in ["embedding_model", "llm", "vector_store", "op", "flow_engine", "service"]}
+
+    @property
+    def language(self) -> str:
+        return self._data.get("language", "")
+
+    @language.setter
+    def language(self, value: str):
+        self._data["language"] = value
+
+    @property
+    def thread_pool(self) -> ThreadPoolExecutor:
+        return self._data["thread_pool"]
+
+    @thread_pool.setter
+    def thread_pool(self, thread_pool: ThreadPoolExecutor):
+        self._data["thread_pool"] = thread_pool
+
+    def get_vector_store(self, name: str = "default"):
+        vector_store_dict: dict = self._data["vector_store_dict"]
+        if name not in vector_store_dict:
+            raise KeyError(f"vector store {name} not found")
+
+        return vector_store_dict[name]
+
+    def set_vector_store(self, name: str, vector_store):
+        if "vector_store_dict" not in self._data:
+            self.set_vector_stores({})
+
+        self._data["vector_store_dict"][name] = vector_store
+
+    def set_vector_stores(self, vector_store_dict: dict):
+        self._data["vector_store_dict"] = vector_store_dict
+
+    """
+    register models
+    """
+
+    def register_embedding_model(self, name: str = ""):
+        return self.registry_dict["embedding_model"].register(name=name)
+
+    def register_llm(self, name: str = ""):
+        return self.registry_dict["llm"].register(name=name)
+
+    def register_vector_store(self, name: str = ""):
+        return self.registry_dict["vector_store"].register(name=name)
+
+    def register_op(self, name: str = ""):
+        return self.registry_dict["op"].register(name=name)
+
+    def register_flow_engine(self, name: str = ""):
+        return self.registry_dict["flow_engine"].register(name=name)
+
+    def register_service(self, name: str = ""):
+        return self.registry_dict["service"].register(name=name)
+
+    """
+    resolve models
+    """
+
+    def resolve_embedding_model(self, name: str):
+        assert name in self.registry_dict["embedding_model"], f"embedding_model={name} not found!"
+        return self.registry_dict["embedding_model"][name]
+
+    def resolve_llm(self, name: str):
+        assert name in self.registry_dict["llm"], f"llm={name} not found!"
+        return self.registry_dict["llm"][name]
+
+    def resolve_vector_store(self, name: str):
+        assert name in self.registry_dict["vector_store"], f"vector_store={name} not found!"
+        return self.registry_dict["vector_store"][name]
+
+    def resolve_op(self, name: str):
+        assert name in self.registry_dict["op"], f"op={name} not found!"
+        return self.registry_dict["op"][name]
+
+    def resolve_flow_engine(self, name: str):
+        assert name in self.registry_dict["flow_engine"], f"flow={name} not found!"
+        return self.registry_dict["flow_engine"][name]
+
+    def resolve_service(self, name: str):
+        assert name in self.registry_dict["service"], f"service={name} not found!"
+        return self.registry_dict["service"][name]
+
+
+
+C = ServiceContext()

flowllm/embedding_model/__init__.py

@@ -0,0 +1 @@
+from flowllm.embedding_model.openai_compatible_embedding_model import OpenAICompatibleEmbeddingModel

{llmflow → flowllm}/embedding_model/base_embedding_model.py

@@ -4,7 +4,7 @@ from typing import List
 from loguru import logger
 from pydantic import BaseModel, Field
 
-from llmflow.schema.vector_node import VectorNode
+from flowllm.schema.vector_node import VectorNode
 
 
 class BaseEmbeddingModel(BaseModel, ABC):
@@ -101,4 +101,4 @@ class BaseEmbeddingModel(BaseModel, ABC):
             return nodes
 
         else:
-            raise RuntimeError(f"unsupported type={type(nodes)}")
+            raise TypeError(f"unsupported type={type(nodes)}")