flowllm 0.1.2__py3-none-any.whl → 0.1.5__py3-none-any.whl

flowllm/__init__.py

@@ -1,5 +1,9 @@
 import os
 
+from flowllm.utils.logger_utils import init_logger
+
+init_logger()
+
 from flowllm.utils.common_utils import load_env
 
 load_env()
@@ -14,8 +18,9 @@ if not os.environ.get("FLOW_USE_FRAMEWORK", "").lower() == "true":
 
 from flowllm import service
 
-from flowllm.context.service_context import C
-from flowllm.op import BaseOp, BaseRayOp, BaseLLMOp
+from flowllm.context import C
+from flowllm.op import BaseOp, BaseLLMOp, BaseToolOp
+
 
-__version__ = "0.1.2"
+__version__ = "0.1.5"
 

flowllm/app.py

@@ -5,7 +5,7 @@ from flowllm.service.base_service import BaseService
 
 def main():
     with BaseService.get_service(*sys.argv[1:]) as service:
-        service()
+        service(logo="FlowLLM")
 
 
 if __name__ == "__main__":

flowllm/config/base.yaml

@@ -0,0 +1,75 @@
+backend: http
+language: ""
+thread_pool_max_workers: 64
+ray_max_workers: 1
+
+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:
+  llm_flow:
+    flow_content: simple_llm_op
+    stream: false
+    use_async: true
+    service_type: http
+    description: "llm_flow"
+    input_schema:
+      query:
+        type: "str"
+        description: "user query"
+        required: true
+
+  llm_flow_stream:
+    flow_content: stream_llm_op
+    stream: true
+    use_async: true
+    service_type: http
+    description: "llm_flow"
+    input_schema:
+      query:
+        type: "str"
+        description: "user query"
+        required: true
+
+op:
+  mock1_op:
+    backend: mock1_op
+    llm: default
+    vector_store: default
+
+llm:
+  default:
+    backend: openai_compatible
+    model_name: qwen3-30b-a3b-instruct-2507
+    params:
+      temperature: 0.6
+
+  qwen3_30b_instruct:
+    backend: openai_compatible
+    model_name: qwen3-30b-a3b-instruct-2507
+
+  qwen3_30b_thinking:
+    backend: openai_compatible
+    model_name: qwen3-30b-a3b-thinking-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/fin_supply.yaml

@@ -0,0 +1,39 @@
+backend: mcp
+import_config: base
+disabled_flows:
+  - llm_flow
+  - llm_flow_stream
+  - mock_async_tool_flow
+  - mock_tool_flow
+  - react_llm_tool_flow
+  - simple_llm_tool_flow
+  - stream_llm_tool_flow
+
+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
+    stream: false
+    use_async: false
+    service_type: http+mcp
+    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
+    stream: false
+    use_async: false
+    service_type: http+mcp
+    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"
+
+  ant_search:
+    flow_content: ant_search_op
+
+  ant_investment:
+    flow_content: ant_investment_op

flowllm/config/pydantic_config_parser.py

@@ -202,9 +202,24 @@ class PydanticConfigParser(Generic[T]):
         config_path = Path(self.current_file).parent / config
         if not config_path.exists():
             config_path = Path(config)
+        logger.info(f"flowllm using config={config_path}")
 
         yaml_config = self.load_from_yaml(config_path)
-        logger.info(f"flowllm using config={config_path}")
+
+        # load import configs
+        import_config = yaml_config.get("import_config", "")
+        if import_config:
+            if not import_config.endswith(".yaml"):
+                import_config += ".yaml"
+            import_config_path = Path(self.current_file).parent / import_config
+            if not import_config_path.exists():
+                import_config_path = Path(import_config)
+            logger.info(f"flowllm using import_config_path={import_config_path}")
+
+            # load import config
+            import_yaml_config = self.load_from_yaml(import_config_path)
+            configs_to_merge.append(import_yaml_config)
+
         configs_to_merge.append(yaml_config)
 
         # 3. Command line override configuration

flowllm/context/__init__.py

@@ -0,0 +1,2 @@
+from .flow_context import FlowContext
+from .service_context import C

flowllm/context/base_context.py

@@ -1,22 +1,13 @@
 class BaseContext:
     def __init__(self, **kwargs):
-        self._data = {**kwargs}
+        self._data: dict = {**kwargs}
 
     def __getattr__(self, name: str):
