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

camel/agents/search_agent.py

@@ -0,0 +1,122 @@
+# =========== 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 typing import Any, Optional
+
+from camel.agents.chat_agent import ChatAgent
+from camel.messages import BaseMessage
+from camel.prompts import TextPrompt
+from camel.types import ModelType, RoleType
+from camel.utils import create_chunks
+
+
+class SearchAgent(ChatAgent):
+    r"""An agent that summarizes text based on a query and evaluates the
+    relevance of an answer.
+
+    Args:
+        model_type (ModelType, optional): The type of model to use for the
+            agent. (default: :obj:`ModelType.GPT_3_5_TURBO`)
+        model_config (Any, optional): The configuration for the model.
+            (default: :obj:`None`)
+    """
+
+    def __init__(
+        self,
+        model_type: ModelType = ModelType.GPT_3_5_TURBO,
+        model_config: Optional[Any] = None,
+    ) -> None:
+        system_message = BaseMessage(
+            role_name="Assistant",
+            role_type=RoleType.ASSISTANT,
+            meta_dict=None,
+            content="You are a helpful assistant.",
+        )
+        super().__init__(system_message, model_type, model_config)
+
+    def summarize_text(self, text: str, query: str) -> str:
+        r"""Summarize the information from the text, base on the query.
+
+        Args:
+            text (str): Text to summarize.
+            query (str): What information you want.
+
+        Returns:
+            str: Strings with information.
+        """
+        self.reset()
+
+        summary_prompt = TextPrompt(
+            '''Gather information from this text that relative to the
+            question, but do not directly answer the question.\nquestion:
+            {query}\ntext '''
+        )
+        summary_prompt = summary_prompt.format(query=query)
+        # Max length of each chunk
+        max_len = 3000
+        results = ""
+        chunks = create_chunks(text, max_len)
+        # Summarize
+        for i, chunk in enumerate(chunks, start=1):
+            prompt = summary_prompt + str(i) + ": " + chunk
+            user_msg = BaseMessage.make_user_message(
+                role_name="User",
+                content=prompt,
+            )
+            result = self.step(user_msg).msg.content
+            results += result + "\n"
+
+        # Final summarise
+        final_prompt = TextPrompt(
+            '''Here are some summarized texts which split from one text. Using
+            the information to answer the question. If can't find the answer,
+            you must answer "I can not find the answer to the query" and
+            explain why.\n Query:\n{query}.\n\nText:\n'''
+        )
+        final_prompt = final_prompt.format(query=query)
+        prompt = final_prompt + results
+
+        user_msg = BaseMessage.make_user_message(
+            role_name="User",
+            content=prompt,
+        )
+        response = self.step(user_msg).msg.content
+
+        return response
+
+    def continue_search(self, query: str, answer: str) -> bool:
+        r"""Ask whether to continue search or not based on the provided answer.
+
+        Args:
+            query (str): The question.
+            answer (str): The answer to the question.
+
+        Returns:
+            bool: `True` if the user want to continue search, `False`
+            otherwise.
+        """
+        prompt = TextPrompt(
+            "Do you think the ANSWER can answer the QUERY? "
+            "Use only 'yes' or 'no' to answer.\n"
+            "===== QUERY =====\n{query}\n\n"
+            "===== ANSWER =====\n{answer}"
+        )
+        prompt = prompt.format(query=query, answer=answer)
+        user_msg = BaseMessage.make_user_message(
+            role_name="User",
+            content=prompt,
+        )
+        response = self.step(user_msg).msg.content
+        if "yes" in str(response).lower():
+            return False
+        return True

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,103 @@
+# =========== 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
+
+from camel.agents import ChatAgent
+from camel.messages import BaseMessage
+
+if TYPE_CHECKING:
+    from discord import Message
+
+
+class DiscordBot:
+    r"""Represents a Discord bot that is powered by an agent.
+
+    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.
+    """
+
+    def __init__(
+        self,
+        chat_agent: ChatAgent,
+        channel_ids: Optional[List[int]] = None,
+        discord_token: Optional[str] = None,
+    ) -> None:
+        self.chat_agent = chat_agent
+        self.token = discord_token or os.getenv('DISCORD_TOKEN')
+        self.channel_ids = channel_ids
+
+        if not self.token:
+            raise ValueError(
+                "`DISCORD_TOKEN` not found in environment variables. Get it"
+                " here: `https://discord.com/developers/applications`."
+            )
+
+        try:
+            import discord
+        except ImportError:
+            raise ImportError(
+                "Please install `discord` first. You can install it by running"
+                " `python3 -m pip install -U discord.py`."
+            )
+        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 message.author == self.client.user:
+            return
+
+        if self.channel_ids and message.channel.id not in self.channel_ids:
+            return
+
+        if not self.client.user or not self.client.user.mentioned_in(message):
+            return
+
+        self.chat_agent.reset()
+
+        user_msg = BaseMessage.make_user_message(
+            role_name="User", content=message.content
+        )
+        assistant_response = self.chat_agent.step(user_msg)
+        await message.channel.send(assistant_response.msg.content)

camel/bots/telegram_bot.py

@@ -0,0 +1,84 @@
+# =========== 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
+
+# Conditionally import telebot types only for type checking
+if TYPE_CHECKING:
+    from telebot.types import Message  # type: ignore[import-untyped]
+
+
+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.
+    """
+
+    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
+
+        try:
+            import telebot  # type: ignore[import-untyped]
+        except ImportError:
+            raise ImportError(
+                "Please install `telegram_bot` first. "
+                "You can install it by running "
+                "`pip install pyTelegramBotAPI`."
+            )
+        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/__init__.py

@@ -13,6 +13,7 @@
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 from .anthropic_config import ANTHROPIC_API_PARAMS, AnthropicConfig
 from .base_config import BaseConfig
+from .litellm_config import LITELLM_API_PARAMS, LiteLLMConfig
 from .openai_config import (
     OPENAI_API_PARAMS,
     ChatGPTConfig,
@@ -26,4 +27,6 @@ __all__ = [
     'AnthropicConfig',
     'ANTHROPIC_API_PARAMS',
     'OpenSourceConfig',
+    'LiteLLMConfig',
+    'LITELLM_API_PARAMS',
 ]

camel/configs/anthropic_config.py

@@ -15,7 +15,7 @@ from __future__ import annotations
 
 from dataclasses import asdict, dataclass
 
-from anthropic._types import NOT_GIVEN, NotGiven
+from anthropic import NOT_GIVEN, NotGiven
 
 from camel.configs.base_config import BaseConfig
 

camel/configs/litellm_config.py

@@ -0,0 +1,113 @@
+# =========== 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 __future__ import annotations
+
+from dataclasses import asdict, dataclass, field
+from typing import List, Optional, Union
+
+from camel.configs.base_config import BaseConfig
+
+
+@dataclass(frozen=True)
+class LiteLLMConfig(BaseConfig):
+    r"""Defines the parameters for generating chat completions using the
+    LiteLLM API.
+
+    Args:
+        model (str): The name of the language model to use for text completion.
+        messages (List): A list of message objects representing the
+            conversation context. (default: [])
+        timeout (Optional[Union[float, str]], optional): Request timeout.
+            (default: None)
+        temperature (Optional[float], optional): Temperature parameter for
+            controlling randomness. (default: None)
+        top_p (Optional[float], optional): Top-p parameter for nucleus
+            sampling. (default: None)
+        n (Optional[int], optional): Number of completions to generate.
+            (default: None)
+        stream (Optional[bool], optional): Whether to return a streaming
+            response. (default: None)
+        stream_options (Optional[dict], optional): Options for the streaming
+            response. (default: None)
+        stop (Optional[Union[str, List[str]]], optional): Sequences where the
+            API will stop generating further tokens. (default: None)
+        max_tokens (Optional[int], optional): Maximum number of tokens to
+            generate. (default: None)
+        presence_penalty (Optional[float], optional): Penalize new tokens
+            based on their existence in the text so far. (default: None)
+        frequency_penalty (Optional[float], optional): Penalize new tokens
+            based on their frequency in the text so far. (default: None)
+        logit_bias (Optional[dict], optional): Modify the probability of
+            specific tokens appearing in the completion. (default: None)
+        user (Optional[str], optional): A unique identifier representing the
+            end-user. (default: None)
+        response_format (Optional[dict], optional): Response format
+            parameters. (default: None)
+        seed (Optional[int], optional): Random seed. (default: None)
+        tools (Optional[List], optional): List of tools. (default: None)
+        tool_choice (Optional[Union[str, dict]], optional): Tool choice
+            parameters. (default: None)
+        logprobs (Optional[bool], optional): Whether to return log
+            probabilities of the output tokens. (default: None)
+        top_logprobs (Optional[int], optional): Number of most likely tokens
+            to return at each token position. (default: None)
+        deployment_id (Optional[str], optional): Deployment ID. (default: None)
+        extra_headers (Optional[dict], optional): Additional headers for the
+            request. (default: None)
+        base_url (Optional[str], optional): Base URL for the API. (default:
+            None)
+        api_version (Optional[str], optional): API version. (default: None)
+        api_key (Optional[str], optional): API key. (default: None)
+        model_list (Optional[list], optional): List of API base, version,
+            keys. (default: None)
+        mock_response (Optional[str], optional): Mock completion response for
+            testing or debugging. (default: None)
+        custom_llm_provider (Optional[str], optional): Non-OpenAI LLM
+            provider. (default: None)
+        max_retries (Optional[int], optional): Maximum number of retries.
+            (default: None)
+    """
+
+    model: str = "gpt-3.5-turbo"
+    messages: List = field(default_factory=list)
+    timeout: Optional[Union[float, str]] = None
+    temperature: Optional[float] = None
+    top_p: Optional[float] = None
+    n: Optional[int] = None
+    stream: Optional[bool] = None
+    stream_options: Optional[dict] = None
+    stop: Optional[Union[str, List[str]]] = None
+    max_tokens: Optional[int] = None
+    presence_penalty: Optional[float] = None
+    frequency_penalty: Optional[float] = None
+    logit_bias: Optional[dict] = field(default_factory=dict)
+    user: Optional[str] = None
+    response_format: Optional[dict] = None
+    seed: Optional[int] = None
+    tools: Optional[List] = field(default_factory=list)
+    tool_choice: Optional[Union[str, dict]] = None
+    logprobs: Optional[bool] = None
+    top_logprobs: Optional[int] = None
+    deployment_id: Optional[str] = None
+    extra_headers: Optional[dict] = field(default_factory=dict)
+    base_url: Optional[str] = None
+    api_version: Optional[str] = None
+    api_key: Optional[str] = None
+    model_list: Optional[list] = field(default_factory=list)
+    mock_response: Optional[str] = None
+    custom_llm_provider: Optional[str] = None
+    max_retries: Optional[int] = None
+
+
+LITELLM_API_PARAMS = {param for param in asdict(LiteLLMConfig()).keys()}

camel/embeddings/__init__.py

@@ -14,9 +14,11 @@
 from .base import BaseEmbedding
 from .openai_embedding import OpenAIEmbedding
 from .sentence_transformers_embeddings import SentenceTransformerEncoder
+from .vlm_embedding import VisionLanguageEmbedding
 
 __all__ = [
     "BaseEmbedding",
     "OpenAIEmbedding",
     "SentenceTransformerEncoder",
+    "VisionLanguageEmbedding",
 ]

camel/embeddings/openai_embedding.py

@@ -18,7 +18,7 @@ from openai import OpenAI
 
 from camel.embeddings.base import BaseEmbedding
 from camel.types import EmbeddingModelType
-from camel.utils import api_key_required
+from camel.utils import model_api_key_required
 
 
 class OpenAIEmbedding(BaseEmbedding[str]):
@@ -46,7 +46,7 @@ class OpenAIEmbedding(BaseEmbedding[str]):
         self._api_key = api_key or os.environ.get("OPENAI_API_KEY")
         self.client = OpenAI(timeout=60, max_retries=3, api_key=self._api_key)
 
-    @api_key_required
+    @model_api_key_required
     def embed_list(
         self,
         objs: List[str],

camel/embeddings/sentence_transformers_embeddings.py

@@ -11,7 +11,7 @@
 # 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 Any, List, Union
+from typing import Any, List
 
 from camel.embeddings.base import BaseEmbedding
 
@@ -38,17 +38,18 @@ class SentenceTransformerEncoder(BaseEmbedding[str]):
 
     def embed_list(
         self,
-        objs: Union[str, List[str]],
+        objs: List[str],
         **kwargs: Any,
-    ) -> list:
+    ) -> List[List[float]]:
         r"""Generates embeddings for the given texts using the model.
 
         Args:
-            objs (str | List[str]): The texts for which to generate the
+            objs (List[str]): The texts for which to generate the
             embeddings.
 
         Returns:
-            list: A list of float representing embeddings.
+            List[List[float]]: A list that represents the generated embedding
+                as a list of floating-point numbers.
         """
         if not objs:
             raise ValueError("Input text list is empty")

camel/embeddings/vlm_embedding.py

@@ -0,0 +1,146 @@
+# =========== 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 typing import Any, List, Optional, Union
+
+from PIL import Image
+
+from camel.embeddings import BaseEmbedding
+
+
+class VisionLanguageEmbedding(BaseEmbedding[Union[str, Image.Image]]):
+    r"""Provides image embedding functionalities using multimodal model.
+
+    Args:
+        model_name : The model type to be used for generating embeddings.
+            And the default value is: obj:`openai/clip-vit-base-patch32`.
+
+    Raises:
+        RuntimeError: If an unsupported model type is specified.
+    """
+
+    def __init__(
+        self, model_name: str = "openai/clip-vit-base-patch32"
+    ) -> None:
+        r"""Initializes the: obj: `VisionLanguageEmbedding` class with a
+        specified model and return the dimension of embeddings.
+
+        Args:
+            model_name (str, optional): The version name of the model to use.
+                (default: :obj:`openai/clip-vit-base-patch32`)
+        """
+        from transformers import AutoModel, AutoProcessor
+
+        try:
+            self.model = AutoModel.from_pretrained(model_name)
+            self.processor = AutoProcessor.from_pretrained(model_name)
+        except Exception as e:
+            raise RuntimeError(f"Failed to load model '{model_name}': {e}")
+
+        self.valid_processor_kwargs = []
+        self.valid_model_kwargs = []
+
+        try:
+            self.valid_processor_kwargs = (
+                self.processor.image_processor._valid_processor_keys
+            )
+            self.valid_model_kwargs = [
+                "pixel_values",
+                "return_dict",
+                "interpolate_pos_encoding",
+            ]
+        except Exception:
+            print("Warning: not typically processor and model structure")
+            pass
+        self.dim: Optional[int] = None
+
+    def embed_list(
+        self, objs: List[Union[Image.Image, str]], **kwargs: Any
+    ) -> List[List[float]]:
+        """Generates embeddings for the given images or texts.
+
+        Args:
+            objs (List[Image.Image|str]): The list of images or texts for
+                which to generate the embeddings.
+            image_processor_kwargs: Extra kwargs passed to the image processor.
+            tokenizer_kwargs: Extra kwargs passed to the text tokenizer
+                (processor).
+            model_kwargs: Extra kwargs passed to the main model.
+
+        Returns:
+            List[List[float]]: A list that represents the generated embedding
+                as a list of floating-point numbers.
+
+        Raises:
+            ValueError: If the input type is not `Image.Image` or `str`.
+        """
+        if not objs:
+            raise ValueError("Input objs list is empty.")
+
+        image_processor_kwargs: Optional[dict] = kwargs.get(
+            'image_processor_kwargs', {}
+        )
+        tokenizer_kwargs: Optional[dict] = kwargs.get('tokenizer_kwargs', {})
+        model_kwargs: Optional[dict] = kwargs.get('model_kwargs', {})
+
+        result_list = []
+        for obj in objs:
+            if isinstance(obj, Image.Image):
+                image_input = self.processor(
+                    images=obj,
+                    return_tensors="pt",
+                    padding=True,
+                    **image_processor_kwargs,
+                )
+                image_feature = (
+                    self.model.get_image_features(
+                        **image_input, **model_kwargs
+                    )
+                    .squeeze(dim=0)
+                    .tolist()
+                )
+                result_list.append(image_feature)
+            elif isinstance(obj, str):
+                text_input = self.processor(
+                    text=obj,
+                    return_tensors="pt",
+                    padding=True,
+                    **tokenizer_kwargs,
+                )
+                text_feature = (
+                    self.model.get_text_features(**text_input, **model_kwargs)
+                    .squeeze(dim=0)
+                    .tolist()
+                )
+                result_list.append(text_feature)
+            else:
+                raise ValueError("Input type is not image nor text.")
+
+        self.dim = len(result_list[0])
+
+        if any(len(result) != self.dim for result in result_list):
+            raise ValueError("Dimensionality is not consistent.")
+
+        return result_list
+
+    def get_output_dim(self) -> int:
+        r"""Returns the output dimension of the embeddings.
+
+        Returns:
+            int: The dimensionality of the embedding for the current model.
+        """
+        if self.dim is None:
+            text = 'dimension'
+            inputs = self.processor(text=[text], return_tensors="pt")
+            self.dim = self.model.get_text_features(**inputs).shape[1]
+        return self.dim