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

flowllm/op/base_tool_op.py

@@ -0,0 +1,47 @@
+from abc import ABC, abstractmethod
+
+from loguru import logger
+
+from flowllm.op.base_llm_op import BaseLLMOp
+from flowllm.schema.tool_call import ToolCall
+from flowllm.storage.cache import DataCache
+
+
+class BaseToolOp(BaseLLMOp, ABC):
+
+    def __init__(self,
+                 enable_cache: bool = False,
+                 cache_path: str = "cache",
+                 cache_expire_hours: float = 0.1,
+                 enable_print_output: bool = True,
+                 **kwargs):
+        super().__init__(**kwargs)
+
+        self.enable_cache = enable_cache
+        self.cache_path: str = cache_path
+        self.cache_expire_hours: float = cache_expire_hours
+        self.enable_print_output: bool = enable_print_output
+        self._cache: DataCache | None = None
+
+        self.tool_call: ToolCall = self.build_tool_call()
+        self.input_dict: dict = {}
+        self.output_dict: dict = {}
+
+    @property
+    def cache(self):
+        if self.enable_cache and self._cache is None:
+            self._cache = DataCache(f"{self.cache_path}/{self.name}")
+        return self._cache
+
+    @abstractmethod
+    def build_tool_call(self) -> ToolCall:
+        ...
+
+    def before_execute(self):
+        for key in self.tool_call.input_schema.keys():
+            self.input_dict[key] = self.context.get(key)
+
+    def after_execute(self):
+        self.context.update(self.output_dict)
+        if self.enable_print_output:
+            logger.info(f"{self.name}.output_dict={self.output_dict}")

flowllm/op/gallery/__init__.py

@@ -1,2 +1 @@
 from .mock_op import Mock1Op, Mock2Op, Mock3Op, Mock4Op, Mock5Op, Mock6Op
-from .terminate_op import TerminateOp

flowllm/op/gallery/mock_op.py

@@ -1,8 +1,9 @@
+import asyncio
 import time
 
 from loguru import logger
 
-from flowllm.context.service_context import C
+from flowllm.context import C
 from flowllm.op.base_llm_op import BaseLLMOp
 
 
@@ -10,8 +11,8 @@ from flowllm.op.base_llm_op import BaseLLMOp
 class Mock1Op(BaseLLMOp):
     def execute(self):
         time.sleep(1)
-        a = self.context.a
-        b = self.context.b
+        a = self.context.get("a", 1)
+        b = self.context.get("b", 2)
         logger.info(f"enter class={self.name}. a={a} b={b}")
 
         self.context.response.answer = f"{self.name} {a} {b} answer=47"
@@ -28,15 +29,20 @@ class Mock3Op(Mock1Op):
 
 
 @C.register_op()
-class Mock4Op(Mock1Op):
-    ...
+class Mock4Op(BaseLLMOp):
+    async def async_execute(self):
+        await asyncio.sleep(1)
+        a = self.context.get("a", 1)
+        b = self.context.get("b", 2)
+        logger.info(f"enter class={self.name}. a={a} b={b}")
+        self.context.response.answer = f"{self.name} {a} {b} answer=47"
 
 
 @C.register_op()
-class Mock5Op(Mock1Op):
+class Mock5Op(Mock4Op):
     ...
 
 
 @C.register_op()
-class Mock6Op(Mock1Op):
+class Mock6Op(Mock4Op):
     ...

flowllm/op/llm/__init__.py

@@ -0,0 +1,3 @@
+from .react_llm_op import ReactLLMOp
+from .simple_llm_op import SimpleLLMOp
+from .stream_llm_op import StreamLLMOp

flowllm/op/llm/react_llm_op.py