-        # Avoid infinite recursion when _data is not yet initialized
-        if name == '_data':
-            raise AttributeError(f"'{self.__class__.__name__}' has no attribute '{name}'")
-        
-        # Use object.__getattribute__ to safely access _data
-        try:
-            data = object.__getattribute__(self, '_data')
-        except AttributeError:
-            raise AttributeError(f"'{self.__class__.__name__}' has no attribute '{name}'")
-            
+        data = object.__getattribute__(self, "_data")
         if name in data:
             return data[name]
-
-        raise AttributeError(f"'{self.__class__.__name__}' has no attribute '{name}'")
+        else:
+            raise AttributeError(f"'{self.__class__.__name__}' has no attribute '{name}'")
 
     def __setattr__(self, name: str, value):
         if name == "_data":
@@ -25,9 +16,10 @@ class BaseContext:
             self._data[name] = value
 
     def __getitem__(self, name: str):
-        if name not in self._data:
+        if name in self._data:
+            return self._data[name]
+        else:
             raise AttributeError(f"'{self.__class__.__name__}' has no attribute '{name}'")
-        return self._data[name]
 
     def __setitem__(self, name: str, value):
         self._data[name] = value
@@ -48,19 +40,17 @@ class BaseContext:
     def keys(self):
         return self._data.keys()
 
-    def update(self, **kwargs):
+    def update(self, kwargs: dict):
         self._data.update(kwargs)
 
     def items(self):
         return self._data.items()
 
     def __getstate__(self):
-        """Support for pickle serialization"""
-        return {'_data': self._data}
+        return self._data
     
     def __setstate__(self, state):
-        """Support for pickle deserialization"""
-        self._data = state['_data']
+        self._data = state
 
 if __name__ == "__main__":
     ctx = BaseContext(**{"name": "Alice", "age": 30, "city": "New York"})

flowllm/context/flow_context.py

@@ -1,16 +1,59 @@
+import asyncio
 import uuid
+from typing import Optional
 
 from flowllm.context.base_context import BaseContext
+from flowllm.enumeration.chunk_enum import ChunkEnum
 from flowllm.schema.flow_response import FlowResponse
+from flowllm.schema.flow_stream_chunk import FlowStreamChunk
 
 
 class FlowContext(BaseContext):
 
     def __init__(self,
                  flow_id: str = uuid.uuid4().hex,
-                 response: FlowResponse = None,
+                 response: Optional[FlowResponse] = None,
+                 stream_queue: Optional[asyncio.Queue] = None,
                  **kwargs):
         super().__init__(**kwargs)
 
         self.flow_id: str = flow_id
-        self.response: FlowResponse = FlowResponse() if response is None else response
+        self.response: Optional[FlowResponse] = response if response is not None else FlowResponse()
+        self.stream_queue: Optional[asyncio.Queue] = stream_queue
+
+    async def add_stream_chunk(self, stream_chunk: FlowStreamChunk):
+        stream_chunk.flow_id = self.flow_id
+        await self.stream_queue.put(stream_chunk)
+        return self
+
+    async def add_stream_chunk_and_type(self, chunk: str | bytes, chunk_type: ChunkEnum):
+        await self.stream_queue.put(FlowStreamChunk(flow_id=self.flow_id, chunk_type=chunk_type, chunk=chunk))
+        return self
+
+    async def add_stream_answer(self, chunk: str):
+        await self.add_stream_chunk_and_type(chunk_type=ChunkEnum.ANSWER, chunk=chunk)
+        return self
+
+    async def add_stream_think(self, chunk: str):
+        await self.add_stream_chunk_and_type(chunk_type=ChunkEnum.THINK, chunk=chunk)
+        return self
+
+    async def add_stream_error(self, e: Exception):
+        await self.add_stream_chunk_and_type(chunk_type=ChunkEnum.ERROR, chunk=str(e))
+        return self
+
+    async def add_stream_done(self):
+        done_chunk = FlowStreamChunk(flow_id=self.flow_id, chunk_type=ChunkEnum.DONE, chunk="", done=True)
+        await self.stream_queue.put(done_chunk)
+        return self
+
+    def add_response_error(self, e: Exception):
+        self.response.success = False
+        self.response.answer = str(e.args)
+
+    def copy(self, **kwargs) -> "FlowContext":
+        context_kwargs = self.dump()
+        context_kwargs.update(kwargs)
+        context_kwargs["response"] = FlowResponse()
+        context = FlowContext(**context_kwargs)
+        return context

