camel-ai 0.1.5.2__py3-none-any.whl → 0.1.5.4__py3-none-any.whl

camel/embeddings/openai_embedding.py

@@ -11,10 +11,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
+from __future__ import annotations
+
 import os
-from typing import Any, List, Optional
+from typing import Any
 
-from openai import OpenAI
+from openai import NOT_GIVEN, NotGiven, OpenAI
 
 from camel.embeddings.base import BaseEmbedding
 from camel.types import EmbeddingModelType
@@ -25,10 +27,13 @@ class OpenAIEmbedding(BaseEmbedding[str]):
     r"""Provides text embedding functionalities using OpenAI's models.
 
     Args:
-        model (OpenAiEmbeddingModel, optional): The model type to be used for
-            generating embeddings. (default: :obj:`ModelType.ADA_2`)
-        api_key (Optional[str]): The API key for authenticating with the
+        model_type (EmbeddingModelType, optional): The model type to be
+            used for text embeddings.
+            (default: :obj:`TEXT_EMBEDDING_3_SMALL`)
+        api_key (str, optional): The API key for authenticating with the
             OpenAI service. (default: :obj:`None`)
+        dimensions (int, optional): The text embedding output dimensions.
+            (default: :obj:`NOT_GIVEN`)
 
     Raises:
         RuntimeError: If an unsupported model type is specified.
@@ -36,36 +41,44 @@ class OpenAIEmbedding(BaseEmbedding[str]):
 
     def __init__(
         self,
-        model_type: EmbeddingModelType = EmbeddingModelType.ADA_2,
-        api_key: Optional[str] = None,
+        model_type: EmbeddingModelType = (
+            EmbeddingModelType.TEXT_EMBEDDING_3_SMALL
+        ),
+        api_key: str | None = None,
+        dimensions: int | NotGiven = NOT_GIVEN,
     ) -> None:
         if not model_type.is_openai:
             raise ValueError("Invalid OpenAI embedding model type.")
         self.model_type = model_type
-        self.output_dim = model_type.output_dim
+        if dimensions == NOT_GIVEN:
+            self.output_dim = model_type.output_dim
+        else:
+            assert isinstance(dimensions, int)
+            self.output_dim = dimensions
         self._api_key = api_key or os.environ.get("OPENAI_API_KEY")
         self.client = OpenAI(timeout=60, max_retries=3, api_key=self._api_key)
 
     @model_api_key_required
     def embed_list(
         self,
-        objs: List[str],
+        objs: list[str],
         **kwargs: Any,
-    ) -> List[List[float]]:
+    ) -> list[list[float]]:
         r"""Generates embeddings for the given texts.
 
         Args:
-            objs (List[str]): The texts for which to generate the embeddings.
+            objs (list[str]): The texts for which to generate the embeddings.
             **kwargs (Any): Extra kwargs passed to the embedding API.
 
         Returns:
-            List[List[float]]: A list that represents the generated embedding
+            list[list[float]]: A list that represents the generated embedding
                 as a list of floating-point numbers.
         """
         # TODO: count tokens
         response = self.client.embeddings.create(
             input=objs,
             model=self.model_type.value,
+            dimensions=self.output_dim,
             **kwargs,
         )
         return [data.embedding for data in response.data]

camel/embeddings/sentence_transformers_embeddings.py

@@ -11,51 +11,63 @@
 # 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, List
+from __future__ import annotations
+
+from typing import Any
+
+from numpy import ndarray
 
 from camel.embeddings.base import BaseEmbedding
 
 
 class SentenceTransformerEncoder(BaseEmbedding[str]):
-    r"""This class provides functionalities to generate embeddings
-    using a specified model from `Sentence Transformers`.
+    r"""This class provides functionalities to generate text
+    embeddings using `Sentence Transformers`.
 
     References:
         https://www.sbert.net/
     """
 
-    def __init__(self, model_name: str = 'intfloat/e5-large-v2'):
+    def __init__(
+        self,
+        model_name: str = "intfloat/e5-large-v2",
+        **kwargs,
+    ):
         r"""Initializes the: obj: `SentenceTransformerEmbedding` class
         with the specified transformer model.
 
         Args:
             model_name (str, optional): The name of the model to use.
-                                        Defaults to `intfloat/e5-large-v2`.
+                (default: :obj:`intfloat/e5-large-v2`)
+            **kwargs (optional): Additional arguments of
+                :class:`SentenceTransformer`, such as :obj:`prompts` etc.
         """
         from sentence_transformers import SentenceTransformer
 
-        self.model = SentenceTransformer(model_name)
+        self.model = SentenceTransformer(model_name, **kwargs)
 
     def embed_list(
         self,
-        objs: List[str],
+        objs: list[str],
         **kwargs: Any,
-    ) -> List[List[float]]:
+    ) -> list[list[float]]:
         r"""Generates embeddings for the given texts using the model.
 
         Args:
-            objs (List[str]): The texts for which to generate the
-            embeddings.
+            objs (list[str]): The texts for which to generate the
+                embeddings.
 
         Returns:
-            List[List[float]]: A list that represents the generated embedding
+            list[list[float]]: A list that represents the generated embedding
                 as a list of floating-point numbers.
         """
         if not objs:
             raise ValueError("Input text list is empty")
-        return self.model.encode(
+        embeddings = self.model.encode(
             objs, normalize_embeddings=True, **kwargs
-        ).tolist()
+        )
+        assert isinstance(embeddings, ndarray)
+        return embeddings.tolist()
 
     def get_output_dim(self) -> int:
         r"""Returns the output dimension of the embeddings.
@@ -63,4 +75,6 @@ class SentenceTransformerEncoder(BaseEmbedding[str]):
         Returns:
             int: The dimensionality of the embeddings.
         """
-        return self.model.get_sentence_embedding_dimension()
+        output_dim = self.model.get_sentence_embedding_dimension()
+        assert isinstance(output_dim, int)
+        return output_dim

camel/functions/open_api_function.py

@@ -13,16 +13,15 @@
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 import json
 import os
-from typing import Any, Callable, Dict, List, Tuple
+from typing import Any, Callable, Dict, List, Optional, Tuple
 
-import prance
 import requests
 
 from camel.functions import OpenAIFunction, openapi_security_config
 from camel.types import OpenAPIName
 
 
-def parse_openapi_file(openapi_spec_path: str) -> Dict[str, Any]:
+def parse_openapi_file(openapi_spec_path: str) -> Optional[Dict[str, Any]]:
     r"""Load and parse an OpenAPI specification file.
 
     This function utilizes the `prance.ResolvingParser` to parse and resolve
@@ -34,8 +33,14 @@ def parse_openapi_file(openapi_spec_path: str) -> Dict[str, Any]:
             specification.
 
     Returns:
-        Dict[str, Any]: The parsed OpenAPI specification as a dictionary.
+        Optional[Dict[str, Any]]: The parsed OpenAPI specification
+            as a dictionary. :obj:`None` if the package is not installed.
     """
