camel-ai 0.2.10__py3-none-any.whl → 0.2.11__py3-none-any.whl

camel/__init__.py

@@ -12,9 +12,14 @@
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 
-__version__ = '0.2.10'
+from camel.logger import disable_logging, enable_logging, set_log_level
+
+__version__ = '0.2.11'
 
 __all__ = [
     '__version__',
     'camel',
+    'disable_logging',
+    'enable_logging',
+    'set_log_level',
 ]

camel/agents/chat_agent.py

@@ -21,6 +21,7 @@ from collections import defaultdict
 from typing import (
     TYPE_CHECKING,
     Any,
+    Callable,
     Dict,
     List,
     Optional,
@@ -41,7 +42,12 @@ from camel.memories import (
     ScoreBasedContextCreator,
 )
 from camel.messages import BaseMessage, FunctionCallingMessage, OpenAIMessage
-from camel.models import BaseModelBackend, ModelFactory
+from camel.models import (
+    BaseModelBackend,
+    ModelFactory,
+    ModelManager,
+    ModelProcessingError,
+)
 from camel.responses import ChatAgentResponse
 from camel.types import (
     ChatCompletion,
@@ -145,12 +151,16 @@ class ChatAgent(BaseAgent):
         response_terminators (List[ResponseTerminator], optional): List of
             :obj:`ResponseTerminator` bind to one chat agent.
             (default: :obj:`None`)
+        scheduling_strategy (str): name of function that defines how to select
+            the next model in ModelManager. (default: :str:`round_robin`)
     """
 
     def __init__(
         self,
         system_message: Optional[Union[BaseMessage, str]] = None,
-        model: Optional[BaseModelBackend] = None,
+        model: Optional[
+            Union[BaseModelBackend, List[BaseModelBackend]]
+        ] = None,
         memory: Optional[AgentMemory] = None,
         message_window_size: Optional[int] = None,
         token_limit: Optional[int] = None,
@@ -158,6 +168,7 @@ class ChatAgent(BaseAgent):
         tools: Optional[List[FunctionTool]] = None,
         external_tools: Optional[List[FunctionTool]] = None,
         response_terminators: Optional[List[ResponseTerminator]] = None,
+        scheduling_strategy: str = "round_robin",
     ) -> None:
         if isinstance(system_message, str):
             system_message = BaseMessage.make_assistant_message(
@@ -172,13 +183,14 @@ class ChatAgent(BaseAgent):
         self.role_type: RoleType = (
             getattr(system_message, 'role_type', None) or RoleType.ASSISTANT
         )
-        self.model_backend: BaseModelBackend = (
+        self.model_backend = ModelManager(
             model
             if model is not None
             else ModelFactory.create(
                 model_platform=ModelPlatformType.DEFAULT,
                 model_type=ModelType.DEFAULT,
-            )
+            ),
+            scheduling_strategy=scheduling_strategy,
         )
 
         self.model_type = self.model_backend.model_type
@@ -945,8 +957,32 @@ class ChatAgent(BaseAgent):
         str,
     ]:
         r"""Internal function for agent step model response."""
+
+        response = None
         # Obtain the model's response
-        response = self.model_backend.run(openai_messages)
+        for _ in range(len(self.model_backend.models)):
+            try:
+                response = self.model_backend.run(openai_messages)
+                break
+            except Exception as exc:
+                logger.error(
+                    f"An error occurred while running model "
+                    f"{self.model_backend.model_type}, "
+                    f"index: {self.model_backend.current_model_index}",
+                    exc_info=exc,
+                )
+                continue
+        if not response:
+            raise ModelProcessingError(
+                "Unable to process messages: none of the provided models "
+                "run succesfully."
+            )
+
+        logger.info(
+            f"Model {self.model_backend.model_type}, "
+            f"index {self.model_backend.current_model_index}, "
+            f"processed these messages: {openai_messages}"
+        )
 
         if isinstance(response, ChatCompletion):
             output_messages, finish_reasons, usage_dict, response_id = (
@@ -1054,8 +1090,32 @@ class ChatAgent(BaseAgent):
                 role_type=self.role_type,
                 meta_dict=dict(),
                 content=choice.message.content or "",
+                parsed=getattr(choice.message, 'parsed', None),
             )
+            # Process log probabilities and append to the message meta information
+            if choice.logprobs is not None:
+                tokens_logprobs = choice.logprobs.content
+
+                if tokens_logprobs is not None:
+                    # Extract and structure logprob information
+                    logprobs_info = [
+                        {
+                            "token": token_logprob.token,
+                            "logprob": token_logprob.logprob,
+                            "top_logprobs": [
+                                (top_logprob.token, top_logprob.logprob)
+                                for top_logprob in token_logprob.top_logprobs
+                            ],
+                        }
+                        for token_logprob in tokens_logprobs
+                    ]
+                # Ensure meta_dict exists before adding logprobs info
+                if chat_message.meta_dict is None:
+                    chat_message.meta_dict = {}
+                chat_message.meta_dict["logprobs_info"] = logprobs_info
+            # Append the processed chat message to output
             output_messages.append(chat_message)
+
         finish_reasons = [
             str(choice.finish_reason) for choice in response.choices
         ]
@@ -1298,6 +1358,15 @@ class ChatAgent(BaseAgent):
         )
         return usage_dict
 
+    def add_model_scheduling_strategy(self, name: str, strategy_fn: Callable):
+        r"""Add a scheduling strategy method provided by user to ModelManger.
+
+        Args:
+            name (str): The name of the strategy.
+            strategy_fn (Callable): The scheduling strategy function.
+        """
+        self.model_backend.add_strategy(name, strategy_fn)
+
     def __repr__(self) -> str:
         r"""Returns a string representation of the :obj:`ChatAgent`.
 

camel/agents/deductive_reasoner_agent.py

@@ -15,11 +15,14 @@ import re
 from typing import Dict, List, Optional, Union
 
 from camel.agents.chat_agent import ChatAgent
+from camel.logger import get_logger
 from camel.messages import BaseMessage
 from camel.models import BaseModelBackend
 from camel.prompts import TextPrompt
 from camel.types import RoleType
 
+logger = get_logger(__name__)
+
 # AgentOps decorator setting
 try:
     import os
@@ -253,7 +256,7 @@ square brackets)
                 "Deduction failed. Error:\n" + f"{response.info}"
             )
         msg: BaseMessage = response.msg
