camel-ai 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

camel/agents/task_agent.py

@@ -13,7 +13,7 @@
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 from typing import Any, Dict, List, Optional, Union
 
-from camel.agents import ChatAgent
+from camel.agents.chat_agent import ChatAgent
 from camel.configs import ChatGPTConfig
 from camel.messages import BaseMessage
 from camel.prompts import PromptTemplateGenerator, TextPrompt
@@ -43,6 +43,7 @@ class TaskSpecifyAgent(ChatAgent):
         output_language (str, optional): The language to be output by the
         agent. (default: :obj:`None`)
     """
+
     DEFAULT_WORD_LIMIT = 50
 
     def __init__(
@@ -54,14 +55,15 @@ class TaskSpecifyAgent(ChatAgent):
         word_limit: int = DEFAULT_WORD_LIMIT,
         output_language: Optional[str] = None,
     ) -> None:
-
         self.task_specify_prompt: Union[str, TextPrompt]
         if task_specify_prompt is None:
-            task_specify_prompt_template = PromptTemplateGenerator(
-            ).get_task_specify_prompt(task_type)
+            task_specify_prompt_template = (
+                PromptTemplateGenerator().get_task_specify_prompt(task_type)
+            )
 
             self.task_specify_prompt = task_specify_prompt_template.format(
-                word_limit=word_limit)
+                word_limit=word_limit
+            )
         else:
             self.task_specify_prompt = TextPrompt(task_specify_prompt)
 
@@ -74,9 +76,12 @@ class TaskSpecifyAgent(ChatAgent):
             content="You can make a task more specific.",
         )
 
-        super().__init__(system_message, model_type=model_type,
-                         model_config=model_config,
-                         output_language=output_language)
+        super().__init__(
+            system_message,
+            model_type=model_type,
+            model_config=model_config,
+            output_language=output_language,
+        )
 
     def run(
         self,
@@ -101,8 +106,9 @@ class TaskSpecifyAgent(ChatAgent):
         if meta_dict is not None:
             task_specify_prompt = task_specify_prompt.format(**meta_dict)
 
-        task_msg = BaseMessage.make_user_message(role_name="Task Specifier",
-                                                 content=task_specify_prompt)
+        task_msg = BaseMessage.make_user_message(
+            role_name="Task Specifier", content=task_specify_prompt
+        )
         specifier_response = self.step(task_msg)
 
         if specifier_response.terminated:
@@ -138,9 +144,9 @@ class TaskPlannerAgent(ChatAgent):
         model_config: Optional[Any] = None,
         output_language: Optional[str] = None,
     ) -> None:
-
         self.task_planner_prompt = TextPrompt(
-            "Divide this task into subtasks: {task}. Be concise.")
+            "Divide this task into subtasks: {task}. Be concise."
+        )
         system_message = BaseMessage(
             role_name="Task Planner",
             role_type=RoleType.ASSISTANT,
@@ -148,8 +154,12 @@ class TaskPlannerAgent(ChatAgent):
             content="You are a helpful task planner.",
         )
 
-        super().__init__(system_message, model_type, model_config,
-                         output_language=output_language)
+        super().__init__(
+            system_message,
+            model_type,
+            model_config,
+            output_language=output_language,
+        )
 
     def run(
         self,
@@ -168,8 +178,9 @@ class TaskPlannerAgent(ChatAgent):
         self.reset()
         task_planner_prompt = self.task_planner_prompt.format(task=task_prompt)
 
-        task_msg = BaseMessage.make_user_message(role_name="Task Planner",
-                                                 content=task_planner_prompt)
+        task_msg = BaseMessage.make_user_message(
+            role_name="Task Planner", content=task_planner_prompt
+        )
 
         task_response = self.step(task_msg)
 
@@ -220,7 +231,6 @@ class TaskCreationAgent(ChatAgent):
         message_window_size: Optional[int] = None,
         max_task_num: Optional[int] = 3,
     ) -> None:
-
         task_creation_prompt = TextPrompt(
             """Create new a task with the following objective: {objective}.
 Never forget you are a Task Creator of {role_name}.
@@ -239,11 +249,12 @@ You should make task plan and not ask me questions.
 If you think no new tasks are needed right now, write "No tasks to add."
 Now start to give me new tasks one by one. No more than three tasks.
 Be concrete.
-""")
+"""
+        )
 
         self.task_creation_prompt = task_creation_prompt.format(
-            objective=objective, role_name=role_name,
-            max_task_num=max_task_num)
+            objective=objective, role_name=role_name, max_task_num=max_task_num
+        )
         self.objective = objective
 
         system_message = BaseMessage(
@@ -253,9 +264,13 @@ Be concrete.
             content="You are a helpful task creator.",
         )
 
-        super().__init__(system_message, model_type, model_config,
-                         output_language=output_language,
-                         message_window_size=message_window_size)
+        super().__init__(
+            system_message,
+            model_type,
+            model_config,
+            output_language=output_language,
+            message_window_size=message_window_size,
+        )
 
     def run(
         self,
@@ -273,13 +288,16 @@ Be concrete.
 
         if len(task_list) > 0:
             task_creation_prompt = self.task_creation_prompt.format(
-                task_list=task_list)
+                task_list=task_list
+            )
         else:
             task_creation_prompt = self.task_creation_prompt.format(
-                task_list="")
+                task_list=""
+            )
 
-        task_msg = BaseMessage.make_user_message(role_name="Task Creator",
-                                                 content=task_creation_prompt)
+        task_msg = BaseMessage.make_user_message(
+            role_name="Task Creator", content=task_creation_prompt
+        )
         task_response = self.step(task_msg)
 
         if task_response.terminated:
@@ -337,10 +355,12 @@ The result must be a numbered list in the format:
 The entries must be consecutively numbered, starting with 1.
 The number of each entry must be followed by a period.
 Do not include any headers before your ranked list or follow your list \
-with any other output.""")
+with any other output."""
+        )
 
         self.task_prioritization_prompt = task_prioritization_prompt.format(
-            objective=objective)
+            objective=objective
+        )
         self.objective = objective
 
         system_message = BaseMessage(
@@ -350,9 +370,13 @@ with any other output.""")
             content="You are a helpful task prioritizer.",
         )
 
-        super().__init__(system_message, model_type, model_config,
-                         output_language=output_language,
-                         message_window_size=message_window_size)
+        super().__init__(
+            system_message,
+            model_type,
+            model_config,
+            output_language=output_language,
+            message_window_size=message_window_size,
+        )
 
     def run(
         self,
@@ -366,10 +390,12 @@ with any other output.""")
             List[str]: The new prioritized task list generated by the Agent.
         """
         task_prioritization_prompt = self.task_prioritization_prompt.format(
-            task_list=task_list)
+            task_list=task_list
+        )
 
         task_msg = BaseMessage.make_user_message(
-            role_name="Task Prioritizer", content=task_prioritization_prompt)
+            role_name="Task Prioritizer", content=task_prioritization_prompt
+        )
 
         task_response = self.step(task_msg)
 

camel/agents/tool_agents/base.py

@@ -24,7 +24,6 @@ class BaseToolAgent(BaseAgent):
     """
 
     def __init__(self, name: str, description: str) -> None:
-
         self.name = name
         self.description = description
 

camel/agents/tool_agents/hugging_face_tool_agent.py

@@ -13,7 +13,7 @@
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 from typing import Any, Optional
 
-from camel.agents.tool_agents import BaseToolAgent
+from camel.agents.tool_agents.base import BaseToolAgent
 
 
 # flake8: noqa :E501
@@ -44,10 +44,13 @@ class HuggingFaceToolAgent(BaseToolAgent):
             # TODO: Support other tool agents
             import transformers
             from packaging import version
-            if version.parse(
-                    transformers.__version__) < version.parse("4.31.0"):
+
+            if version.parse(transformers.__version__) < version.parse(
+                "4.31.0"
+            ):
                 raise ValueError(
-                    "The version of \"transformers\" package should >= 4.31.0")
+                    "The version of \"transformers\" package should >= 4.31.0"
+                )
 
             from transformers.tools import OpenAiAgent
             from transformers.tools.agent_types import AgentImage

camel/configs.py

@@ -11,15 +11,20 @@
 # 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
+
 from abc import ABC
 from dataclasses import asdict, dataclass, field
-from typing import Any, Dict, List, Optional, Sequence, Union
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Sequence, Union
+
+from anthropic._types import NOT_GIVEN, NotGiven
 
-from camel.functions import OpenAIFunction
+if TYPE_CHECKING:
+    from camel.functions import OpenAIFunction
 
 
 @dataclass(frozen=True)
-class BaseConfig(ABC):
+class BaseConfig(ABC):  # noqa: B024
     pass
 
 
@@ -72,6 +77,7 @@ class ChatGPTConfig(BaseConfig):
             which can help OpenAI to monitor and detect abuse.
             (default: :obj:`""`)
     """
+
     temperature: float = 0.2  # openai default: 1.0
     top_p: float = 1.0
     n: int = 1
@@ -84,6 +90,56 @@ class ChatGPTConfig(BaseConfig):
     user: str = ""
 
 
+@dataclass(frozen=True)
+class ChatGPTVisionConfig(BaseConfig):
+    r"""Defines the parameters for generating chat completions with
+    vision model using the OpenAI API. The vision config here is the
+    subset of the :class:`ChatGPTConfig`.
+
+    Args:
+        temperature (float, optional): Sampling temperature to use, between
+            :obj:`0` and :obj:`2`. Higher values make the output more random,
+            while lower values make it more focused and deterministic.
+            (default: :obj:`0.2`)
+        top_p (float, optional): An alternative to sampling with temperature,
+            called nucleus sampling, where the model considers the results of
+            the tokens with top_p probability mass. So :obj:`0.1` means only
+            the tokens comprising the top 10% probability mass are considered.
+            (default: :obj:`1.0`)
+        n (int, optional): How many chat completion choices to generate for
+            each input message. (default: :obj:`1`)
+        stream (bool, optional): If True, partial message deltas will be sent
+            as data-only server-sent events as they become available.
+            (default: :obj:`False`)
+        max_tokens (int, optional): The maximum number of tokens to generate
+            in the chat completion. The total length of input tokens and
+            generated tokens is limited by the model's context length.
+            (default: :obj:`4096`)
+        presence_penalty (float, optional): Number between :obj:`-2.0` and
+            :obj:`2.0`. Positive values penalize new tokens based on whether
+            they appear in the text so far, increasing the model's likelihood
+            to talk about new topics. See more information about frequency and
+            presence penalties. (default: :obj:`0.0`)
+        frequency_penalty (float, optional): Number between :obj:`-2.0` and
+            :obj:`2.0`. Positive values penalize new tokens based on their
+            existing frequency in the text so far, decreasing the model's
+            likelihood to repeat the same line verbatim. See more information
+            about frequency and presence penalties. (default: :obj:`0.0`)
+        user (str, optional): A unique identifier representing your end-user,
+            which can help OpenAI to monitor and detect abuse.
+            (default: :obj:`""`)
+    """
+
+    temperature: float = 0.2  # openai default: 1.0
+    top_p: float = 1.0
+    n: int = 1
+    stream: bool = False
+    max_tokens: int = 4096
+    presence_penalty: float = 0.0
+    frequency_penalty: float = 0.0
+    user: str = ""
+
+
 @dataclass(frozen=True)
 class FunctionCallingConfig(ChatGPTConfig):
     r"""Defines the parameters for generating chat completions using the
@@ -100,6 +156,7 @@ class FunctionCallingConfig(ChatGPTConfig):
             :obj:`{"name": "my_function"}` forces the model to call that
             function. (default: :obj:`"auto"`)
     """
+
     functions: List[Dict[str, Any]] = field(default_factory=list)
     function_call: Union[Dict[str, str], str] = "auto"
 
@@ -128,7 +185,9 @@ class FunctionCallingConfig(ChatGPTConfig):
                 :obj:`function_call` argument.
         """
         return cls(
-            functions=[func.as_dict() for func in function_list],
+            functions=[
+                func.get_openai_function_schema() for func in function_list
+            ],
             function_call=function_call,
             **(kwargs or {}),
         )
@@ -147,13 +206,66 @@ class OpenSourceConfig(BaseConfig):
         api_params (ChatGPTConfig): An instance of :obj:ChatGPTConfig to
             contain the arguments to be passed to OpenAI API.
     """
+
     model_path: str
     server_url: str
-    api_params: ChatGPTConfig = ChatGPTConfig()
+    api_params: ChatGPTConfig = field(default_factory=ChatGPTConfig)
 
 
 OPENAI_API_PARAMS = {param for param in asdict(ChatGPTConfig()).keys()}
 OPENAI_API_PARAMS_WITH_FUNCTIONS = {
-    param
-    for param in asdict(FunctionCallingConfig()).keys()
+    param for param in asdict(FunctionCallingConfig()).keys()
 }
+
+
+@dataclass(frozen=True)
+class AnthropicConfig(BaseConfig):
+    r"""Defines the parameters for generating chat completions using the
+    Anthropic API.
+
+    See: https://docs.anthropic.com/claude/reference/complete_post
+    Args:
+        max_tokens_to_sample (int, optional): The maximum number of tokens to
+            generate before stopping. Note that Anthropic models may stop
+            before reaching this maximum. This parameter only specifies the
+            absolute maximum number of tokens to generate.
+            (default: :obj:`256`)
+        stop_sequences (List[str], optional): Sequences that will cause the
+            model to stop generating completion text. Anthropic models stop
+            on "\n\nHuman:", and may include additional built-in stop sequences
+            in the future. By providing the stop_sequences parameter, you may
+            include additional strings that will cause the model to stop
+            generating.
+        temperature (float, optional): Amount of randomness injected into the
+            response. Defaults to 1. Ranges from 0 to 1. Use temp closer to 0
+            for analytical / multiple choice, and closer to 1 for creative
+            and generative tasks.
+            (default: :obj:`1`)
+        top_p (float, optional): Use nucleus sampling. In nucleus sampling, we
+            compute the cumulative distribution over all the options for each
+            subsequent token in decreasing probability order and cut it off
+            once it reaches a particular probability specified by `top_p`.
+            You should either alter `temperature` or `top_p`,
+            but not both.
+            (default: :obj:`0.7`)
+        top_k (int, optional): Only sample from the top K options for each
+            subsequent token. Used to remove "long tail" low probability
+            responses.
+            (default: :obj:`5`)
+        metadata: An object describing metadata about the request.
+        stream (bool, optional): Whether to incrementally stream the response
+          using server-sent events.
+            (default: :obj:`False`)
+
+    """
+
+    max_tokens: int = 256
+    stop_sequences: Union[List[str], NotGiven] = NOT_GIVEN
+    temperature: float = 1
+    top_p: Union[float, NotGiven] = NOT_GIVEN
+    top_k: Union[int, NotGiven] = NOT_GIVEN
+    metadata: NotGiven = NOT_GIVEN
+    stream: bool = False
+
+
+ANTHROPIC_API_PARAMS = {param for param in asdict(AnthropicConfig()).keys()}

camel/embeddings/__init__.py

@@ -13,8 +13,10 @@
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 from .base import BaseEmbedding
 from .openai_embedding import OpenAIEmbedding
+from .sentence_transformers_embeddings import SentenceTransformerEncoder
 
 __all__ = [
     "BaseEmbedding",
     "OpenAIEmbedding",
+    "SentenceTransformerEncoder",
 ]

camel/embeddings/base.py

@@ -33,8 +33,9 @@ class BaseEmbedding(ABC, Generic[T]):
             **kwargs (Any): Extra kwargs passed to the embedding API.
 
         Returns:
-            List[List[float]]: A list that represents the generated embedding
-                as a list of floating-point numbers.
+            List[List[float]]: A list that represents the
+            generated embedding as a list of floating-point numbers or a
+            numpy matrix with embeddings.
         """
         pass
 

camel/embeddings/openai_embedding.py

@@ -15,9 +15,9 @@ from typing import Any, List
 
 from openai import OpenAI
 
-from camel.embeddings import BaseEmbedding
+from camel.embeddings.base import BaseEmbedding
 from camel.types import EmbeddingModelType
-from camel.utils import openai_api_key_required
+from camel.utils import api_key_required
 
 
 class OpenAIEmbedding(BaseEmbedding[str]):
@@ -41,7 +41,7 @@ class OpenAIEmbedding(BaseEmbedding[str]):
         self.output_dim = model_type.output_dim
         self.client = OpenAI()
 
-    @openai_api_key_required
+    @api_key_required
     def embed_list(
         self,
         objs: List[str],

camel/embeddings/sentence_transformers_embeddings.py

@@ -0,0 +1,65 @@
+# =========== 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, List, Union
+
+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`.
+
+    References:
+        https://www.sbert.net/
+    """
+
+    def __init__(self, model_name: str = 'intfloat/e5-large-v2'):
+        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`.
+        """
+        from sentence_transformers import SentenceTransformer
+
+        self.model = SentenceTransformer(model_name)
+
+    def embed_list(
+        self,
+        objs: Union[str, List[str]],
+        **kwargs: Any,
+    ) -> list:
+        r"""Generates embeddings for the given texts using the model.
+
+        Args:
+            objs (str | List[str]): The texts for which to generate the
+            embeddings.
+
+        Returns:
+            list: A list of float representing embeddings.
+        """
+        if not objs:
+            raise ValueError("Input text list is empty")
+        return self.model.encode(
+            objs, normalize_embeddings=True, **kwargs
+        ).tolist()
+
+    def get_output_dim(self) -> int:
+        r"""Returns the output dimension of the embeddings.
+
+        Returns:
+            int: The dimensionality of the embeddings.
+        """
+        return self.model.get_sentence_embedding_dimension()

camel/functions/__init__.py

@@ -12,16 +12,26 @@
 # limitations under the License.
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 
+from ..loaders.unstructured_io import UnstructuredIO
+from .google_maps_function import MAP_FUNCS
 from .math_functions import MATH_FUNCS
-from .openai_function import OpenAIFunction
+from .openai_function import (
+    OpenAIFunction,
+    get_openai_function_schema,
+    get_openai_tool_schema,
+)
 from .search_functions import SEARCH_FUNCS
+from .twitter_function import TWITTER_FUNCS
 from .weather_functions import WEATHER_FUNCS
-from .unstructured_io_fuctions import UnstructuredModules
 
 __all__ = [
     'OpenAIFunction',
+    'get_openai_tool_schema',
+    'get_openai_function_schema',
     'MATH_FUNCS',
     'SEARCH_FUNCS',
     'WEATHER_FUNCS',
-    'UnstructuredModules',
+    'MAP_FUNCS',
+    'TWITTER_FUNCS',
+    'UnstructuredIO',
 ]