camel-ai 0.1.1__py3-none-any.whl → 0.1.4__py3-none-any.whl

camel/societies/role_playing.py

@@ -34,9 +34,9 @@ class RolePlaying:
         assistant_role_name (str): The name of the role played by the
             assistant.
         user_role_name (str): The name of the role played by the user.
-        critic_role_name (str): The name of the role played by the critic.
-            Role name with :obj:`"human"` will set critic as a :obj:`Human`
-            agent, else will create a :obj:`CriticAgent`.
+        critic_role_name (str, optional): The name of the role played by the
+            critic. Role name with :obj:`"human"` will set critic as a
+            :obj:`Human` agent, else will create a :obj:`CriticAgent`.
             (default: :obj:`"critic"`)
         task_prompt (str, optional): A prompt for the task to be performed.
             (default: :obj:`""`)
@@ -104,44 +104,65 @@ class RolePlaying:
         self.task_prompt = task_prompt
 
         self.specified_task_prompt: Optional[TextPrompt] = None
-        self.init_specified_task_prompt(assistant_role_name, user_role_name,
-                                        task_specify_agent_kwargs,
-                                        extend_task_specify_meta_dict,
-                                        output_language)
+        self._init_specified_task_prompt(
+            assistant_role_name,
+            user_role_name,
+            task_specify_agent_kwargs=task_specify_agent_kwargs,
+            extend_task_specify_meta_dict=extend_task_specify_meta_dict,
+            output_language=output_language,
+        )
 
         self.planned_task_prompt: Optional[TextPrompt] = None
-        self.init_planned_task_prompt(task_planner_agent_kwargs,
-                                      output_language)
+        self._init_planned_task_prompt(
+            task_planner_agent_kwargs=task_planner_agent_kwargs,
+            output_language=output_language,
+        )
 
         sys_msg_generator = SystemMessageGenerator(
-            task_type=self.task_type, **(sys_msg_generator_kwargs or {}))
+            task_type=self.task_type,
+            **(sys_msg_generator_kwargs or {}),
+        )
 
-        (init_assistant_sys_msg, init_user_sys_msg,
-         sys_msg_meta_dicts) = self.get_sys_message_info(
-             assistant_role_name, user_role_name, sys_msg_generator,
-             extend_sys_msg_meta_dicts)
+        (
+            init_assistant_sys_msg,
+            init_user_sys_msg,
+            sys_msg_meta_dicts,
+        ) = self._get_sys_message_info(
+            assistant_role_name,
+            user_role_name,
+            sys_msg_generator,
+            extend_sys_msg_meta_dicts=extend_sys_msg_meta_dicts,
+        )
 
         self.assistant_agent: ChatAgent
         self.user_agent: ChatAgent
         self.assistant_sys_msg: BaseMessage
         self.user_sys_msg: BaseMessage
