camel-ai 0.2.3__py3-none-any.whl → 0.2.3a1__py3-none-any.whl

camel/__init__.py

@@ -12,7 +12,7 @@
 # limitations under the License.
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 
-__version__ = '0.2.3'
+__version__ = '0.2.2'
 
 __all__ = [
     '__version__',

camel/agents/chat_agent.py

@@ -34,6 +34,7 @@ from openai.types.chat.chat_completion_message_tool_call import Function
 from pydantic import BaseModel
 
 from camel.agents.base import BaseAgent
+from camel.configs import ChatGPTConfig
 from camel.memories import (
     AgentMemory,
     ChatHistoryMemory,
@@ -62,7 +63,7 @@ if TYPE_CHECKING:
     from openai import Stream
 
     from camel.terminators import ResponseTerminator
-    from camel.toolkits import FunctionTool
+    from camel.toolkits import OpenAIFunction
 
 
 logger = logging.getLogger(__name__)
@@ -114,8 +115,7 @@ class ChatAgent(BaseAgent):
     r"""Class for managing conversations of CAMEL Chat Agents.
 
     Args:
-        system_message (Union[BaseMessage, str], optional): The system message
-            for the chat agent.
+        system_message (BaseMessage): The system message for the chat agent.
         model (BaseModelBackend, optional): The model backend to use for
             generating responses. (default: :obj:`OpenAIModel` with
             `GPT_4O_MINI`)
@@ -131,10 +131,10 @@ class ChatAgent(BaseAgent):
             (default: :obj:`None`)
         output_language (str, optional): The language to be output by the
             agent. (default: :obj:`None`)
-        tools (List[FunctionTool], optional): List of available
-            :obj:`FunctionTool`. (default: :obj:`None`)
-        external_tools (List[FunctionTool], optional): List of external tools
-            (:obj:`FunctionTool`) bind to one chat agent. When these tools
+        tools (List[OpenAIFunction], optional): List of available
+            :obj:`OpenAIFunction`. (default: :obj:`None`)
+        external_tools (List[OpenAIFunction], optional): List of external tools
+            (:obj:`OpenAIFunction`) bind to one chat agent. When these tools
             are called, the agent will directly return the request instead of
             processing it. (default: :obj:`None`)
         response_terminators (List[ResponseTerminator], optional): List of
@@ -144,42 +144,34 @@ class ChatAgent(BaseAgent):
 
     def __init__(
         self,
-        system_message: Optional[Union[BaseMessage, str]] = None,
+        system_message: BaseMessage,
         model: Optional[BaseModelBackend] = None,
         memory: Optional[AgentMemory] = None,
         message_window_size: Optional[int] = None,
         token_limit: Optional[int] = None,
         output_language: Optional[str] = None,
-        tools: Optional[List[FunctionTool]] = None,
-        external_tools: Optional[List[FunctionTool]] = None,
+        tools: Optional[List[OpenAIFunction]] = None,
+        external_tools: Optional[List[OpenAIFunction]] = None,
         response_terminators: Optional[List[ResponseTerminator]] = None,
     ) -> None:
-        if isinstance(system_message, str):
-            system_message = BaseMessage.make_assistant_message(
-                role_name='Assistant', content=system_message
-            )
-
-        self.orig_sys_message: Optional[BaseMessage] = system_message
-        self._system_message: Optional[BaseMessage] = system_message
-        self.role_name: str = (
-            getattr(system_message, 'role_name', None) or "assistant"
-        )
-        self.role_type: RoleType = (
-            getattr(system_message, 'role_type', None) or RoleType.ASSISTANT
-        )
+        self.orig_sys_message: BaseMessage = system_message
+        self.system_message = system_message
+        self.role_name: str = system_message.role_name
+        self.role_type: RoleType = system_message.role_type
         self.model_backend: BaseModelBackend = (
             model
             if model is not None
             else ModelFactory.create(
-                model_platform=ModelPlatformType.DEFAULT,
-                model_type=ModelType.DEFAULT,
+                model_platform=ModelPlatformType.OPENAI,
+                model_type=ModelType.GPT_4O_MINI,
+                model_config_dict=ChatGPTConfig().as_dict(),
             )
         )
         self.output_language: Optional[str] = output_language
         if self.output_language is not None:
             self.set_output_language(self.output_language)
 
-        self.model_type = self.model_backend.model_type
+        self.model_type: ModelType = self.model_backend.model_type
 
         # tool registration
         external_tools = external_tools or []
@@ -280,12 +272,11 @@ class ChatAgent(BaseAgent):
             terminator.reset()
 
     @property
-    def system_message(self) -> Optional[BaseMessage]:
+    def system_message(self) -> BaseMessage:
         r"""The getter method for the property :obj:`system_message`.
 
         Returns:
-            Optional[BaseMessage]: The system message of this agent if set,
-                else :obj:`None`.
+            BaseMessage: The system message of this agent.
         """
         return self._system_message
 
@@ -336,22 +327,12 @@ class ChatAgent(BaseAgent):
             BaseMessage: The updated system message object.
         """
         self.output_language = output_language
-        language_prompt = (
+        content = self.orig_sys_message.content + (
             "\nRegardless of the input language, "
             f"you must output text in {output_language}."
         )
-        if self.orig_sys_message is not None:
-            content = self.orig_sys_message.content + language_prompt
-            self._system_message = self.orig_sys_message.create_new_instance(
-                content
-            )
-            return self._system_message
-        else:
-            self._system_message = BaseMessage.make_assistant_message(
-                role_name="Assistant",
-                content=language_prompt,
-            )
-            return self._system_message
+        self.system_message = self.system_message.create_new_instance(content)
+        return self.system_message
 
     def get_info(
         self,
@@ -396,15 +377,12 @@ class ChatAgent(BaseAgent):
         r"""Initializes the stored messages list with the initial system
         message.
         """
-        if self.orig_sys_message is not None:
-            system_record = MemoryRecord(
-                message=self.orig_sys_message,
-                role_at_backend=OpenAIBackendRole.SYSTEM,
-            )
-            self.memory.clear()
-            self.memory.write_record(system_record)
-        else:
-            self.memory.clear()
+        system_record = MemoryRecord(
+            message=self.system_message,
+            role_at_backend=OpenAIBackendRole.SYSTEM,
+        )
+        self.memory.clear()
+        self.memory.write_record(system_record)
 
     def record_message(self, message: BaseMessage) -> None:
         r"""Records the externally provided message into the agent memory as if
@@ -419,19 +397,19 @@ class ChatAgent(BaseAgent):
 
     def step(
         self,
-        input_message: Union[BaseMessage, str],
-        response_format: Optional[Type[BaseModel]] = None,
+        input_message: BaseMessage,
+        output_schema: Optional[Type[BaseModel]] = None,
     ) -> ChatAgentResponse:
         r"""Performs a single step in the chat session by generating a response
         to the input message.
 
         Args:
-            input_message (Union[BaseMessage, str]): The input message to the
-                agent. For BaseMessage input, 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. For str input, the `role_name` would be `User`.
-            response_format (Optional[Type[BaseModel]], optional): A pydantic
+            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.
+            output_schema (Optional[Type[BaseModel]], optional): A pydantic
                 model class that includes value types and field descriptions
                 used to generate a structured response by LLM. This schema
                 helps in defining the expected output format. (default:
@@ -442,12 +420,12 @@ class ChatAgent(BaseAgent):
                 a boolean indicating whether the chat session has terminated,
                 and information about the chat session.
         """
-        if isinstance(input_message, str):
-            input_message = BaseMessage.make_user_message(
-                role_name='User', content=input_message
-            )
-
-        if "llama" in self.model_type.lower():
+        if (
+            isinstance(self.model_type, ModelType)
+            and "lama" in self.model_type.value
+            or isinstance(self.model_type, str)
+            and "lama" in self.model_type
+        ):
             if self.model_backend.model_config_dict.get("tools", None):
                 tool_prompt = self._generate_tool_prompt(self.tool_schema_list)
 
@@ -528,7 +506,10 @@ class ChatAgent(BaseAgent):
                     self._step_tool_call_and_update(response)
                 )
 
-            if response_format is not None:
+            if (
+                output_schema is not None
+                and self.model_type.supports_tool_calling
+            ):
                 (
                     output_messages,
                     finish_reasons,
@@ -536,7 +517,7 @@ class ChatAgent(BaseAgent):
                     response_id,
                     tool_call,
                     num_tokens,
-                ) = self._structure_output_with_function(response_format)
+                ) = self._structure_output_with_function(output_schema)
                 tool_call_records.append(tool_call)
 
             info = self._step_get_info(
@@ -618,8 +599,8 @@ class ChatAgent(BaseAgent):
                 )
 
             if (
-                response_format is not None
-                and self.model_type.support_native_tool_calling
+                output_schema is not None
+                and self.model_type.supports_tool_calling
             ):
                 (
                     output_messages,
@@ -628,7 +609,7 @@ class ChatAgent(BaseAgent):
                     response_id,
                     tool_call,
                     num_tokens,
-                ) = self._structure_output_with_function(response_format)
+                ) = self._structure_output_with_function(output_schema)
                 tool_call_records.append(tool_call)
 
             info = self._step_get_info(
@@ -656,19 +637,19 @@ class ChatAgent(BaseAgent):
 
     async def step_async(
         self,
-        input_message: Union[BaseMessage, str],
-        response_format: Optional[Type[BaseModel]] = None,
+        input_message: BaseMessage,
+        output_schema: Optional[Type[BaseModel]] = None,
     ) -> 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 (Union[BaseMessage, str]): The input message to the
-                agent. For BaseMessage input, 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. For str input, the `role_name` would be `User`.
-            response_format (Optional[Type[BaseModel]], optional): A pydantic
+            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.
+            output_schema (Optional[Type[BaseModel]], optional): A pydantic
                 model class that includes value types and field descriptions
                 used to generate a structured response by LLM. This schema
                 helps in defining the expected output format. (default:
@@ -679,11 +660,6 @@ class ChatAgent(BaseAgent):
                 a boolean indicating whether the chat session has terminated,
                 and information about the chat session.
         """
-        if isinstance(input_message, str):
-            input_message = BaseMessage.make_user_message(
-                role_name='User', content=input_message
-            )
-
         self.update_memory(input_message, OpenAIBackendRole.USER)
 
         tool_call_records: List[FunctionCallingRecord] = []
@@ -732,10 +708,7 @@ class ChatAgent(BaseAgent):
                 await self._step_tool_call_and_update_async(response)
             )
 
-        if (
-            response_format is not None
-            and self.model_type.support_native_tool_calling
-        ):
+        if output_schema is not None and self.model_type.supports_tool_calling:
             (
                 output_messages,
                 finish_reasons,
@@ -743,7 +716,7 @@ class ChatAgent(BaseAgent):
                 response_id,
                 tool_call_record,
                 num_tokens,
-            ) = self._structure_output_with_function(response_format)
+            ) = self._structure_output_with_function(output_schema)
             tool_call_records.append(tool_call_record)
 
         info = self._step_get_info(
@@ -810,7 +783,7 @@ class ChatAgent(BaseAgent):
         return func_record
 
     def _structure_output_with_function(
-        self, response_format: Type[BaseModel]
+        self, output_schema: Type[BaseModel]
     ) -> Tuple[
         List[BaseMessage],
         List[str],
@@ -822,12 +795,12 @@ class ChatAgent(BaseAgent):
         r"""Internal function of structuring the output of the agent based on
         the given output schema.
         """
-        from camel.toolkits import FunctionTool
+        from camel.toolkits import OpenAIFunction
 
-        schema_json = get_pydantic_object_schema(response_format)
+        schema_json = get_pydantic_object_schema(output_schema)
         func_str = json_to_function_code(schema_json)
         func_callable = func_string_to_callable(func_str)
-        func = FunctionTool(func_callable)
+        func = OpenAIFunction(func_callable)
 
         original_func_dict = self.func_dict
         original_model_dict = self.model_backend.model_config_dict
@@ -1201,7 +1174,10 @@ class ChatAgent(BaseAgent):
         Returns:
             dict: Usage dictionary.
         """
-        encoding = get_model_encoding(self.model_type.value_for_tiktoken)
+        if isinstance(self.model_type, ModelType):
+            encoding = get_model_encoding(self.model_type.value_for_tiktoken)
+        else:
+            encoding = get_model_encoding("gpt-4o-mini")
         completion_tokens = 0
         for message in output_messages:
             completion_tokens += len(encoding.encode(message.content))

camel/agents/knowledge_graph_agent.py

@@ -11,10 +11,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
-from typing import TYPE_CHECKING, Optional, Union
+from typing import Optional, Union
 
-if TYPE_CHECKING:
+try:
     from unstructured.documents.elements import Element
+except ImportError:
+    Element = None
 
 from camel.agents import ChatAgent
 from camel.messages import BaseMessage
@@ -142,13 +144,13 @@ class KnowledgeGraphAgent(ChatAgent):
 
     def run(
         self,
-        element: "Element",
+        element: Union[str, Element],
         parse_graph_elements: bool = False,
     ) -> Union[str, GraphElement]:
         r"""Run the agent to extract node and relationship information.
 
         Args:
-            element (Element): The input element.
+            element (Union[str, Element]): The input element or string.
             parse_graph_elements (bool, optional): Whether to parse into
                 `GraphElement`. Defaults to `False`.
 

camel/bots/__init__.py

@@ -11,24 +11,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
-from .discord_app import DiscordApp
-from .slack.models import (
-    SlackAppMentionEventBody,
-    SlackAppMentionEventProfile,
-    SlackAuthProfile,
-    SlackEventBody,
-    SlackEventProfile,
-)
-from .slack.slack_app import SlackApp
+from .discord_bot import DiscordBot
 from .telegram_bot import TelegramBot
 
 __all__ = [
-    'DiscordApp',
-    'SlackApp',
-    'SlackAppMentionEventBody',
-    'SlackAppMentionEventProfile',
-    'SlackAuthProfile',
-    'SlackEventBody',
-    'SlackEventProfile',
+    'DiscordBot',
     'TelegramBot',
 ]

camel/bots/discord_bot.py

@@ -0,0 +1,206 @@
+# =========== 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. ===========
+import os
+from typing import TYPE_CHECKING, List, Optional, Union
+
+from camel.agents import ChatAgent
+from camel.messages import BaseMessage
+from camel.retrievers import AutoRetriever
+from camel.utils import dependencies_required
+
+try:
+    from unstructured.documents.elements import Element
+except ImportError:
+    Element = None
+
+if TYPE_CHECKING:
+    from discord import Message
+
+
+class DiscordBot:
+    r"""Represents a Discord bot that is powered by a CAMEL `ChatAgent`.
+
+    Attributes:
+        chat_agent (ChatAgent): Chat agent that will power the bot.
+        channel_ids (List[int], optional): The channel IDs that the bot will
+            listen to.
+        discord_token (str, optional): The bot token.
+        auto_retriever (AutoRetriever): AutoRetriever instance for RAG.
+        vector_storage_local_path (Union[str, List[str]]): The paths to the
+            contents for RAG.
+        top_k (int): Top choice for the RAG response.
+        return_detailed_info (bool): If show detailed info of the RAG response.
+        contents (Union[str, List[str], Element, List[Element]], optional):
+            Local file paths, remote URLs, string contents or Element objects.
+    """
+
+    @dependencies_required('discord')
+    def __init__(
+        self,
+        chat_agent: ChatAgent,
+        contents: Union[str, List[str], Element, List[Element]] = None,
+        channel_ids: Optional[List[int]] = None,
+        discord_token: Optional[str] = None,
+        auto_retriever: Optional[AutoRetriever] = None,
+        vector_storage_local_path: Union[str, List[str]] = "",
+        top_k: int = 1,
+        return_detailed_info: bool = True,
+    ) -> None:
+        self.chat_agent = chat_agent
+        self.token = discord_token or os.getenv('DISCORD_TOKEN')
+        self.channel_ids = channel_ids
+        self.auto_retriever = auto_retriever
+        self.vector_storage_local_path = vector_storage_local_path
+        self.top_k = top_k
+        self.return_detailed_info = return_detailed_info
+        self.contents = contents
+
+        if not self.token:
+            raise ValueError(
+                "`DISCORD_TOKEN` not found in environment variables. Get it"
+                " here: `https://discord.com/developers/applications`."
+            )
+
+        import discord
+
+        intents = discord.Intents.default()
+        intents.message_content = True
+        self.client = discord.Client(intents=intents)
+
+        # Register event handlers
+        self.client.event(self.on_ready)
+        self.client.event(self.on_message)
+
+    def run(self) -> None:
+        r"""Start the Discord bot using its token.
+
+        This method starts the Discord bot by running the client with the
+        provided token.
+        """
+        self.client.run(self.token)  # type: ignore[arg-type]
+
+    async def on_ready(self) -> None:
+        r"""This method is called when the bot has successfully connected to
+        the Discord server.
+
+        It prints a message indicating that the bot has logged in and displays
+        the username of the bot.
+        """
+        print(f'We have logged in as {self.client.user}')
+
+    async def on_message(self, message: 'Message') -> None:
+        r"""Event handler for when a message is received.
+
+        Args:
+            message (discord.Message): The message object received.
+        """
+
+        # If the message author is the bot itself,
+        # do not respond to this message
+        if message.author == self.client.user:
+            return
+
+        # If allowed channel IDs are provided,
+        # only respond to messages in those channels
+        if self.channel_ids and message.channel.id not in self.channel_ids:
+            return
+
+        # Only respond to messages that mention the bot
+        if not self.client.user or not self.client.user.mentioned_in(message):
+            return
+
+        user_raw_msg = message.content
+
+        if self.auto_retriever:
+            retrieved_content = self.auto_retriever.run_vector_retriever(
+                query=user_raw_msg,
+                contents=self.contents,
+                top_k=self.top_k,
+                return_detailed_info=self.return_detailed_info,
+            )
+            user_raw_msg = (
+                f"Here is the query to you: {user_raw_msg}\n"
+                f"Based on the retrieved content: {retrieved_content}, \n"
+                f"answer the query from {message.author.name}"
+            )
+
+        user_msg = BaseMessage.make_user_message(
+            role_name="User", content=user_raw_msg
+        )
+        assistant_response = self.chat_agent.step(user_msg)
+        await message.channel.send(assistant_response.msg.content)
+
+
+if __name__ == "__main__":
+    assistant_sys_msg = BaseMessage.make_assistant_message(
+        role_name="Assistant",
+        content='''
+            Objective: 
+                You are a customer service bot designed to assist users
+                with inquiries related to our open-source project. 
+                Your responses should be informative, concise, and helpful.
+            
+            Instructions:
+                Understand User Queries: Carefully read and understand the
+                        user's question. Focus on keywords and context to
+                        determine the user's intent.
+                Search for Relevant Information: Use the provided dataset
+                        and refer to the RAG (file to find answers that 
+                        closely match the user's query. The RAG file contains
+                        detailed interactions and should be your primary 
+                        resource for crafting responses.
+                Provide Clear and Concise Responses: Your answers should 
+                        be clear and to the point. Avoid overly technical
+                        language unless the user's query indicates 
+                        familiarity with technical terms.
+                Encourage Engagement: Where applicable, encourage users
+                        to contribute to the project or seek further
+                        assistance.
+            
+            Response Structure:
+                Greeting: Begin with a polite greeting or acknowledgment.
+                Main Response: Provide the main answer to the user's query.
+                Additional Information: Offer any extra tips or direct the
+                        user to additional resources if necessary.
+                Closing: Close the response politely, encouraging
+                        further engagement if appropriate.
+            bd
+            Tone:
+                Professional: Maintain a professional tone that 
+                        instills confidence in the user.
+                Friendly: Be approachable and friendly to make users 
+                        feel comfortable.
+                Helpful: Always aim to be as helpful as possible,
+                        guiding users to solutions.        
+        ''',
+    )
+
+    agent = ChatAgent(
+        assistant_sys_msg,
+        message_window_size=10,
+    )
+    # Uncommented the folowing code and offer storage information
+    # for RAG functionality
+
+    # auto_retriever = AutoRetriever(
+    #     vector_storage_local_path="examples/bots",
+    #     storage_type=StorageType.QDRANT,
+    # )
+
+    bot = DiscordBot(
+        agent,
+        # auto_retriever=auto_retriever,
+        # vector_storage_local_path=["local_data/"],
+    )
+    bot.run()

camel/configs/__init__.py

@@ -18,7 +18,7 @@ from .groq_config import GROQ_API_PARAMS, GroqConfig
 from .litellm_config import LITELLM_API_PARAMS, LiteLLMConfig
 from .mistral_config import MISTRAL_API_PARAMS, MistralConfig
 from .ollama_config import OLLAMA_API_PARAMS, OllamaConfig
-from .openai_config import OPENAI_API_PARAMS, ChatGPTConfig
+from .openai_config import OPENAI_API_PARAMS, ChatGPTConfig, OpenSourceConfig
 from .reka_config import REKA_API_PARAMS, RekaConfig
 from .samba_config import (
     SAMBA_CLOUD_API_PARAMS,
@@ -40,6 +40,7 @@ __all__ = [
     'ANTHROPIC_API_PARAMS',
     'GROQ_API_PARAMS',
     'GroqConfig',
+    'OpenSourceConfig',
     'LiteLLMConfig',
     'LITELLM_API_PARAMS',
     'OllamaConfig',

camel/configs/anthropic_config.py

@@ -15,8 +15,9 @@ from __future__ import annotations
 
 from typing import List, Union
 
+from anthropic import NOT_GIVEN, NotGiven
+
 from camel.configs.base_config import BaseConfig
-from camel.types import NOT_GIVEN, NotGiven
 
 
 class AnthropicConfig(BaseConfig):
@@ -54,7 +55,9 @@ class AnthropicConfig(BaseConfig):
             (default: :obj:`5`)
         metadata: An object describing metadata about the request.
         stream (bool, optional): Whether to incrementally stream the response
-            using server-sent events. (default: :obj:`False`)
+          using server-sent events.
+            (default: :obj:`False`)
+
     """
 
     max_tokens: int = 256