camel-ai 0.2.3__py3-none-any.whl → 0.2.3a0__py3-none-any.whl

camel/models/base_model.py

@@ -17,49 +17,41 @@ from typing import Any, Dict, List, Optional, Union
 from openai import Stream
 
 from camel.messages import OpenAIMessage
-from camel.types import (
-    ChatCompletion,
-    ChatCompletionChunk,
-    ModelType,
-    UnifiedModelType,
-)
+from camel.types import ChatCompletion, ChatCompletionChunk, ModelType
 from camel.utils import BaseTokenCounter
 
 
 class BaseModelBackend(ABC):
     r"""Base class for different model backends.
-    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`)
+    May be OpenAI API, a local LLM, a stub for unit tests, etc.
     """
 
     def __init__(
         self,
-        model_type: Union[ModelType, str],
-        model_config_dict: Optional[Dict[str, Any]] = None,
+        model_type: ModelType,
+        model_config_dict: Dict[str, Any],
         api_key: Optional[str] = None,
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
     ) -> None:
-        self.model_type: UnifiedModelType = UnifiedModelType(model_type)
-        if model_config_dict is None:
-            model_config_dict = {}
+        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_config_dict = model_config_dict
         self._api_key = api_key
         self._url = url
-        self._token_counter = token_counter
         self.check_model_config()
+        self._token_counter = token_counter
 
     @property
     @abstractmethod
@@ -118,9 +110,6 @@ 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.
         """
@@ -131,8 +120,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,10 +11,9 @@
 # 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, Any, Dict, List, Optional, Union
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
 
-from camel.configs import Gemini_API_PARAMS, GeminiConfig
+from camel.configs import Gemini_API_PARAMS
 from camel.messages import OpenAIMessage
 from camel.models import BaseModelBackend
 from camel.types import (
@@ -27,7 +26,6 @@ from camel.utils import (
     BaseTokenCounter,
     GeminiTokenCounter,
     api_keys_required,
-    dependencies_required,
 )
 
 if TYPE_CHECKING:
@@ -35,49 +33,43 @@ if TYPE_CHECKING:
 
 
 class GeminiModel(BaseModelBackend):
-    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')
+    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.
+
     def __init__(
         self,
-        model_type: Union[ModelType, str],
-        model_config_dict: Optional[Dict[str, Any]] = None,
+        model_type: ModelType,
+        model_config_dict: Dict[str, Any],
         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)
+        self._client = genai.GenerativeModel(self.model_type.value)
 
         keys = list(self.model_config_dict.keys())
         generation_config_dict = {
@@ -151,8 +143,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.
@@ -197,7 +189,7 @@ class GeminiModel(BaseModelBackend):
             id=f"chatcmpl-{uuid.uuid4().hex!s}",
             object="chat.completion",
             created=int(time.time()),
-            model=self.model_type,
+            model=self.model_type.value,
             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, GroqConfig
+from camel.configs import GROQ_API_PARAMS
 from camel.messages import OpenAIMessage
 from camel.models import BaseModelBackend
 from camel.types import (
@@ -32,48 +32,42 @@ from camel.utils import (
 
 
 class GroqModel(BaseModelBackend):
-    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`)
-    """
+    r"""LLM API served by Groq in a unified BaseModelBackend interface."""
 
     def __init__(
         self,
-        model_type: Union[ModelType, str],
-        model_config_dict: Optional[Dict[str, Any]] = None,
+        model_type: ModelType,
+        model_config_dict: Dict[str, Any],
         api_key: Optional[str] = None,
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
     ) -> None:
-        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"
-        )
+        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.
+        """
         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,
+            base_url=self._url or "https://api.groq.com/openai/v1",
         )
+        self._token_counter = token_counter
 
     @property
     def token_counter(self) -> BaseTokenCounter:
@@ -107,7 +101,7 @@ class GroqModel(BaseModelBackend):
         """
         response = self._client.chat.completions.create(
             messages=messages,
-            model=self.model_type,
+            model=self.model_type.value,
             **self.model_config_dict,
         )
 

camel/models/litellm_model.py

@@ -11,58 +11,49 @@
 # 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, Union
+from typing import Any, Dict, List, Optional
 
-from camel.configs import LITELLM_API_PARAMS, LiteLLMConfig
+from camel.configs import LITELLM_API_PARAMS
 from camel.messages import OpenAIMessage
-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`)
-    """
+from camel.types import ChatCompletion
+from camel.utils import BaseTokenCounter, LiteLLMTokenCounter
+
+
+class LiteLLMModel:
+    r"""Constructor for LiteLLM backend with OpenAI compatibility."""
 
     # NOTE: Currently stream mode is not supported.
 
-    @dependencies_required('litellm')
     def __init__(
         self,
-        model_type: Union[ModelType, str],
-        model_config_dict: Optional[Dict[str, Any]] = None,
+        model_type: str,
+        model_config_dict: Dict[str, Any],
         api_key: Optional[str] = None,
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
     ) -> None:
-        from litellm import completion
+        r"""Constructor for LiteLLM backend.
 
-        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
+        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
 
     def _convert_response_from_litellm_to_openai(
         self, response
@@ -95,16 +86,26 @@ class LiteLLMModel(BaseModelBackend):
         )
 
     @property
-    def token_counter(self) -> BaseTokenCounter:
+    def client(self):
+        if self._client is None:
+            from litellm import completion
+
+            self._client = completion
+        return self._client
+
+    @property
+    def token_counter(self) -> LiteLLMTokenCounter:
         r"""Initialize the token counter for the model backend.
 
         Returns:
-            BaseTokenCounter: The token counter following the model's
+            LiteLLMTokenCounter: The token counter following the model's
                 tokenization style.
         """
         if not self._token_counter:
-            self._token_counter = LiteLLMTokenCounter(self.model_type)
-        return self._token_counter
+            self._token_counter = LiteLLMTokenCounter(  # type: ignore[assignment]
+                self.model_type
+            )
+        return self._token_counter  # type: ignore[return-value]
 
     def run(
         self,
@@ -143,3 +144,19 @@ class LiteLLMModel(BaseModelBackend):
                     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, Union
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
 
 if TYPE_CHECKING:
     from mistralai.models import (
@@ -20,7 +20,7 @@ if TYPE_CHECKING:
         Messages,
     )
 
-from camel.configs import MISTRAL_API_PARAMS, MistralConfig
+from camel.configs import MISTRAL_API_PARAMS
 from camel.messages import OpenAIMessage
 from camel.models import BaseModelBackend
 from camel.types import ChatCompletion, ModelType
@@ -28,10 +28,11 @@ 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:
@@ -41,44 +42,40 @@ except (ImportError, AttributeError):
 
 
 class MistralModel(BaseModelBackend):
-    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')
+    r"""Mistral API in a unified BaseModelBackend interface."""
+
     def __init__(
         self,
-        model_type: Union[ModelType, str],
-        model_config_dict: Optional[Dict[str, Any]] = None,
+        model_type: ModelType,
+        model_config_dict: Dict[str, Any],
         api_key: Optional[str] = None,
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
     ) -> None:
-        from mistralai import Mistral
+        r"""Constructor for Mistral backend.
 
-        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")
+        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.
+        """
         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'
@@ -218,7 +215,7 @@ class MistralModel(BaseModelBackend):
 
         response = self._client.chat.complete(
             messages=mistral_messages,
-            model=self.model_type,
+            model=self.model_type.value,
             **self.model_config_dict,
         )
 
@@ -234,7 +231,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,
+                model=self.model_type.value,
             )
             record(llm_event)