camel-ai 0.2.3__py3-none-any.whl → 0.2.3a0__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 Dict, Optional, Type, Union
+from typing import Any, Dict, Optional, Union
 
 from camel.models.anthropic_model import AnthropicModel
 from camel.models.azure_openai_model import AzureOpenAIModel
@@ -21,7 +21,8 @@ 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.openai_compatible_model import OpenAICompatibleModel
+from camel.models.open_source_model import OpenSourceModel
+from camel.models.openai_compatibility_model import OpenAICompatibilityModel
 from camel.models.openai_model import OpenAIModel
 from camel.models.reka_model import RekaModel
 from camel.models.samba_model import SambaModel
@@ -29,7 +30,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, UnifiedModelType
+from camel.types import ModelPlatformType, ModelType
 from camel.utils import BaseTokenCounter
 
 
@@ -44,7 +45,7 @@ class ModelFactory:
     def create(
         model_platform: ModelPlatformType,
         model_type: Union[ModelType, str],
-        model_config_dict: Optional[Dict] = None,
+        model_config_dict: Dict,
         token_counter: Optional[BaseTokenCounter] = None,
         api_key: Optional[str] = None,
         url: Optional[str] = None,
@@ -54,71 +55,80 @@ 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 (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`)
+            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.
 
         Returns:
             BaseModelBackend: The initialized backend.
-
-        Raises:
-            ValueError: If there is no backend for the model.
         """
-        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}`."
-            )
-
+        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.")
         return model_class(
-            model_type=model_type,
-            model_config_dict=model_config_dict,
-            api_key=api_key,
-            url=url,
-            token_counter=token_counter,
+            model_type, model_config_dict, api_key, url, token_counter
         )

camel/models/nemotron_model.py

@@ -12,12 +12,11 @@
 # limitations under the License.
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 import os
-from typing import List, Optional, Union
+from typing import List, Optional
 
 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,
@@ -25,38 +24,40 @@ from camel.utils import (
 )
 
 
-class NemotronModel(BaseModelBackend):
-    r"""Nemotron model API backend with OpenAI compatibility.
+class NemotronModel:
+    r"""Nemotron model API backend with OpenAI compatibility."""
 
-    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.
-    """
+    # NOTE: Nemotron model doesn't support additional model config like OpenAI.
 
     def __init__(
         self,
-        model_type: Union[ModelType, str],
+        model_type: ModelType,
         api_key: Optional[str] = None,
         url: Optional[str] = None,
     ) -> None:
-        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)
+        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."
+            )
         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(
@@ -73,17 +74,6 @@ class NemotronModel(BaseModelBackend):
         """
         response = self._client.chat.completions.create(
             messages=messages,
-            model=self.model_type,
+            model=self.model_type.value,
         )
         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,64 +17,54 @@ from typing import Any, Dict, List, Optional, Union
 
 from openai import OpenAI, Stream
 
-from camel.configs import OLLAMA_API_PARAMS, OllamaConfig
+from camel.configs import OLLAMA_API_PARAMS
 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
 
 
-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
-    """
+class OllamaModel:
+    r"""Ollama service interface."""
 
     def __init__(
         self,
-        model_type: Union[ModelType, str],
-        model_config_dict: Optional[Dict[str, Any]] = None,
-        api_key: Optional[str] = None,
+        model_type: str,
+        model_config_dict: Dict[str, Any],
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
     ) -> None:
-        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
+        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 not self._url:
+        if not url and not os.environ.get("OLLAMA_BASE_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."""
@@ -84,9 +74,8 @@ class OllamaModel(BaseModelBackend):
                 stdout=subprocess.PIPE,
                 stderr=subprocess.PIPE,
             )
-            self._url = "http://localhost:11434/v1"
             print(
-                f"Ollama server started on {self._url} "
+                f"Ollama server started on http://localhost:11434/v1 "
                 f"for {self.model_type} model."
             )
         except Exception as e:
@@ -142,6 +131,22 @@ class OllamaModel(BaseModelBackend):
         )
         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/open_source_model.py