+    try:
+        import prance
+    except Exception:
+        return None
+
     # Load the OpenAPI spec
     parser = prance.ResolvingParser(
         openapi_spec_path, backend="openapi-spec-validator", strict=False
@@ -451,6 +456,8 @@ def apinames_filepaths_to_funs_schemas(
         )
 
         openapi_spec = parse_openapi_file(file_path)
+        if openapi_spec is None:
+            return [], []
 
         # Generate and merge function schemas
         openapi_functions_schemas = openapi_spec_to_openai_schemas(

camel/functions/slack_functions.py

@@ -24,8 +24,6 @@ if TYPE_CHECKING:
 
     from slack_sdk import WebClient
 
-from slack_sdk.errors import SlackApiError
-
 from camel.functions import OpenAIFunction
 
 logger = logging.getLogger(__name__)
@@ -89,6 +87,8 @@ def create_slack_channel(name: str, is_private: Optional[bool] = True) -> str:
         SlackApiError: If there is an error during get slack channel
             information.
     """
+    from slack_sdk.errors import SlackApiError
+
     try:
         slack_client = _login_slack()
         response = slack_client.conversations_create(
@@ -115,6 +115,8 @@ def join_slack_channel(channel_id: str) -> str:
         SlackApiError: If there is an error during get slack channel
             information.
     """
+    from slack_sdk.errors import SlackApiError
+
     try:
         slack_client = _login_slack()
         response = slack_client.conversations_join(channel=channel_id)
@@ -137,6 +139,8 @@ def leave_slack_channel(channel_id: str) -> str:
         SlackApiError: If there is an error during get slack channel
             information.
     """
+    from slack_sdk.errors import SlackApiError
+
     try:
         slack_client = _login_slack()
         response = slack_client.conversations_leave(channel=channel_id)
@@ -155,6 +159,8 @@ def get_slack_channel_information() -> str:
         SlackApiError: If there is an error during get slack channel
             information.
     """
+    from slack_sdk.errors import SlackApiError
+
     try:
         slack_client = _login_slack()
         response = slack_client.conversations_list()
@@ -189,6 +195,8 @@ def get_slack_channel_message(channel_id: str) -> str:
     Raises:
         SlackApiError: If there is an error during get slack channel message.
     """
+    from slack_sdk.errors import SlackApiError
+
     try:
         slack_client = _login_slack()
         result = slack_client.conversations_history(channel=channel_id)
@@ -222,6 +230,8 @@ def send_slack_message(
     Raises:
         SlackApiError: If an error occurs while sending the message.
     """
+    from slack_sdk.errors import SlackApiError
+
     try:
         slack_client = _login_slack()
         if user:
@@ -254,6 +264,8 @@ def delete_slack_message(
     Raises:
         SlackApiError: If an error occurs while sending the message.
     """
+    from slack_sdk.errors import SlackApiError
+
     try:
         slack_client = _login_slack()
         response = slack_client.chat_delete(channel=channel_id, ts=time_stamp)

camel/models/__init__.py

@@ -15,6 +15,8 @@ from .anthropic_model import AnthropicModel
 from .base_model import BaseModelBackend
 from .litellm_model import LiteLLMModel
 from .model_factory import ModelFactory
+from .nemotron_model import NemotronModel
+from .ollama_model import OllamaModel
 from .open_source_model import OpenSourceModel
 from .openai_audio_models import OpenAIAudioModels
 from .openai_model import OpenAIModel
@@ -31,4 +33,6 @@ __all__ = [
     'ModelFactory',
     'LiteLLMModel',
     'OpenAIAudioModels',
+    'NemotronModel',
+    'OllamaModel',
 ]

camel/models/anthropic_model.py

@@ -35,6 +35,7 @@ class AnthropicModel(BaseModelBackend):
         model_type: ModelType,
         model_config_dict: Dict[str, Any],
         api_key: Optional[str] = None,
+        url: Optional[str] = None,
     ) -> None:
         r"""Constructor for Anthropic backend.
 
@@ -45,10 +46,11 @@ class AnthropicModel(BaseModelBackend):
                 be fed into Anthropic.messages.create().
             api_key (Optional[str]): The API key for authenticating with the
                 Anthropic service. (default: :obj:`None`)
+            url (Optional[str]): The url to the model service.
         """
-        super().__init__(model_type, model_config_dict)
+        super().__init__(model_type, model_config_dict, api_key, url)
         self._api_key = api_key or os.environ.get("ANTHROPIC_API_KEY")
-        self.client = Anthropic(api_key=self._api_key)
+        self.client = Anthropic(api_key=self._api_key, base_url=url)
         self._token_counter: Optional[BaseTokenCounter] = None
 
     def _convert_response_from_anthropic_to_openai(self, response):

camel/models/base_model.py

@@ -31,6 +31,7 @@ class BaseModelBackend(ABC):
         model_type: ModelType,
         model_config_dict: Dict[str, Any],
         api_key: Optional[str] = None,
+        url: Optional[str] = None,
     ) -> None:
         r"""Constructor for the model backend.
 
@@ -38,12 +39,14 @@ class BaseModelBackend(ABC):
             model_type (ModelType): Model for which a backend is created.
             model_config_dict (Dict[str, Any]): A config dictionary.
             api_key (Optional[str]): The API key for authenticating with the
-                LLM service.
+                model service.
+            url (Optional[str]): The url to the model service.
         """
         self.model_type = model_type
 
         self.model_config_dict = model_config_dict
         self._api_key = api_key
+        self._url = url
         self.check_model_config()
 
     @property

camel/models/model_factory.py

@@ -11,15 +11,17 @@
 # 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
+from typing import Any, Dict, Optional, Union
 
 from camel.models.anthropic_model import AnthropicModel
 from camel.models.base_model import BaseModelBackend
+from camel.models.litellm_model import LiteLLMModel
+from camel.models.ollama_model import OllamaModel
 from camel.models.open_source_model import OpenSourceModel
 from camel.models.openai_model import OpenAIModel
 from camel.models.stub_model import StubModel
 from camel.models.zhipuai_model import ZhipuAIModel
-from camel.types import ModelType
+from camel.types import ModelPlatformType, ModelType
 
 
 class ModelFactory:
@@ -31,18 +33,24 @@ class ModelFactory:
 
     @staticmethod
     def create(
-        model_type: ModelType,
+        model_platform: ModelPlatformType,
+        model_type: Union[ModelType, str],
         model_config_dict: Dict,
         api_key: Optional[str] = None,
+        url: Optional[str] = None,
     ) -> BaseModelBackend:
         r"""Creates an instance of `BaseModelBackend` of the specified type.
 
         Args:
-            model_type (ModelType): Model for which a backend is created.
+            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.
             api_key (Optional[str]): The API key for authenticating with the
-                LLM service.
+                model service.
+            url (Optional[str]): The url to the model service.
 
         Raises:
             ValueError: If there is not backend for the model.
@@ -51,22 +59,35 @@ class ModelFactory:
             BaseModelBackend: The initialized backend.
         """
         model_class: Any
-        if model_type.is_openai:
-            model_class = OpenAIModel
-        elif model_type == ModelType.STUB:
-            model_class = StubModel
-        elif model_type.is_open_source:
-            model_class = OpenSourceModel
-        elif model_type.is_anthropic:
-            model_class = AnthropicModel
-        elif model_type.is_zhipuai:
-            model_class = ZhipuAIModel
-        else:
-            raise ValueError(f"Unknown model type `{model_type}` is input")
 
-        if model_type.is_open_source:
-            inst = model_class(model_type, model_config_dict)
+        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)
+            if model_platform.is_openai and model_type.is_openai:
+                model_class = OpenAIModel
+            elif model_platform.is_anthropic and model_type.is_anthropic:
+                model_class = AnthropicModel
+            elif model_platform.is_zhipuai and model_type.is_zhipuai:
+                model_class = ZhipuAIModel
+            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
+            elif model_platform.is_litellm:
+                model_class = LiteLLMModel
+            else:
+                raise ValueError(
+                    f"Unknown pair of model platform `{model_platform}` "
+                    f"and model type `{model_type}`."
+                )
         else:
-            inst = model_class(model_type, model_config_dict, api_key)
+            raise ValueError(f"Invalid model type `{model_type}` provided.")
 
-        return inst
+        return model_class(model_type, model_config_dict, api_key, url)

camel/models/nemotron_model.py

@@ -0,0 +1,71 @@
+# =========== 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. ===========
+import os
+from typing import List, Optional
+
+from openai import OpenAI
+
+from camel.messages import OpenAIMessage
+from camel.types import ChatCompletion, ModelType
+from camel.utils import (
+    BaseTokenCounter,
+    model_api_key_required,
+)
+
+
+class NemotronModel:
+    r"""Nemotron model API backend with OpenAI compatibility."""
+
+    # NOTE: Nemotron model doesn't support additional model config like OpenAI.
+
+    def __init__(
+        self,
+        model_type: ModelType,
+        api_key: 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`)
+        """
+        self.model_type = model_type
+        url = os.environ.get('NVIDIA_API_BASE_URL', None)
+        self._api_key = api_key or os.environ.get("NVIDIA_API_KEY")
+        if not url or not self._api_key:
+            raise ValueError("The NVIDIA API base url and key should be set.")
+        self._client = OpenAI(
+            timeout=60, max_retries=3, base_url=url, api_key=self._api_key
+        )
+        self._token_counter: Optional[BaseTokenCounter] = None
+
+    @model_api_key_required
+    def run(
+        self,
+        messages: List[OpenAIMessage],
+    ) -> ChatCompletion:
+        r"""Runs inference of OpenAI chat completion.
+
+        Args:
+            messages (List[OpenAIMessage]): Message list.
+
+        Returns:
+            ChatCompletion.
+        """
+        response = self._client.chat.completions.create(
+            messages=messages,
+            model=self.model_type.value,
+        )
+        return response

camel/models/ollama_model.py

@@ -0,0 +1,121 @@
+# =========== 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. ===========
+import os
+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.types import ChatCompletion, ChatCompletionChunk, ModelType
+from camel.utils import BaseTokenCounter, OpenAITokenCounter
+
+
+class OllamaModel:
+    r"""Ollama service interface."""
+
+    # NOTE: Current `ModelType and `TokenCounter` desigen is not suitable,
+    # stream mode is not supported
+
+    def __init__(
+        self,
+        model_type: str,
+        model_config_dict: Dict[str, Any],
+        api_key: Optional[str] = None,
+        url: Optional[str] = None,
+    ) -> None:
+        r"""Constructor for Ollama backend with OpenAI compatibility.
+
+        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 (Optional[str]): The API key for authenticating with the
+                model service. (default: :obj:`None`)
+            url (Optional[str]): The url to the model service.
+        """
+        self.model_type = model_type
+        self.model_config_dict = model_config_dict
+        self._url = url or os.environ.get('OPENAI_API_BASE_URL')
+        self._api_key = api_key or os.environ.get("OPENAI_API_KEY")
+        # Use OpenAI cilent as interface call Ollama
+        # Reference: https://github.com/ollama/ollama/blob/main/docs/openai.md
+        self._client = OpenAI(
+            timeout=60,
+            max_retries=3,
+            base_url=self._url,
+            api_key=self._api_key,
+        )
+        self._token_counter: Optional[BaseTokenCounter] = None
+
+    @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.
+        """
+        # NOTE: Use OpenAITokenCounter temporarily
+        if not self._token_counter:
+            self._token_counter = OpenAITokenCounter(ModelType.GPT_3_5_TURBO)
+        return self._token_counter
+
+    def check_model_config(self):
+        r"""Check whether the model configuration contains any
+        unexpected arguments to OpenAI API.
+
+        Raises:
+            ValueError: If the model configuration dictionary contains any
+                unexpected arguments to OpenAI API.
+        """
+        for param in self.model_config_dict:
+            if param not in OPENAI_API_PARAMS:
+                raise ValueError(
+                    f"Unexpected argument `{param}` is "
+                    "input into OpenAI model backend."
+                )
+
+    def run(
+        self,
+        messages: List[OpenAIMessage],
+    ) -> Union[ChatCompletion, Stream[ChatCompletionChunk]]:
+        r"""Runs inference of OpenAI 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.
+        """
+
+        response = self._client.chat.completions.create(
+            messages=messages,
+            model=self.model_type,
+            **self.model_config_dict,
+        )
+        return response
+
+    @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)

camel/models/open_source_model.py

@@ -31,6 +31,8 @@ class OpenSourceModel(BaseModelBackend):
         self,
         model_type: ModelType,
         model_config_dict: Dict[str, Any],
+        api_key: Optional[str] = None,
+        url: Optional[str] = None,
     ) -> None:
         r"""Constructor for model backends of Open-source models.
 
@@ -38,8 +40,11 @@ class OpenSourceModel(BaseModelBackend):
             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.
         """
-        super().__init__(model_type, model_config_dict)
+        super().__init__(model_type, model_config_dict, api_key, url)
         self._token_counter: Optional[BaseTokenCounter] = None
 
         # Check whether the input model type is open-source
@@ -65,7 +70,7 @@ class OpenSourceModel(BaseModelBackend):
             )
 
         # Load the server URL and check whether it is None
-        server_url: Optional[str] = self.model_config_dict.get(
+        server_url: Optional[str] = url or self.model_config_dict.get(
             "server_url", None
         )
         if not server_url: