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

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'
@@ -93,7 +96,7 @@ class MistralModel(BaseModelBackend):
                         "name": tool_call.function.name,  # type: ignore[union-attr]
                         "arguments": tool_call.function.arguments,  # type: ignore[union-attr]
                     },
-                    type=tool_call.TYPE,  # type: ignore[union-attr]
+                    type=tool_call.type,  # type: ignore[union-attr]
                 )
                 for tool_call in response.choices[0].message.tool_calls
             ]
@@ -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)
 

camel/models/model_factory.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, Dict, Optional, Union
+from typing import Dict, Optional, Type, Union
 
 from camel.models.anthropic_model import AnthropicModel
 from camel.models.azure_openai_model import AzureOpenAIModel
@@ -21,8 +21,7 @@ from camel.models.groq_model import GroqModel
 from camel.models.litellm_model import LiteLLMModel
 from camel.models.mistral_model import MistralModel
 from camel.models.ollama_model import OllamaModel
-from camel.models.open_source_model import OpenSourceModel
-from camel.models.openai_compatibility_model import OpenAICompatibilityModel
+from camel.models.openai_compatible_model import OpenAICompatibleModel
 from camel.models.openai_model import OpenAIModel
 from camel.models.reka_model import RekaModel
 from camel.models.samba_model import SambaModel
@@ -30,7 +29,7 @@ from camel.models.stub_model import StubModel
 from camel.models.togetherai_model import TogetherAIModel
 from camel.models.vllm_model import VLLMModel
 from camel.models.zhipuai_model import ZhipuAIModel
-from camel.types import ModelPlatformType, ModelType
+from camel.types import ModelPlatformType, ModelType, UnifiedModelType
 from camel.utils import BaseTokenCounter
 
 
@@ -45,7 +44,7 @@ class ModelFactory:
     def create(
         model_platform: ModelPlatformType,
         model_type: Union[ModelType, str],
-        model_config_dict: Dict,
+        model_config_dict: Optional[Dict] = None,
         token_counter: Optional[BaseTokenCounter] = None,
         api_key: Optional[str] = None,
         url: Optional[str] = None,
@@ -55,80 +54,71 @@ class ModelFactory:
         Args:
             model_platform (ModelPlatformType): Platform from which the model
                 originates.
-            model_type (Union[ModelType, str]): Model for which a backend is
-                created can be a `str` for open source platforms.
-            model_config_dict (Dict): A dictionary that will be fed into
-                the backend constructor.
-            token_counter (Optional[BaseTokenCounter]): Token counter to use
-                for the model. If not provided, OpenAITokenCounter(ModelType.
-                GPT_3_5_TURBO) will be used if the model platform didn't
-                provide official token counter.
-            api_key (Optional[str]): The API key for authenticating with the
-                model service.
-            url (Optional[str]): The url to the model service.
-
-        Raises:
-            ValueError: If there is not backend for the model.
+            model_type (Union[ModelType, str]): Model for which a
+                backend is created. Can be a `str` for open source platforms.
+            model_config_dict (Optional[Dict]): A dictionary that will be fed
+                into the backend constructor. (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 if the model platform didn't provide official
+                token counter. (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`)
 
         Returns:
             BaseModelBackend: The initialized backend.
+
+        Raises:
+            ValueError: If there is no backend for the model.
         """
-        model_class: Any
-        if isinstance(model_type, ModelType):
-            if model_platform.is_open_source and model_type.is_open_source:
-                model_class = OpenSourceModel
-                return model_class(
-                    model_type, model_config_dict, url, token_counter
-                )
-            if model_platform.is_openai and model_type.is_openai:
-                model_class = OpenAIModel
-            elif model_platform.is_azure and model_type.is_azure_openai:
-                model_class = AzureOpenAIModel
-            elif model_platform.is_anthropic and model_type.is_anthropic:
-                model_class = AnthropicModel
-            elif model_type.is_groq:
-                model_class = GroqModel
-            elif model_platform.is_zhipuai and model_type.is_zhipuai:
-                model_class = ZhipuAIModel
-            elif model_platform.is_gemini and model_type.is_gemini:
-                model_class = GeminiModel
-            elif model_platform.is_mistral and model_type.is_mistral:
-                model_class = MistralModel
-            elif model_platform.is_reka and model_type.is_reka:
-                model_class = RekaModel
-            elif model_type == ModelType.STUB:
-                model_class = StubModel
-            else:
-                raise ValueError(
-                    f"Unknown pair of model platform `{model_platform}` "
-                    f"and model type `{model_type}`."
-                )
-        elif isinstance(model_type, str):
-            if model_platform.is_ollama:
-                model_class = OllamaModel
-                return model_class(
-                    model_type, model_config_dict, url, token_counter
-                )
-            elif model_platform.is_vllm:
-                model_class = VLLMModel
-            elif model_platform.is_litellm:
-                model_class = LiteLLMModel
-            elif model_platform.is_openai_compatibility_model:
-                model_class = OpenAICompatibilityModel
-            elif model_platform.is_samba:
-                model_class = SambaModel
-            elif model_platform.is_together:
-                model_class = TogetherAIModel
-                return model_class(
-                    model_type, model_config_dict, api_key, token_counter
-                )
-            else:
-                raise ValueError(
-                    f"Unknown pair of model platform `{model_platform}` "
-                    f"and model type `{model_type}`."
-                )
-        else:
-            raise ValueError(f"Invalid model type `{model_type}` provided.")
+        model_class: Optional[Type[BaseModelBackend]] = None
+        model_type = UnifiedModelType(model_type)
+
+        if model_platform.is_ollama:
+            model_class = OllamaModel
+        elif model_platform.is_vllm:
+            model_class = VLLMModel
+        elif model_platform.is_openai_compatible_model:
+            model_class = OpenAICompatibleModel
+        elif model_platform.is_samba:
+            model_class = SambaModel
+        elif model_platform.is_together:
+            model_class = TogetherAIModel
+        elif model_platform.is_litellm:
+            model_class = LiteLLMModel
+
+        elif model_platform.is_openai and model_type.is_openai:
+            model_class = OpenAIModel
+        elif model_platform.is_azure and model_type.is_azure_openai:
+            model_class = AzureOpenAIModel
+        elif model_platform.is_anthropic and model_type.is_anthropic:
+            model_class = AnthropicModel
+        elif model_platform.is_groq and model_type.is_groq:
+            model_class = GroqModel
+        elif model_platform.is_zhipuai and model_type.is_zhipuai:
+            model_class = ZhipuAIModel
+        elif model_platform.is_gemini and model_type.is_gemini:
+            model_class = GeminiModel
+        elif model_platform.is_mistral and model_type.is_mistral:
+            model_class = MistralModel
+        elif model_platform.is_reka and model_type.is_reka:
+            model_class = RekaModel
+        elif model_type == ModelType.STUB:
+            model_class = StubModel
+
+        if model_class is None:
+            raise ValueError(
+                f"Unknown pair of model platform `{model_platform}` "
+                f"and model type `{model_type}`."
+            )
+
         return model_class(
-            model_type, model_config_dict, api_key, url, token_counter
+            model_type=model_type,
+            model_config_dict=model_config_dict,
+            api_key=api_key,
+            url=url,
+            token_counter=token_counter,
         )

camel/models/nemotron_model.py

@@ -12,11 +12,12 @@
 # limitations under the License.
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 import os
-from typing import List, Optional
+from typing import List, Optional, Union
 
 from openai import OpenAI
 
 from camel.messages import OpenAIMessage
+from camel.models import BaseModelBackend
 from camel.types import ChatCompletion, ModelType
 from camel.utils import (
     BaseTokenCounter,
@@ -24,40 +25,38 @@ from camel.utils import (
 )
 
 
-class NemotronModel:
-    r"""Nemotron model API backend with OpenAI compatibility."""
+class NemotronModel(BaseModelBackend):
+    r"""Nemotron model API backend with OpenAI compatibility.
 
-    # NOTE: Nemotron model doesn't support additional model config like OpenAI.
+    Args:
+        model_type (Union[ModelType, str]): Model for which a backend is
+            created.
+        api_key (Optional[str], optional): The API key for authenticating with
+            the Nvidia service. (default: :obj:`None`)
+        url (Optional[str], optional): The url to the Nvidia service.
+            (default: :obj:`https://integrate.api.nvidia.com/v1`)
+
+    Notes:
+        Nemotron model doesn't support additional model config like OpenAI.
+    """
 
     def __init__(
         self,
-        model_type: ModelType,
+        model_type: Union[ModelType, str],
         api_key: Optional[str] = None,
         url: Optional[str] = None,
     ) -> None:
-        r"""Constructor for Nvidia backend.
-
-        Args:
-            model_type (ModelType): Model for which a backend is created.
-            api_key (Optional[str]): The API key for authenticating with the
-                Nvidia service. (default: :obj:`None`)
-            url (Optional[str]): The url to the Nvidia service. (default:
-                :obj:`None`)
-        """
-        self.model_type = model_type
-        self._url = url or os.environ.get("NVIDIA_API_BASE_URL")
-        self._api_key = api_key or os.environ.get("NVIDIA_API_KEY")
-        if not self._url or not self._api_key:
-            raise ValueError(
-                "NVIDIA_API_BASE_URL and NVIDIA_API_KEY should be set."
-            )
+        url = url or os.environ.get(
+            "NVIDIA_API_BASE_URL", "https://integrate.api.nvidia.com/v1"
+        )
+        api_key = api_key or os.environ.get("NVIDIA_API_KEY")
+        super().__init__(model_type, {}, api_key, url)
         self._client = OpenAI(
             timeout=60,
             max_retries=3,
             base_url=self._url,
             api_key=self._api_key,
         )
-        self._token_counter: Optional[BaseTokenCounter] = None
 
     @api_keys_required("NVIDIA_API_KEY")
     def run(
@@ -74,6 +73,17 @@ class NemotronModel:
         """
         response = self._client.chat.completions.create(
             messages=messages,
-            model=self.model_type.value,
+            model=self.model_type,
         )
         return response
+
+    @property
+    def token_counter(self) -> BaseTokenCounter:
+        raise NotImplementedError(
+            "Nemotron model doesn't support token counter."
+        )
+
+    def check_model_config(self):
+        raise NotImplementedError(
+            "Nemotron model doesn't support model config."
+        )