@@ -0,0 +1,105 @@
+import asyncio
+import datetime
+import json
+import time
+from typing import List, Dict
+
+from loguru import logger
+
+from flowllm.context.flow_context import FlowContext
+from flowllm.context.service_context import C
+from flowllm.op import BaseToolOp
+from flowllm.schema.flow_response import FlowResponse
+from flowllm.schema.message import Message, Role
+from flowllm.schema.tool_call import ToolCall
+
+
+@C.register_op(name="react_llm_op")
+class ReactLLMOp(BaseToolOp):
+    file_path: str = __file__
+
+    def __init__(self, llm="qwen3_30b_instruct", **kwargs):
+        super().__init__(llm=llm, **kwargs)
+
+    def build_tool_call(self) -> ToolCall:
+        return ToolCall(**{
+            "name": "query_llm",
+            "description": "use this query to query an LLM",
+            "input_schema": {
+                "query": {
+                    "type": "str",
+                    "description": "search keyword",
+                    "required": True
+                }
+            }
+        })
+
+    async def async_execute(self):
+        query: str = self.context.query
+
+        max_steps: int = int(self.op_params.get("max_steps", 10))
+        from flowllm.op import BaseToolOp
+        from flowllm.op.search import DashscopeSearchOp
+
+        tools: List[BaseToolOp] = [DashscopeSearchOp(save_answer=True)]
+        tool_dict: Dict[str, BaseToolOp] = {x.tool_call.name: x for x in tools}
+        for name, tool_call in tool_dict.items():
+            logger.info(f"name={name} "
+                        f"tool_call={json.dumps(tool_call.tool_call.simple_input_dump(), ensure_ascii=False)}")
+
+        now_time = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+        user_prompt = self.prompt_format(prompt_name="role_prompt",
+                                         time=now_time,
+                                         tools=",".join(list(tool_dict.keys())),
+                                         query=query)
+        messages: List[Message] = [Message(role=Role.USER, content=user_prompt)]
+        logger.info(f"step.0 user_prompt={user_prompt}")
+
+        for i in range(max_steps):
+            assistant_message: Message = await self.llm.achat(messages, tools=[x.tool_call for x in tools])
+            messages.append(assistant_message)
+            logger.info(f"assistant.round{i}.reasoning_content={assistant_message.reasoning_content}\n"
+                        f"content={assistant_message.content}\n"
+                        f"tool.size={len(assistant_message.tool_calls)}")
+
+            if not assistant_message.tool_calls:
+                break
+
+            for j, tool_call in enumerate(assistant_message.tool_calls):
+                logger.info(f"submit step={i} tool_calls.name={tool_call.name} argument_dict={tool_call.argument_dict}")
+
+                if tool_call.name not in tool_dict:
+                    logger.warning(f"step={i} no tool_call.name={tool_call.name}")
+                    continue
+
+                self.submit_async_task(tool_dict[tool_call.name].copy().async_call,
+                                       context=self.context.copy(**tool_call.argument_dict))
+                time.sleep(1)
+
+            task_results = await self.join_async_task()
+
+            for j, tool_result in enumerate(task_results):
+                tool_call = assistant_message.tool_calls[j]
+                logger.info(f"submit step.index={i}.{j} tool_result={tool_result}")
+                if isinstance(tool_result, FlowResponse):
+                    tool_result = tool_result.answer
+                else:
+                    tool_result = str(tool_result)
+                tool_message = Message(role=Role.TOOL, content=tool_result, tool_call_id=tool_call.id)
+                messages.append(tool_message)
+
+        self.context.response.messages = messages
+        self.context.response.answer = messages[-1].content
+
+
+async def main():
+    C.set_service_config().init_by_service_config()
+    context = FlowContext(query="茅台和五粮现在股价多少？")
+
+    op = ReactLLMOp()
+    result = await op.async_call(context=context)
+    print(result)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

flowllm/op/{agent/react_prompt.yaml → llm/react_llm_prompt.yaml}

@@ -8,21 +8,28 @@ role_prompt: |
   
   {query}
 
-# write a complete and rigorous report to answer user's questions based on the context.
 next_prompt: |
-  Think based on the current content and the user's question: Is the current context sufficient to answer the user's question?  
-  
+  Think based on the current content and the user's question: Is the current context sufficient to answer the user's question?    
   - If the current context is not sufficient to answer the user's question, consider what information is missing. 
     Re-plan and think about how to break down the missing information into subtasks. 
     For each subtask, determine what tools and parameters should be used for the query.
     Please first provide the reasoning process, then give the tool call name and parameters.
-  
-  - If the current context is sufficient to answer the user's question, use the **terminate** tool.
+  - If the current context is sufficient to answer the user's question, please integrate the context and provide a complete answer to the user's question.
 
