camel-ai 0.1.5.1__py3-none-any.whl → 0.1.5.2__py3-none-any.whl

camel/agents/__init__.py

@@ -17,6 +17,7 @@ from .critic_agent import CriticAgent
 from .embodied_agent import EmbodiedAgent
 from .knowledge_graph_agent import KnowledgeGraphAgent
 from .role_assignment_agent import RoleAssignmentAgent
+from .search_agent import SearchAgent
 from .task_agent import (
     TaskCreationAgent,
     TaskPlannerAgent,
@@ -38,5 +39,6 @@ __all__ = [
     'HuggingFaceToolAgent',
     'EmbodiedAgent',
     'RoleAssignmentAgent',
+    'SearchAgent',
     'KnowledgeGraphAgent',
 ]

camel/agents/chat_agent.py

@@ -306,7 +306,7 @@ class ChatAgent(BaseAgent):
         tool_calls: List[FunctionCallingRecord] = []
         while True:
             # Format messages and get the token number
-            openai_messages: Optional[List[OpenAIMessage]]
+            openai_messages: list[OpenAIMessage] | None
 
             try:
                 openai_messages, num_tokens = self.memory.get_context()
@@ -314,18 +314,13 @@ class ChatAgent(BaseAgent):
                 return self.step_token_exceed(
                     e.args[1], tool_calls, "max_tokens_exceeded"
                 )
-
-            # Obtain the model's response
-            response = self.model_backend.run(openai_messages)
-
-            if isinstance(response, ChatCompletion):
-                output_messages, finish_reasons, usage_dict, response_id = (
-                    self.handle_batch_response(response)
-                )
-            else:
-                output_messages, finish_reasons, usage_dict, response_id = (
-                    self.handle_stream_response(response, num_tokens)
-                )
+            (
+                response,
+                output_messages,
+                finish_reasons,
+                usage_dict,
+                response_id,
+            ) = self._step_model_response(openai_messages, num_tokens)
 
             if (
                 self.is_tools_added()
@@ -350,38 +345,165 @@ class ChatAgent(BaseAgent):
 
             else:
                 # Function calling disabled or not a function calling
+                info = self._step_get_info(
+                    output_messages,
+                    finish_reasons,
+                    usage_dict,
+                    response_id,
+                    tool_calls,
+                    num_tokens,
+                )
+                break
+
+        return ChatAgentResponse(output_messages, self.terminated, info)
+
+    async def step_async(
+        self,
+        input_message: BaseMessage,
+    ) -> ChatAgentResponse:
+        r"""Performs a single step in the chat session by generating a response
+        to the input message. This agent step can call async function calls.
+
+        Args:
+            input_message (BaseMessage): The input message to the agent.
+            Its `role` field that specifies the role at backend may be either
+            `user` or `assistant` but it will be set to `user` anyway since
+            for the self agent any incoming message is external.
+
+        Returns:
+            ChatAgentResponse: A struct containing the output messages,
+                a boolean indicating whether the chat session has terminated,
+                and information about the chat session.
+        """
+        self.update_memory(input_message, OpenAIBackendRole.USER)
+
+        output_messages: List[BaseMessage]
+        info: Dict[str, Any]
+        tool_calls: List[FunctionCallingRecord] = []
+        while True:
+            # Format messages and get the token number
+            openai_messages: list[OpenAIMessage] | None
+
+            try:
+                openai_messages, num_tokens = self.memory.get_context()
+            except RuntimeError as e:
+                return self.step_token_exceed(
+                    e.args[1], tool_calls, "max_tokens_exceeded"
+                )
+            (
+                response,
+                output_messages,
+                finish_reasons,
+                usage_dict,
+                response_id,
+            ) = self._step_model_response(openai_messages, num_tokens)
+
+            if (
+                self.is_tools_added()
+                and isinstance(response, ChatCompletion)
+                and response.choices[0].message.tool_calls is not None
+            ):
+                # Tools added for function calling and not in stream mode
 
-                # Loop over responses terminators, get list of termination
-                # tuples with whether the terminator terminates the agent
-                # and termination reason
-                termination = [
-                    terminator.is_terminated(output_messages)
-                    for terminator in self.response_terminators
-                ]
-                # Terminate the agent if any of the terminator terminates
-                self.terminated, termination_reason = next(
-                    (
-                        (terminated, termination_reason)
-                        for terminated, termination_reason in termination
-                        if terminated
-                    ),
-                    (False, None),
+                # Do function calling
+                (
+                    func_assistant_msg,
+                    func_result_msg,
+                    func_record,
+                ) = await self.step_tool_call_async(response)
+
+                # Update the messages
+                self.update_memory(
+                    func_assistant_msg, OpenAIBackendRole.ASSISTANT
                 )
-                # For now only retain the first termination reason
-                if self.terminated and termination_reason is not None:
-                    finish_reasons = [termination_reason] * len(finish_reasons)
+                self.update_memory(func_result_msg, OpenAIBackendRole.FUNCTION)
 
-                info = self.get_info(
-                    response_id,
-                    usage_dict,
+                # Record the function calling
+                tool_calls.append(func_record)
+
+            else:
+                # Function calling disabled or not a function calling
+                info = self._step_get_info(
+                    output_messages,
                     finish_reasons,
-                    num_tokens,
+                    usage_dict,
+                    response_id,
                     tool_calls,
+                    num_tokens,
                 )
                 break
 
         return ChatAgentResponse(output_messages, self.terminated, info)
 
+    def _step_model_response(
+        self,
+        openai_messages: list[OpenAIMessage],
+        num_tokens: int,
+    ) -> tuple[
+        ChatCompletion | Stream[ChatCompletionChunk],
+        list[BaseMessage],
+        list[str],
+        dict[str, int],
+        str,
+    ]:
+        r"""Internal function for agent step model response."""
+        # Obtain the model's response
+        response = self.model_backend.run(openai_messages)
+
+        if isinstance(response, ChatCompletion):
+            output_messages, finish_reasons, usage_dict, response_id = (
+                self.handle_batch_response(response)
+            )
+        else:
+            output_messages, finish_reasons, usage_dict, response_id = (
+                self.handle_stream_response(response, num_tokens)
+            )
+        return (
+            response,
+            output_messages,
+            finish_reasons,
+            usage_dict,
+            response_id,
+        )
+
+    def _step_get_info(
+        self,
+        output_messages: List[BaseMessage],
+        finish_reasons: List[str],
+        usage_dict: Dict[str, int],
+        response_id: str,
+        tool_calls: List[FunctionCallingRecord],
+        num_tokens: int,
+    ) -> Dict[str, Any]:
+        # Loop over responses terminators, get list of termination
+        # tuples with whether the terminator terminates the agent
+        # and termination reason
+        termination = [
+            terminator.is_terminated(output_messages)
+            for terminator in self.response_terminators
+        ]
+        # Terminate the agent if any of the terminator terminates
+        self.terminated, termination_reason = next(
+            (
+                (terminated, termination_reason)
+                for terminated, termination_reason in termination
+                if terminated
+            ),
+            (False, None),
+        )
+        # For now only retain the first termination reason
+        if self.terminated and termination_reason is not None:
+            finish_reasons = [termination_reason] * len(finish_reasons)
+
+        info = self.get_info(
+            response_id,
+            usage_dict,
+            finish_reasons,
+            num_tokens,
+            tool_calls,
+        )
+        return info
+
     def handle_batch_response(
         self, response: ChatCompletion
     ) -> Tuple[List[BaseMessage], List[str], Dict[str, int], str]:
@@ -516,7 +638,7 @@ class ChatAgent(BaseAgent):
         """
         choice = response.choices[0]
         if choice.message.tool_calls is None:
-            raise RuntimeError("Tool calls is None")
+            raise RuntimeError("Tool call is None")
         func_name = choice.message.tool_calls[0].function.name
         func = self.func_dict[func_name]
 
@@ -553,6 +675,65 @@ class ChatAgent(BaseAgent):
         func_record = FunctionCallingRecord(func_name, args, result)
         return assist_msg, func_msg, func_record
 
+    async def step_tool_call_async(
+        self,
+        response: ChatCompletion,
+    ) -> Tuple[
+        FunctionCallingMessage, FunctionCallingMessage, FunctionCallingRecord
+    ]:
+        r"""Execute the async function with arguments following the model's
+        response.
+
+        Args:
+            response (Dict[str, Any]): The response obtained by calling the
+                model.
+
+        Returns:
+            tuple: A tuple consisting of two obj:`FunctionCallingMessage`,
+                one about the arguments and the other about the execution
+                result, and a struct for logging information about this
+                function call.
+        """
+        # Note that when function calling is enabled, `n` is set to 1.
+        choice = response.choices[0]
+        if choice.message.tool_calls is None:
+            raise RuntimeError("Tool call is None")
+        func_name = choice.message.tool_calls[0].function.name
+        func = self.func_dict[func_name]
+
+        args_str: str = choice.message.tool_calls[0].function.arguments
+        args = json.loads(args_str.replace("'", "\""))
+
+        # Pass the extracted arguments to the indicated function
+        try:
+            result = await func(**args)
+        except Exception:
+            raise ValueError(
+                f"Execution of function {func.__name__} failed with "
+                f"arguments being {args}."
+            )
+
+        assist_msg = FunctionCallingMessage(
+            role_name=self.role_name,
+            role_type=self.role_type,
+            meta_dict=None,
+            content="",
+            func_name=func_name,
+            args=args,
+        )
+        func_msg = FunctionCallingMessage(
+            role_name=self.role_name,
+            role_type=self.role_type,
+            meta_dict=None,
+            content="",
+            func_name=func_name,
+            result=result,
+        )
+
+        # Record information about this function call
+        func_record = FunctionCallingRecord(func_name, args, result)
+        return assist_msg, func_msg, func_record
+
     def get_usage_dict(
         self, output_messages: List[BaseMessage], prompt_tokens: int
     ) -> Dict[str, int]:

camel/agents/deductive_reasoner_agent.py

@@ -90,52 +90,106 @@ class DeductiveReasonerAgent(ChatAgent):
         """
         self.reset()
 
-        deduce_prompt = """You are a deductive reasoner. You are tasked to complete the TASK based on the THOUGHT OF DEDUCTIVE REASONING, the STARTING STATE A and the TARGET STATE B. You are given the CONTEXT CONTENT to help you complete the TASK.
-Your answer MUST strictly adhere to the structure of ANSWER TEMPLATE, ONLY fill in the BLANKs, and DO NOT alter or modify any other part of the template
+        deduce_prompt = """You are a deductive reasoner. You are tasked to 
+        complete the TASK based on the THOUGHT OF DEDUCTIVE REASONING, the 
+        STARTING STATE A and the TARGET STATE B. You are given the CONTEXT 
+        CONTENT to help you complete the TASK.
+Your answer MUST strictly adhere to the structure of ANSWER TEMPLATE, ONLY 
+fill in the BLANKs, and DO NOT alter or modify any other part of the template
 
 ===== MODELING OF DEDUCTIVE REASONING =====
-You are tasked with understanding a mathematical model based on the components ${A, B, C, Q, L}$. In this model: ``L: A ⊕ C -> q * B``.
+You are tasked with understanding a mathematical model based on the components 
+${A, B, C, Q, L}$. In this model: ``L: A ⊕ C -> q * B``.
 - $A$ represents the known starting state.
 - $B$ represents the known target state.
 - $C$ represents the conditions required to transition from $A$ to $B$.
-- $Q$ represents the quality or effectiveness of the transition from $A$ to $B$.
+- $Q$ represents the quality or effectiveness of the transition from $A$ to 
+$B$.
 - $L$ represents the path or process from $A$ to $B$.
 
 ===== THOUGHT OF DEDUCTIVE REASONING =====
 1. Define the Parameters of A and B:
-    - Characterization: Before delving into transitions, thoroughly understand the nature and boundaries of both $A$ and $B$. This includes the type, properties, constraints, and possible interactions between the two.
-    - Contrast and Compare: Highlight the similarities and differences between $A$ and $B$. This comparative analysis will give an insight into what needs changing and what remains constant.
+    - Characterization: Before delving into transitions, thoroughly understand 
+    the nature and boundaries of both $A$ and $B$. This includes the type, 
+    properties, constraints, and possible interactions between the two.
+    - Contrast and Compare: Highlight the similarities and differences between 
+    $A$ and $B$. This comparative analysis will give an insight into what 
+    needs changing and what remains constant.
 2. Historical & Empirical Analysis:
-    - Previous Transitions according to the Knowledge Base of GPT: (if applicable) Extract conditions and patterns from the historical instances where a similar transition from a state comparable to $A$ moved towards $B$.
-    - Scientific Principles: (if applicable) Consider the underlying scientific principles governing or related to the states and their transition. For example, if $A$ and $B$ are physical states, laws of physics might apply.
+    - Previous Transitions according to the Knowledge Base of GPT: (if 
+    applicable) Extract conditions and patterns from the historical instances 
+    where a similar transition from a state comparable to $A$ moved towards 
+    $B$.
+    - Scientific Principles: (if applicable) Consider the underlying 
+    scientific principles governing or related to the states and their 
+    transition. For example, if $A$ and $B$ are physical states, laws of 
+    physics might apply.
 3. Logical Deduction of Conditions ($C$):
-    - Direct Path Analysis: What are the immediate and direct conditions required to move from $A$ to $B$?
-    - Intermediate States: Are there states between $A$ and $B$ that must be transversed or can be used to make the transition smoother or more efficient? If yes, what is the content?
-    - Constraints & Limitations: Identify potential barriers or restrictions in moving from $A$ to $B$. These can be external (e.g., environmental factors) or internal (properties of $A$ or $B$).
-    - Resource and Information Analysis: What resources and information are required for the transition? This could be time, entity, factor, code language, software platform, unknowns, etc.
-    - External Influences: Consider socio-economic, political, or environmental factors (if applicable) that could influence the transition conditions.
-    - Creative/Heuristic Reasoning: Open your mind to multiple possible $C$'s, no matter how unconventional they might seem. Utilize analogies, metaphors, or brainstorming techniques to envision possible conditions or paths from $A$ to $B$.
-    - The conditions $C$ should be multiple but in one sentence. And each condition should be concerned with one aspect/entity.
+    - Direct Path Analysis: What are the immediate and direct conditions 
+    required to move from $A$ to $B$?
+    - Intermediate States: Are there states between $A$ and $B$ that must be 
+    transversed or can be used to make the transition smoother or more 
+    efficient? If yes, what is the content?
+    - Constraints & Limitations: Identify potential barriers or restrictions 
+    in moving from $A$ to $B$. These can be external (e.g., environmental 
+    factors) or internal (properties of $A$ or $B$).
+    - Resource and Information Analysis: What resources and information are 
+    required for the transition? This could be time, entity, factor, code 
+    language, software platform, unknowns, etc.
+    - External Influences: Consider socio-economic, political, or 
+    environmental factors (if applicable) that could influence the transition 
+    conditions.
+    - Creative/Heuristic Reasoning: Open your mind to multiple possible $C$'s, 
+    no matter how unconventional they might seem. Utilize analogies, 
+    metaphors, or brainstorming techniques to envision possible conditions or 
+    paths from $A$ to $B$.
+    - The conditions $C$ should be multiple but in one sentence. And each 
+    condition should be concerned with one aspect/entity.
 4. Entity/Label Recognition of Conditions ($C$):
-    - Identify and categorize entities of Conditions ($C$) such as the names, locations, dates, specific technical terms or contextual parameters that might be associated with events, innovations post-2022.
-    - The output of the entities/labels will be used as tags or labels for semantic similarity searches. The entities/labels may be the words, or phrases, each of them should contain valuable, high information entropy information, and should be independent.
-    - Ensure that the identified entities are formatted in a manner suitable for database indexing and retrieval. Organize the entities into categories, and combine the category with its instance into a continuous phrase, without using colons or other separators.
-    - Format these entities for database indexing: output the category rather than its instance/content into a continuous phrase. For example, instead of "Jan. 02", identify it as "Event time".
+    - Identify and categorize entities of Conditions ($C$) such as the names, 
+    locations, dates, specific technical terms or contextual parameters that 
+    might be associated with events, innovations post-2022.
+    - The output of the entities/labels will be used as tags or labels for 
+    semantic similarity searches. The entities/labels may be the words, or 
+    phrases, each of them should contain valuable, high information entropy 
+    information, and should be independent.
+    - Ensure that the identified entities are formatted in a manner suitable 
+    for database indexing and retrieval. Organize the entities into 
+    categories, and combine the category with its instance into a continuous 
+    phrase, without using colons or other separators.
+    - Format these entities for database indexing: output the category rather 
+    than its instance/content into a continuous phrase. For example, instead 
+    of "Jan. 02", identify it as "Event time".
 5. Quality Assessment ($Q$):
-    - Efficiency: How efficient is the transition from $A$ to $B$, which measures the resources used versus the desired outcome?
-    - Effectiveness: Did the transition achieve the desired outcome or was the target state achieved as intended?
-    - Safety & Risks: Assess any risks associated with the transition and the measures to mitigate them.
-    - Feedback Mechanisms: Incorporate feedback loops to continuously monitor and adjust the quality of transition, making it more adaptive.
+    - Efficiency: How efficient is the transition from $A$ to $B$, which 
+    measures the resources used versus the desired outcome?
+    - Effectiveness: Did the transition achieve the desired outcome or was the 
+    target state achieved as intended?
+    - Safety & Risks: Assess any risks associated with the transition and the 
+    measures to mitigate them.
+    - Feedback Mechanisms: Incorporate feedback loops to continuously monitor 
+    and adjust the quality of transition, making it more adaptive.
 6. Iterative Evaluation:
-    - Test & Refine: Based on the initially deduced conditions and assessed quality, iterate the process to refine and optimize the transition. This might involve tweaking conditions, employing different paths, or changing resources.
-    - Feedback Integration: Use feedback to make improvements and increase the quality of the transition.
-7. Real-world scenarios often present challenges that may not be captured by models and frameworks. While using the model, maintain an adaptive mindset:
-    - Scenario Exploration: Continuously imagine various possible scenarios, both positive and negative, to prepare for unexpected events.
-    - Flexibility: Be prepared to modify conditions ($C$) or alter the path/process ($L$) if unforeseen challenges arise.
-    - Feedback Integration: Rapidly integrate feedback from actual implementations to adjust the model's application, ensuring relevancy and effectiveness.
+    - Test & Refine: Based on the initially deduced conditions and assessed 
+    quality, iterate the process to refine and optimize the transition. This 
+    might involve tweaking conditions, employing different paths, or changing 
+    resources.
+    - Feedback Integration: Use feedback to make improvements and increase the 
+    quality of the transition.
+7. Real-world scenarios often present challenges that may not be captured by 
+models and frameworks. While using the model, maintain an adaptive mindset:
+    - Scenario Exploration: Continuously imagine various possible scenarios, 
+    both positive and negative, to prepare for unexpected events.
+    - Flexibility: Be prepared to modify conditions ($C$) or alter the path/
+    process ($L$) if unforeseen challenges arise.
+    - Feedback Integration: Rapidly integrate feedback from actual 
+    implementations to adjust the model's application, ensuring relevancy and 
+    effectiveness.
 
 ===== TASK =====
-Given the starting state $A$ and the target state $B$, assuming that a path $L$ always exists between $A$ and $B$, how can one deduce or identify the necessary conditions $C$ and the quality $Q$ of the transition?
+Given the starting state $A$ and the target state $B$, assuming that a path 
+$L$ always exists between $A$ and $B$, how can one deduce or identify the 
+necessary conditions $C$ and the quality $Q$ of the transition?
 
 ===== STARTING STATE $A$ =====
 {starting_state}
@@ -150,7 +204,8 @@ Given the starting state $A$ and the target state $B$, assuming that a path $L$
 - Logical Deduction of Conditions ($C$) (multiple conditions can be deduced):
     condition <NUM>:
         <BLANK>.
-- Entity/Label Recognition of Conditions:\n[<BLANK>, <BLANK>, ...] (include square brackets)
+- Entity/Label Recognition of Conditions:\n[<BLANK>, <BLANK>, ...] (include 
+square brackets)
 - Quality Assessment ($Q$) (do not use symbols):
     <BLANK>.
 - Iterative Evaluation:\n<BLANK>/None"""

camel/agents/knowledge_graph_agent.py

@@ -26,37 +26,49 @@ from camel.storages.graph_storages.graph_element import (
 from camel.types import ModelType, RoleType
 
 text_prompt = """
-You are tasked with extracting nodes and relationships from given content and structures them into Node and Relationship objects. Here's the outline of what you needs to do:
+You are tasked with extracting nodes and relationships from given content and 
+structures them into Node and Relationship objects. Here's the outline of what 
+you needs to do:
 
 Content Extraction:
-You should be able to process input content and identify entities mentioned within it.
-Entities can be any noun phrases or concepts that represent distinct entities in the context of the given content.
+You should be able to process input content and identify entities mentioned 
+within it.
+Entities can be any noun phrases or concepts that represent distinct entities 
+in the context of the given content.
 
 Node Extraction:
 For each identified entity, you should create a Node object.
 Each Node object should have a unique identifier (id) and a type (type).
-Additional properties associated with the node can also be extracted and stored.
+Additional properties associated with the node can also be extracted and 
+stored.
 
 Relationship Extraction:
 You should identify relationships between entities mentioned in the content.
 For each relationship, create a Relationship object.
-A Relationship object should have a subject (subj) and an object (obj) which are Node objects representing the entities involved in the relationship.
-Each relationship should also have a type (type), and additional properties if applicable.
+A Relationship object should have a subject (subj) and an object (obj) which 
+are Node objects representing the entities involved in the relationship.
+Each relationship should also have a type (type), and additional properties if 
+applicable.
 
 Output Formatting:
-The extracted nodes and relationships should be formatted as instances of the provided Node and Relationship classes.
+The extracted nodes and relationships should be formatted as instances of the 
+provided Node and Relationship classes.
 Ensure that the extracted data adheres to the structure defined by the classes.
-Output the structured data in a format that can be easily validated against the provided code.
+Output the structured data in a format that can be easily validated against 
+the provided code.
 
 Instructions for you:
 Read the provided content thoroughly.
-Identify distinct entities mentioned in the content and categorize them as nodes.
-Determine relationships between these entities and represent them as directed relationships.
+Identify distinct entities mentioned in the content and categorize them as 
+nodes.
+Determine relationships between these entities and represent them as directed 
+relationships.
 Provide the extracted nodes and relationships in the specified format below.
 Example for you:
 
 Example Content:
-"John works at XYZ Corporation. He is a software engineer. The company is located in New York City."
+"John works at XYZ Corporation. He is a software engineer. The company is 
+located in New York City."
 
 Expected Output:
 
@@ -68,18 +80,23 @@ Node(id='New York City', type='Location', properties={'agent_generated'})
 
 Relationships:
 
-Relationship(subj=Node(id='John', type='Person'), obj=Node(id='XYZ Corporation', type='Organization'), type='WorksAt', properties={'agent_generated'})
-Relationship(subj=Node(id='John', type='Person'), obj=Node(id='New York City', type='Location'), type='ResidesIn', properties={'agent_generated'})
+Relationship(subj=Node(id='John', type='Person'), obj=Node(id='XYZ 
+Corporation', type='Organization'), type='WorksAt', properties=
+{'agent_generated'})
+Relationship(subj=Node(id='John', type='Person'), obj=Node(id='New York City', 
+type='Location'), type='ResidesIn', properties={'agent_generated'})
 
 ===== TASK =====
-Please extracts nodes and relationships from given content and structures them into Node and Relationship objects. 
+Please extracts nodes and relationships from given content and structures them 
+into Node and Relationship objects. 
 
 {task}
 """
 
 
 class KnowledgeGraphAgent(ChatAgent):
-    r"""An agent that can extract node and relationship information for different entities from given `Element` content.
+    r"""An agent that can extract node and relationship information for
+    different entities from given `Element` content.
 
     Attributes:
         task_prompt (TextPrompt): A prompt for the agent to extract node and
@@ -106,7 +123,8 @@ class KnowledgeGraphAgent(ChatAgent):
             content="Your mission is to transform unstructured content "
             "intostructured graph data. Extract nodes and relationships with "
             "precision, and let the connections unfold. Your graphs will "
-            "illuminate the hidden connections within the chaos of information.",
+            "illuminate the hidden connections within the chaos of "
+            "information.",
         )
         super().__init__(system_message, model_type, model_config)
 
@@ -124,7 +142,8 @@ class KnowledgeGraphAgent(ChatAgent):
 
         Returns:
             Union[str, GraphElement]: The extracted node and relationship
-                information. If `parse_graph_elements` is `True` then return `GraphElement`, else return `str`.
+                information. If `parse_graph_elements` is `True` then return
+                `GraphElement`, else return `str`.
         """
         self.reset()
         self.element = element
@@ -191,7 +210,11 @@ class KnowledgeGraphAgent(ChatAgent):
 
         # Regular expressions to extract nodes and relationships
         node_pattern = r"Node\(id='(.*?)', type='(.*?)', properties=(.*?)\)"
-        rel_pattern = r"Relationship\(subj=Node\(id='(.*?)', type='(.*?)'\), obj=Node\(id='(.*?)', type='(.*?)'\), type='(.*?)', properties=\{(.*?)\}\)"
+        rel_pattern = (
+            r"Relationship\(subj=Node\(id='(.*?)', type='(.*?)'\), "
+            r"obj=Node\(id='(.*?)', type='(.*?)'\), type='(.*?)', "
+            r"properties=\{(.*?)\}\)"
+        )
 
         nodes = {}
         relationships = []

camel/agents/role_assignment_agent.py

@@ -22,6 +22,7 @@ from camel.types import ModelType, RoleType
 
 class RoleAssignmentAgent(ChatAgent):
     r"""An agent that generates role names based on the task prompt.
+
     Attributes:
         role_assignment_prompt (TextPrompt): A prompt for the agent to generate
         role names.
@@ -115,7 +116,9 @@ class RoleAssignmentAgent(ChatAgent):
         ]
 
         if len(role_names) != num_roles or len(role_descriptions) != num_roles:
-            raise RuntimeError("Got None or insufficient information of roles.")
+            raise RuntimeError(
+                "Got None or insufficient information of roles."
+            )
         if terminated:
             raise RuntimeError("Role assignment failed.")