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

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."
+        )

camel/models/ollama_model.py

@@ -17,54 +17,64 @@ from typing import Any, Dict, List, Optional, Union
 
 from openai import OpenAI, Stream
 
-from camel.configs import OLLAMA_API_PARAMS
+from camel.configs import OLLAMA_API_PARAMS, OllamaConfig
 from camel.messages import OpenAIMessage
-from camel.types import ChatCompletion, ChatCompletionChunk, ModelType
+from camel.models import BaseModelBackend
+from camel.types import (
+    ChatCompletion,
+    ChatCompletionChunk,
+    ModelType,
+)
 from camel.utils import BaseTokenCounter, OpenAITokenCounter
 
 
-class OllamaModel:
-    r"""Ollama service interface."""
+class OllamaModel(BaseModelBackend):
+    r"""Ollama service 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:`OllamaConfig().as_dict()` will be used.
+            (default: :obj:`None`)
+        api_key (Optional[str], optional): The API key for authenticating with
+            the model service.  Ollama doesn't need API key, it would be
+            ignored if set. (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(
+            ModelType.GPT_4O_MINI)` will be used.
+            (default: :obj:`None`)
+
+    References:
+        https://github.com/ollama/ollama/blob/main/docs/openai.md
+    """
 
     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 Ollama backend with OpenAI compatibility.
-
-        # Reference: https://github.com/ollama/ollama/blob/main/docs/openai.md
-
-        Args:
-            model_type (str): Model for which a backend is created.
-            model_config_dict (Dict[str, Any]): A dictionary that will
-                be fed into openai.ChatCompletion.create().
-            url (Optional[str]): The url to the model service. (default:
-                :obj:`"http://localhost:11434/v1"`)
-            token_counter (Optional[BaseTokenCounter]): Token counter to use
-                for the model. If not provided, `OpenAITokenCounter(ModelType.
-                GPT_4O_MINI)` will be used.
-        """
-        self.model_type = model_type
-        self.model_config_dict = model_config_dict
-        self._url = (
-            url
-            or os.environ.get("OLLAMA_BASE_URL")
-            or "http://localhost:11434/v1"
+        if model_config_dict is None:
+            model_config_dict = OllamaConfig().as_dict()
+        url = url or os.environ.get("OLLAMA_BASE_URL")
+        super().__init__(
+            model_type, model_config_dict, api_key, url, token_counter
         )
-        if not url and not os.environ.get("OLLAMA_BASE_URL"):
+        if not self._url:
             self._start_server()
         # Use OpenAI client as interface call Ollama
         self._client = OpenAI(
             timeout=60,
             max_retries=3,
+            api_key="Set-but-ignored",  # required but ignored
             base_url=self._url,
-            api_key="ollama",  # required but ignored
         )
-        self._token_counter = token_counter
-        self.check_model_config()
 
     def _start_server(self) -> None:
         r"""Starts the Ollama server in a subprocess."""
@@ -74,8 +84,9 @@ class OllamaModel:
                 stdout=subprocess.PIPE,
                 stderr=subprocess.PIPE,
             )
+            self._url = "http://localhost:11434/v1"
             print(
-                f"Ollama server started on http://localhost:11434/v1 "
+                f"Ollama server started on {self._url} "
                 f"for {self.model_type} model."
             )
         except Exception as e:
@@ -131,22 +142,6 @@ class OllamaModel:
         )
         return response
 
-    @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
-
     @property
     def stream(self) -> bool:
         r"""Returns whether the model is in stream mode, which sends partial

camel/models/{openai_compatibility_model.py → openai_compatible_model.py}

@@ -18,59 +18,54 @@ from typing import Any, Dict, List, Optional, Union
 from openai import OpenAI, Stream
 
 from camel.messages import OpenAIMessage
-from camel.types import ChatCompletion, ChatCompletionChunk, ModelType
+from camel.models import BaseModelBackend
+from camel.types import (
+    ChatCompletion,
+    ChatCompletionChunk,
+    ModelType,
+)
 from camel.utils import (
     BaseTokenCounter,
     OpenAITokenCounter,
 )
 
 