flowllm/context/service_context.py

@@ -1,15 +1,18 @@
+import asyncio
+import json
 import os
 import uuid
 from concurrent.futures import ThreadPoolExecutor
 from inspect import isclass
 from typing import Dict, List
 
-import ray
+from fastmcp import Client
 from loguru import logger
 
 from flowllm.context.base_context import BaseContext
 from flowllm.context.registry import Registry
 from flowllm.schema.service_config import ServiceConfig, EmbeddingModelConfig
+from flowllm.schema.tool_call import ToolCall
 from flowllm.utils.singleton import singleton
 
 
@@ -24,6 +27,7 @@ class ServiceContext(BaseContext):
         self.language: str = ""
         self.thread_pool: ThreadPoolExecutor | None = None
         self.vector_store_dict: dict = {}
+        self.sse_mcp_dict: dict = {}
 
         self.registry_dict: Dict[str, Registry] = {}
         use_framework: bool = os.environ.get("FLOW_USE_FRAMEWORK", "").lower() == "true"
@@ -37,13 +41,42 @@ class ServiceContext(BaseContext):
                     register_flow_module = False
             self.registry_dict[key] = Registry(key, enable_log=enable_log, register_flow_module=register_flow_module)
 
-        self.tool_flow_dict: dict = {}
+        self.flow_dict: dict = {}
 
-    def set_default_service_config(self):
-        from flowllm.config.pydantic_config_parser import PydanticConfigParser
+    def set_service_config(self, parser=None, config_name: str = "config=base"):
+        if parser is None:
+            from flowllm.config.pydantic_config_parser import PydanticConfigParser
+            parser = PydanticConfigParser
 
-        config_parser = PydanticConfigParser(ServiceConfig)
-        self.service_config = config_parser.parse_args("config=default")
+        config_parser = parser(ServiceConfig)
+        self.service_config = config_parser.parse_args(config_name)
+        return self
+
+    @staticmethod
+    async def get_sse_mcp_dict(hosts: List[str]):
+        tool_call_dict = {}
+
+        for host in hosts:
+            async with Client(f"{host}/sse/") as client:
+                tools = await client.list_tools()
+                for tool in tools:
+                    tool_call = ToolCall.from_mcp_tool(tool)
+                    key = host + "/" + tool.name
+                    tool_call_dict[key] = tool_call
+                    logger.info(f"{host} find mcp_name={key} "
+                                f"tool_call={json.dumps(tool_call.simple_input_dump(), ensure_ascii=False)}")
+        return tool_call_dict
+
+    def prepare_sse_mcp(self):
+        hosts = os.getenv("FLOW_MCP_HOSTS")
+        if not hosts:
+            return self
+
+        hosts = [x.strip() for x in hosts.strip().split(",") if x.strip()]
+        if not hosts:
+            return self
+
+        self.sse_mcp_dict = asyncio.run(self.get_sse_mcp_dict(hosts))
         return self
 
     def init_by_service_config(self, service_config: ServiceConfig = None):
@@ -53,6 +86,7 @@ class ServiceContext(BaseContext):
         self.language = self.service_config.language
         self.thread_pool = ThreadPoolExecutor(max_workers=self.service_config.thread_pool_max_workers)
         if self.service_config.ray_max_workers > 1:
+            import ray
             ray.init(num_cpus=self.service_config.ray_max_workers)
 
         # add vector store
@@ -65,33 +99,50 @@ class ServiceContext(BaseContext):
             self.vector_store_dict[name] = vector_store_cls(embedding_model=embedding_model, **config.params)
 
         from flowllm.flow.base_tool_flow import BaseToolFlow
-        from flowllm.flow.gallery import ExpressionToolFlow
+        from flowllm.flow.expression.expression_tool_flow import ExpressionToolFlow
 
         # add tool flow cls
         for name, tool_flow_cls in self.registry_dict["tool_flow"].items():
             if not isclass(tool_flow_cls):
                 continue
 
+            if name in self.service_config.disabled_flows:
+                continue
+
             tool_flow: BaseToolFlow = tool_flow_cls()
-            self.tool_flow_dict[tool_flow.name] = tool_flow
-            logger.info(f"add diy tool_flow: {tool_flow.name}")
+            self.flow_dict[tool_flow.name] = tool_flow
+            logger.info(f"add cls tool_flow: {tool_flow.name}")
 
         # add tool flow config
         for name, flow_config in self.service_config.flow.items():
