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

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:

camel/models/openai_model.py

@@ -35,6 +35,7 @@ class OpenAIModel(BaseModelBackend):
         model_type: ModelType,
         model_config_dict: Dict[str, Any],
         api_key: Optional[str] = None,
+        url: Optional[str] = None,
     ) -> None:
         r"""Constructor for OpenAI backend.
 
@@ -45,12 +46,16 @@ class OpenAIModel(BaseModelBackend):
                 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.
         """
-        super().__init__(model_type, model_config_dict)
-        url = os.environ.get('OPENAI_API_BASE_URL', None)
+        super().__init__(model_type, model_config_dict, api_key, url)
+        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, base_url=url, api_key=self._api_key
+            timeout=60,
+            max_retries=3,
+            base_url=self._url,
+            api_key=self._api_key,
         )
         self._token_counter: Optional[BaseTokenCounter] = None
 

camel/models/stub_model.py

@@ -54,11 +54,13 @@ class StubModel(BaseModelBackend):
         model_type: ModelType,
         model_config_dict: Dict[str, Any],
         api_key: Optional[str] = None,
+        url: Optional[str] = None,
     ) -> None:
         r"""All arguments are unused for the dummy model."""
-        super().__init__(model_type, model_config_dict)
+        super().__init__(model_type, model_config_dict, api_key, url)
         self._token_counter: Optional[BaseTokenCounter] = None
         self._api_key = api_key
+        self._url = url
 
     @property
     def token_counter(self) -> BaseTokenCounter:

camel/prompts/__init__.py

@@ -16,6 +16,9 @@ from .base import CodePrompt, TextPrompt, TextPromptDict
 from .code import CodePromptTemplateDict
 from .descripte_video_prompt import DescriptionVideoPromptTemplateDict
 from .evaluation import EvaluationPromptTemplateDict
+from .generate_text_embedding_data import (
+    GenerateTextEmbeddingDataPromptTemplateDict,
+)
 from .misalignment import MisalignmentPromptTemplateDict
 from .object_recognition import ObjectRecognitionPromptTemplateDict
 from .prompt_templates import PromptTemplateGenerator
@@ -37,6 +40,7 @@ __all__ = [
     'TaskPromptTemplateDict',
     'PromptTemplateGenerator',
     'SolutionExtractionPromptTemplateDict',
+    'GenerateTextEmbeddingDataPromptTemplateDict',
     'ObjectRecognitionPromptTemplateDict',
     'DescriptionVideoPromptTemplateDict',
 ]

camel/prompts/generate_text_embedding_data.py

@@ -0,0 +1,79 @@
+# =========== 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
+
+from camel.prompts import TextPrompt, TextPromptDict
+from camel.types import RoleType
+
+
+# flake8: noqa :E501
+class GenerateTextEmbeddingDataPromptTemplateDict(TextPromptDict):
+    r"""A :obj:`TextPrompt` dictionary containing text embedding tasks
+    generation, query, positive and hard negative samples generation,
+    from the `"Improving Text Embeddings with Large Language Models"
+    <https://arxiv.org/abs/2401.00368>`_ paper.
+
+
+    Attributes:
+        GENERATE_TASKS (TextPrompt): A prompt to generate a list
+            of :obj:`num_tasks` synthetic text_embedding tasks.
+        ASSISTANT_PROMPT (TextPrompt): A system prompt for the AI assistant
+            to generate synthetic :obj:`user_query`, :obj:`positive document`,
+            and :obj:`hard_negative_document` for a specific :obj:`task` with
+            specified parameters including :obj:`query_type`,
+            :obj:`query_length`, :obj:`clarity`, :obj:`num_words`,
+            :obj:`language` and :obj:`difficulty`.
+    """
+
+    GENERATE_TASKS = TextPrompt(
+        """You are an expert to brainstorm a list of {num_tasks} potentially useful text retrieval tasks
+Here are a few examples for your reference:
+  - Provided a scientific claim as query, retrieve documents that help verify or refute the claim.
+  - Search for documents that answers a FAQ-style query on children's nutrition.
+Please adhere to the following guidelines:
+  - Specify what the query is, and what the desired documents are.
+  - Each retrieval task should cover a wide range of queries, and should not be too specific.
+Your output should always be a python list of strings starting with `1.`, `2.` etc.
+And each element corresponds to a distinct retrieval task in one sentence.
+Do not explain yourself or output anything else.
+Be creative!"""
+    )
+
+    ASSISTANT_PROMPT = TextPrompt(
+        """You have been assigned a retrieval task: {task}
+Your mission is to write one text retrieval example for this task in JSON format. The JSON object must
+contain the following keys:
+  - "user_query": a string, a random user search query specified by the retrieval task.
+  - "positive_document": a string, a relevant document for the user query.
+  - "hard_negative_document": a string, a hard negative document that only appears relevant to the query.
+Please adhere to the following guidelines:
+  - The "user_query" should be {query_type}, {query_length}, {clarity}, and diverse in topic.
+  - All documents must be created independent of the query. Avoid copying the query verbatim.
+It's acceptable if some parts of the "positive_document" are not topically related to the query.
+  - All documents should be at least {num_words} words long.
+  - The "hard_negative_document" contains some useful information, but it should be less useful or comprehensive compared to the "positive_document".
+  - Both the query and documents should be in {language}.
+  - Do not provide any explanation in any document on why it is relevant or not relevant to the query.
+  - Both the query and documents require {difficulty} level education to understand.
+Your output must always be a JSON object only (starting and ending with curly brackets), do not explain yourself or output anything else. Be creative!"""
+    )
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self.update(
+            {
+                "generate_tasks": self.GENERATE_TASKS,
+                RoleType.ASSISTANT: self.ASSISTANT_PROMPT,
+            }
+        )

camel/prompts/task_prompt_template.py

@@ -24,6 +24,9 @@ from camel.prompts.descripte_video_prompt import (
 from camel.prompts.evaluation import (
     EvaluationPromptTemplateDict,
 )
+from camel.prompts.generate_text_embedding_data import (
+    GenerateTextEmbeddingDataPromptTemplateDict,
+)
 from camel.prompts.misalignment import MisalignmentPromptTemplateDict
 from camel.prompts.object_recognition import (
     ObjectRecognitionPromptTemplateDict,
@@ -60,6 +63,7 @@ class TaskPromptTemplateDict(Dict[Any, TextPromptDict]):
                 TaskType.SOLUTION_EXTRACTION: SolutionExtractionPromptTemplateDict(),  # noqa: E501
                 TaskType.ROLE_DESCRIPTION: RoleDescriptionPromptTemplateDict(),
                 TaskType.OBJECT_RECOGNITION: ObjectRecognitionPromptTemplateDict(),  # noqa: E501
+                TaskType.GENERATE_TEXT_EMBEDDING_DATA: GenerateTextEmbeddingDataPromptTemplateDict(),  # noqa: E501
                 TaskType.VIDEO_DESCRIPTION: DescriptionVideoPromptTemplateDict(),  # noqa: E501
             }
         )