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

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
             }
         )

camel/retrievers/auto_retriever.py

@@ -159,11 +159,11 @@ class AutoRetriever:
     ) -> str:
         r"""Retrieves the last modified date and time of a given file. This
         function takes vector storage instance as input and returns the last
-        modified date from the meta data.
+        modified date from the metadata.
 
         Args:
             vector_storage_instance (BaseVectorStorage): The vector storage
-                where modified date is to be retrieved from meta data.
+                where modified date is to be retrieved from metadata.
 
         Returns:
             str: The last modified date from vector storage.

camel/societies/role_playing.py

@@ -22,9 +22,10 @@ from camel.agents import (
 from camel.generators import SystemMessageGenerator
 from camel.human import Human
 from camel.messages import BaseMessage
+from camel.models import BaseModelBackend
 from camel.prompts import TextPrompt
 from camel.responses import ChatAgentResponse
-from camel.types import ModelType, RoleType, TaskType
+from camel.types import RoleType, TaskType
 
 
 class RolePlaying:
@@ -48,9 +49,9 @@ class RolePlaying:
             in the loop. (default: :obj:`False`)
         critic_criteria (str, optional): Critic criteria for the critic agent.
             If not specified, set the criteria to improve task performance.
-        model_type (ModelType, optional): Model type that will be used for
-            role playing. If specified, it will override the model in all
-            agents. (default: :obj:`None`)
+        model (BaseModelBackend, optional): The model backend to use for
+            generating responses. If specified, it will override the model in
+            all agents. (default: :obj:`None`)
         task_type (TaskType, optional): The type of task to perform.
             (default: :obj:`TaskType.AI_SOCIETY`)
         assistant_agent_kwargs (Dict, optional): Additional arguments to pass
@@ -84,7 +85,7 @@ class RolePlaying:
         with_task_planner: bool = False,
         with_critic_in_the_loop: bool = False,
         critic_criteria: Optional[str] = None,
-        model_type: Optional[ModelType] = None,
+        model: Optional[BaseModelBackend] = None,
         task_type: TaskType = TaskType.AI_SOCIETY,
         assistant_agent_kwargs: Optional[Dict] = None,
         user_agent_kwargs: Optional[Dict] = None,
@@ -99,7 +100,7 @@ class RolePlaying:
         self.with_task_specify = with_task_specify
         self.with_task_planner = with_task_planner
         self.with_critic_in_the_loop = with_critic_in_the_loop
-        self.model_type = model_type
+        self.model = model
         self.task_type = task_type
         self.task_prompt = task_prompt
 
@@ -189,12 +190,10 @@ class RolePlaying:
                     )
                 )
             task_specify_meta_dict.update(extend_task_specify_meta_dict or {})
-            if self.model_type is not None:
+            if self.model is not None:
                 if task_specify_agent_kwargs is None:
                     task_specify_agent_kwargs = {}
-                task_specify_agent_kwargs.update(
-                    dict(model_type=self.model_type)
-                )
+                task_specify_agent_kwargs.update(dict(model=self.model))
             task_specify_agent = TaskSpecifyAgent(
                 task_type=self.task_type,
                 output_language=output_language,
@@ -224,12 +223,10 @@ class RolePlaying:
                 agents. (default: :obj:`None`)
         """
         if self.with_task_planner:
-            if self.model_type is not None:
+            if self.model is not None:
                 if task_planner_agent_kwargs is None:
                     task_planner_agent_kwargs = {}