+            if name in self.service_config.disabled_flows:
+                continue
+
             flow_config.name = name
             tool_flow: BaseToolFlow = ExpressionToolFlow(flow_config=flow_config)
-            self.tool_flow_dict[tool_flow.name] = tool_flow
+            self.flow_dict[tool_flow.name] = tool_flow
             logger.info(f"add expression tool_flow:{tool_flow.name}")
 
+    def stop_by_service_config(self, wait_thread_pool=True, wait_ray: bool = True):
+        self.thread_pool.shutdown(wait=wait_thread_pool)
+        if self.service_config.ray_max_workers > 1:
+            import ray
+            ray.shutdown(_exiting_interpreter=not wait_ray)
+
+        from flowllm.storage.vector_store.base_vector_store import BaseVectorStore
+        for name, vector_store in self.vector_store_dict.items():
+            assert isinstance(vector_store, BaseVectorStore)
+            vector_store.close()
+
     def get_vector_store(self, name: str = "default"):
         return self.vector_store_dict[name]
 
     def get_tool_flow(self, name: str = "default"):
-        return self.tool_flow_dict[name]
+        return self.flow_dict[name]
 
     @property
     def tool_flow_names(self) -> List[str]:
-        return sorted(self.tool_flow_dict.keys())
+        return sorted(self.flow_dict.keys())
 
     """
     register models
@@ -143,5 +194,15 @@ class ServiceContext(BaseContext):
         assert name in self.registry_dict["service"], f"service={name} not found!"
         return self.registry_dict["service"][name]
 
+    @staticmethod
+    def list_flow_schemas() -> List[dict]:
+        from flowllm.flow.base_tool_flow import BaseToolFlow
+
+        flow_schemas = []
+        for name, tool_flow in C.flow_dict.items():
+            assert isinstance(tool_flow, BaseToolFlow)
+            flow_schemas.append(tool_flow.tool_call.simple_input_dump())
+        return flow_schemas
+
 
 C = ServiceContext()

flowllm/embedding_model/openai_compatible_embedding_model.py

@@ -65,8 +65,7 @@ class OpenAICompatibleEmbeddingModel(BaseEmbeddingModel):
             model=self.model_name,
             input=input_text,
             dimensions=self.dimensions,
-            encoding_format=self.encoding_format
-        )
+            encoding_format=self.encoding_format)
 
         if isinstance(input_text, str):
             return completion.data[0].embedding

flowllm/enumeration/chunk_enum.py

@@ -7,3 +7,4 @@ class ChunkEnum(str, Enum):
     TOOL = "tool"
     USAGE = "usage"
     ERROR = "error"
+    DONE = "done"

flowllm/flow/__init__.py

@@ -1 +1,10 @@
+from .base_flow import BaseFlow
+from .base_tool_flow import BaseToolFlow
+from .tool_op_flow import TavilySearchToolFlow, DashscopeSearchToolFlow, SimpleLLMToolFlow, ReactLLMToolFlow, \
+    StreamLLMToolFlow
+
+"""
+"""
+
 from . import gallery
+from . import expression

flowllm/flow/base_flow.py

@@ -1,23 +1,35 @@
+import asyncio
 from abc import ABC, abstractmethod
-from typing import Optional
+from functools import partial
+from typing import Union
 
 from loguru import logger
 
 from flowllm.context.flow_context import FlowContext
+from flowllm.context.service_context import C
 from flowllm.op.base_op import BaseOp
 from flowllm.op.parallel_op import ParallelOp
 from flowllm.op.sequential_op import SequentialOp
 from flowllm.schema.flow_response import FlowResponse
+from flowllm.schema.flow_stream_chunk import FlowStreamChunk
 from flowllm.utils.common_utils import camel_to_snake
 
 
 class BaseFlow(ABC):
 
-    def __init__(self, name: str = "", **kwargs):
+    def __init__(self,
+                 name: str = "",
+                 use_async: bool = True,
+                 stream: bool = True,
+                 service_type: str = "",
+                 **kwargs):
         self.name: str = name or camel_to_snake(self.__class__.__name__)
+        self.use_async: bool = use_async
+        self.stream: bool = stream
+        self.service_type: str = service_type
         self.flow_params: dict = kwargs
 
-        self.flow_op: Optional[BaseOp] = self.build_flow()
+        self.flow_op = self.build_flow()
         self.print_flow()
 
     @abstractmethod
@@ -53,20 +65,41 @@ class BaseFlow(ABC):
 
         else:
             logger.info(f"{prefix}Operation: {op.name}")
+            if op.sub_op is not None:
+                self._print_operation_tree(op.sub_op, indent + 2)
 
-    def return_callback(self, context: FlowContext):
-        return context.response
+    def after_flow(self, context):
+        ...
 
-    def __call__(self, **kwargs) -> FlowResponse:
-        context = FlowContext(**kwargs)
+    async def __call__(self, **kwargs) -> Union[FlowResponse | FlowStreamChunk | None]:
+        context = FlowContext(stream=self.stream, use_async=self.use_async, service_type=self.service_type, **kwargs)
         logger.info(f"request.params={kwargs}")
 
         try:
-            self.flow_op(context=context)
+            flow_op: BaseOp = self.build_flow()
+
+            if self.use_async:
+                await flow_op.async_call(context=context)
+
+            else:
+                loop = asyncio.get_event_loop()
+                op_call_fn = partial(flow_op.__call__, context=context)
+                await loop.run_in_executor(executor=C.thread_pool, func=op_call_fn)  # noqa
+
+            if self.stream:
+                await context.add_stream_done()
+            else:
+                self.after_flow(context)
 
         except Exception as e:
             logger.exception(f"flow_name={self.name} encounter error={e.args}")
-            context.response.success = False
-            context.response.answer = str(e.args)
 
-        return self.return_callback(context=context)
+            if self.stream:
+                await context.add_stream_error(e)
+            else:
+                context.add_response_error(e)
+
+        if self.stream:
+            return context.stream_queue
+        else:
+            return context.response

flowllm/flow/expression/__init__.py

@@ -0,0 +1 @@
+from .expression_tool_flow import ExpressionToolFlow

flowllm/flow/{parser → expression}/expression_parser.py

@@ -141,11 +141,13 @@ class ExpressionParser:
     def _create_op(op_name: str) -> BaseOp:
         if op_name in C.service_config.op:
             op_config: OpConfig = C.service_config.op[op_name]
-            op_cls = C.resolve_op(op_config.backend)
+        else:
+            op_config: OpConfig = OpConfig()
 
+        if op_config.backend in C.registry_dict["op"]:
+            op_cls = C.resolve_op(op_config.backend)
 
         elif op_name in C.registry_dict["op"]:
-            op_config: OpConfig = OpConfig()
             op_cls = C.resolve_op(op_name)
 
         else:
@@ -153,6 +155,7 @@ class ExpressionParser:
 
         kwargs = {
             "name": op_name,
+            "max_retries": op_config.max_retries,
             "raise_exception": op_config.raise_exception,
             **op_config.params
         }

flowllm/flow/expression/expression_tool_flow.py

@@ -0,0 +1,25 @@
+from flowllm.flow.base_tool_flow import BaseToolFlow
+from flowllm.flow.expression.expression_parser import ExpressionParser
+from flowllm.schema.service_config import FlowConfig
+from flowllm.schema.tool_call import ToolCall
+
+
+class ExpressionToolFlow(BaseToolFlow):
+
+    def __init__(self, flow_config: FlowConfig = None, **kwargs):
+        self.flow_config: FlowConfig = flow_config
+        super().__init__(name=flow_config.name,
+                         use_async=self.flow_config.use_async,
+                         stream=self.flow_config.stream,
+                         service_type=self.flow_config.service_type,
+                         **kwargs)
+
+    def build_flow(self):
+        parser = ExpressionParser(self.flow_config.flow_content)
+        return parser.parse_flow()
+
+    def build_tool_call(self) -> ToolCall:
+        if hasattr(self.flow_op, "tool_call"):
+            return self.flow_op.tool_call
+        else:
+            return ToolCall(**self.flow_config.model_dump())

flowllm/flow/gallery/__init__.py

@@ -1,8 +1 @@
-from .cmd_flow import CmdFlow
-from .code_tool_flow import CodeToolFlow
-from .dashscope_search_tool_flow import DashscopeSearchToolFlow
-from .deepsearch_tool_flow import DeepSearchToolFlow
-from .expression_tool_flow import ExpressionToolFlow
-from .mock_tool_flow import MockToolFlow
-from .tavily_search_tool_flow import TavilySearchToolFlow
-from .terminate_tool_flow import TerminateToolFlow
+from .mock_tool_flow import MockToolFlow, MockAsyncToolFlow