-class OpenAICompatibilityModel:
-    r"""LLM API served by OpenAI-compatible providers."""
+class OpenAICompatibleModel(BaseModelBackend):
+    r"""Constructor for model backend supporting OpenAI compatibility.
+
+    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:`{}` will be used. (default: :obj:`None`)
+        api_key (str): The API key for authenticating with the model service.
+        url (str): The url to the model service.
+        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: 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 model backend.
-
-        Args:
-            model_type (str): Model for which a backend is created.
-            model_config_dict (Dict[str, Any]): A dictionary that will
-                be fed into openai.ChatCompletion.create().
-            api_key (str): The API key for authenticating with the
-                model service. (default: :obj:`None`)
-            url (str): The url to the model service. (default:
-                :obj:`None`)
-            token_counter (Optional[BaseTokenCounter]): Token counter to use
-                for the model. If not provided, `OpenAITokenCounter(ModelType.
-                GPT_4O_MINI)` will be used.
-        """
-        self.model_type = model_type
-        self.model_config_dict = model_config_dict
-        self._url = url or os.environ.get("OPENAI_COMPATIBILIY_API_BASE_URL")
-        self._api_key = api_key or os.environ.get(
-            "OPENAI_COMPATIBILIY_API_KEY"
+        self.api_key = api_key or os.environ.get("OPENAI_COMPATIBILIY_API_KEY")
+        self.url = url or os.environ.get("OPENAI_COMPATIBILIY_API_BASE_URL")
+        super().__init__(
+            model_type, model_config_dict, api_key, url, token_counter
         )
-        if self._url is None:
-            raise ValueError(
-                "For OpenAI-compatible models, you must provide the `url`."
-            )
-        if self._api_key is None:
-            raise ValueError(
-                "For OpenAI-compatible models, you must provide the `api_key`."
-            )
         self._client = OpenAI(
             timeout=60,
             max_retries=3,
-            base_url=self._url,
             api_key=self._api_key,
+            base_url=self._url,
         )
-        self._token_counter = token_counter
 
     def run(
         self,
@@ -117,18 +112,5 @@ class OpenAICompatibilityModel:
         """
         return self.model_config_dict.get('stream', False)
 
-    @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
+    def check_model_config(self):
+        pass

camel/models/openai_model.py

@@ -12,14 +12,19 @@
 # limitations under the License.
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 import os
+import warnings
 from typing import Any, Dict, List, Optional, Union
 
 from openai import OpenAI, Stream
 
-from camel.configs import OPENAI_API_PARAMS
+from camel.configs import OPENAI_API_PARAMS, ChatGPTConfig
 from camel.messages import OpenAIMessage
 from camel.models import BaseModelBackend
-from camel.types import ChatCompletion, ChatCompletionChunk, ModelType
+from camel.types import (
+    ChatCompletion,
+    ChatCompletionChunk,
+    ModelType,
+)
 from camel.utils import (
     BaseTokenCounter,
     OpenAITokenCounter,
@@ -28,36 +33,39 @@ from camel.utils import (
 
 
 class OpenAIModel(BaseModelBackend):
-    r"""OpenAI API in a unified BaseModelBackend interface."""
+    r"""OpenAI API in a unified BaseModelBackend interface.
+
+    Args:
+        model_type (Union[ModelType, str]): Model for which a backend is
+            created, one of GPT_* series.
+        model_config_dict (Optional[Dict[str, Any]], optional): A dictionary
+            that will be fed into:obj:`openai.ChatCompletion.create()`. If
+            :obj:`None`, :obj:`ChatGPTConfig().as_dict()` will be used.
+            (default: :obj:`None`)
+        api_key (Optional[str], optional): The API key for authenticating
+            with the OpenAI service. (default: :obj:`None`)
+        url (Optional[str], optional): The url to the OpenAI 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 OpenAI backend.
-
-        Args:
-            model_type (ModelType): Model for which a backend is created,
-                one of GPT_* series.
-            model_config_dict (Dict[str, Any]): A dictionary that will
-                be fed into openai.ChatCompletion.create().
-            api_key (Optional[str]): The API key for authenticating with the
-                OpenAI service. (default: :obj:`None`)
-            url (Optional[str]): The url to the OpenAI service. (default:
-                :obj:`None`)
-            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 = ChatGPTConfig().as_dict()
+        api_key = api_key or os.environ.get("OPENAI_API_KEY")
+        url = url or os.environ.get("OPENAI_API_BASE_URL")
         super().__init__(
             model_type, model_config_dict, api_key, url, token_counter
         )
-        self._url = url or os.environ.get("OPENAI_API_BASE_URL")
-        self._api_key = api_key or os.environ.get("OPENAI_API_KEY")
         self._client = OpenAI(
             timeout=60,
             max_retries=3,
@@ -96,13 +104,23 @@ class OpenAIModel(BaseModelBackend):
         # o1-preview and o1-mini have Beta limitations
         # reference: https://platform.openai.com/docs/guides/reasoning
         if self.model_type in [ModelType.O1_MINI, ModelType.O1_PREVIEW]:
+            warnings.warn(
+                "Warning: You are using an O1 model (O1_MINI or O1_PREVIEW), "
+                "which has certain limitations, reference: "
+                "`https://platform.openai.com/docs/guides/reasoning`.",
+                UserWarning,
+            )
+
             # Remove system message that is not supported in o1 model.
             messages = [msg for msg in messages if msg.get("role") != "system"]
 
-            # Remove unsupported parameters and reset the fixed parameters
-            del self.model_config_dict["stream"]
-            del self.model_config_dict["tools"]
-            del self.model_config_dict["tool_choice"]
+            # Check and remove unsupported parameters and reset the fixed
+            # parameters
+            unsupported_keys = ["stream", "tools", "tool_choice"]
+            for key in unsupported_keys:
+                if key in self.model_config_dict:
+                    del self.model_config_dict[key]
+
             self.model_config_dict["temperature"] = 1.0
             self.model_config_dict["top_p"] = 1.0
             self.model_config_dict["n"] = 1.0
@@ -111,7 +129,7 @@ class OpenAIModel(BaseModelBackend):
 
         response = self._client.chat.completions.create(
             messages=messages,
-            model=self.model_type.value,
+            model=self.model_type,
             **self.model_config_dict,
         )
         return response
@@ -133,8 +151,9 @@ class OpenAIModel(BaseModelBackend):
 
     @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.
         """