@@ -0,0 +1,170 @@
+# =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
+# Licensed under the Apache License, Version 2.0 (the “License”);
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an “AS IS” BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
+from typing import Any, Dict, List, Optional, Union
+
+from openai import OpenAI, Stream
+
+from camel.configs import OPENAI_API_PARAMS
+from camel.messages import OpenAIMessage
+from camel.models import BaseModelBackend
+from camel.types import ChatCompletion, ChatCompletionChunk, ModelType
+from camel.utils import (
+    BaseTokenCounter,
+    OpenSourceTokenCounter,
+)
+
+
+class OpenSourceModel(BaseModelBackend):
+    r"""Class for interace with OpenAI-API-compatible servers running
+    open-source models.
+    """
+
+    def __init__(
+        self,
+        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 model backends of Open-source models.
+
+        Args:
+            model_type (ModelType): Model for which a backend is created.
+            model_config_dict (Dict[str, Any]): A dictionary that will
+                be fed into :obj:`openai.ChatCompletion.create()`.
+            api_key (Optional[str]): The API key for authenticating with the
+                model service. (ignored for open-source models)
+            url (Optional[str]): The url to the model service.
+            token_counter (Optional[BaseTokenCounter]): Token counter to use
+                for the model. If not provided, `OpenSourceTokenCounter` will
+                be used.
+        """
+        super().__init__(
+            model_type, model_config_dict, api_key, url, token_counter
+        )
+
+        # Check whether the input model type is open-source
+        if not model_type.is_open_source:
+            raise ValueError(
+                f"Model `{model_type}` is not a supported open-source model."
+            )
+
+        # Check whether input model path is empty
+        model_path: Optional[str] = self.model_config_dict.get(
+            "model_path", None
+        )
+        if not model_path:
+            raise ValueError("Path to open-source model is not provided.")
+        self.model_path: str = model_path
+
+        # Check whether the model name matches the model type
+        self.model_name: str = self.model_path.split('/')[-1]
+        if not self.model_type.validate_model_name(self.model_name):
+            raise ValueError(
+                f"Model name `{self.model_name}` does not match model type "
+                f"`{self.model_type.value}`."
+            )
+
+        # Load the server URL and check whether it is None
+        server_url: Optional[str] = url or self.model_config_dict.get(
+            "server_url", None
+        )
+        if not server_url:
+            raise ValueError(
+                "URL to server running open-source LLM is not provided."
+            )
+        self.server_url: str = server_url
+        self._client = OpenAI(
+            base_url=self.server_url,
+            timeout=60,
+            max_retries=3,
+            api_key="fake_key",
+        )
+
+        # Replace `model_config_dict` with only the params to be
+        # passed to OpenAI API
+        self.model_config_dict = self.model_config_dict["api_params"]
+
+    @property
+    def token_counter(self) -> BaseTokenCounter:
+        r"""Initialize the token counter for the model backend.
+
+        Returns:
+            BaseTokenCounter: The token counter following the model's
+                tokenization style.
+        """
+        if not self._token_counter:
+            self._token_counter = OpenSourceTokenCounter(
+                self.model_type, self.model_path
+            )
+        return self._token_counter
+
+    def run(
+        self,
+        messages: List[OpenAIMessage],
+    ) -> Union[ChatCompletion, Stream[ChatCompletionChunk]]:
+        r"""Runs inference of OpenAI-API-style chat completion.
+
+        Args:
+            messages (List[OpenAIMessage]): Message list with the chat history
+                in OpenAI API format.
+
+        Returns:
+            Union[ChatCompletion, Stream[ChatCompletionChunk]]:
+                `ChatCompletion` in the non-stream mode, or
+                `Stream[ChatCompletionChunk]` in the stream mode.
+        """
+        messages_openai: List[OpenAIMessage] = messages
+        response = self._client.chat.completions.create(
+            messages=messages_openai,
+            model=self.model_name,
+            **self.model_config_dict,
+        )
+        return response
+
+    def check_model_config(self):
+        r"""Check whether the model configuration is valid for open-source
+        model backends.
+
+        Raises:
+            ValueError: If the model configuration dictionary contains any
+                unexpected arguments to OpenAI API, or it does not contain
+                :obj:`model_path` or :obj:`server_url`.
+        """
+        if (
+            "model_path" not in self.model_config_dict
+            or "server_url" not in self.model_config_dict
+        ):
+            raise ValueError(
+                "Invalid configuration for open-source model backend with "
+                ":obj:`model_path` or :obj:`server_url` missing."
+            )
+
+        for param in self.model_config_dict["api_params"]:
+            if param not in OPENAI_API_PARAMS:
+                raise ValueError(
+                    f"Unexpected argument `{param}` is "
+                    "input into open-source model backend."
+                )
+
+    @property
+    def stream(self) -> bool:
+        r"""Returns whether the model is in stream mode,
+            which sends partial results each time.
+
+        Returns:
+            bool: Whether the model is in stream mode.
+        """
+        return self.model_config_dict.get('stream', False)