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

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}

@@ -12,51 +12,59 @@
 # limitations under the License.
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 
+import os
 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"""Constructor for model backend supporting OpenAI compatibility."""
+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],
-        api_key: str,
-        url: str,
+        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._token_counter = token_counter
+        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
+        )
         self._client = OpenAI(
             timeout=60,
             max_retries=3,
-            api_key=api_key,
-            base_url=url,
+            api_key=self._api_key,
+            base_url=self._url,
         )
 
     def run(
@@ -104,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.
         """

camel/models/reka_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
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
 
-from camel.configs import REKA_API_PARAMS
+from camel.configs import REKA_API_PARAMS, RekaConfig
 from camel.messages import OpenAIMessage
 from camel.models import BaseModelBackend
 from camel.types import ChatCompletion, ModelType
@@ -22,6 +21,7 @@ from camel.utils import (
     BaseTokenCounter,
     OpenAITokenCounter,
     api_keys_required,
+    dependencies_required,
 )
 
 if TYPE_CHECKING:
@@ -39,40 +39,42 @@ except (ImportError, AttributeError):
 
 
 class RekaModel(BaseModelBackend):
-    r"""Reka API in a unified BaseModelBackend interface."""
-
+    r"""Reka API in a unified BaseModelBackend interface.
+
+    Args:
+        model_type (Union[ModelType, str]): Model for which a backend is
+            created, one of REKA_* series.
+        model_config_dict (Optional[Dict[str, Any]], optional): A dictionary
+            that will be fed into:obj:`Reka.chat.create()`. If :obj:`None`,
+            :obj:`RekaConfig().as_dict()` will be used. (default: :obj:`None`)
+        api_key (Optional[str], optional): The API key for authenticating with
+            the Reka service. (default: :obj:`None`)
+        url (Optional[str], optional): The url to the Reka 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('reka')
     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 Reka backend.
+        from reka.client import Reka
 
-        Args:
-            model_type (ModelType): Model for which a backend is created,
-                one of REKA_* series.
-            model_config_dict (Dict[str, Any]): A dictionary that will
-                be fed into `Reka.chat.create`.
-            api_key (Optional[str]): The API key for authenticating with the
-                Reka service. (default: :obj:`None`)
-            url (Optional[str]): The url to the Reka 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 = RekaConfig().as_dict()
+        api_key = api_key or os.environ.get("REKA_API_KEY")
+        url = url or os.environ.get("REKA_API_BASE_URL")
         super().__init__(
             model_type, model_config_dict, api_key, url, token_counter
         )
-        self._api_key = api_key or os.environ.get("REKA_API_KEY")
-        self._url = url or os.environ.get("REKA_SERVER_URL")
-
-        from reka.client import Reka
-
         self._client = Reka(api_key=self._api_key, base_url=self._url)
-        self._token_counter: Optional[BaseTokenCounter] = None
 
     def _convert_reka_to_openai_response(
         self, response: 'ChatResponse'
@@ -184,7 +186,7 @@ class RekaModel(BaseModelBackend):
 
         response = self._client.chat.create(
             messages=reka_messages,
-            model=self.model_type.value,
+            model=self.model_type,
             **self.model_config_dict,
         )
 
@@ -200,7 +202,7 @@ class RekaModel(BaseModelBackend):
                 prompt_tokens=openai_response.usage.input_tokens,  # type: ignore[union-attr]
                 completion=openai_response.choices[0].message.content,
                 completion_tokens=openai_response.usage.output_tokens,  # type: ignore[union-attr]
-                model=self.model_type.value,
+                model=self.model_type,
             )
             record(llm_event)