-                task_planner_agent_kwargs.update(
-                    dict(model_type=self.model_type)
-                )
+                task_planner_agent_kwargs.update(dict(model=self.model))
             task_planner_agent = TaskPlannerAgent(
                 output_language=output_language,
                 **(task_planner_agent_kwargs or {}),
@@ -321,13 +318,13 @@ class RolePlaying:
             output_language (str, optional): The language to be output by the
                 agents. (default: :obj:`None`)
         """
-        if self.model_type is not None:
+        if self.model is not None:
             if assistant_agent_kwargs is None:
                 assistant_agent_kwargs = {}
-            assistant_agent_kwargs.update(dict(model_type=self.model_type))
+            assistant_agent_kwargs.update(dict(model=self.model))
             if user_agent_kwargs is None:
                 user_agent_kwargs = {}
-            user_agent_kwargs.update(dict(model_type=self.model_type))
+            user_agent_kwargs.update(dict(model=self.model))
 
         self.assistant_agent = ChatAgent(
             init_assistant_sys_msg,
@@ -383,10 +380,10 @@ class RolePlaying:
                     critic_msg_meta_dict,
                     role_tuple=(critic_role_name, RoleType.CRITIC),
                 )
-                if self.model_type is not None:
+                if self.model is not None:
                     if critic_kwargs is None:
                         critic_kwargs = {}
-                    critic_kwargs.update(dict(model_type=self.model_type))
+                    critic_kwargs.update(dict(model=self.model))
                 self.critic = CriticAgent(
                     self.critic_sys_msg,
                     **(critic_kwargs or {}),

camel/storages/graph_storages/graph_element.py

@@ -16,7 +16,10 @@ from __future__ import annotations
 from dataclasses import dataclass, field
 from typing import List, Union
 
-from unstructured.documents.elements import Element
+try:
+    from unstructured.documents.elements import Element
+except ImportError:
+    Element = None
 
 
 @dataclass
@@ -72,3 +75,8 @@ class GraphElement:
     nodes: List[Node]
     relationships: List[Relationship]
     source: Element
+
+    def __post_init__(self):
+        if Element is None:
+            raise ImportError("""The 'unstructured' package is required to use
+                              the 'source' attribute.""")

camel/types/__init__.py

@@ -14,6 +14,7 @@
 from .enums import (
     AudioModelType,
     EmbeddingModelType,
+    ModelPlatformType,
     ModelType,
     OpenAIBackendRole,
     OpenAIImageType,
@@ -62,6 +63,7 @@ __all__ = [
     'OpenAIImageType',
     'OpenAIVisionDetailType',
     'OpenAPIName',
+    'ModelPlatformType',
     'AudioModelType',
     'VoiceType',
 ]

camel/types/enums.py

@@ -45,14 +45,22 @@ class ModelType(Enum):
     CLAUDE_2_0 = "claude-2.0"
     CLAUDE_INSTANT_1_2 = "claude-instant-1.2"
 
-    #  3 models
+    # Claude3 models
     CLAUDE_3_OPUS = "claude-3-opus-20240229"
     CLAUDE_3_SONNET = "claude-3-sonnet-20240229"
     CLAUDE_3_HAIKU = "claude-3-haiku-20240307"
+    CLAUDE_3_5_SONNET = "claude-3-5-sonnet-20240620"
+
+    # Nvidia models
+    NEMOTRON_4_REWARD = "nvidia/nemotron-4-340b-reward"
 
     @property
     def value_for_tiktoken(self) -> str:
-        return self.value if self is not ModelType.STUB else "gpt-3.5-turbo"
+        return (
+            self.value
+            if self is not ModelType.STUB and not isinstance(self, str)
+            else "gpt-3.5-turbo"
+        )
 
     @property
     def is_openai(self) -> bool:
@@ -97,6 +105,18 @@ class ModelType(Enum):
             ModelType.CLAUDE_3_OPUS,
             ModelType.CLAUDE_3_SONNET,
             ModelType.CLAUDE_3_HAIKU,
+            ModelType.CLAUDE_3_5_SONNET,
+        }
+
+    @property
+    def is_nvidia(self) -> bool:
+        r"""Returns whether this type of models is Nvidia-released model.
+
+        Returns:
+            bool: Whether this type of models is nvidia.
+        """
+        return self in {
+            ModelType.NEMOTRON_4_REWARD,
         }
 
     @property
@@ -130,15 +150,18 @@ class ModelType(Enum):
             return 2048
         elif self is ModelType.VICUNA_16K:
             return 16384
-        if self in {ModelType.CLAUDE_2_0, ModelType.CLAUDE_INSTANT_1_2}:
+        elif self in {ModelType.CLAUDE_2_0, ModelType.CLAUDE_INSTANT_1_2}:
             return 100_000
         elif self in {
             ModelType.CLAUDE_2_1,
             ModelType.CLAUDE_3_OPUS,
             ModelType.CLAUDE_3_SONNET,
             ModelType.CLAUDE_3_HAIKU,
+            ModelType.CLAUDE_3_5_SONNET,
         }:
             return 200_000
+        elif self is ModelType.NEMOTRON_4_REWARD:
+            return 4096
         else:
             raise ValueError("Unknown model type")
 
@@ -166,35 +189,27 @@ class ModelType(Enum):
 
 
 class EmbeddingModelType(Enum):
-    ADA_2 = "text-embedding-ada-002"
-    ADA_1 = "text-embedding-ada-001"
-    BABBAGE_1 = "text-embedding-babbage-001"
-    CURIE_1 = "text-embedding-curie-001"
-    DAVINCI_1 = "text-embedding-davinci-001"
+    TEXT_EMBEDDING_ADA_2 = "text-embedding-ada-002"
+    TEXT_EMBEDDING_3_SMALL = "text-embedding-3-small"
+    TEXT_EMBEDDING_3_LARGE = "text-embedding-3-large"
 
     @property
     def is_openai(self) -> bool:
         r"""Returns whether this type of models is an OpenAI-released model."""
         return self in {
-            EmbeddingModelType.ADA_2,
-            EmbeddingModelType.ADA_1,
-            EmbeddingModelType.BABBAGE_1,
-            EmbeddingModelType.CURIE_1,
-            EmbeddingModelType.DAVINCI_1,
+            EmbeddingModelType.TEXT_EMBEDDING_ADA_2,
+            EmbeddingModelType.TEXT_EMBEDDING_3_SMALL,
+            EmbeddingModelType.TEXT_EMBEDDING_3_LARGE,
         }
 
     @property
     def output_dim(self) -> int:
-        if self is EmbeddingModelType.ADA_2:
+        if self is EmbeddingModelType.TEXT_EMBEDDING_ADA_2:
             return 1536
-        elif self is EmbeddingModelType.ADA_1:
-            return 1024
-        elif self is EmbeddingModelType.BABBAGE_1:
-            return 2048
-        elif self is EmbeddingModelType.CURIE_1:
-            return 4096
-        elif self is EmbeddingModelType.DAVINCI_1:
-            return 12288
+        elif self is EmbeddingModelType.TEXT_EMBEDDING_3_SMALL:
+            return 1536
+        elif self is EmbeddingModelType.TEXT_EMBEDDING_3_LARGE:
+            return 3072
         else:
             raise ValueError(f"Unknown model type {self}.")
 
@@ -207,6 +222,7 @@ class TaskType(Enum):
     EVALUATION = "evaluation"
     SOLUTION_EXTRACTION = "solution_extraction"
     ROLE_DESCRIPTION = "role_description"
+    GENERATE_TEXT_EMBEDDING_DATA = "generate_text_embedding_data"
     OBJECT_RECOGNITION = "object_recognition"
     DEFAULT = "default"
     VIDEO_DESCRIPTION = "video_description"
@@ -279,6 +295,52 @@ class OpenAPIName(Enum):
     WEB_SCRAPER = "web_scraper"
 
 
+class ModelPlatformType(Enum):
+    OPENAI = "openai"
+    AZURE = "azure"
+    ANTHROPIC = "anthropic"
+    OPENSOURCE = "opensource"
+    OLLAMA = "ollama"
+    LITELLM = "litellm"
+    ZHIPU = "zhipuai"
+    DEFAULT = "default"
+
+    @property
+    def is_openai(self) -> bool:
+        r"""Returns whether this platform is openai."""
+        return self is ModelPlatformType.OPENAI
+
+    @property
+    def is_azure(self) -> bool:
+        r"""Returns whether this platform is azure."""
+        return self is ModelPlatformType.AZURE
+
+    @property
+    def is_anthropic(self) -> bool:
+        r"""Returns whether this platform is anthropic."""
+        return self is ModelPlatformType.ANTHROPIC
+
+    @property
+    def is_ollama(self) -> bool:
+        r"""Returns whether this platform is ollama."""
+        return self is ModelPlatformType.OLLAMA
+
+    @property
+    def is_litellm(self) -> bool:
+        r"""Returns whether this platform is litellm."""
+        return self is ModelPlatformType.LITELLM
+
+    @property
+    def is_zhipuai(self) -> bool:
+        r"""Returns whether this platform is zhipu."""
+        return self is ModelPlatformType.ZHIPU
+
+    @property
+    def is_open_source(self) -> bool:
+        r"""Returns whether this platform is opensource."""
+        return self is ModelPlatformType.OPENSOURCE
+
+
 class AudioModelType(Enum):
     TTS_1 = "tts-1"
     TTS_1_HD = "tts-1-hd"

camel/utils/commons.py

@@ -62,6 +62,10 @@ def model_api_key_required(func: F) -> F:
             if not self._api_key and 'ANTHROPIC_API_KEY' not in os.environ:
                 raise ValueError('Anthropic API key not found.')
             return func(self, *args, **kwargs)
+        elif self.model_type.is_nvidia:
+            if not self._api_key and 'NVIDIA_API_KEY' not in os.environ:
+                raise ValueError('NVIDIA API key not found.')
+            return func(self, *args, **kwargs)
         else:
             raise ValueError('Unsupported model type.')
 

camel/utils/token_counting.py

@@ -296,9 +296,11 @@ class AnthropicTokenCounter(BaseTokenCounter):
         Returns:
             int: Number of tokens in the messages.
         """
-        prompt = messages_to_prompt(messages, self.model_type)
-
-        return self.client.count_tokens(prompt)
+        num_tokens = 0
+        for message in messages:
+            content = str(message["content"])
+            num_tokens += self.client.count_tokens(content)
+        return num_tokens
 
 
 class LiteLLMTokenCounter: