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

camel/__init__.py

@@ -11,18 +11,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
-import camel.agents
-import camel.configs
-import camel.generators
-import camel.messages
-import camel.prompts
-import camel.types
-import camel.utils
-import camel.functions
-import camel.memories
-import camel.storages
 
-__version__ = '0.1.1'
+__version__ = '0.1.4'
 
 __all__ = [
     '__version__',

camel/agents/__init__.py

@@ -13,17 +13,18 @@
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 from .base import BaseAgent
 from .chat_agent import ChatAgent
+from .critic_agent import CriticAgent
+from .embodied_agent import EmbodiedAgent
+from .knowledge_graph_agent import KnowledgeGraphAgent
+from .role_assignment_agent import RoleAssignmentAgent
 from .task_agent import (
-    TaskSpecifyAgent,
-    TaskPlannerAgent,
     TaskCreationAgent,
+    TaskPlannerAgent,
     TaskPrioritizationAgent,
+    TaskSpecifyAgent,
 )
-from .critic_agent import CriticAgent
 from .tool_agents.base import BaseToolAgent
 from .tool_agents.hugging_face_tool_agent import HuggingFaceToolAgent
-from .embodied_agent import EmbodiedAgent
-from .role_assignment_agent import RoleAssignmentAgent
 
 __all__ = [
     'BaseAgent',
@@ -37,4 +38,5 @@ __all__ = [
     'HuggingFaceToolAgent',
     'EmbodiedAgent',
     'RoleAssignmentAgent',
+    'KnowledgeGraphAgent',
 ]

camel/agents/chat_agent.py

@@ -11,18 +11,17 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
+from __future__ import annotations
+
 import json
 from collections import defaultdict
 from dataclasses import dataclass
-from typing import Any, Callable, Dict, List, Optional, Tuple
-
-from openai import Stream
+from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Tuple
 
-from camel.agents import BaseAgent
-from camel.configs import BaseConfig, ChatGPTConfig
-from camel.functions import OpenAIFunction
+from camel.agents.base import BaseAgent
+from camel.configs import ChatGPTConfig
 from camel.memories import (
-    BaseMemory,
+    AgentMemory,
     ChatHistoryMemory,
     MemoryRecord,
     ScoreBasedContextCreator,
@@ -30,7 +29,6 @@ from camel.memories import (
 from camel.messages import BaseMessage, FunctionCallingMessage, OpenAIMessage
 from camel.models import BaseModelBackend, ModelFactory
 from camel.responses import ChatAgentResponse
-from camel.terminators import ResponseTerminator
 from camel.types import (
     ChatCompletion,
     ChatCompletionChunk,
@@ -40,6 +38,13 @@ from camel.types import (
 )
 from camel.utils import get_model_encoding
 
+if TYPE_CHECKING:
+    from openai import Stream
+
+    from camel.configs import BaseConfig
+    from camel.functions import OpenAIFunction
+    from camel.terminators import ResponseTerminator
+
 
 @dataclass(frozen=True)
 class FunctionCallingRecord:
@@ -51,6 +56,7 @@ class FunctionCallingRecord:
             the function.
         result (Any): The execution result of calling this function.
     """
+
     func_name: str
     args: Dict[str, Any]
     result: Any
@@ -62,9 +68,11 @@ class FunctionCallingRecord:
             str: Modified string to represent the function calling.
         """
 
-        return (f"Function Execution: {self.func_name}\n"
-                f"\tArgs: {self.args}\n"
-                f"\tResult: {self.result}")
+        return (
+            f"Function Execution: {self.func_name}\n"
+            f"\tArgs: {self.args}\n"
+            f"\tResult: {self.result}"
+        )
 
 
 class ChatAgent(BaseAgent):
@@ -76,19 +84,22 @@ class ChatAgent(BaseAgent):
             responses. (default :obj:`ModelType.GPT_3_5_TURBO`)
         model_config (BaseConfig, optional): Configuration options for the
             LLM model. (default: :obj:`None`)
-        memory (BaseMemory, optional): The agent memory for managing chat
+        api_key (str, optional): The API key for authenticating with the
+            LLM service. Only OpenAI and Anthropic model supported (default:
+            :obj:`None`)
+        memory (AgentMemory, optional): The agent memory for managing chat
             messages. If `None`, a :obj:`ChatHistoryMemory` will be used.
             (default: :obj:`None`)
         message_window_size (int, optional): The maximum number of previous
             messages to include in the context window. If `None`, no windowing
             is performed. (default: :obj:`None`)
-        token_limit (int, optional): The maxinum number of tokens in a context.
+        token_limit (int, optional): The maximum number of tokens in a context.
             The context will be automatically pruned to fulfill the limitation.
             If `None`, it will be set according to the backend model.
             (default: :obj:`None`)
         output_language (str, optional): The language to be output by the
             agent. (default: :obj:`None`)
-        function_list (List[OpenAIFunction], optional): List of available
+        tools (List[OpenAIFunction], optional): List of available
             :obj:`OpenAIFunction`. (default: :obj:`None`)
         response_terminators (List[ResponseTerminator], optional): List of
             :obj:`ResponseTerminator` bind to one chat agent.
@@ -100,14 +111,14 @@ class ChatAgent(BaseAgent):
         system_message: BaseMessage,
         model_type: Optional[ModelType] = None,
         model_config: Optional[BaseConfig] = None,
-        memory: Optional[BaseMemory] = None,
+        api_key: Optional[str] = None,
+        memory: Optional[AgentMemory] = None,
         message_window_size: Optional[int] = None,
         token_limit: Optional[int] = None,
         output_language: Optional[str] = None,
-        function_list: Optional[List[OpenAIFunction]] = None,
+        tools: Optional[List[OpenAIFunction]] = None,
         response_terminators: Optional[List[ResponseTerminator]] = None,
     ) -> None:
-
         self.orig_sys_message: BaseMessage = system_message
         self.system_message = system_message
         self.role_name: str = system_message.role_name
@@ -116,24 +127,28 @@ class ChatAgent(BaseAgent):
         if self.output_language is not None:
             self.set_output_language(self.output_language)
 
-        self.model_type: ModelType = (model_type if model_type is not None else
-                                      ModelType.GPT_3_5_TURBO)
+        self.model_type: ModelType = (
+            model_type if model_type is not None else ModelType.GPT_3_5_TURBO
+        )
 
         self.func_dict: Dict[str, Callable] = {}
-        if function_list is not None:
-            for func in function_list:
-                self.func_dict[func.name] = func.func
-        self.model_config = model_config or ChatGPTConfig()
+        if tools is not None:
+            for func in tools:
+                self.func_dict[func.get_function_name()] = func.func
 
+        self.model_config = model_config or ChatGPTConfig()
+        self._api_key = api_key
         self.model_backend: BaseModelBackend = ModelFactory.create(
-            self.model_type, self.model_config.__dict__)
+            self.model_type, self.model_config.__dict__, self._api_key
+        )
         self.model_token_limit = token_limit or self.model_backend.token_limit
         context_creator = ScoreBasedContextCreator(
             self.model_backend.token_counter,
             self.model_token_limit,
         )
-        self.memory: BaseMemory = memory or ChatHistoryMemory(
-            context_creator, window_size=message_window_size)
+        self.memory: AgentMemory = memory or ChatHistoryMemory(
+            context_creator, window_size=message_window_size
+        )
 
         self.terminated: bool = False
         self.response_terminators = response_terminators or []
@@ -170,18 +185,19 @@ class ChatAgent(BaseAgent):
         """
         self._system_message = message
 
-    def is_function_calling_enabled(self) -> bool:
+    def is_tools_added(self) -> bool:
         r"""Whether OpenAI function calling is enabled for this agent.
 
         Returns:
             bool: Whether OpenAI function calling is enabled for this
-                agent, determined by whether the dictionary of functions
+                agent, determined by whether the dictionary of tools
                 is empty.
         """
         return len(self.func_dict) > 0
 
-    def update_memory(self, message: BaseMessage,
-                      role: OpenAIBackendRole) -> None:
+    def update_memory(
+        self, message: BaseMessage, role: OpenAIBackendRole
+    ) -> None:
         r"""Updates the agent memory with a new message.
 
         Args:
@@ -204,15 +220,21 @@ class ChatAgent(BaseAgent):
             BaseMessage: The updated system message object.
         """
         self.output_language = output_language
-        content = (self.orig_sys_message.content +
-                   ("\nRegardless of the input language, "
-                    f"you must output text in {output_language}."))
+        content = self.orig_sys_message.content + (
+            "\nRegardless of the input language, "
+            f"you must output text in {output_language}."
+        )
         self.system_message = self.system_message.create_new_instance(content)
         return self.system_message
 
-    def get_info(self, id: Optional[str], usage: Optional[Dict[str, int]],
-                 termination_reasons: List[str], num_tokens: int,
-                 called_funcs: List[FunctionCallingRecord]) -> Dict[str, Any]:
+    def get_info(
+        self,
+        id: Optional[str],
+        usage: Optional[Dict[str, int]],
+        termination_reasons: List[str],
+        num_tokens: int,
+        tool_calls: List[FunctionCallingRecord],
+    ) -> Dict[str, Any]:
         r"""Returns a dictionary containing information about the chat session.
 
         Args:
@@ -222,9 +244,9 @@ class ChatAgent(BaseAgent):
             termination_reasons (List[str]): The reasons for the termination
                 of the chat session.
             num_tokens (int): The number of tokens used in the chat session.
-            called_funcs (List[FunctionCallingRecord]): The list of function
+            tool_calls (List[FunctionCallingRecord]): The list of function
                 calling records, containing the information of called
-                functions.
+                tools.
 
         Returns:
             Dict[str, Any]: The chat session information.
@@ -234,15 +256,16 @@ class ChatAgent(BaseAgent):
             "usage": usage,
             "termination_reasons": termination_reasons,
             "num_tokens": num_tokens,
-            "called_functions": called_funcs,
+            "tool_calls": tool_calls,
         }
 
     def init_messages(self) -> None:
         r"""Initializes the stored messages list with the initial system
         message.
         """
-        system_record = MemoryRecord(self.system_message,
-                                     OpenAIBackendRole.SYSTEM)
+        system_record = MemoryRecord(
+            self.system_message, OpenAIBackendRole.SYSTEM
+        )
         self.memory.clear()
         self.memory.write_record(system_record)
 
@@ -266,9 +289,10 @@ class ChatAgent(BaseAgent):
 
         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.
+                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,
@@ -279,7 +303,7 @@ class ChatAgent(BaseAgent):
 
         output_messages: List[BaseMessage]
         info: Dict[str, Any]
-        called_funcs: List[FunctionCallingRecord] = []
+        tool_calls: List[FunctionCallingRecord] = []
         while True:
             # Format messages and get the token number
             openai_messages: Optional[List[OpenAIMessage]]
@@ -287,33 +311,43 @@ class ChatAgent(BaseAgent):
             try:
                 openai_messages, num_tokens = self.memory.get_context()
             except RuntimeError as e:
-                return self.step_token_exceed(e.args[1], called_funcs,
-                                              "max_tokens_exceeded")
+                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))
+                    self.handle_batch_response(response)
+                )
             else:
                 output_messages, finish_reasons, usage_dict, response_id = (
-                    self.handle_stream_response(response, num_tokens))
+                    self.handle_stream_response(response, 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
 
-            if (self.is_function_calling_enabled()
-                    and finish_reasons[0] == 'function_call'
-                    and isinstance(response, ChatCompletion)):
                 # Do function calling
                 func_assistant_msg, func_result_msg, func_record = (
-                    self.step_function_call(response))
+                    self.step_tool_call(response)
+                )
 
                 # Update the messages
-                self.update_memory(func_assistant_msg,
-                                   OpenAIBackendRole.ASSISTANT)
+                self.update_memory(
+                    func_assistant_msg, OpenAIBackendRole.ASSISTANT
+                )
                 self.update_memory(func_result_msg, OpenAIBackendRole.FUNCTION)
 
                 # Record the function calling
-                called_funcs.append(func_record)
+                tool_calls.append(func_record)
+
             else:
                 # Function calling disabled or not a function calling
 
@@ -326,9 +360,13 @@ class ChatAgent(BaseAgent):
                 ]
                 # 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))
+                    (
+                        (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)
@@ -338,7 +376,7 @@ class ChatAgent(BaseAgent):
                     usage_dict,
                     finish_reasons,
                     num_tokens,
-                    called_funcs,
+                    tool_calls,
                 )
                 break
 
@@ -368,8 +406,9 @@ class ChatAgent(BaseAgent):
         finish_reasons = [
             str(choice.finish_reason) for choice in response.choices
         ]
-        usage = (response.usage.model_dump()
-                 if response.usage is not None else {})
+        usage = (
+            response.usage.model_dump() if response.usage is not None else {}
+        )
         return (
             output_messages,
             finish_reasons,
@@ -408,10 +447,12 @@ class ChatAgent(BaseAgent):
                     content_dict[index] += delta.content
                 else:
                     finish_reasons_dict[index] = choice.finish_reason
-                    chat_message = BaseMessage(role_name=self.role_name,
-                                               role_type=self.role_type,
-                                               meta_dict=dict(),
-                                               content=content_dict[index])
+                    chat_message = BaseMessage(
+                        role_name=self.role_name,
+                        role_type=self.role_type,
+                        meta_dict=dict(),
+                        content=content_dict[index],
+                    )
                     output_messages.append(chat_message)
         finish_reasons = [
             finish_reasons_dict[i] for i in range(len(finish_reasons_dict))
@@ -419,15 +460,18 @@ class ChatAgent(BaseAgent):
         usage_dict = self.get_usage_dict(output_messages, prompt_tokens)
         return output_messages, finish_reasons, usage_dict, response_id
 
-    def step_token_exceed(self, num_tokens: int,
-                          called_funcs: List[FunctionCallingRecord],
-                          termination_reason: str) -> ChatAgentResponse:
+    def step_token_exceed(
+        self,
+        num_tokens: int,
+        tool_calls: List[FunctionCallingRecord],
+        termination_reason: str,
+    ) -> ChatAgentResponse:
         r"""Return trivial response containing number of tokens and information
         of called functions when the number of tokens exceeds.
 
         Args:
             num_tokens (int): Number of tokens in the messages.
-            called_funcs (List[FunctionCallingRecord]): List of information
+            tool_calls (List[FunctionCallingRecord]): List of information
                 objects of functions called in the current step.
             termination_reason (str): String of termination reason.
 
@@ -443,7 +487,7 @@ class ChatAgent(BaseAgent):
             None,
             [termination_reason],
             num_tokens,
-            called_funcs,
+            tool_calls,
         )
 
         return ChatAgentResponse(
@@ -452,11 +496,12 @@ class ChatAgent(BaseAgent):
             info,
         )
 
-    def step_function_call(
+    def step_tool_call(
         self,
         response: ChatCompletion,
-    ) -> Tuple[FunctionCallingMessage, FunctionCallingMessage,
-               FunctionCallingRecord]:
+    ) -> Tuple[
+        FunctionCallingMessage, FunctionCallingMessage, FunctionCallingRecord
+    ]:
         r"""Execute the function with arguments following the model's response.
 
         Args:
@@ -469,15 +514,14 @@ class ChatAgent(BaseAgent):
                 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.function_call is None:
-            raise RuntimeError("Function call is None")
-        func_name = choice.message.function_call.name
+        if choice.message.tool_calls is None:
+            raise RuntimeError("Tool calls is None")
+        func_name = choice.message.tool_calls[0].function.name
         func = self.func_dict[func_name]
 
-        args_str: str = choice.message.function_call.arguments
-        args = json.loads(args_str.replace("\'", "\""))
+        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:
@@ -485,7 +529,8 @@ class ChatAgent(BaseAgent):
         except Exception:
             raise ValueError(
                 f"Execution of function {func.__name__} failed with "
-                f"arguments being {args}.")
+                f"arguments being {args}."
+            )
 
         assist_msg = FunctionCallingMessage(
             role_name=self.role_name,
@@ -508,8 +553,9 @@ class ChatAgent(BaseAgent):
         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]:
+    def get_usage_dict(
+        self, output_messages: List[BaseMessage], prompt_tokens: int
+    ) -> Dict[str, int]:
         r"""Get usage dictionary when using the stream mode.
 
         Args:
@@ -523,9 +569,11 @@ class ChatAgent(BaseAgent):
         completion_tokens = 0
         for message in output_messages:
             completion_tokens += len(encoding.encode(message.content))
-        usage_dict = dict(completion_tokens=completion_tokens,
-                          prompt_tokens=prompt_tokens,
-                          total_tokens=completion_tokens + prompt_tokens)
+        usage_dict = dict(
+            completion_tokens=completion_tokens,
+            prompt_tokens=prompt_tokens,
+            total_tokens=completion_tokens + prompt_tokens,
+        )
         return usage_dict
 
     def __repr__(self) -> str:

camel/agents/critic_agent.py

@@ -17,8 +17,8 @@ from typing import Any, Dict, Optional, Sequence
 
 from colorama import Fore
 
-from camel.agents import ChatAgent
-from camel.memories import BaseMemory
+from camel.agents.chat_agent import ChatAgent
+from camel.memories import AgentMemory
 from camel.messages import BaseMessage
 from camel.responses import ChatAgentResponse
 from camel.types import ModelType
@@ -50,15 +50,19 @@ class CriticAgent(ChatAgent):
         system_message: BaseMessage,
         model_type: ModelType = ModelType.GPT_3_5_TURBO,
         model_config: Optional[Any] = None,
-        memory: Optional[BaseMemory] = None,
+        memory: Optional[AgentMemory] = None,
         message_window_size: int = 6,
         retry_attempts: int = 2,
         verbose: bool = False,
         logger_color: Any = Fore.MAGENTA,
     ) -> None:
-        super().__init__(system_message, model_type=model_type,
-                         model_config=model_config, memory=memory,
-                         message_window_size=message_window_size)
+        super().__init__(
+            system_message,
+            model_type=model_type,
+            model_config=model_config,
+            memory=memory,
+            message_window_size=message_window_size,
+        )
         self.options_dict: Dict[str, str] = dict()
         self.retry_attempts = retry_attempts
         self.verbose = verbose
@@ -77,13 +81,15 @@ class CriticAgent(ChatAgent):
         flatten_options = (
             f"> Proposals from "
             f"{messages[0].role_name} ({messages[0].role_type}). "
-            "Please choose an option:\n")
+            "Please choose an option:\n"
+        )
         for index, option in enumerate(options):
             flatten_options += f"Option {index + 1}:\n{option}\n\n"
             self.options_dict[str(index + 1)] = option
         format = (
             f"Please first enter your choice ([1-{len(self.options_dict)}]) "
-            "and then your explanation and comparison: ")
+            "and then your explanation and comparison: "
+        )
         return flatten_options + format
 
     def get_option(self, input_message: BaseMessage) -> str:
@@ -110,8 +116,10 @@ class CriticAgent(ChatAgent):
             critic_msg = critic_response.msg
             self.record_message(critic_msg)
             if self.verbose:
-                print_text_animated(self.logger_color + "\n> Critic response: "
-                                    f"\x1b[3m{critic_msg.content}\x1b[0m\n")
+                print_text_animated(
+                    self.logger_color + "\n> Critic response: "
+                    f"\x1b[3m{critic_msg.content}\x1b[0m\n"
+                )
             choice = self.parse_critic(critic_msg)
 
             if choice in self.options_dict:
@@ -121,13 +129,15 @@ class CriticAgent(ChatAgent):
                     role_name=input_message.role_name,
                     role_type=input_message.role_type,
                     meta_dict=input_message.meta_dict,
-                    content="> Invalid choice. Please choose again.\n" +
-                    msg_content,
+                    content="> Invalid choice. Please choose again.\n"
+                    + msg_content,
                 )
                 i += 1
-        warnings.warn("Critic failed to get a valid option. "
-                      f"After {self.retry_attempts} attempts. "
-                      "Returning a random option.")
+        warnings.warn(
+            "Critic failed to get a valid option. "
+            f"After {self.retry_attempts} attempts. "
+            "Returning a random option."
+        )
         return random.choice(list(self.options_dict.values()))
 
     def parse_critic(self, critic_msg: BaseMessage) -> Optional[str]:
@@ -168,8 +178,9 @@ class CriticAgent(ChatAgent):
 
         flatten_options = self.flatten_options(input_messages)
         if self.verbose:
-            print_text_animated(self.logger_color +
-                                f"\x1b[3m{flatten_options}\x1b[0m\n")
+            print_text_animated(
+                self.logger_color + f"\x1b[3m{flatten_options}\x1b[0m\n"
+            )
         input_msg = meta_chat_message.create_new_instance(flatten_options)
 
         option = self.get_option(input_msg)