-        print(f"Message content:\n{msg.content}")
+        logger.info(f"Message content:\n{msg.content}")
 
         # Extract the conditions from the message
         conditions_dict = {

camel/configs/__init__.py

@@ -19,6 +19,7 @@ from .gemini_config import Gemini_API_PARAMS, GeminiConfig
 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 .nvidia_config import NVIDIA_API_PARAMS, NvidiaConfig
 from .ollama_config import OLLAMA_API_PARAMS, OllamaConfig
 from .openai_config import OPENAI_API_PARAMS, ChatGPTConfig
 from .qwen_config import QWEN_API_PARAMS, QwenConfig
@@ -44,6 +45,8 @@ __all__ = [
     'GroqConfig',
     'LiteLLMConfig',
     'LITELLM_API_PARAMS',
+    'NvidiaConfig',
+    'NVIDIA_API_PARAMS',
     'OllamaConfig',
     'OLLAMA_API_PARAMS',
     'ZhipuAIConfig',

camel/configs/mistral_config.py

@@ -35,8 +35,6 @@ class MistralConfig(BaseConfig):
             tokens to generate, e.g. 0.9. Defaults to None.
         max_tokens (Optional[int], optional): the maximum number of tokens to
             generate, e.g. 100. Defaults to None.
-        min_tokens (Optional[int], optional): the minimum number of tokens to
-            generate, e.g. 100. Defaults to None.
         stop (Optional[Union[str,list[str]]]): Stop generation if this token
             is detected. Or if one of these tokens is detected when providing
             a string list.
@@ -58,7 +56,6 @@ class MistralConfig(BaseConfig):
     temperature: Optional[float] = None
     top_p: Optional[float] = None
     max_tokens: Optional[int] = None
-    min_tokens: Optional[int] = None
     stop: Optional[Union[str, list[str]]] = None
     random_seed: Optional[int] = None
     safe_prompt: bool = False

camel/configs/nvidia_config.py

@@ -0,0 +1,70 @@
+# ========= Copyright 2023-2024 @ 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-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+from __future__ import annotations
+
+from typing import List, Optional, Union
+
+from pydantic import Field
+
+from camel.configs.base_config import BaseConfig
+from camel.types import NOT_GIVEN, NotGiven
+
+
+class NvidiaConfig(BaseConfig):
+    r"""Configuration class for NVIDIA API models.
+
+    This class defines the configuration parameters for NVIDIA's language
+    models, including temperature, sampling parameters, and response format
+    settings.
+
+    Args:
+        stream (bool, optional): Whether to stream the response.
+            (default: :obj:`False`)
+        temperature (float, optional): Controls randomness in the response.
+            Higher values make output more random, lower values make it more
+            deterministic. Range: [0.0, 2.0]. (default: :obj:`0.7`)
+        top_p (float, optional): Controls diversity via nucleus sampling.
+            Range: [0.0, 1.0]. (default: :obj:`0.95`)
+        presence_penalty (float, optional): Penalizes new tokens based on
+            whether they appear in the text so far. Range: [-2.0, 2.0].
+            (default: :obj:`0.0`)
+        frequency_penalty (float, optional): Penalizes new tokens based on
+            their frequency in the text so far. Range: [-2.0, 2.0].
+            (default: :obj:`0.0`)
+        max_tokens (Union[int, NotGiven], optional): Maximum number of tokens
+            to generate. If not provided, model will use its default maximum.
+            (default: :obj:`NOT_GIVEN`)
+        seed (Optional[int], optional): Random seed for deterministic sampling.
+            (default: :obj:`None`)
+        tools (Optional[List[Dict]], optional): List of tools available to the
+            model. This includes tools such as a text editor, a calculator, or
+            a search engine. (default: :obj:`None`)
+        tool_choice (Optional[str], optional): Tool choice configuration.
+            (default: :obj:`None`)
+        stop (Optional[List[str]], optional): List of stop sequences.
+            (default: :obj:`None`)
+    """
+
+    stream: bool = Field(default=False)
+    temperature: float = Field(default=0.7)
+    top_p: float = Field(default=0.95)
+    presence_penalty: float = Field(default=0.0)
+    frequency_penalty: float = Field(default=0.0)
+    max_tokens: Union[int, NotGiven] = Field(default=NOT_GIVEN)
+    seed: Optional[int] = Field(default=None)
+    tool_choice: Optional[str] = Field(default=None)
+    stop: Optional[List[str]] = Field(default=None)
+
+
+NVIDIA_API_PARAMS = {param for param in NvidiaConfig.model_fields.keys()}

camel/configs/vllm_config.py

@@ -13,7 +13,7 @@
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 from __future__ import annotations
 
-from typing import Sequence, Union
+from typing import Optional, Sequence, Union
 
 from pydantic import Field
 
@@ -84,6 +84,13 @@ class VLLMConfig(BaseConfig):
         user (str, optional): A unique identifier representing your end-user,
             which can help OpenAI to monitor and detect abuse.
             (default: :obj:`""`)
+        logprobs: Whether to return log probabilities of the output tokens or
+            not. If true, returns the log probabilities of each output token
+            returned in the `logits` of `message`. (default: :obj:`None`)
+        top_logprobs: An integer between 0 and 20 specifying the number of
+            most likely tokens to return at each token position, each with an
+            associated log probability. `logprobs` must be set to `true` if
+            this parameter is used. (default: :obj:`None`)
     """
 
     temperature: float = 0.2  # openai default: 1.0
@@ -97,6 +104,8 @@ class VLLMConfig(BaseConfig):
     frequency_penalty: float = 0.0
     logit_bias: dict = Field(default_factory=dict)
     user: str = ""
+    logprobs: Optional[bool] = None
+    top_logprobs: Optional[int] = None
 
 
 VLLM_API_PARAMS = {param for param in VLLMConfig.model_fields.keys()}

camel/embeddings/vlm_embedding.py

@@ -16,6 +16,9 @@ from typing import Any, List, Optional, Union
 from PIL import Image
 
 from camel.embeddings import BaseEmbedding
+from camel.logger import get_logger
+
+logger = get_logger(__name__)
 
 
 class VisionLanguageEmbedding(BaseEmbedding[Union[str, Image.Image]]):
@@ -60,7 +63,7 @@ class VisionLanguageEmbedding(BaseEmbedding[Union[str, Image.Image]]):
                 "interpolate_pos_encoding",
             ]
         except Exception:
-            print("Warning: not typically processor and model structure")
+            logger.warning("not typically processor and model structure")
             pass
         self.dim: Optional[int] = None
 

camel/interpreters/docker_interpreter.py

@@ -23,11 +23,14 @@ from colorama import Fore
 
 from camel.interpreters.base import BaseInterpreter
 from camel.interpreters.interpreter_error import InterpreterError
+from camel.logger import get_logger
 from camel.utils import is_docker_running
 
 if TYPE_CHECKING:
     from docker.models.containers import Container
 
+logger = get_logger(__name__)
+
 
 class DockerInterpreter(BaseInterpreter):
     r"""A class for executing code files or code strings in a docker container.
@@ -187,8 +190,10 @@ class DockerInterpreter(BaseInterpreter):
 
         # Print code for security checking
         if self.require_confirm:
-            print(f"The following {code_type} code will run in container:")
-            print(Fore.CYAN + code + Fore.RESET)
+            logger.info(
+                f"The following {code_type} code will run on your "
+                "computer: {code}"
+            )
             while True:
                 choice = input("Running code? [Y/n]:").lower()
                 if choice in ["y", "yes", "ye", ""]:

camel/interpreters/subprocess_interpreter.py

@@ -22,6 +22,9 @@ from colorama import Fore
 
 from camel.interpreters.base import BaseInterpreter
 from camel.interpreters.interpreter_error import InterpreterError
+from camel.logger import get_logger
+
+logger = get_logger(__name__)
 
 
 class SubprocessInterpreter(BaseInterpreter):
@@ -141,8 +144,10 @@ class SubprocessInterpreter(BaseInterpreter):
 
         # Print code for security checking
         if self.require_confirm:
-            print(f"The following {code_type} code will run on your computer:")
-            print(Fore.CYAN + code + Fore.RESET)
+            logger.info(
+                f"The following {code_type} code will run on your "
+                "computer: {code}"
+            )
             while True:
                 choice = input("Running code? [Y/n]:").lower()
                 if choice in ["y", "yes", "ye", ""]:

camel/loaders/firecrawl_reader.py

@@ -17,8 +17,6 @@ from typing import Any, Dict, Optional
 
 from pydantic import BaseModel
 
-from camel.utils import api_keys_required
-
 
 class Firecrawl:
     r"""Firecrawl allows you to turn entire websites into LLM-ready markdown.
@@ -32,7 +30,6 @@ class Firecrawl:
         https://docs.firecrawl.dev/introduction
     """
 
-    @api_keys_required("FIRECRAWL_API_KEY")
     def __init__(
         self,
         api_key: Optional[str] = None,

camel/logger.py

@@ -0,0 +1,112 @@
+# ========= Copyright 2023-2024 @ 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-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+
+import logging
+import os
+import sys
+
+# Create a private logger
+_logger = logging.getLogger('camel')
+
+
+def _configure_library_logging():
+    if os.environ.get('CAMEL_LOGGING_DISABLED', 'False').lower() == 'true':
+        return
+
+    if not logging.root.handlers and not _logger.handlers:
+        logging.basicConfig(
+            level=os.environ.get('LOGLEVEL', 'INFO').upper(),
+            format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+            stream=sys.stdout,
+        )
+        logging.setLoggerClass(logging.Logger)
+        _logger.info("Camel library logging has been configured.")
+    else:
+        _logger.debug("Existing logger configuration found, using that.")
+
+
+def disable_logging():
+    r"""Disable all logging for the Camel library.
+
+    This function sets the log level to a value higher than CRITICAL,
+    effectively disabling all log messages, and adds a NullHandler to
+    suppress any potential warnings about no handlers being found.
+    """
+    os.environ['CAMEL_LOGGING_DISABLED'] = 'true'
+    _logger.setLevel(logging.CRITICAL + 1)
+    # Avoid adding multiple NullHandlers
+    if not any(
+        isinstance(handler, logging.NullHandler)
+        for handler in _logger.handlers
+    ):
+        _logger.addHandler(logging.NullHandler())
+    _logger.debug("Logging has been disabled.")
+
+
+def enable_logging():
+    r"""Enable logging for the Camel library.
+
+    This function re-enables logging if it was previously disabled,
+    and configures the library logging using the default settings.
+    If the logging is already configured,
+        this function does not change its configuration.
+    """
+    os.environ['CAMEL_LOGGING_DISABLED'] = 'false'
+    _configure_library_logging()
+
+
+def set_log_level(level):
+    r"""Set the logging level for the Camel library.
+
+    Args:
+        level (Union[str, int]): The logging level to set. This can be a string
+            (e.g., 'INFO') or a logging level constant (e.g., logging.INFO,
+            logging.DEBUG).
+            See https://docs.python.org/3/library/logging.html#levels
+
+    Raises:
+        ValueError: If the provided level is not a valid logging level.
+    """
+    valid_levels = ['NOTSET', 'DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL']
+    if isinstance(level, str):
+        if level.upper() not in valid_levels:
+            raise ValueError(
+                f"Invalid logging level."
+                f" Choose from: {', '.join(valid_levels)}"
+            )
+        level = level.upper()
+    elif not isinstance(level, int):
+        raise ValueError(
+            "Logging level must be an option from the logging module."
+        )
+
+    _logger.setLevel(level)
+    _logger.debug(f"Logging level set to: {logging.getLevelName(level)}")
+
+
+def get_logger(name):
+    r"""Get a logger with the specified name, prefixed with 'camel.'.
+
+    Args:
+        name (str): The name to be appended to 'camel.' to create the logger.
+
+    Returns:
+        logging.Logger: A logger instance with the name 'camel.{name}'.
+    """
+    return logging.getLogger(f'camel.{name}')
+
+
+# Lazy configuration: Only configure logging if explicitly enabled.
+if os.environ.get('CAMEL_LOGGING_DISABLED', 'False').strip().lower() != 'true':
+    _configure_library_logging()

camel/messages/__init__.py

@@ -23,7 +23,7 @@ from .conversion import (
     HermesFunctionFormatter,
     ShareGPTMessage,
 )
-from .conversion.models import (
+from .conversion.conversation_models import (
     ShareGPTConversation,
 )
 from .conversion.sharegpt.function_call_formatter import (

camel/messages/base.py

@@ -15,10 +15,11 @@ import base64
 import io
 import re
 from dataclasses import dataclass
-from typing import Any, Dict, List, Literal, Optional, Tuple, Union
+from typing import Any, Dict, List, Literal, Optional, Tuple, Type, Union
 
 import numpy as np
 from PIL import Image
+from pydantic import BaseModel
 
 from camel.messages import (
     FunctionCallFormatter,
@@ -51,24 +52,27 @@ class BaseMessage:
             for the message.
         content (str): The content of the message.
         video_bytes (Optional[bytes]): Optional bytes of a video associated
-            with the message. Default is None.
+            with the message. (default::obj:`None`)
         image_list (Optional[List[Image.Image]]): Optional list of PIL Image
-            objects associated with the message. Default is None.
+            objects associated with the message. (default::obj:`None`)
         image_detail (Literal["auto", "low", "high"]): Detail level of the
-            images associated with the message. Default is "auto".
+            images associated with the message. (default::obj:`auto`)
         video_detail (Literal["auto", "low", "high"]): Detail level of the
-            videos associated with the message. Default is "low".
+            videos associated with the message. (default::obj:`low`)
+        parsed: Optional[Union[Type[BaseModel], dict]]: Optional object which
+            is parsed from the content. (default::obj:`None`)
     """
 
     role_name: str
     role_type: RoleType
-    meta_dict: Optional[Dict[str, str]]
+    meta_dict: Optional[Dict[str, Any]]
     content: str
 
     video_bytes: Optional[bytes] = None
     image_list: Optional[List[Image.Image]] = None
     image_detail: Literal["auto", "low", "high"] = "auto"
     video_detail: Literal["auto", "low", "high"] = "low"
+    parsed: Optional[Union[Type[BaseModel], dict]] = None
 
     @classmethod
     def make_user_message(
@@ -419,7 +423,6 @@ class BaseMessage:
                 "text": self.content,
             }
         )
-
         if self.image_list and len(self.image_list) > 0:
             for image in self.image_list:
                 if image.format is None:

camel/messages/conversion/__init__.py

@@ -12,7 +12,8 @@
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 
-from .models import (
+from .alpaca import AlpacaItem
+from .conversation_models import (
     ShareGPTConversation,
     ShareGPTMessage,
     ToolCall,
@@ -24,6 +25,7 @@ __all__ = [
     'ShareGPTMessage',
     'ShareGPTConversation',
     'HermesFunctionFormatter',
+    'AlpacaItem',
     'ToolCall',
     'ToolResponse',
 ]