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

camel/agents/role_assignment_agent.py

@@ -14,7 +14,7 @@
 import re
 from typing import Any, Dict, Optional, Union
 
-from camel.agents import ChatAgent
+from camel.agents.chat_agent import ChatAgent
 from camel.messages import BaseMessage
 from camel.prompts import TextPrompt
 from camel.types import ModelType, RoleType
@@ -68,21 +68,27 @@ class RoleAssignmentAgent(ChatAgent):
         expert_prompt = "===== ANSWER PROMPT =====\n" + "\n".join(
             f"Domain expert {i + 1}: <BLANK>\n"
             f"Associated competencies, characteristics, duties "
-            f"and workflows: <BLANK>. End." for i in range(num_roles or 0))
+            f"and workflows: <BLANK>. End."
+            for i in range(num_roles or 0)
+        )
         role_assignment_generation_prompt = TextPrompt(
-            "You are a role assignment agent, and you're in charge of " +
-            "recruiting {num_roles} experts for the following task." +
-            "\n==== TASK =====\n {task}\n\n" +
-            "Identify the domain experts you'd recruit and detail their " +
-            "associated competencies, characteristics, duties and workflows " +
-            "to complete the task.\n " +
-            "Your answer MUST adhere to the format of ANSWER PROMPT, and " +
-            "ONLY answer the BLANKs.\n" + expert_prompt)
+            "You are a role assignment agent, and you're in charge of "
+            + "recruiting {num_roles} experts for the following task."
+            + "\n==== TASK =====\n {task}\n\n"
+            + "Identify the domain experts you'd recruit and detail their "
+            + "associated competencies, characteristics, duties and workflows "
+            + "to complete the task.\n "
+            + "Your answer MUST adhere to the format of ANSWER PROMPT, and "
+            + "ONLY answer the BLANKs.\n"
+            + expert_prompt
+        )
         role_assignment_generation = role_assignment_generation_prompt.format(
-            num_roles=num_roles, task=task_prompt)
+            num_roles=num_roles, task=task_prompt
+        )
 
         role_assignment_generation_msg = BaseMessage.make_user_message(
-            role_name="Role Assigner", content=role_assignment_generation)
+            role_name="Role Assigner", content=role_assignment_generation
+        )
 
         response = self.step(input_message=role_assignment_generation_msg)
 
