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

camel/models/base_model.py

@@ -17,41 +17,49 @@ from typing import Any, Dict, List, Optional, Union
 from openai import Stream
 
 from camel.messages import OpenAIMessage
-from camel.types import ChatCompletion, ChatCompletionChunk, ModelType
+from camel.types import (
+    ChatCompletion,
+    ChatCompletionChunk,
+    ModelType,
+    UnifiedModelType,
+)
 from camel.utils import BaseTokenCounter
 
 
 class BaseModelBackend(ABC):
     r"""Base class for different model backends.
-    May be OpenAI API, a local LLM, a stub for unit tests, etc.
+    It may be OpenAI API, a local LLM, a stub for unit tests, etc.
+
+    Args:
+        model_type (Union[ModelType, str]): Model for which a backend is
+            created.
+        model_config_dict (Optional[Dict[str, Any]], optional): A config
+            dictionary. (default: :obj:`{}`)
+        api_key (Optional[str], optional): The API key for authenticating
+            with the model service. (default: :obj:`None`)
+        url (Optional[str], optional): The url to the model service.
+            (default: :obj:`None`)
+        token_counter (Optional[BaseTokenCounter], optional): Token
+            counter to use for the model. If not provided,
+            :obj:`OpenAITokenCounter` will be used. (default: :obj:`None`)
     """
 
     def __init__(
         self,
-        model_type: ModelType,
-        model_config_dict: Dict[str, Any],
+        model_type: Union[ModelType, str],
+        model_config_dict: Optional[Dict[str, Any]] = None,
         api_key: Optional[str] = None,
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
     ) -> None:
-        r"""Constructor for the model backend.
-
-        Args:
-            model_type (ModelType): Model for which a backend is created.
-            model_config_dict (Dict[str, Any]): A config dictionary.
-            api_key (Optional[str]): The API key for authenticating with the
-                model service.
-            url (Optional[str]): The url to the model service.
-            token_counter (Optional[BaseTokenCounter]): Token counter to use
-                for the model. If not provided, `OpenAITokenCounter` will
-                be used.
-        """
-        self.model_type = model_type
+        self.model_type: UnifiedModelType = UnifiedModelType(model_type)
+        if model_config_dict is None:
+            model_config_dict = {}
         self.model_config_dict = model_config_dict
         self._api_key = api_key
         self._url = url
-        self.check_model_config()
         self._token_counter = token_counter
+        self.check_model_config()
 
     @property
     @abstractmethod
@@ -110,6 +118,9 @@ class BaseModelBackend(ABC):
     def token_limit(self) -> int:
         r"""Returns the maximum token limit for a given model.
 
+        This method retrieves the maximum token limit either from the
+        `model_config_dict` or from the model's default token limit.
+
         Returns:
             int: The maximum token limit for the given model.
         """
@@ -120,8 +131,8 @@ class BaseModelBackend(ABC):
 
     @property
     def stream(self) -> bool:
-        r"""Returns whether the model is in stream mode,
-            which sends partial results each time.
+        r"""Returns whether the model is in stream mode, which sends partial
+        results each time.
 
         Returns:
             bool: Whether the model is in stream mode.

camel/models/gemini_model.py

@@ -11,9 +11,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
+import os
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
 