-#   Please determine the response language based on the language of the user's question.
-final_prompt: |
-  Please integrate the context and provide a complete answer to the user's question.
-
-  # User's Question
+role_prompt_zh: |
+  你是一个有用的助手。
+  当前时间是 {time}。
+  请根据用户的问题，主动选择最合适的工具或工具组合，包括 {tools} 等。
+  请先思考如何将问题分解为子任务，每个子任务应使用哪些工具和参数，最后提供工具调用名称和参数。
+  尝试多次使用相同的工具，但使用不同的参数，从多个角度获取信息。
+  请根据用户问题的语言来确定回复的语言。
+  
   {query}
 
+next_prompt_zh: |
+  根据当前内容和用户的问题进行思考：当前上下文是否足以回答用户的问题？
+  - 如果当前上下文不足以回答用户的问题，请考虑缺少哪些信息。
+    重新规划并思考如何将缺失的信息分解为子任务。
+    对于每个子任务，确定应使用哪些工具和参数进行查询。
+    请先提供推理过程，然后给出工具调用名称和参数。
+  - 如果当前上下文足以回答用户的问题，请整合上下文，为用户的问题提供一个完整的答案。

flowllm/op/llm/simple_llm_op.py

@@ -0,0 +1,48 @@
+import asyncio
+from typing import List
+
+from loguru import logger
+
+from flowllm.context.flow_context import FlowContext
+from flowllm.context.service_context import C
+from flowllm.op import BaseToolOp
+from flowllm.schema.message import Message, Role
+from flowllm.schema.tool_call import ToolCall
+
+
+@C.register_op(name="simple_llm_op")
+class SimpleLLMOp(BaseToolOp):
+
+    def build_tool_call(self) -> ToolCall:
+        return ToolCall(**{
+            "name": "query_llm",
+            "description": "use this query to query an LLM",
+            "input_schema": {
+                "query": {
+                    "type": "str",
+                    "description": "search keyword",
+                    "required": True
+                }
+            }
+        })
+
+    async def async_execute(self):
+        query: str = self.input_dict["query"]
+        logger.info(f"query={query}")
+        messages: List[Message] = [Message(role=Role.USER, content=query)]
+
+        assistant_message: Message = await self.llm.achat(messages)
+        self.context.response.answer = assistant_message.content
+
+
+async def main():
+    C.set_service_config().init_by_service_config()
+    context = FlowContext(query="hello", stream_queue=asyncio.Queue())
+
+    op = SimpleLLMOp()
+    result = await op.async_call(context=context)
+    print(result)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

flowllm/op/llm/stream_llm_op.py

@@ -0,0 +1,61 @@
+import asyncio
+from typing import List
+
+from loguru import logger
+
+from flowllm.context.flow_context import FlowContext
+from flowllm.context.service_context import C
+from flowllm.enumeration.chunk_enum import ChunkEnum
+from flowllm.op import BaseToolOp
+from flowllm.schema.message import Message, Role
+from flowllm.schema.tool_call import ToolCall
+
+
+@C.register_op(name="stream_llm_op")
+class StreamLLMOp(BaseToolOp):
+
+    def build_tool_call(self) -> ToolCall:
+        return ToolCall(**{
+            "name": "query_llm",
+            "description": "use this query to query an LLM",
+            "input_schema": {
+                "query": {
+                    "type": "str",
+                    "description": "search keyword",
+                    "required": True
+                }
+            }
+        })
+
+    async def async_execute(self):
+        query: str = self.input_dict["query"]
+        logger.info(f"query={query}")
+        messages: List[Message] = [Message(role=Role.USER, content=query)]
+
+        async for chunk, chunk_type in self.llm.astream_chat(messages):  # noqa
+            if chunk_type == ChunkEnum.ANSWER:
+                await self.context.add_stream_answer(chunk)
+
+        await self.context.add_stream_done()
+
+
+async def main():
+    C.set_service_config().init_by_service_config()
+    context = FlowContext(query="hello, introduce yourself.", stream_queue=asyncio.Queue())
+
+    op = StreamLLMOp()
+    task = asyncio.create_task(op.async_call(context=context))
+
+    while True:
+        stream_chunk = await context.stream_queue.get()
+        if stream_chunk.done:
+            print("\nend")
+            break
+        else:
+            print(stream_chunk.chunk, end="")
+
+    await task
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