@@ -91,21 +97,25 @@ class RoleAssignmentAgent(ChatAgent):
 
         # Distribute the output completions into role names and descriptions
         role_names = [
-            desc.replace("<|", "").replace("|>", "") for desc in re.findall(
+            desc.replace("<|", "").replace("|>", "")
+            for desc in re.findall(
                 r"Domain expert \d: (.+?)\nAssociated competencies,",
                 msg.content,
                 re.DOTALL,
             )
         ]
         role_descriptions = [
-            desc.replace("<|", "").replace("|>", "") for desc in re.findall(
+            desc.replace("<|", "").replace("|>", "")
+            for desc in re.findall(
                 r"Associated competencies, characteristics, "
-                r"duties and workflows: (.+?) End.", msg.content, re.DOTALL)
+                r"duties and workflows: (.+?) End.",
+                msg.content,
+                re.DOTALL,
+            )
         ]
 
         if len(role_names) != num_roles or len(role_descriptions) != num_roles:
-            raise RuntimeError(
-                "Got None or insufficient information of roles.")
+            raise RuntimeError("Got None or insufficient information of roles.")
         if terminated:
             raise RuntimeError("Role assignment failed.")
 

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/__init__.py

@@ -0,0 +1,29 @@
+# =========== 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 .anthropic_config import ANTHROPIC_API_PARAMS, AnthropicConfig
+from .base_config import BaseConfig
+from .openai_config import (
+    OPENAI_API_PARAMS,
+    ChatGPTConfig,
+    OpenSourceConfig,
+)
+
+__all__ = [
+    'BaseConfig',
+    'ChatGPTConfig',
+    'OPENAI_API_PARAMS',
+    'AnthropicConfig',
+    'ANTHROPIC_API_PARAMS',
+    'OpenSourceConfig',
+]

camel/configs/anthropic_config.py

@@ -0,0 +1,73 @@
+# =========== 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 __future__ import annotations
+
+from dataclasses import asdict, dataclass
+
+from anthropic._types import NOT_GIVEN, NotGiven
+
+from camel.configs.base_config import BaseConfig
+
+
+@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 (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: list[str] | NotGiven = NOT_GIVEN
+    temperature: float = 1
+    top_p: float | NotGiven = NOT_GIVEN
+    top_k: int | NotGiven = NOT_GIVEN
+    metadata: NotGiven = NOT_GIVEN
+    stream: bool = False
+
+
+ANTHROPIC_API_PARAMS = {param for param in asdict(AnthropicConfig()).keys()}

camel/configs/base_config.py

@@ -0,0 +1,22 @@
+# =========== 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 __future__ import annotations
+
+from abc import ABC
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class BaseConfig(ABC):  # noqa: B024
+    pass

camel/{configs.py → configs/openai_config.py}

@@ -11,16 +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 abc import ABC
+from __future__ import annotations
+
 from dataclasses import asdict, dataclass, field
-from typing import Any, Dict, List, Optional, Sequence, Union
+from typing import TYPE_CHECKING, Optional, Sequence
 
-from camel.functions import OpenAIFunction
+from openai._types import NOT_GIVEN, NotGiven
 
+from camel.configs.base_config import BaseConfig
 
-@dataclass(frozen=True)
-class BaseConfig(ABC):
-    pass
+if TYPE_CHECKING:
+    from camel.functions import OpenAIFunction
 
 
 @dataclass(frozen=True)
@@ -71,67 +72,45 @@ class ChatGPTConfig(BaseConfig):
         user (str, optional): A unique identifier representing your end-user,
             which can help OpenAI to monitor and detect abuse.
             (default: :obj:`""`)
+        tools (list[OpenAIFunction], optional): A list of tools the model may
+            call. Currently, only functions are supported as a tool. Use this
+            to provide a list of functions the model may generate JSON inputs
+            for. A max of 128 functions are supported.
+        tool_choice (Union[dict[str, str], str], optional): Controls which (if
+            any) tool is called by the model. :obj:`"none"` means the model
+            will not call any tool and instead generates a message.
+            :obj:`"auto"` means the model can pick between generating a
+            message or calling one or more tools.  :obj:`"required"` means the
+            model must call one or more tools. Specifying a particular tool
+            via {"type": "function", "function": {"name": "my_function"}}
+            forces the model to call that tool. :obj:`"none"` is the default
+            when no tools are present. :obj:`"auto"` is the default if tools
+            are present.
     """
+
     temperature: float = 0.2  # openai default: 1.0
     top_p: float = 1.0
     n: int = 1
     stream: bool = False
-    stop: Optional[Union[str, Sequence[str]]] = None
-    max_tokens: Optional[int] = None
+    stop: str | Sequence[str] | NotGiven = NOT_GIVEN
+    max_tokens: int | NotGiven = NOT_GIVEN
     presence_penalty: float = 0.0
     frequency_penalty: float = 0.0
-    logit_bias: Dict = field(default_factory=dict)
+    logit_bias: dict = field(default_factory=dict)
     user: str = ""
+    tools: Optional[list[OpenAIFunction]] = None
+    tool_choice: Optional[dict[str, str] | str] = None
 
+    def __post_init__(self):
+        if self.tools is not None:
+            object.__setattr__(
+                self,
+                'tools',
+                [tool.get_openai_tool_schema() for tool in self.tools],
+            )
 
-@dataclass(frozen=True)
-class FunctionCallingConfig(ChatGPTConfig):
-    r"""Defines the parameters for generating chat completions using the
-    OpenAI API with functions included.
-
-    Args:
-        functions (List[Dict[str, Any]]): A list of functions the model may
-            generate JSON inputs for.
-        function_call (Union[Dict[str, str], str], optional): Controls how the
-            model responds to function calls. :obj:`"none"` means the model
-            does not call a function, and responds to the end-user.
-            :obj:`"auto"` means the model can pick between an end-user or
-            calling a function. Specifying a particular function via
-            :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"
 
-    @classmethod
-    def from_openai_function_list(
-        cls,
-        function_list: List[OpenAIFunction],
-        function_call: Union[Dict[str, str], str] = "auto",
-        kwargs: Optional[Dict[str, Any]] = None,
-    ):
-        r"""Class method for creating an instance given the function-related
-        arguments.
-
-        Args:
-            function_list (List[OpenAIFunction]): The list of function objects
-                to be loaded into this configuration and passed to the model.
-            function_call (Union[Dict[str, str], str], optional): Controls how
-                the model responds to function calls, as specified in the
-                creator's documentation.
-            kwargs (Optional[Dict[str, Any]]): The extra modifications to be
-                made on the original settings defined in :obj:`ChatGPTConfig`.
-
-        Return:
-            FunctionCallingConfig: A new instance which loads the given
-                function list into a list of dictionaries and the input
-                :obj:`function_call` argument.
-        """
-        return cls(
-            functions=[func.as_dict() for func in function_list],
-            function_call=function_call,
-            **(kwargs or {}),
-        )
+OPENAI_API_PARAMS = {param for param in asdict(ChatGPTConfig()).keys()}
 
 
 @dataclass(frozen=True)
@@ -147,13 +126,7 @@ 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()
-
-
-OPENAI_API_PARAMS = {param for param in asdict(ChatGPTConfig()).keys()}
-OPENAI_API_PARAMS_WITH_FUNCTIONS = {
-    param
-    for param in asdict(FunctionCallingConfig()).keys()
-}
+    api_params: ChatGPTConfig = field(default_factory=ChatGPTConfig)

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

@@ -11,13 +11,14 @@
 # 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
+import os
+from typing import Any, List, Optional
 
 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]):
@@ -26,6 +27,8 @@ class OpenAIEmbedding(BaseEmbedding[str]):
     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
+            OpenAI service. (default: :obj:`None`)
 
     Raises:
         RuntimeError: If an unsupported model type is specified.
@@ -34,14 +37,16 @@ class OpenAIEmbedding(BaseEmbedding[str]):
     def __init__(
         self,
         model_type: EmbeddingModelType = EmbeddingModelType.ADA_2,
+        api_key: Optional[str] = None,
     ) -> 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
-        self.client = OpenAI()
+        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)
 
-    @openai_api_key_required
+    @api_key_required
     def embed_list(
         self,
         objs: List[str],