-from camel.configs import Gemini_API_PARAMS
+from camel.configs import Gemini_API_PARAMS, GeminiConfig
 from camel.messages import OpenAIMessage
 from camel.models import BaseModelBackend
 from camel.types import (
@@ -26,6 +27,7 @@ from camel.utils import (
     BaseTokenCounter,
     GeminiTokenCounter,
     api_keys_required,
+    dependencies_required,
 )
 
 if TYPE_CHECKING:
@@ -33,43 +35,49 @@ if TYPE_CHECKING:
 
 
 class GeminiModel(BaseModelBackend):
-    r"""Gemini API in a unified BaseModelBackend interface."""
-
-    # NOTE: Currently "stream": True is not supported with Gemini due to the
-    # limitation of the current camel design.
-
+    r"""Gemini API in a unified BaseModelBackend interface.
+
+    Args:
+        model_type (Union[ModelType, str]): Model for which a backend is
+            created.
+        model_config_dict (Optional[Dict[str, Any]], optional): A dictionary
+            that will be fed into:obj:`genai.GenerativeModel.generate_content()
+            `. If:obj:`None`, :obj:`GeminiConfig().as_dict()` will be used.
+            (default: :obj:`None`)
+        api_key (Optional[str], optional): The API key for authenticating with
+            the gemini service. (default: :obj:`None`)
+        url (Optional[str], optional): The url to the gemini service.
+            (default: :obj:`None`)
+        token_counter (Optional[BaseTokenCounter], optional): Token counter to
+            use for the model. If not provided, :obj:`GeminiTokenCounter` will
+            be used. (default: :obj:`None`)
+
+    Notes:
+        Currently :obj:`"stream": True` is not supported with Gemini due to the
+        limitation of the current camel design.
+    """
+
+    @dependencies_required('google')
     def __init__(
         self,
-        model_type: ModelType,
-        model_config_dict: Dict[str, Any],
+        model_type: Union[ModelType, str],
+        model_config_dict: Optional[Dict[str, Any]] = None,
         api_key: Optional[str] = None,
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
     ) -> None:
-        r"""Constructor for Gemini backend.
-
-        Args:
-            model_type (ModelType): Model for which a backend is created.
-            model_config_dict (Dict[str, Any]): A dictionary that will
-                be fed into generate_content().
-            api_key (Optional[str]): The API key for authenticating with the
-                gemini service. (default: :obj:`None`)
-            url (Optional[str]): The url to the gemini service.
-            token_counter (Optional[BaseTokenCounter]): Token counter to use
-                for the model. If not provided, `GeminiTokenCounter` will be
-                used.
-        """
-        import os
-
         import google.generativeai as genai
         from google.generativeai.types.generation_types import GenerationConfig
 
+        if model_config_dict is None:
+            model_config_dict = GeminiConfig().as_dict()
+
+        api_key = api_key or os.environ.get("GOOGLE_API_KEY")
         super().__init__(
             model_type, model_config_dict, api_key, url, token_counter
         )
-        self._api_key = api_key or os.environ.get("GOOGLE_API_KEY")
         genai.configure(api_key=self._api_key)
-        self._client = genai.GenerativeModel(self.model_type.value)
+        self._client = genai.GenerativeModel(self.model_type)
 
         keys = list(self.model_config_dict.keys())
         generation_config_dict = {
@@ -143,8 +151,8 @@ class GeminiModel(BaseModelBackend):
         return self.model_config_dict.get('stream', False)
 
     def to_gemini_req(self, messages: List[OpenAIMessage]) -> 'ContentsType':
-        r"""Converts the request from the OpenAI API format to
-            the Gemini API request format.
+        r"""Converts the request from the OpenAI API format to the Gemini API
+        request format.
 
         Args:
             messages: The request object from the OpenAI API.
@@ -189,7 +197,7 @@ class GeminiModel(BaseModelBackend):
             id=f"chatcmpl-{uuid.uuid4().hex!s}",
             object="chat.completion",
             created=int(time.time()),
-            model=self.model_type.value,
+            model=self.model_type,
             choices=[],
         )
         for i, candidate in enumerate(response.candidates):

camel/models/groq_model.py

@@ -16,7 +16,7 @@ from typing import Any, Dict, List, Optional, Union
 
 from openai import OpenAI, Stream
 
-from camel.configs import GROQ_API_PARAMS
+from camel.configs import GROQ_API_PARAMS, GroqConfig
 from camel.messages import OpenAIMessage
 from camel.models import BaseModelBackend
 from camel.types import (
@@ -32,42 +32,48 @@ from camel.utils import (
 
 
 class GroqModel(BaseModelBackend):
-    r"""LLM API served by Groq in a unified BaseModelBackend interface."""
+    r"""LLM API served by Groq in a unified BaseModelBackend interface.
+
+    Args:
+        model_type (Union[ModelType, str]): Model for which a backend is
+            created.
+        model_config_dict (Optional[Dict[str, Any]], optional): A dictionary
+            that will be fed into:obj:`openai.ChatCompletion.create()`.
+            If:obj:`None`, :obj:`GroqConfig().as_dict()` will be used.
+            (default: :obj:`None`)
+        api_key (Optional[str], optional): The API key for authenticating
+            with the Groq service. (default: :obj:`None`).
+        url (Optional[str], optional): The url to the Groq service.
+            (default: :obj:`None`)
+        token_counter (Optional[BaseTokenCounter], optional): Token counter to
+            use for the model. If not provided, :obj:`OpenAITokenCounter(
+            ModelType.GPT_4O_MINI)` will be used.
+            (default: :obj:`None`)
+    """
 
     def __init__(
         self,
-        model_type: ModelType,
-        model_config_dict: Dict[str, Any],
+        model_type: Union[ModelType, str],
+        model_config_dict: Optional[Dict[str, Any]] = None,
         api_key: Optional[str] = None,
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
     ) -> None:
-        r"""Constructor for Groq backend.
-
-        Args:
-            model_type (str): Model for which a backend is created.
-            model_config_dict (Dict[str, Any]): A dictionary of parameters for
-                the model configuration.
-            api_key (Optional[str]): The API key for authenticating with the
-                Groq service. (default: :obj:`None`).
-            url (Optional[str]): The url to the Groq service. (default:
-                :obj:`"https://api.groq.com/openai/v1"`)
-            token_counter (Optional[BaseTokenCounter]): Token counter to use
-                for the model. If not provided, `OpenAITokenCounter(ModelType.
-                GPT_4O_MINI)` will be used.
-        """
+        if model_config_dict is None:
+            model_config_dict = GroqConfig().as_dict()
+        api_key = api_key or os.environ.get("GROQ_API_KEY")
+        url = url or os.environ.get(
+            "GROQ_API_BASE_URL" or "https://api.groq.com/openai/v1"
+        )
         super().__init__(
             model_type, model_config_dict, api_key, url, token_counter
         )
-        self._url = url or os.environ.get("GROQ_API_BASE_URL")
-        self._api_key = api_key or os.environ.get("GROQ_API_KEY")
         self._client = OpenAI(
             timeout=60,
             max_retries=3,
             api_key=self._api_key,
-            base_url=self._url or "https://api.groq.com/openai/v1",
+            base_url=self._url,
         )
-        self._token_counter = token_counter
 
     @property
     def token_counter(self) -> BaseTokenCounter:
@@ -101,7 +107,7 @@ class GroqModel(BaseModelBackend):
         """
         response = self._client.chat.completions.create(
             messages=messages,
-            model=self.model_type.value,
+            model=self.model_type,
             **self.model_config_dict,
         )
 

camel/models/litellm_model.py

@@ -11,49 +11,58 @@
 # 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, Dict, List, Optional
+from typing import Any, Dict, List, Optional, Union
 
-from camel.configs import LITELLM_API_PARAMS
+from camel.configs import LITELLM_API_PARAMS, LiteLLMConfig
 from camel.messages import OpenAIMessage
-from camel.types import ChatCompletion
-from camel.utils import BaseTokenCounter, LiteLLMTokenCounter
-
-
-class LiteLLMModel:
-    r"""Constructor for LiteLLM backend with OpenAI compatibility."""
+from camel.models import BaseModelBackend
+from camel.types import ChatCompletion, ModelType
+from camel.utils import (
+    BaseTokenCounter,
+    LiteLLMTokenCounter,
+    dependencies_required,
+)
+
+
+class LiteLLMModel(BaseModelBackend):
+    r"""Constructor for LiteLLM backend with OpenAI compatibility.
+
+    Args:
+        model_type (Union[ModelType, str]): Model for which a backend is
+            created, such as GPT-3.5-turbo, Claude-2, etc.
+        model_config_dict (Optional[Dict[str, Any]], optional): A dictionary
+            that will be fed into:obj:`openai.ChatCompletion.create()`.
+            If:obj:`None`, :obj:`LiteLLMConfig().as_dict()` will be used.
+            (default: :obj:`None`)
+        api_key (Optional[str], optional): The API key for authenticating with
+            the model service. (default: :obj:`None`)
+        url (Optional[str], optional): The url to the model service.
+            (default: :obj:`None`)
+        token_counter (Optional[BaseTokenCounter], optional): Token counter to
+            use for the model. If not provided, :obj:`LiteLLMTokenCounter` will
+            be used. (default: :obj:`None`)
+    """
 
     # NOTE: Currently stream mode is not supported.
 
+    @dependencies_required('litellm')
     def __init__(
         self,
-        model_type: str,
-        model_config_dict: Dict[str, Any],
+        model_type: Union[ModelType, str],
+        model_config_dict: Optional[Dict[str, Any]] = None,
         api_key: Optional[str] = None,
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
     ) -> None:
-        r"""Constructor for LiteLLM backend.
+        from litellm import completion
 
-        Args:
-            model_type (str): Model for which a backend is created,
-                such as GPT-3.5-turbo, Claude-2, etc.
-            model_config_dict (Dict[str, Any]): A dictionary of parameters for
-                the model configuration.
-            api_key (Optional[str]): The API key for authenticating with the
-                model service. (default: :obj:`None`)
-            url (Optional[str]): The url to the model service. (default:
-                :obj:`None`)
-            token_counter (Optional[BaseTokenCounter]): Token counter to use
-                for the model. If not provided, `LiteLLMTokenCounter` will
-                be used.
-        """
-        self.model_type = model_type
-        self.model_config_dict = model_config_dict
-        self._client = None
-        self._token_counter = token_counter
-        self.check_model_config()
-        self._url = url
-        self._api_key = api_key
+        if model_config_dict is None:
+            model_config_dict = LiteLLMConfig().as_dict()
+
+        super().__init__(
+            model_type, model_config_dict, api_key, url, token_counter
+        )
+        self.client = completion
 
     def _convert_response_from_litellm_to_openai(
         self, response
@@ -86,26 +95,16 @@ class LiteLLMModel:
         )
 
     @property
-    def client(self):
-        if self._client is None:
-            from litellm import completion
-
-            self._client = completion
-        return self._client
-
-    @property
-    def token_counter(self) -> LiteLLMTokenCounter:
+    def token_counter(self) -> BaseTokenCounter:
         r"""Initialize the token counter for the model backend.
 
         Returns:
-            LiteLLMTokenCounter: The token counter following the model's
+            BaseTokenCounter: The token counter following the model's
                 tokenization style.
         """
         if not self._token_counter:
-            self._token_counter = LiteLLMTokenCounter(  # type: ignore[assignment]
-                self.model_type
-            )
-        return self._token_counter  # type: ignore[return-value]
+            self._token_counter = LiteLLMTokenCounter(self.model_type)
+        return self._token_counter
 
     def run(
         self,
@@ -144,19 +143,3 @@ class LiteLLMModel:
                     f"Unexpected argument `{param}` is "
                     "input into LiteLLM model backend."
                 )
-
-    @property
-    def token_limit(self) -> int:
-        r"""Returns the maximum token limit for the given model.
-
-        Returns:
-            int: The maximum token limit for the given model.
-        """
-        max_tokens = self.model_config_dict.get("max_tokens")
-        if isinstance(max_tokens, int):
-            return max_tokens
-        print(
-            "Must set `max_tokens` as an integer in `model_config_dict` when"
-            " setting up the model. Using 4096 as default value."
-        )
-        return 4096

camel/models/mistral_model.py

@@ -12,7 +12,7 @@
 # limitations under the License.
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 import os
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
 
 if TYPE_CHECKING:
     from mistralai.models import (
@@ -20,7 +20,7 @@ if TYPE_CHECKING:
         Messages,
     )
 
-from camel.configs import MISTRAL_API_PARAMS
+from camel.configs import MISTRAL_API_PARAMS, MistralConfig
 from camel.messages import OpenAIMessage
 from camel.models import BaseModelBackend
 from camel.types import ChatCompletion, ModelType
@@ -28,11 +28,10 @@ from camel.utils import (
     BaseTokenCounter,
     OpenAITokenCounter,
     api_keys_required,
+    dependencies_required,
 )
 
 try:
-    import os
-
     if os.getenv("AGENTOPS_API_KEY") is not None:
         from agentops import LLMEvent, record
     else:
@@ -42,40 +41,44 @@ except (ImportError, AttributeError):
 
 
 class MistralModel(BaseModelBackend):
-    r"""Mistral API in a unified BaseModelBackend interface."""
-
+    r"""Mistral API in a unified BaseModelBackend interface.
+
+    Args:
+        model_type (Union[ModelType, str]): Model for which a backend is
+            created, one of MISTRAL_* series.
+        model_config_dict (Optional[Dict[str, Any]], optional): A dictionary
+            that will be fed into:obj:`Mistral.chat.complete()`.
+            If:obj:`None`, :obj:`MistralConfig().as_dict()` will be used.
+            (default: :obj:`None`)
+        api_key (Optional[str], optional): The API key for authenticating with
+            the mistral service. (default: :obj:`None`)
+        url (Optional[str], optional): The url to the mistral service.
+            (default: :obj:`None`)
+        token_counter (Optional[BaseTokenCounter], optional): Token counter to
+            use for the model. If not provided, :obj:`OpenAITokenCounter` will
+            be used. (default: :obj:`None`)
+    """
+
+    @dependencies_required('mistralai')
     def __init__(
         self,
-        model_type: ModelType,
-        model_config_dict: Dict[str, Any],
+        model_type: Union[ModelType, str],
+        model_config_dict: Optional[Dict[str, Any]] = None,
         api_key: Optional[str] = None,
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
     ) -> None:
-        r"""Constructor for Mistral backend.
+        from mistralai import Mistral
 
-        Args:
-            model_type (ModelType): Model for which a backend is created,
-                one of MISTRAL_* series.
-            model_config_dict (Dict[str, Any]): A dictionary that will
-                be fed into `MistralClient.chat`.
-            api_key (Optional[str]): The API key for authenticating with the
-                mistral service. (default: :obj:`None`)
-            url (Optional[str]): The url to the mistral service.
-            token_counter (Optional[BaseTokenCounter]): Token counter to use
-                for the model. If not provided, `OpenAITokenCounter` will be
-                used.
-        """
+        if model_config_dict is None:
+            model_config_dict = MistralConfig().as_dict()
+
+        api_key = api_key or os.environ.get("MISTRAL_API_KEY")
+        url = url or os.environ.get("MISTRAL_API_BASE_URL")
         super().__init__(
             model_type, model_config_dict, api_key, url, token_counter
         )
-        self._api_key = api_key or os.environ.get("MISTRAL_API_KEY")
-        self._url = url or os.environ.get("MISTRAL_SERVER_URL")
-
-        from mistralai import Mistral
-
         self._client = Mistral(api_key=self._api_key, server_url=self._url)
-        self._token_counter: Optional[BaseTokenCounter] = None
 
     def _to_openai_response(
         self, response: 'ChatCompletionResponse'
@@ -215,7 +218,7 @@ class MistralModel(BaseModelBackend):
 
         response = self._client.chat.complete(
             messages=mistral_messages,
-            model=self.model_type.value,
+            model=self.model_type,
             **self.model_config_dict,
         )
 
@@ -231,7 +234,7 @@ class MistralModel(BaseModelBackend):
                 prompt_tokens=openai_response.usage.prompt_tokens,  # type: ignore[union-attr]
                 completion=openai_response.choices[0].message.content,
                 completion_tokens=openai_response.usage.completion_tokens,  # type: ignore[union-attr]
-                model=self.model_type.value,
+                model=self.model_type,
             )
             record(llm_event)