-        self.init_agents(
+        self._init_agents(
             init_assistant_sys_msg,
-            assistant_agent_kwargs,
             init_user_sys_msg,
-            user_agent_kwargs,
-            output_language,
+            assistant_agent_kwargs=assistant_agent_kwargs,
+            user_agent_kwargs=user_agent_kwargs,
+            output_language=output_language,
         )
         self.critic: Optional[Union[CriticAgent, Human]] = None
         self.critic_sys_msg: Optional[BaseMessage] = None
-        self.init_critic(critic_role_name, critic_criteria, critic_kwargs,
-                         sys_msg_generator, sys_msg_meta_dicts)
-
-    def init_specified_task_prompt(
-            self, assistant_role_name: str, user_role_name: str,
-            task_specify_agent_kwargs: Optional[Dict],
-            extend_task_specify_meta_dict: Optional[Dict],
-            output_language: Optional[str]):
+        self._init_critic(
+            sys_msg_generator,
+            sys_msg_meta_dicts,
+            critic_role_name,
+            critic_criteria=critic_criteria,
+            critic_kwargs=critic_kwargs,
+        )
+
+    def _init_specified_task_prompt(
+        self,
+        assistant_role_name: str,
+        user_role_name: str,
+        task_specify_agent_kwargs: Optional[Dict] = None,
+        extend_task_specify_meta_dict: Optional[Dict] = None,
+        output_language: Optional[str] = None,
+    ) -> None:
         r"""Use a task specify agent to generate a specified task prompt.
         Generated specified task prompt will be used to replace original
         task prompt. If there is no task specify agent, specified task
@@ -152,24 +173,28 @@ class RolePlaying:
                 assistant.
             user_role_name (str): The name of the role played by the user.
             task_specify_agent_kwargs (Dict, optional): Additional arguments
-                to pass to the task specify agent.
+                to pass to the task specify agent. (default: :obj:`None`)
             extend_task_specify_meta_dict (Dict, optional): A dict to extend
-                the task specify meta dict with.
+                the task specify meta dict with. (default: :obj:`None`)
             output_language (str, optional): The language to be output by the
-                agents.
+                agents. (default: :obj:`None`)
         """
         if self.with_task_specify:
             task_specify_meta_dict = dict()
             if self.task_type in [TaskType.AI_SOCIETY, TaskType.MISALIGNMENT]:
                 task_specify_meta_dict.update(
-                    dict(assistant_role=assistant_role_name,
-                         user_role=user_role_name))
+                    dict(
+                        assistant_role=assistant_role_name,
+                        user_role=user_role_name,
+                    )
+                )
             task_specify_meta_dict.update(extend_task_specify_meta_dict or {})
             if self.model_type is not None:
                 if task_specify_agent_kwargs is None:
                     task_specify_agent_kwargs = {}
                 task_specify_agent_kwargs.update(
-                    dict(model_type=self.model_type))
+                    dict(model_type=self.model_type)
+                )
             task_specify_agent = TaskSpecifyAgent(
                 task_type=self.task_type,
                 output_language=output_language,
@@ -181,9 +206,11 @@ class RolePlaying:
             )
             self.task_prompt = self.specified_task_prompt
 
-    def init_planned_task_prompt(self,
-                                 task_planner_agent_kwargs: Optional[Dict],
-                                 output_language: Optional[str]):
+    def _init_planned_task_prompt(
+        self,
+        task_planner_agent_kwargs: Optional[Dict] = None,
+        output_language: Optional[str] = None,
+    ) -> None:
         r"""Use a task plan agent to append a planned task prompt to task
         prompt. The planned task prompt is generated based on the task
         prompt, which can be original task prompt or specified task prompt
@@ -192,27 +219,29 @@ class RolePlaying:
 
         Args:
             task_planner_agent_kwargs (Dict, optional): Additional arguments
-                to pass to the task planner agent.
+                to pass to the task planner agent. (default: :obj:`None`)
             output_language (str, optional): The language to be output by the
-                agents.
+                agents. (default: :obj:`None`)
         """
         if self.with_task_planner:
             if self.model_type is not None:
                 if task_planner_agent_kwargs is None:
                     task_planner_agent_kwargs = {}
                 task_planner_agent_kwargs.update(
-                    dict(model_type=self.model_type))
+                    dict(model_type=self.model_type)
+                )
             task_planner_agent = TaskPlannerAgent(
                 output_language=output_language,
                 **(task_planner_agent_kwargs or {}),
             )
             self.planned_task_prompt = task_planner_agent.run(self.task_prompt)
-            self.task_prompt = (f"{self.task_prompt}\n"
-                                f"{self.planned_task_prompt}")
+            self.task_prompt = (
+                f"{self.task_prompt}\n" f"{self.planned_task_prompt}"
+            )
         else:
             self.planned_task_prompt = None
 
