camel-ai 0.2.1a0__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.1a'
+__version__ = '0.2.2'
 
 __all__ = [
     '__version__',

camel/agents/chat_agent.py

@@ -188,7 +188,7 @@ 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
             ]
@@ -426,7 +426,7 @@ class ChatAgent(BaseAgent):
             or isinstance(self.model_type, str)
             and "lama" in self.model_type
         ):
-            if self.model_backend.model_config_dict['tools']:
+            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(

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)

camel/configs/gemini_config.py

@@ -86,7 +86,7 @@ class GeminiConfig(BaseConfig):
 
     @model_validator(mode="before")
     @classmethod
-    def fields_type_checking(cls, data: Any):
+    def model_type_checking(cls, data: Any):
         if isinstance(data, dict):
             response_schema = data.get("response_schema")
             safety_settings = data.get("safety_settings")

camel/loaders/unstructured_io.py

@@ -13,6 +13,7 @@
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 import uuid
 import warnings
+from io import IOBase
 from typing import (
     Any,
     Dict,
@@ -108,7 +109,7 @@ class UnstructuredIO:
                 specified.
 
         Notes:
-            Available document types:
+            Supported file types:
                 "csv", "doc", "docx", "epub", "image", "md", "msg", "odt",
                 "org", "pdf", "ppt", "pptx", "rtf", "rst", "tsv", "xlsx".
 
@@ -152,6 +153,39 @@ class UnstructuredIO:
                 warnings.warn(f"Failed to partition the file: {input_path}")
                 return None
 
+    @staticmethod
+    def parse_bytes(file: IOBase, **kwargs: Any) -> Union[List[Element], None]:
+        r"""Parses a bytes stream and converts its contents into elements.
+
+        Args:
+            file (IOBase): The file in bytes format to be parsed.
+            **kwargs: Extra kwargs passed to the partition function.
+
+        Returns:
+            Union[List[Element], None]: List of elements after parsing the file
+                if successful, otherwise `None`.
+
+        Notes:
+            Supported file types:
+                "csv", "doc", "docx", "epub", "image", "md", "msg", "odt",
+                "org", "pdf", "ppt", "pptx", "rtf", "rst", "tsv", "xlsx".
+
+        References:
+            https://docs.unstructured.io/open-source/core-functionality/partitioning
+        """
+
+        from unstructured.partition.auto import partition
+
+        try:
+            # Use partition to process the bytes stream
+            elements = partition(file=file, **kwargs)
+            return elements
+        except Exception as e:
+            import warnings
+
+            warnings.warn(f"Failed to partition the file stream: {e}")
+            return None
+
     @staticmethod
     def clean_text_data(
         text: str,

camel/messages/func_message.py

@@ -93,10 +93,10 @@ class FunctionCallingMessage(BaseMessage):
             OpenAIMessage: The converted :obj:`OpenAIMessage` object
                 with its role being "function".
         """
-        if (not self.func_name) or (not self.result):
+        if not self.func_name:
             raise ValueError(
                 "Invalid request for converting into function message"
-                " due to missing function name or results."
+                " due to missing function name."
             )
 
         result_content = {"result": {str(self.result)}}

camel/models/openai_compatibility_model.py

@@ -12,6 +12,7 @@
 # limitations under the License.
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 
+import os
 from typing import Any, Dict, List, Optional, Union
 
 from openai import OpenAI, Stream
@@ -25,14 +26,14 @@ from camel.utils import (
 
 
 class OpenAICompatibilityModel:
-    r"""Constructor for model backend supporting OpenAI compatibility."""
+    r"""LLM API served by OpenAI-compatible providers."""
 
     def __init__(
         self,
         model_type: str,
         model_config_dict: Dict[str, Any],
-        api_key: str,
-        url: str,
+        api_key: Optional[str] = None,
+        url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
     ) -> None:
         r"""Constructor for model backend.
@@ -51,13 +52,25 @@ class OpenAICompatibilityModel:
         """
         self.model_type = model_type
         self.model_config_dict = model_config_dict
-        self._token_counter = token_counter
+        self._url = url or os.environ.get("OPENAI_COMPATIBILIY_API_BASE_URL")
+        self._api_key = api_key or os.environ.get(
+            "OPENAI_COMPATIBILIY_API_KEY"
+        )
+        if self._url is None:
+            raise ValueError(
+                "For OpenAI-compatible models, you must provide the `url`."
+            )
+        if self._api_key is None:
+            raise ValueError(
+                "For OpenAI-compatible models, you must provide the `api_key`."
+            )
         self._client = OpenAI(
             timeout=60,
             max_retries=3,
-            api_key=api_key,
-            base_url=url,
+            base_url=self._url,
+            api_key=self._api_key,
         )
+        self._token_counter = token_counter
 
     def run(
         self,

camel/retrievers/vector_retriever.py

@@ -13,6 +13,7 @@
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 import os
 import warnings
+from io import IOBase
 from typing import Any, Dict, List, Optional, Union
 from urllib.parse import urlparse
 
@@ -72,26 +73,34 @@ class VectorRetriever(BaseRetriever):
 
     def process(
         self,
-        content: Union[str, Element],
+        content: Union[str, Element, IOBase],
         chunk_type: str = "chunk_by_title",
         max_characters: int = 500,
+        embed_batch: int = 50,
+        should_chunk: bool = True,
         **kwargs: Any,
     ) -> None:
-        r"""Processes content from a file or URL, divides it into chunks by
-        using `Unstructured IO`, and stores their embeddings in the specified
-        vector storage.
+        r"""Processes content from local file path, remote URL, string
+        content, Element object, or a binary file object, divides it into
+        chunks by using `Unstructured IO`, and stores their embeddings in the
+        specified vector storage.
 
         Args:
-            content (Union[str, Element]): Local file path, remote URL,
-                string content or Element object.
+            content (Union[str, Element, IOBase]): Local file path, remote
+                URL, string content, Element object, or a binary file object.
             chunk_type (str): Type of chunking going to apply. Defaults to
                 "chunk_by_title".
             max_characters (int): Max number of characters in each chunk.
                 Defaults to `500`.
+            embed_batch (int): Size of batch for embeddings. Defaults to `50`.
+            should_chunk (bool): If True, divide the content into chunks,
+                otherwise skip chunking. Defaults to True.
             **kwargs (Any): Additional keyword arguments for content parsing.
         """
         if isinstance(content, Element):
             elements = [content]
+        elif isinstance(content, IOBase):
+            elements = self.uio.parse_bytes(file=content, **kwargs) or []
         else:
             # Check if the content is URL
             parsed_url = urlparse(content)
@@ -100,20 +109,26 @@ class VectorRetriever(BaseRetriever):
                 elements = self.uio.parse_file_or_url(content, **kwargs) or []
             else:
                 elements = [self.uio.create_element_from_text(text=content)]
-        if elements:
-            chunks = self.uio.chunk_elements(
-                chunk_type=chunk_type,
-                elements=elements,
-                max_characters=max_characters,
-            )
         if not elements:
             warnings.warn(
                 f"No elements were extracted from the content: {content}"
             )
             return
-        # Iterate to process and store embeddings, set batch of 50
-        for i in range(0, len(chunks), 50):
-            batch_chunks = chunks[i : i + 50]
+
+        # Chunk the content if required
+        chunks = (
+            self.uio.chunk_elements(
+                chunk_type=chunk_type,
+                elements=elements,
+                max_characters=max_characters,
+            )
+            if should_chunk
+            else elements
+        )
+
+        # Process chunks in batches and store embeddings
+        for i in range(0, len(chunks), embed_batch):
+            batch_chunks = chunks[i : i + embed_batch]
             batch_vectors = self.embedding_model.embed_list(
                 objs=[str(chunk) for chunk in batch_chunks]
             )
@@ -124,6 +139,8 @@ class VectorRetriever(BaseRetriever):
             for vector, chunk in zip(batch_vectors, batch_chunks):
                 if isinstance(content, str):
                     content_path_info = {"content path": content}
+                elif isinstance(content, IOBase):
+                    content_path_info = {"content path": "From file bytes"}
                 elif isinstance(content, Element):
                     content_path_info = {
                         "content path": content.metadata.file_directory

camel/societies/role_playing.py

@@ -11,6 +11,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
+import logging
 from typing import Dict, List, Optional, Sequence, Tuple, Union
 
 from camel.agents import (
@@ -27,6 +28,9 @@ from camel.prompts import TextPrompt
 from camel.responses import ChatAgentResponse
 from camel.types import RoleType, TaskType
 
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.WARNING)
+
 
 class RolePlaying:
     r"""Role playing between two agents.
@@ -97,6 +101,14 @@ class RolePlaying:
         extend_task_specify_meta_dict: Optional[Dict] = None,
         output_language: Optional[str] = None,
     ) -> None:
+        if model is not None:
+            logger.warning(
+                "The provided model will override the model settings in "
+                "all agents, including any configurations passed "
+                "through assistant_agent_kwargs, user_agent_kwargs, and "
+                "other agent-specific kwargs."
+            )
+
         self.with_task_specify = with_task_specify
         self.with_task_planner = with_task_planner
         self.with_critic_in_the_loop = with_critic_in_the_loop

camel/storages/__init__.py

@@ -13,6 +13,7 @@
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 
 from .graph_storages.base import BaseGraphStorage
+from .graph_storages.nebula_graph import NebulaGraph
 from .graph_storages.neo4j_graph import Neo4jGraph
 from .key_value_storages.base import BaseKeyValueStorage
 from .key_value_storages.in_memory import InMemoryKeyValueStorage
@@ -40,4 +41,5 @@ __all__ = [
     'MilvusStorage',
     'BaseGraphStorage',
     'Neo4jGraph',
+    'NebulaGraph',
 ]

camel/storages/graph_storages/__init__.py

@@ -14,10 +14,12 @@
 
 from .base import BaseGraphStorage
 from .graph_element import GraphElement
+from .nebula_graph import NebulaGraph
 from .neo4j_graph import Neo4jGraph
 
 __all__ = [
     'BaseGraphStorage',
     'GraphElement',
     'Neo4jGraph',
+    'NebulaGraph',
 ]