flowllm/op/mcp/__init__.py

@@ -0,0 +1,2 @@
+from .ant_op import AntSearchOp, AntInvestmentOp
+from .base_sse_mcp_op import BaseSSEMcpOp

flowllm/op/mcp/ant_op.py

@@ -0,0 +1,42 @@
+import asyncio
+import json
+import os
+
+from flowllm.context import FlowContext, C
+from flowllm.op.mcp.base_sse_mcp_op import BaseSSEMcpOp
+
+
+@C.register_op()
+class AntSearchOp(BaseSSEMcpOp):
+
+    def __init__(self, **kwargs):
+        host = os.getenv("FLOW_MCP_HOSTS", "").split(",")[0]
+        super().__init__(host=host, tool_name="search", **kwargs)
+
+
+@C.register_op()
+class AntInvestmentOp(BaseSSEMcpOp):
+
+    def __init__(self, **kwargs):
+        host = os.getenv("FLOW_MCP_HOSTS", "").split(",")[0]
+        super().__init__(host=host, tool_name="investment_analysis", **kwargs)
+
+
+async def async_main():
+    op = AntSearchOp()
+    context = FlowContext(query="阿里巴巴怎么样？", entity="阿里巴巴")
+    await op.async_call(context=context)
+    print(json.dumps(op.tool_call.simple_input_dump(), ensure_ascii=False))
+    print(context.response.answer)
+
+    op = AntInvestmentOp()
+    context = FlowContext(entity="阿里巴巴", analysis_category="股票")
+    await op.async_call(context=context)
+    print(json.dumps(op.tool_call.simple_input_dump(), ensure_ascii=False))
+    print(context.response.answer)
+
+
+if __name__ == "__main__":
+    C.prepare_sse_mcp().set_service_config().init_by_service_config()
+
+    asyncio.run(async_main())

flowllm/op/mcp/base_sse_mcp_op.py

@@ -0,0 +1,28 @@
+from fastmcp import Client
+from mcp.types import CallToolResult
+
+from flowllm.context import C
+from flowllm.op import BaseToolOp
+from flowllm.schema.tool_call import ToolCall
+
+
+class BaseSSEMcpOp(BaseToolOp):
+
+    def __init__(self, host: str = "", tool_name: str = "", **kwargs):
+        self.host: str = host
+        self.tool_name: str = tool_name
+        super().__init__(**kwargs)
+
+    def build_tool_call(self) -> ToolCall:
+        key = f"{self.host}/{self.tool_name}"
+        assert key in C.sse_mcp_dict, \
+            f"host={self.host} tool_name={self.tool_name} not found in mcp_tool_call_dict"
+        return C.sse_mcp_dict[key]
+
+    def default_execute(self):
+        self.context.response.answer = self.output_dict[f"{self.name}_result"] = f"{self.name} execute failed!"
+
+    async def async_execute(self):
+        async with Client(f"{self.host}/sse/") as client:
+            result: CallToolResult = await client.call_tool(self.tool_name, arguments=self.input_dict)
+        self.context.response.answer = self.output_dict[f"{self.name}_result"] = result.content[0].text

flowllm/op/parallel_op.py

@@ -12,9 +12,13 @@ class ParallelOp(BaseOp):
     def execute(self):
         for op in self.ops:
             self.submit_task(op.__call__, context=self.context)
-
         self.join_task(task_desc="parallel execution")
 
+    async def async_execute(self):
+        for op in self.ops:
+            self.submit_async_task(op.async_call, context=self.context)
+        return await self.join_async_task()
+
     def __or__(self, op: BaseOp):
         if isinstance(op, ParallelOp):
             self.ops.extend(op.ops)

flowllm/op/search/__init__.py

@@ -1,3 +1,2 @@
-from .dashscope_deep_research_op import DashscopeDeepResearchOp
 from .dashscope_search_op import DashscopeSearchOp
-from .tavily_search_op import TavilySearchOp
+from .tavily_search_op import TavilySearchOp