-    def get_sys_message_info(
+    def _get_sys_message_info(
         self,
         assistant_role_name: str,
         user_role_name: str,
@@ -230,28 +259,33 @@ class RolePlaying:
                 generator for agents.
             extend_sys_msg_meta_dicts (List[Dict], optional): A list of dicts
                 to extend the system message meta dicts with.
+                (default: :obj:`None`)
 
         Returns:
-            A tuple containing a `BaseMessage` representing the assistant's
-            initial system message, a `BaseMessage` representing the user's
-            initial system message, and a list of system message meta dicts.
+            Tuple[BaseMessage, BaseMessage, List[Dict]]: A tuple containing a
+                `BaseMessage` representing the assistant's initial system
+                message, a `BaseMessage` representing the user's initial system
+                message, and a list of system message meta dicts.
         """
         sys_msg_meta_dicts = [dict(task=self.task_prompt) for _ in range(2)]
-        if (extend_sys_msg_meta_dicts is None and self.task_type in [
-                TaskType.AI_SOCIETY,
-                TaskType.MISALIGNMENT,
-        ]):
+        if extend_sys_msg_meta_dicts is None and self.task_type in [
+            TaskType.AI_SOCIETY,
+            TaskType.MISALIGNMENT,
+        ]:
             extend_sys_msg_meta_dicts = [
-                dict(assistant_role=assistant_role_name,
-                     user_role=user_role_name) for _ in range(2)
+                dict(
+                    assistant_role=assistant_role_name, user_role=user_role_name
+                )
+                for _ in range(2)
             ]
 
         if extend_sys_msg_meta_dicts is not None:
-            sys_msg_meta_dicts = [{
-                **sys_msg_meta_dict,
-                **extend_sys_msg_meta_dict
-            } for sys_msg_meta_dict, extend_sys_msg_meta_dict in zip(
-                sys_msg_meta_dicts, extend_sys_msg_meta_dicts)]
+            sys_msg_meta_dicts = [
+                {**sys_msg_meta_dict, **extend_sys_msg_meta_dict}
+                for sys_msg_meta_dict, extend_sys_msg_meta_dict in zip(
+                    sys_msg_meta_dicts, extend_sys_msg_meta_dicts
+                )
+            ]
 
         init_assistant_sys_msg, init_user_sys_msg = (
             sys_msg_generator.from_dicts(
@@ -260,30 +294,31 @@ class RolePlaying:
                     (assistant_role_name, RoleType.ASSISTANT),
                     (user_role_name, RoleType.USER),
                 ],
-            ))
+            )
+        )
         return init_assistant_sys_msg, init_user_sys_msg, sys_msg_meta_dicts
 
-    def init_agents(
+    def _init_agents(
         self,
         init_assistant_sys_msg: BaseMessage,
-        assistant_agent_kwargs: Optional[Dict],
         init_user_sys_msg: BaseMessage,
-        user_agent_kwargs: Optional[Dict],
-        output_language: Optional[str],
-    ):
+        assistant_agent_kwargs: Optional[Dict] = None,
+        user_agent_kwargs: Optional[Dict] = None,
+        output_language: Optional[str] = None,
+    ) -> None:
         r"""Initialize assistant and user agents with their system messages.
 
         Args:
             init_assistant_sys_msg (BaseMessage): Assistant agent's initial
                 system message.
-            assistant_agent_kwargs (Dict, optional): Additional arguments to
-                pass to the assistant agent.
             init_user_sys_msg (BaseMessage): User agent's initial system
                 message.
+            assistant_agent_kwargs (Dict, optional): Additional arguments to
+                pass to the assistant agent. (default: :obj:`None`)
             user_agent_kwargs (Dict, optional): Additional arguments to
-                pass to the user agent.
+                pass to the user agent. (default: :obj:`None`)
             output_language (str, optional): The language to be output by the
-                agents.
+                agents. (default: :obj:`None`)
         """
         if self.model_type is not None:
             if assistant_agent_kwargs is None:
@@ -307,36 +342,42 @@ class RolePlaying:
         )
         self.user_sys_msg = self.user_agent.system_message
 
-    def init_critic(self, critic_role_name: str,
-                    critic_criteria: Optional[str],
-                    critic_kwargs: Optional[Dict],
-                    sys_msg_generator: SystemMessageGenerator,
-                    sys_msg_meta_dicts: List[Dict]):
+    def _init_critic(
+        self,
+        sys_msg_generator: SystemMessageGenerator,
+        sys_msg_meta_dicts: List[Dict],
+        critic_role_name: str,
+        critic_criteria: Optional[str] = None,
+        critic_kwargs: Optional[Dict] = None,
+    ) -> None:
         r"""Initialize critic agent. If critic role name is :obj:`"human"`,
         create a :obj:`Human` critic agent. Else, create a :obj:`CriticAgent`
         critic agent with specified critic criteria. If the critic criteria
         is not specified, set it to improve task performance.
 
         Args:
+            sys_msg_generator (SystemMessageGenerator): A system message
+                generator for agents.
+            sys_msg_meta_dicts (list): A list of system message meta dicts.
             critic_role_name (str): The name of the role played by the critic.
             critic_criteria (str, optional): Critic criteria for the
                 critic agent. If not specified, set the criteria to
-                improve task performance.
+                improve task performance. (default: :obj:`None`)
             critic_kwargs (Dict, optional): Additional arguments to
-                pass to the critic.
-            sys_msg_generator (SystemMessageGenerator): A system message
-                generator for agents.
-            sys_msg_meta_dicts (list): A list of system message meta dicts.
+                pass to the critic. (default: :obj:`None`)
         """
         if self.with_critic_in_the_loop:
             if critic_role_name.lower() == "human":
                 self.critic = Human(**(critic_kwargs or {}))
             else:
-                critic_criteria = (critic_criteria
-                                   or "improving the task performance")
-                critic_msg_meta_dict = dict(critic_role=critic_role_name,
-                                            criteria=critic_criteria,
-                                            **sys_msg_meta_dicts[0])
+                critic_criteria = (
+                    critic_criteria or "improving the task performance"
+                )
+                critic_msg_meta_dict = dict(
+                    critic_role=critic_role_name,
+                    criteria=critic_criteria,
+                    **sys_msg_meta_dicts[0],
+                )
                 self.critic_sys_msg = sys_msg_generator.from_dict(
                     critic_msg_meta_dict,
                     role_tuple=(critic_role_name, RoleType.CRITIC),
@@ -350,37 +391,7 @@ class RolePlaying:
                     **(critic_kwargs or {}),
                 )
 
-    def init_chat(self) -> Tuple[BaseMessage, List[BaseMessage]]:
-        r"""Initializes the chat by resetting both of the assistant and user
-        agents, and sending the system messages again to the agents using
-        chat messages. Returns the assistant's introductory message and the
-        user's response messages.
-
-        Returns:
-            A tuple containing a `BaseMessage` representing the assistant's
-            introductory message, and a list of `BaseMessage` representing
-            the user's response messages.
-        """
-        self.assistant_agent.reset()
-        self.user_agent.reset()
-
-        # Send the system messages again to the agents using chat messages
-        assistant_msg = BaseMessage.make_assistant_message(
-            role_name=self.assistant_sys_msg.role_name,
-            content=(f"{self.user_sys_msg.content}. "
-                     "Now start to give me instructions one by one. "
-                     "Only reply with Instruction and Input."))
-        user_msg = BaseMessage.make_user_message(
-            role_name=self.user_sys_msg.role_name,
-            content=f"{self.assistant_sys_msg.content}")
-        assistant_response = self.assistant_agent.step(user_msg)
-        if assistant_response.terminated or assistant_response.msgs is None:
-            raise ValueError(f"Assistant agent terminated unexpectedly. "
-                             f"Error info: {assistant_response.info}")
-
-        return assistant_msg, assistant_response.msgs
-
-    def reduce_message_options(
+    def _reduce_message_options(
         self,
         messages: Sequence[BaseMessage],
     ) -> BaseMessage:
@@ -390,16 +401,20 @@ class RolePlaying:
         If no messages are provided, a `ValueError` will be raised.
 
         Args:
-            messages: A sequence of `BaseMessage` objects to process.
+            messages (Sequence[BaseMessage]): A sequence of `BaseMessage`
+                objects to process.
 
         Returns:
-            A single `BaseMessage` representing the processed message.
+            BaseMessage: A single `BaseMessage` representing the processed
+                message.
         """
         if len(messages) == 0:
             raise ValueError("No messages to process.")
         if len(messages) > 1 and not self.with_critic_in_the_loop:
-            raise ValueError("Got than one message to process. "
-                             f"Num of messages: {len(messages)}.")
+            raise ValueError(
+                "Got than one message to process. "
+                f"Num of messages: {len(messages)}."
+            )
         elif self.with_critic_in_the_loop and self.critic is not None:
             critic_response = self.critic.reduce_step(messages)
             processed_msg = critic_response.msg
@@ -408,6 +423,35 @@ class RolePlaying:
 
         return processed_msg
 
+    def init_chat(self, init_msg_content: Optional[str] = None) -> BaseMessage:
+        r"""Initializes the chat by resetting both of the assistant and user
+        agents. Returns an initial message for the role-playing session.
+
+        Args:
+            init_msg_content (str, optional): A user-specified initial message.
+                Will be sent to the role-playing session as the initial
+                message. (default: :obj:`None`)
+
+        Returns:
+            BaseMessage: A single `BaseMessage` representing the initial
+                message.
+        """
+        self.assistant_agent.reset()
+        self.user_agent.reset()
+        default_init_msg_content = (
+            "Now start to give me instructions one by one. "
+            "Only reply with Instruction and Input."
+        )
+        if init_msg_content is None:
+            init_msg_content = default_init_msg_content
+        # Initialize a message sent by the assistant
+        init_msg = BaseMessage.make_assistant_message(
+            role_name=self.assistant_sys_msg.role_name,
+            content=init_msg_content,
+        )
+
+        return init_msg
+
     def step(
         self,
         assistant_msg: BaseMessage,
@@ -425,32 +469,43 @@ class RolePlaying:
                 assistant.
 
         Returns:
-            A tuple containing two ChatAgentResponse: the first struct contains
-            the resulting assistant message, whether the assistant agent
-            terminated the conversation, and any additional assistant
-            information; the second struct contains the resulting user message,
-            whether the user agent terminated the conversation, and any
-            additional user information.
+            Tuple[ChatAgentResponse, ChatAgentResponse]: A tuple containing two
+                ChatAgentResponse: the first struct contains the resulting
+                assistant message, whether the assistant agent terminated the
+                conversation, and any additional assistant information; the
+                second struct contains the resulting user message, whether the
+                user agent terminated the conversation, and any additional user
+                information.
         """
         user_response = self.user_agent.step(assistant_msg)
         if user_response.terminated or user_response.msgs is None:
-            return (ChatAgentResponse([], False, {}),
-                    ChatAgentResponse([], user_response.terminated,
-                                      user_response.info))
-        user_msg = self.reduce_message_options(user_response.msgs)
+            return (
+                ChatAgentResponse([], False, {}),
+                ChatAgentResponse(
+                    [], user_response.terminated, user_response.info
+                ),
+            )
+        user_msg = self._reduce_message_options(user_response.msgs)
         self.user_agent.record_message(user_msg)
 
         assistant_response = self.assistant_agent.step(user_msg)
         if assistant_response.terminated or assistant_response.msgs is None:
-            return (ChatAgentResponse([], assistant_response.terminated,
-                                      assistant_response.info),
-                    ChatAgentResponse([user_msg], False, user_response.info))
-        assistant_msg = self.reduce_message_options(assistant_response.msgs)
+            return (
+                ChatAgentResponse(
+                    [], assistant_response.terminated, assistant_response.info
+                ),
+                ChatAgentResponse([user_msg], False, user_response.info),
+            )
+        assistant_msg = self._reduce_message_options(assistant_response.msgs)
         self.assistant_agent.record_message(assistant_msg)
 
         return (
-            ChatAgentResponse([assistant_msg], assistant_response.terminated,
-                              assistant_response.info),
-            ChatAgentResponse([user_msg], user_response.terminated,
-                              user_response.info),
+            ChatAgentResponse(
+                [assistant_msg],
+                assistant_response.terminated,
+                assistant_response.info,
+            ),
+            ChatAgentResponse(
+                [user_msg], user_response.terminated, user_response.info
+            ),
         )

camel/storages/__init__.py

@@ -12,12 +12,30 @@
 # limitations under the License.
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 
+from .graph_storages.base import BaseGraphStorage
+from .graph_storages.neo4j_graph import Neo4jGraph
 from .key_value_storages.base import BaseKeyValueStorage
 from .key_value_storages.in_memory import InMemoryKeyValueStorage
 from .key_value_storages.json import JsonStorage
+from .vectordb_storages.base import (
+    BaseVectorStorage,
+    VectorDBQuery,
+    VectorDBQueryResult,
+    VectorRecord,
+)
+from .vectordb_storages.milvus import MilvusStorage
+from .vectordb_storages.qdrant import QdrantStorage
 
 __all__ = [
     'BaseKeyValueStorage',
     'InMemoryKeyValueStorage',
     'JsonStorage',
+    'VectorRecord',
+    'BaseVectorStorage',
+    'VectorDBQuery',
+    'VectorDBQueryResult',
+    'QdrantStorage',
+    'MilvusStorage',
+    'BaseGraphStorage',
+    'Neo4jGraph',
 ]

camel/storages/graph_storages/__init__.py

@@ -0,0 +1,23 @@
+# =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
+# Licensed under the Apache License, Version 2.0 (the “License”);
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an “AS IS” BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
+
+from .base import BaseGraphStorage
+from .graph_element import GraphElement
+from .neo4j_graph import Neo4jGraph
+
+__all__ = [
+    'BaseGraphStorage',
+    'GraphElement',
+    'Neo4jGraph',
+]

camel/storages/graph_storages/base.py

@@ -0,0 +1,82 @@
+# =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
+# Licensed under the Apache License, Version 2.0 (the “License”);
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an “AS IS” BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
+
+from abc import ABC, abstractmethod
+from typing import Any, Dict, List, Optional
+
+
+class BaseGraphStorage(ABC):
+    r"""An abstract base class for graph storage systems."""
+
+    @property
+    @abstractmethod
+    def get_client(self) -> Any:
+        r"""Get the underlying graph storage client."""
+        pass
+
+    @property
+    @abstractmethod
+    def get_schema(self) -> str:
+        r"""Get the schema of the graph storage"""
+        pass
+
+    @property
+    @abstractmethod
+    def get_structured_schema(self) -> Dict[str, Any]:
+        r"""Get the structured schema of the graph storage"""
+        pass
+
+    @abstractmethod
+    def refresh_schema(self) -> None:
+        r"""Refreshes the graph schema information."""
+        pass
+
+    @abstractmethod
+    def add_triplet(self, subj: str, obj: str, rel: str) -> None:
+        r"""Adds a relationship (triplet) between two entities in the database.
+
+        Args:
+            subj (str): The identifier for the subject entity.
+            obj (str): The identifier for the object entity.
+            rel (str): The relationship between the subject and object.
+        """
+        pass
+
+    @abstractmethod
+    def delete_triplet(self, subj: str, obj: str, rel: str) -> None:
+        r"""Deletes a specific triplet from the graph, comprising a subject,
+        object and relationship.
+
+        Args:
+            subj (str): The identifier for the subject entity.
+            obj (str): The identifier for the object entity.
+            rel (str): The relationship between the subject and object.
+        """
+        pass
+
+    @abstractmethod
+    def query(
+        self, query: str, params: Optional[Dict[str, Any]] = None
+    ) -> List[Dict[str, Any]]:
+        r"""Query the graph store with statement and parameters.
+        Args:
+            query (str): The query to be executed.
+            params (Optional[Dict[str, Any]]): A dictionary of parameters to
+                be used in the query. Defaults to `None`.
+
+        Returns:
+            List[Dict[str, Any]]: A list of dictionaries, each
+                dictionary represents a row of results from the query.
+        """
+        pass