camel-ai 0.2.1__py3-none-any.whl → 0.2.2__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.1'
+__version__ = '0.2.2'
 
 __all__ = [
     '__version__',

camel/agents/chat_agent.py

@@ -15,6 +15,8 @@ from __future__ import annotations
 
 import json
 import logging
+import re
+import uuid
 from collections import defaultdict
 from typing import (
     TYPE_CHECKING,
@@ -28,6 +30,7 @@ from typing import (
 )
 
 from openai.types.chat import ChatCompletionMessageToolCall
+from openai.types.chat.chat_completion_message_tool_call import Function
 from pydantic import BaseModel
 
 from camel.agents.base import BaseAgent
@@ -185,12 +188,12 @@ class ChatAgent(BaseAgent):
         # the tools set from `ChatAgent` will be used.
         # This design simplifies the interface while retaining tool-running
         # capabilities for `BaseModelBackend`.
-        if all_tools and not self.model_backend.model_config_dict['tools']:
+        if all_tools and not self.model_backend.model_config_dict.get("tools"):
             tool_schema_list = [
                 tool.get_openai_tool_schema() for tool in all_tools
             ]
             self.model_backend.model_config_dict['tools'] = tool_schema_list
-
+            self.tool_schema_list = tool_schema_list
         self.model_config_dict = self.model_backend.model_config_dict
 
         self.model_token_limit = token_limit or self.model_backend.token_limit
@@ -206,6 +209,56 @@ class ChatAgent(BaseAgent):
         self.response_terminators = response_terminators or []
         self.init_messages()
 
+    # ruff: noqa: E501
+    def _generate_tool_prompt(self, tool_schema_list: List[Dict]) -> str:
+        tool_prompts = []
+
+        for tool in tool_schema_list:
+            tool_info = tool['function']
+            tool_name = tool_info['name']
+            tool_description = tool_info['description']
+            tool_json = json.dumps(tool_info, indent=4)
+
+            prompt = f"Use the function '{tool_name}' to '{tool_description}':\n{tool_json}\n"
+            tool_prompts.append(prompt)
+
+        tool_prompt_str = "\n".join(tool_prompts)
+
+        final_prompt = f'''
+    # Tool prompt
+    TOOL_PROMPT = f"""
+    You have access to the following functions:
+
+    {tool_prompt_str}
+
+    If you choose to call a function ONLY reply in the following format with no prefix or suffix:
+
+    <function=example_function_name>{{"example_name": "example_value"}}</function>
+
+    Reminder:
+    - Function calls MUST follow the specified format, start with <function= and end with </function>
+    - Required parameters MUST be specified
+    - Only call one function at a time
+    - Put the entire function call reply on one line
+    - If there is no function call available, answer the question like normal with your current knowledge and do not tell the user about function calls
+    """
+    '''
+        return final_prompt
+
+    def _parse_tool_response(self, response: str):
+        function_regex = r"<function=(\w+)>(.*?)</function>"
+        match = re.search(function_regex, response)
+
+        if match:
+            function_name, args_string = match.groups()
+            try:
+                args = json.loads(args_string)
+                return {"function": function_name, "arguments": args}
+            except json.JSONDecodeError as error:
+                print(f"Error parsing function arguments: {error}")
+                return None
+        return None
+
     def reset(self):
         r"""Resets the :obj:`ChatAgent` to its initial state and returns the
         stored messages.
@@ -367,89 +420,221 @@ class ChatAgent(BaseAgent):
                 a boolean indicating whether the chat session has terminated,
                 and information about the chat session.
         """
-        self.update_memory(input_message, OpenAIBackendRole.USER)
+        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)
+
+                tool_sys_msg = BaseMessage.make_assistant_message(
+                    role_name="Assistant",
+                    content=tool_prompt,
+                )
 
-        tool_call_records: List[FunctionCallingRecord] = []
-        while True:
-            # Check if token has exceeded
-            try:
-                openai_messages, num_tokens = self.memory.get_context()
-            except RuntimeError as e:
-                return self._step_token_exceed(
-                    e.args[1], tool_call_records, "max_tokens_exceeded"
+                self.update_memory(tool_sys_msg, OpenAIBackendRole.SYSTEM)
+
+            self.update_memory(input_message, OpenAIBackendRole.USER)
+
+            tool_call_records: List[FunctionCallingRecord] = []
+            while True:
+                # Check if token has exceeded
+                try:
+                    openai_messages, num_tokens = self.memory.get_context()
+                except RuntimeError as e:
+                    return self._step_token_exceed(
+                        e.args[1], tool_call_records, "max_tokens_exceeded"
+                    )
+
+                (
+                    response,
+                    output_messages,
+                    finish_reasons,
+                    usage_dict,
+                    response_id,
+                ) = self._step_model_response(openai_messages, num_tokens)
+                # If the model response is not a function call, meaning the
+                # model has generated a message response, break the loop
+                if (
+                    not self.is_tools_added()
+                    or not isinstance(response, ChatCompletion)
+                    or "</function>" not in response.choices[0].message.content  # type: ignore[operator]
+                ):
+                    break
+
+                parsed_content = self._parse_tool_response(
+                    response.choices[0].message.content  # type: ignore[arg-type]
                 )
 
-            (
-                response,
+                response.choices[0].message.tool_calls = [
+                    ChatCompletionMessageToolCall(
+                        id=str(uuid.uuid4()),
+                        function=Function(
+                            arguments=str(parsed_content["arguments"]).replace(
+                                "'", '"'
+                            ),
+                            name=str(parsed_content["function"]),
+                        ),
+                        type="function",
+                    )
+                ]
+
+                # Check for external tool call
+                tool_call_request = response.choices[0].message.tool_calls[0]
+                if tool_call_request.function.name in self.external_tool_names:
+                    # if model calls an external tool, directly return the
+                    # request
+                    info = self._step_get_info(
+                        output_messages,
+                        finish_reasons,
+                        usage_dict,
+                        response_id,
+                        tool_call_records,
+                        num_tokens,
+                        tool_call_request,
+                    )
+                    return ChatAgentResponse(
+                        msgs=output_messages,
+                        terminated=self.terminated,
+                        info=info,
+                    )
+
+                # Normal function calling
+                tool_call_records.append(
+                    self._step_tool_call_and_update(response)
+                )
+
+            if (
+                output_schema is not None
+                and self.model_type.supports_tool_calling
+            ):
+                (
+                    output_messages,
+                    finish_reasons,
+                    usage_dict,
+                    response_id,
+                    tool_call,
+                    num_tokens,
+                ) = self._structure_output_with_function(output_schema)
+                tool_call_records.append(tool_call)
+
+            info = self._step_get_info(
                 output_messages,
                 finish_reasons,
                 usage_dict,
                 response_id,
-            ) = self._step_model_response(openai_messages, num_tokens)
+                tool_call_records,
+                num_tokens,
+            )
 
-            # If the model response is not a function call, meaning the model
-            # has generated a message response, break the loop
-            if (
-                not self.is_tools_added()
-                or not isinstance(response, ChatCompletion)
-                or response.choices[0].message.tool_calls is None
-            ):
-                break
+            if len(output_messages) == 1:
+                # Auto record if the output result is a single message
+                self.record_message(output_messages[0])
+            else:
+                logger.warning(
+                    "Multiple messages returned in `step()`, message won't be "
+                    "recorded automatically. Please call `record_message()` "
+                    "to record the selected message manually."
+                )
 
-            # Check for external tool call
-            tool_call_request = response.choices[0].message.tool_calls[0]
-            if tool_call_request.function.name in self.external_tool_names:
-                # if model calls an external tool, directly return the request
-                info = self._step_get_info(
+            return ChatAgentResponse(
+                msgs=output_messages, terminated=self.terminated, info=info
+            )
+
+        else:
+            self.update_memory(input_message, OpenAIBackendRole.USER)
+
+            tool_call_records: List[FunctionCallingRecord] = []  # type: ignore[no-redef]
+            while True:
+                # Check if token has exceeded
+                try:
+                    openai_messages, num_tokens = self.memory.get_context()
+                except RuntimeError as e:
+                    return self._step_token_exceed(
+                        e.args[1], tool_call_records, "max_tokens_exceeded"
+                    )
+
+                (
+                    response,
                     output_messages,
                     finish_reasons,
                     usage_dict,
                     response_id,
-                    tool_call_records,
-                    num_tokens,
-                    tool_call_request,
-                )
-                return ChatAgentResponse(
-                    msgs=output_messages, terminated=self.terminated, info=info
+                ) = self._step_model_response(openai_messages, num_tokens)
+                # If the model response is not a function call, meaning the
+                # model has generated a message response, break the loop
+                if (
+                    not self.is_tools_added()
+                    or not isinstance(response, ChatCompletion)
+                    or response.choices[0].message.tool_calls is None
+                ):
+                    break
+
+                # Check for external tool call
+                tool_call_request = response.choices[0].message.tool_calls[0]
+
+                if tool_call_request.function.name in self.external_tool_names:
+                    # if model calls an external tool, directly return the
+                    # request
+                    info = self._step_get_info(
+                        output_messages,
+                        finish_reasons,
+                        usage_dict,
+                        response_id,
+                        tool_call_records,
+                        num_tokens,
+                        tool_call_request,
+                    )
+                    return ChatAgentResponse(
+                        msgs=output_messages,
+                        terminated=self.terminated,
+                        info=info,
+                    )
+
+                # Normal function calling
+                tool_call_records.append(
+                    self._step_tool_call_and_update(response)
                 )
 
-            # Normal function calling
-            tool_call_records.append(self._step_tool_call_and_update(response))
+            if (
+                output_schema is not None
+                and self.model_type.supports_tool_calling
+            ):
+                (
+                    output_messages,
+                    finish_reasons,
+                    usage_dict,
+                    response_id,
+                    tool_call,
+                    num_tokens,
+                ) = self._structure_output_with_function(output_schema)
+                tool_call_records.append(tool_call)
 
-        if output_schema is not None and self.model_type.supports_tool_calling:
-            (
+            info = self._step_get_info(
                 output_messages,
                 finish_reasons,
                 usage_dict,
                 response_id,
-                tool_call,
+                tool_call_records,
                 num_tokens,
-            ) = self._structure_output_with_function(output_schema)
-            tool_call_records.append(tool_call)
+            )
 
-        info = self._step_get_info(
-            output_messages,
-            finish_reasons,
-            usage_dict,
-            response_id,
-            tool_call_records,
-            num_tokens,
-        )
+            if len(output_messages) == 1:
+                # Auto record if the output result is a single message
+                self.record_message(output_messages[0])
+            else:
+                logger.warning(
+                    "Multiple messages returned in `step()`, message won't be "
+                    "recorded automatically. Please call `record_message()` "
+                    "to record the selected message manually."
+                )
 
-        if len(output_messages) == 1:
-            # Auto record if the output result is a single message
-            self.record_message(output_messages[0])
-        else:
-            logger.warning(
-                "Multiple messages returned in `step()`, message won't be "
-                "recorded automatically. Please call `record_message()` to "
-                "record the selected message manually."
+            return ChatAgentResponse(
+                msgs=output_messages, terminated=self.terminated, info=info
             )
 
-        return ChatAgentResponse(
-            msgs=output_messages, terminated=self.terminated, info=info
-        )
-
     async def step_async(
         self,
         input_message: BaseMessage,

camel/bots/__init__.py

@@ -0,0 +1,20 @@
+# =========== 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 .discord_bot import DiscordBot
+from .telegram_bot import TelegramBot
+
+__all__ = [
+    '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/bots/telegram_bot.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. ===========
+import os
+from typing import TYPE_CHECKING, Optional
+
+from camel.agents import ChatAgent
+from camel.messages import BaseMessage
+from camel.utils import dependencies_required
+
+# Conditionally import telebot types only for type checking
+if TYPE_CHECKING:
+    from telebot.types import (  # type: ignore[import-untyped]
+        Message,
+    )
+
+
+class TelegramBot:
+    r"""Represents a Telegram bot that is powered by an agent.
+
+    Attributes:
+        chat_agent (ChatAgent): Chat agent that will power the bot.
+        telegram_token (str, optional): The bot token.
+    """
+
+    @dependencies_required('telebot')
+    def __init__(
+        self,
+        chat_agent: ChatAgent,
+        telegram_token: Optional[str] = None,
+    ) -> None:
+        self.chat_agent = chat_agent
+
+        if not telegram_token:
+            self.token = os.getenv('TELEGRAM_TOKEN')
+            if not self.token:
+                raise ValueError(
+                    "`TELEGRAM_TOKEN` not found in environment variables. "
+                    "Get it from t.me/BotFather."
+                )
+        else:
+            self.token = telegram_token
+
+        import telebot  # type: ignore[import-untyped]
+
+        self.bot = telebot.TeleBot(token=self.token)
+
+        # Register the message handler within the constructor
+        self.bot.message_handler(func=lambda message: True)(self.on_message)
+
+    def run(self) -> None:
+        r"""Start the Telegram bot."""
+        print("Telegram bot is running...")
+        self.bot.infinity_polling()
+
+    def on_message(self, message: 'Message') -> None:
+        r"""Handles incoming messages from the user.
+
+        Args:
+            message (types.Message): The incoming message object.
+        """
+        self.chat_agent.reset()
+
+        if not message.text:
+            return
+
+        user_msg = BaseMessage.make_user_message(
+            role_name="User", content=message.text
+        )
+        assistant_response = self.chat_agent.step(user_msg)
+
+        self.bot.reply_to(message, assistant_response.msg.content)