agentUniverse 0.0.6.dev1__tar.gz → 0.0.8.dev1__tar.gz

{agentuniverse-0.0.6.dev1 → agentuniverse-0.0.8.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: agentUniverse
-Version: 0.0.6.dev1
+Version: 0.0.8.dev1
 Summary: agentUniverse is a framework for developing applications powered by multi-agent base on large language model.
 Home-page: https://github.com/alipay/agentUniverse
 Author: AntGroup
@@ -13,26 +13,34 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Provides-Extra: log-ext
+Provides-Extra: store-ext
+Requires-Dist: Jinja2 (>=3.1.4,<4.0.0)
 Requires-Dist: SQLAlchemy (==2.0.25)
 Requires-Dist: aliyun-log-python-sdk (==0.8.8) ; extra == "log-ext"
+Requires-Dist: anthropic (>=0.26.0,<0.27.0)
 Requires-Dist: cffi (>=1.15.1,<2.0.0)
 Requires-Dist: chromadb (==0.4.24)
-Requires-Dist: flask (==2.2)
+Requires-Dist: dashscope (>=1.19.1,<2.0.0)
+Requires-Dist: flask (>=2.3.2,<3.0.0)
 Requires-Dist: flask_cors (==4.0.0)
 Requires-Dist: googleapis-common-protos (>=1.63.0,<2.0.0)
 Requires-Dist: grpcio (==1.63.0)
-Requires-Dist: gunicorn (==21.2.0)
-Requires-Dist: langchain (==0.0.352)
-Requires-Dist: langchain-core (==0.1.3)
+Requires-Dist: gunicorn (>=22.0.0,<23.0.0)
+Requires-Dist: langchain (==0.1.20)
+Requires-Dist: langchain-community (==0.0.38)
+Requires-Dist: langchain-core (==0.1.52)
 Requires-Dist: loguru (==0.7.2)
 Requires-Dist: myst-parser (>=2.0.0,<3.0.0)
 Requires-Dist: openai (==1.13.3)
 Requires-Dist: pydantic (>=2.6.4,<3.0.0)
-Requires-Dist: requests (>=2.31.0,<3.0.0)
+Requires-Dist: pymilvus (>=2.4.3,<3.0.0) ; extra == "store-ext"
+Requires-Dist: qianfan (>=0.3.12,<0.4.0)
+Requires-Dist: requests (>=2.32.0,<3.0.0)
 Requires-Dist: sphinx (>=7.2.6,<8.0.0)
 Requires-Dist: sphinx-rtd-theme (>=2.0.0,<3.0.0)
 Requires-Dist: tiktoken (==0.5.2)
-Requires-Dist: werkzeug (==2.2.2)
+Requires-Dist: tqdm (>=4.66.3,<5.0.0)
+Requires-Dist: werkzeug (>=3.0.3,<4.0.0)
 Project-URL: Repository, https://github.com/alipay/agentUniverse
 Description-Content-Type: text/markdown
 

agentuniverse-0.0.8.dev1/agentuniverse/agent/action/knowledge/store/milvus_store.py

@@ -0,0 +1,228 @@
+# !/usr/bin/env python3
+# -*- coding:utf-8 -*-
+
+# @Time    : 2024/5/30 10:22
+# @Author  : fanen.lhy
+# @Email   : fanen.lhy@antgroup.com
+# @FileName: milvus_store.py
+from typing import List, Optional
+
+try:
+    from pymilvus import connections, Collection, CollectionSchema, \
+        FieldSchema, DataType, utility
+except ImportError as e:
+    raise ImportError(
+        "pymilvus is not installed. Please install it with 'pip install pymilvus'") from e
+
+from agentuniverse.agent.action.knowledge.store.document import Document
+from agentuniverse.agent.action.knowledge.store.query import Query
+from agentuniverse.agent.action.knowledge.store.store import Store
+
+DEFAULT_CONNECTION_ARGS = {
+    "host": "localhost",
+    "port": "19530"
+}
+
+DEFAULT_SEARCH_ARGS = {
+    "metric_type": "L2",
+    "params": {"nprobe": 10}
+}
+
+DEFAULT_INDEX_PARAMS = {
+    "metric_type": "L2",
+    "index_type": "HNSW",
+    "params": {"M": 8, "efConstruction": 64},
+}
+
+
+class MilvusStore(Store):
+    collection_name: Optional[str] = 'milvus_db'
+    collection: Collection = None
+    connection_name: str = 'default_connection'
+
+    def __init__(
+            self,
+            connection_args: dict = None,
+            **kwargs
+    ):
+        """Initialize the Milvus store class."""
+        super().__init__(**kwargs)
+        if not connection_args:
+            connection_args = DEFAULT_CONNECTION_ARGS
+        host = connection_args["host"]
+        port = connection_args["port"]
+        db_name = connection_args.get("db_name", "default")
+        self.connection_name = f"{host}_{port}_{db_name}"
+        self._connect_to_milvus(connection_args)
+        if utility.has_collection(self.collection_name,
+                                  using=self.connection_name):
+            self.collection = Collection(
+                self.collection_name, using=self.connection_name
+            )
+            self.collection.load()
+
+
+    def _connect_to_milvus(self, connection_args: dict):
+        """Connect to Milvus server."""
+        if not connections.has_connection(self.connection_name):
+            connections.connect(
+                alias=self.connection_name, **connection_args
+            )
+
+    def _create_or_load_collection(self,
+                                   dim: int = 128,
+                                   max_length: int = 65535,
+                                   index_params: dict = None):
+        """
+        Create a new collection or load an existing collection.
+
+        This method handles the creation of a new collection with specified parameters
+        or loads an existing collection if it already exists. Collections are used
+        to store data with specific dimensional attributes and indexing parameters.
+
+        Parameters:
+        - dim (int): The dimension of the collection, default is 128.
+        - max_length (int): The maximum length of the collection, default is 65535.
+        - index_params (dict, optional): Additional parameters for indexing. This
+          dictionary can include specific configurations for the index creation or loading.
+
+        Returns:
+        None
+        """
+        if utility.has_collection(self.collection_name,
+                                  using=self.connection_name):
+            self.collection = Collection(
+                self.collection_name, using=self.connection_name
+            )
+        else:
+            if not index_params:
+                index_params = DEFAULT_INDEX_PARAMS
+            fields = [
+                FieldSchema(name="id", dtype=DataType.VARCHAR, max_length=100,
+                            is_primary=True),
+                FieldSchema(name="embedding", dtype=DataType.FLOAT_VECTOR,
+                            dim=dim),
+                FieldSchema(name="text", dtype=DataType.VARCHAR,
+                            max_length=max_length),
+                FieldSchema(name="metadata", dtype=DataType.JSON)
+            ]
+            schema = CollectionSchema(fields, "Milvus collection schema")
+            self.collection = Collection(self.collection_name, schema,
+                                         using=self.connection_name)
+            self.collection.create_index(
+                field_name="embedding",
+                index_params=index_params
+            )
+            self.collection.load()
+
+    def query(self,
+              query: Query,
+              search_args: dict = None,
+              **kwargs) -> List[Document]:
+        """
+        Query the Milvus collection with the given query and return the top k results.
+
+        Parameters:
+        - query (Query): The query object that contains the parameters and data for the search.
+        - search_args (dict, optional): A dictionary of additional arguments for the search.
+          This can include parameters such as the number of results to return, specific search
+          algorithms, or other configurations.
+
+        Returns:
+        - List[Document]: A list of Document objects that are the top k results from the query.
+        """
+        if not self.collection:
+            return self.to_documents([])
+        embedding = query.embedding
+        if self.embedding_model is not None and len(embedding) == 0:
+            embedding = self.embedding_model.get_embeddings([query.query_str])[
+                0]
+        if not search_args:
+            search_args = DEFAULT_SEARCH_ARGS
+        if len(embedding) > 0:
+            query_result = self.collection.search(
+                data=[embedding],
+                anns_field="embedding",
+                param=search_args,
+                limit=query.similarity_top_k,
+                output_fields=["id", "text", "embedding", "metadata"]
+            )
+        else:
+            query_result = []
+        return self.to_documents(query_result)
+
+
+    def upsert_document(self,
+                        documents: List[Document],
+                        max_length: int = 65535,
+                        index_params: dict = None,
+                        **kwargs):
+        """
+        This method inserts new documents or updates existing documents in the collection.
+        The upsert operation ensures that the documents are either added if they do not
+        already exist or updated if they do.
+
+        Parameters:
+        - documents (List[Document]): A list of Document objects to be upserted into the collection.
+        - max_length (int): The maximum length of the collection, default is 65535.
+        - index_params (dict, optional): Additional parameters for indexing. This dictionary
+          can include specific configurations for the index creation or updating.
+
+        Returns:
+        None
+        """
+        for document in documents:
+            embedding = document.embedding
+            if self.embedding_model is not None and len(embedding) == 0:
+                embedding = self.embedding_model.get_embeddings([document.text])[0]
+            if not self.collection:
+                self._create_or_load_collection(
+                    dim=len(embedding),
+                    max_length=max_length,
+                    index_params=index_params
+                )
+            expr = f'id == "{document.id}"'
+            existing_docs = self.collection.query(expr)
+            entities = [
+                [document.id],
+                [embedding],
+                [document.text],
+                [document.metadata]
+            ]
+            if existing_docs:
+                self.collection.delete(expr)
+                self.collection.insert(entities)
+            else:
+                self.collection.insert(entities)
+            self.collection.load()
+
+    def insert_documents(self,
+                         documents: List[Document],
+                         max_length: int = 65535,
+                         index_params: dict = None,
+                         ):
+        """Insert documents to the Milvus collection."""
+        self.upsert_document(documents, max_length, index_params)
+
+    def update_document(self, documents: List[Document], **kwargs):
+        """Update document into the store."""
+        self.upsert_document(documents)
+
+    @staticmethod
+    def to_documents(query_result) -> List[Document]:
+        """Convert the query results of Milvus to the AgentUniverse(AU)
+        document format."""
+        if query_result is None:
+            return []
+        documents = []
+        for result in query_result:
+            for res in result:
+                documents.append(Document(
+                    id=res.fields.get("id"),
+                    text=res.fields.get("text"),
+                    embedding=res.fields.get("embedding")
+                    if res.fields.get("embedding") else [],
+                    metadata=res.fields.get("metadata")
+                    if res.fields.get("metadata") else None)
+                )
+        return documents

{agentuniverse-0.0.6.dev1 → agentuniverse-0.0.8.dev1}/agentuniverse/agent/default/planning_agent/planning_agent.py

@@ -5,7 +5,8 @@
 # @Email   : lc299034@antgroup.com
 # @FileName: planning_agent.py
 """Planning agent module."""
-import json
+from langchain.output_parsers.json import parse_json_markdown
+
 from agentuniverse.agent.agent import Agent
 from agentuniverse.agent.input_object import InputObject
 
@@ -44,7 +45,7 @@ class PlanningAgent(Agent):
             dict: Agent result object.
         """
         output = planner_result.get('output')
-        output = json.loads(output)
+        output = parse_json_markdown(output)
         planner_result['framework'] = output['framework']
         planner_result['thought'] = output['thought']
         return planner_result

{agentuniverse-0.0.6.dev1 → agentuniverse-0.0.8.dev1}/agentuniverse/agent/default/rag_agent/rag_agent.yaml

@@ -4,7 +4,7 @@ info:
 profile:
   llm_model:
     name: 'default_openai_llm'
-    model_name: 'gpt-4'
+    model_name: 'gpt-4o'
 plan:
   planner:
     name: 'rag_planner'

{agentuniverse-0.0.6.dev1 → agentuniverse-0.0.8.dev1}/agentuniverse/agent/default/reviewing_agent/reviewing_agent.py

@@ -5,7 +5,8 @@
 # @Email   : lc299034@antgroup.com
 # @FileName: reviewing_agent.py
 """Reviewing Agent class."""
-import json
+from langchain.output_parsers.json import parse_json_markdown
+
 from agentuniverse.agent.agent import Agent
 from agentuniverse.agent.input_object import InputObject
 
@@ -46,7 +47,7 @@ class ReviewingAgent(Agent):
         agent_result = dict()
 
         output = planner_result.get('output')
-        output = json.loads(output)
+        output = parse_json_markdown(output)
         is_useful = output.get('is_useful')
         if is_useful is None:
             is_useful = False

{agentuniverse-0.0.6.dev1 → agentuniverse-0.0.8.dev1}/agentuniverse/agent/memory/chat_memory.py

@@ -70,10 +70,10 @@ class ChatMemory(Memory):
             ChatMemory: the ChatMemory object
         """
         super().initialize_by_component_configer(component_configer)
-        if component_configer.input_key:
+        if hasattr(component_configer, 'input_key') and component_configer.input_key:
             self.input_key = component_configer.input_key
-        if component_configer.output_key:
+        if hasattr(component_configer, 'output_key') and component_configer.output_key:
             self.output_key = component_configer.output_key
-        if component_configer.prompt_version:
+        if hasattr(component_configer, 'prompt_version') and component_configer.prompt_version:
             self.prompt_version = component_configer.prompt_version
         return self

{agentuniverse-0.0.6.dev1 → agentuniverse-0.0.8.dev1}/agentuniverse/agent/memory/default/default_memory.py

@@ -6,7 +6,7 @@
 # @Email   : wangchongshi.wcs@antgroup.com
 # @FileName: default_memory.py
 from agentuniverse.agent.memory.chat_memory import ChatMemory
-from agentuniverse.llm.openai_llm import OpenAILLM
+from agentuniverse.llm.default.default_openai_llm import DefaultOpenAILLM
 
 
 class DefaultMemory(ChatMemory):
@@ -24,4 +24,4 @@ class DefaultMemory(ChatMemory):
             default memory uses OpenAILLM(gpt-3.5-turbo) object as the memory llm.
         """
         super().__init__(**kwargs)
-        self.llm = OpenAILLM(model_name="gpt-3.5-turbo")
+        self.llm = DefaultOpenAILLM(model_name="gpt-4o")

{agentuniverse-0.0.6.dev1 → agentuniverse-0.0.8.dev1}/agentuniverse/agent/memory/langchain_instance.py

@@ -7,10 +7,8 @@
 # @FileName: langchain_instance.py
 from typing import List, Optional, Dict, Any
 
-from langchain.chains import LLMChain
 from langchain_core.messages import BaseMessage, get_buffer_string
 from langchain.memory import ConversationSummaryBufferMemory, ConversationTokenBufferMemory
-from langchain.memory.summary import SummarizerMixin
 
 from agentuniverse.agent.memory.enum import ChatMessageEnum
 from agentuniverse.agent.memory.message import Message
@@ -18,7 +16,7 @@ from agentuniverse.prompt.prompt import Prompt
 from agentuniverse.prompt.prompt_manager import PromptManager
 
 
-class AuConversationSummaryBufferMemory(ConversationSummaryBufferMemory, SummarizerMixin):
+class AuConversationSummaryBufferMemory(ConversationSummaryBufferMemory):
     """Long term memory to store conversation memory.
 
     If memories exceeds the max tokens limit,
@@ -46,18 +44,18 @@ class AuConversationSummaryBufferMemory(ConversationSummaryBufferMemory, Summari
     @property
     def load_memory(self) -> List[BaseMessage]:
         """ General method: load the memory context from the memory buffer."""
-        buffer = self.buffer
+        messages = self.chat_memory.messages
         if self.moving_summary_buffer != "":
             moving_messages: List[BaseMessage] = [
                 self.summary_message_cls(content=self.moving_summary_buffer)
             ]
-            buffer = moving_messages + buffer
-        return buffer
+            messages = moving_messages + messages
+        return messages
 
     @property
     def load_memory_str(self) -> str:
         """ General method: load the memory context from the memory buffer as string format."""
-        buffer = get_buffer_string(self.buffer)
+        buffer = get_buffer_string(self.chat_memory.messages)
         if self.moving_summary_buffer is not None:
             buffer = self.moving_summary_buffer + buffer
         return buffer
@@ -117,8 +115,9 @@ class AuConversationSummaryBufferMemory(ConversationSummaryBufferMemory, Summari
         )
         prompt_version = self.prompt_version if self.prompt_version else 'chat_memory.summarizer_cn'
         prompt: Prompt = PromptManager().get_instance_obj(prompt_version)
-        chain = LLMChain(llm=self.llm, prompt=prompt.as_langchain())
-        return chain.predict(summary=existing_summary, new_lines=new_lines)
+        chain = prompt.as_langchain() | self.llm
+        res = chain.invoke(input={'summary': existing_summary, 'new_lines': new_lines})
+        return res.content
 
 
 class AuConversationTokenBufferMemory(ConversationTokenBufferMemory):

{agentuniverse-0.0.6.dev1 → agentuniverse-0.0.8.dev1}/agentuniverse/agent/plan/planner/executing_planner/executing_planner.py

@@ -7,12 +7,14 @@
 """Execution planner module."""
 import asyncio
 
-from langchain.chains import LLMChain
-from langchain_core.memory import BaseMemory
+from langchain_core.chat_history import InMemoryChatMessageHistory
+from langchain_core.runnables.history import RunnableWithMessageHistory
 
 from agentuniverse.agent.agent_model import AgentModel
 from agentuniverse.agent.input_object import InputObject
+from agentuniverse.agent.memory.chat_memory import ChatMemory
 from agentuniverse.agent.plan.planner.planner import Planner
+from agentuniverse.base.util.memory_util import generate_memories
 from agentuniverse.base.util.prompt_util import process_llm_token
 from agentuniverse.llm.llm import LLM
 from agentuniverse.prompt.prompt import Prompt
@@ -34,7 +36,7 @@ class ExecutingPlanner(Planner):
             dict: The planner result.
         """
 
-        memory: BaseMemory = self.handle_memory(agent_model, planner_input)
+        memory: ChatMemory = self.handle_memory(agent_model, planner_input)
 
         self.handle_all_actions(agent_model, planner_input, input_object)
 
@@ -43,10 +45,17 @@ class ExecutingPlanner(Planner):
         prompt: Prompt = self.handle_prompt(agent_model, planner_input)
         process_llm_token(llm, prompt.as_langchain(), agent_model.profile, planner_input)
 
-        llm_chain = LLMChain(llm=llm.as_langchain(),
-                             prompt=prompt.as_langchain(),
-                             output_key=self.output_key, memory=memory)
-        return asyncio.run(llm_chain.acall(inputs=planner_input))
+        chat_history = memory.as_langchain().chat_memory if memory else InMemoryChatMessageHistory()
+
+        chain_with_history = RunnableWithMessageHistory(
+            prompt.as_langchain() | llm.as_langchain(),
+            lambda session_id: chat_history,
+            history_messages_key="chat_history",
+            input_messages_key=self.input_key,
+        )
+        res = asyncio.run(
+            chain_with_history.ainvoke(input=planner_input, config={"configurable": {"session_id": "unused"}}))
+        return {**planner_input, self.output_key: res.content, 'chat_history': generate_memories(chat_history)}
 
     def handle_prompt(self, agent_model: AgentModel, planner_input: dict) -> Prompt:
         """Prompt module processing.

{agentuniverse-0.0.6.dev1 → agentuniverse-0.0.8.dev1}/agentuniverse/agent/plan/planner/expressing_planner/expressing_planner.py

@@ -7,12 +7,14 @@
 """Expressing planner module."""
 import asyncio
 
-from langchain.chains import LLMChain
-from langchain_core.memory import BaseMemory
+from langchain_core.chat_history import InMemoryChatMessageHistory
+from langchain_core.runnables.history import RunnableWithMessageHistory
 
 from agentuniverse.agent.agent_model import AgentModel
 from agentuniverse.agent.input_object import InputObject
+from agentuniverse.agent.memory.chat_memory import ChatMemory
 from agentuniverse.agent.plan.planner.planner import Planner
+from agentuniverse.base.util.memory_util import generate_memories
 from agentuniverse.base.util.prompt_util import process_llm_token
 from agentuniverse.llm.llm import LLM
 from agentuniverse.prompt.prompt import Prompt
@@ -33,18 +35,24 @@ class ExpressingPlanner(Planner):
         Returns:
             dict: The planner result.
         """
-        memory: BaseMemory = self.handle_memory(agent_model, planner_input)
+        memory: ChatMemory = self.handle_memory(agent_model, planner_input)
 
         llm: LLM = self.handle_llm(agent_model)
 
         prompt: Prompt = self.handle_prompt(agent_model, planner_input)
         process_llm_token(llm, prompt.as_langchain(), agent_model.profile, planner_input)
 
-        llm_chain = LLMChain(llm=llm.as_langchain(),
-                             prompt=prompt.as_langchain(),
-                             output_key=self.output_key, memory=memory)
-
-        return asyncio.run(llm_chain.acall(inputs=planner_input))
+        chat_history = memory.as_langchain().chat_memory if memory else InMemoryChatMessageHistory()
+
+        chain_with_history = RunnableWithMessageHistory(
+            prompt.as_langchain() | llm.as_langchain(),
+            lambda session_id: chat_history,
+            history_messages_key="chat_history",
+            input_messages_key=self.input_key,
+        )
+        res = asyncio.run(
+            chain_with_history.ainvoke(input=planner_input, config={"configurable": {"session_id": "unused"}}))
+        return {**planner_input, self.output_key: res.content, 'chat_history': generate_memories(chat_history)}
 
     def handle_prompt(self, agent_model: AgentModel, planner_input: dict) -> Prompt:
         """Prompt module processing.

{agentuniverse-0.0.6.dev1 → agentuniverse-0.0.8.dev1}/agentuniverse/agent/plan/planner/peer_planner/peer_planner.py

@@ -56,6 +56,8 @@ class PeerPlanner(Planner):
         agents = dict()
         for config_key, default_agent in default_sub_agents.items():
             config_data = planner_config.get(config_key, None)
+            if config_data == '':
+                continue
             agents[config_key] = AgentManager().get_instance_obj(config_data if config_data else default_agent)
         return agents
 
@@ -108,10 +110,10 @@ class PeerPlanner(Planner):
         reviewingAgent = agents.get('reviewing')
 
         for _ in range(retry_count):
-            LOGGER.info(f"Starting peer agents, retry_count is {_}.")
+            LOGGER.info(f"Starting peer agents, retry_count is {_ + 1}.")
             if not planning_result or jump_step == "planning":
                 if not planningAgent:
-                    LOGGER.warn("no planning agent, use default.")
+                    LOGGER.warn("no planning agent.")
                     planning_result = OutputObject({"framework": [agent_input.get('input')]})
                 else:
                     LOGGER.info(f"Starting planning agent.")
@@ -126,7 +128,7 @@ class PeerPlanner(Planner):
 
             if not executing_result or jump_step in ["planning", "executing"]:
                 if not executingAgent:
-                    LOGGER.warn("no executing agent, use default.")
+                    LOGGER.warn("no executing agent.")
                     executing_result = OutputObject({})
                 else:
                     LOGGER.info(f"Starting executing agent.")
@@ -135,15 +137,16 @@ class PeerPlanner(Planner):
                 input_object.add_data('executing_result', executing_result)
                 # add executing agent log info
                 logger_info = f"\nExecuting agent execution result is :\n"
-                for index, one_exec_res in enumerate(executing_result.get_data('executing_result')):
-                    one_exec_log_info = f"[{index + 1}] input: {one_exec_res['input']}\n"
-                    one_exec_log_info += f"[{index + 1}] output: {one_exec_res['output']}\n"
-                    logger_info += one_exec_log_info
+                if executing_result.get_data('executing_result'):
+                    for index, one_exec_res in enumerate(executing_result.get_data('executing_result')):
+                        one_exec_log_info = f"[{index + 1}] input: {one_exec_res['input']}\n"
+                        one_exec_log_info += f"[{index + 1}] output: {one_exec_res['output']}\n"
+                        logger_info += one_exec_log_info
                 LOGGER.info(logger_info)
 
             if not expressing_result or jump_step in ["planning", "executing", "expressing"]:
                 if not expressingAgent:
-                    LOGGER.warn("no expression agent, use default.")
+                    LOGGER.warn("no expression agent.")
                     expressing_result = OutputObject({})
                 else:
                     LOGGER.info(f"Starting expressing agent.")
@@ -157,7 +160,7 @@ class PeerPlanner(Planner):
 
             if not reviewing_result or jump_step in ["planning", "executing", "expressing", "reviewing"]:
                 if not reviewingAgent:
-                    LOGGER.warn("no expression agent, use default.")
+                    LOGGER.warn("no expression agent.")
                     loopResults.append({
                         "planning_result": planning_result,
                         "executing_result": executing_result,
@@ -169,7 +172,7 @@ class PeerPlanner(Planner):
                 else:
                     LOGGER.info(f"Starting reviewing agent.")
                     reviewing_result = reviewingAgent.run(**input_object.to_dict())
-                    input_object.add_data('evaluator_result', reviewing_result)
+                    input_object.add_data('reviewing_result', reviewing_result)
 
                     # add reviewing agent log info
                     logger_info = f"\nReviewing agent execution result is :\n"

{agentuniverse-0.0.6.dev1 → agentuniverse-0.0.8.dev1}/agentuniverse/agent/plan/planner/planner.py

@@ -5,12 +5,11 @@
 # @Email   : lc299034@antgroup.com
 # @FileName: planner.py
 """Base class for Planner."""
-import copy
 from abc import abstractmethod
+import copy
+import logging
 from typing import Optional, List
 
-from langchain_core.memory import BaseMemory
-
 from agentuniverse.agent.action.knowledge.knowledge import Knowledge
 from agentuniverse.agent.action.knowledge.knowledge_manager import KnowledgeManager
 from agentuniverse.agent.action.knowledge.store.document import Document
@@ -18,6 +17,7 @@ from agentuniverse.agent.action.knowledge.store.query import Query
 from agentuniverse.agent.action.tool.tool_manager import ToolManager
 from agentuniverse.agent.agent_model import AgentModel
 from agentuniverse.agent.input_object import InputObject
+from agentuniverse.agent.memory.chat_memory import ChatMemory
 from agentuniverse.agent.memory.memory import Memory
 from agentuniverse.agent.memory.message import Message
 from agentuniverse.agent.memory.memory_manager import MemoryManager
@@ -29,6 +29,8 @@ from agentuniverse.llm.llm_manager import LLMManager
 from agentuniverse.prompt.prompt import Prompt
 from agentuniverse.base.util.memory_util import generate_messages
 
+logging.getLogger().setLevel(logging.ERROR)
+
 
 class Planner(ComponentBase):
     """
@@ -60,7 +62,7 @@ class Planner(ComponentBase):
         """
         pass
 
-    def handle_memory(self, agent_model: AgentModel, planner_input: dict) -> BaseMemory | None:
+    def handle_memory(self, agent_model: AgentModel, planner_input: dict) -> ChatMemory | None:
         """Memory module processing.
 
         Args:
@@ -82,15 +84,11 @@ class Planner(ComponentBase):
         params['input_key'] = self.input_key
         params['output_key'] = self.output_key
 
-        memory: Memory = MemoryManager().get_instance_obj(memory_name)
+        memory: ChatMemory = MemoryManager().get_instance_obj(component_instance_name=memory_name, new_instance=True)
         if memory is None:
             return None
-        copied_memory = copy.deepcopy(memory)
-        copied_memory.set_by_agent_model(**params)
-        langchain_memory: BaseMemory = copied_memory.as_langchain()
-
-        planner_input['chat_history'] = langchain_memory.load_memory_str
-        return langchain_memory
+        memory.set_by_agent_model(**params)
+        return memory
 
     def handle_all_actions(self, agent_model: AgentModel, planner_input: dict, input_object: InputObject):
         """Tool and knowledge processing.
@@ -144,10 +142,9 @@ class Planner(ComponentBase):
             LLM: The language model.
         """
         llm_name = agent_model.profile.get('llm_model').get('name')
-        llm: LLM = LLMManager().get_instance_obj(llm_name)
-        copied_llm = copy.deepcopy(llm)
-        copied_llm.set_by_agent_model(**agent_model.profile.get('llm_model'))
-        return copied_llm
+        llm: LLM = LLMManager().get_instance_obj(component_instance_name=llm_name, new_instance=True)
+        llm.set_by_agent_model(**agent_model.profile.get('llm_model'))
+        return llm
 
     def initialize_by_component_configer(self, component_configer: PlannerConfiger) -> 'Planner':
         """Initialize the planner by the PlannerConfiger object.