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

camel/models/model_factory.py

@@ -11,14 +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.types import ModelType
+from camel.models.zhipuai_model import ZhipuAIModel
+from camel.types import ModelPlatformType, ModelType
 
 
 class ModelFactory:
@@ -30,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.
@@ -50,16 +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
+
+        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:
-            raise ValueError(f"Unknown model type `{model_type}` is input")
+            raise ValueError(f"Invalid model type `{model_type}` provided.")
 
-        inst = model_class(model_type, model_config_dict, api_key)
-        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:
@@ -150,6 +155,7 @@ class OpenSourceModel(BaseModelBackend):
     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.
         """

camel/models/openai_model.py

@@ -20,7 +20,11 @@ from camel.configs import OPENAI_API_PARAMS
 from camel.messages import OpenAIMessage
 from camel.models import BaseModelBackend
 from camel.types import ChatCompletion, ChatCompletionChunk, ModelType
-from camel.utils import BaseTokenCounter, OpenAITokenCounter, api_key_required
+from camel.utils import (
+    BaseTokenCounter,
+    OpenAITokenCounter,
+    model_api_key_required,
+)
 
 
 class OpenAIModel(BaseModelBackend):
@@ -31,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.
 
@@ -41,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
 
@@ -62,7 +71,7 @@ class OpenAIModel(BaseModelBackend):
             self._token_counter = OpenAITokenCounter(self.model_type)
         return self._token_counter
 
-    @api_key_required
+    @model_api_key_required
     def run(
         self,
         messages: List[OpenAIMessage],

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/models/zhipuai_model.py

@@ -0,0 +1,125 @@
+# =========== 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.models import BaseModelBackend
+from camel.types import ChatCompletion, ChatCompletionChunk, ModelType
+from camel.utils import (
+    BaseTokenCounter,
+    OpenAITokenCounter,
+    model_api_key_required,
+)
+
+
+class ZhipuAIModel(BaseModelBackend):
+    r"""ZhipuAI API in a unified BaseModelBackend interface."""
+
+    def __init__(
+        self,
+        model_type: ModelType,
+        model_config_dict: Dict[str, Any],
+        api_key: Optional[str] = None,
+        url: Optional[str] = None,
+    ) -> None:
+        r"""Constructor for ZhipuAI backend.
+
+        Args:
+            model_type (ModelType): Model for which a backend is created,
+                such as GLM_* series.
+            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
+                ZhipuAI service. (default: :obj:`None`)
+        """
+        super().__init__(model_type, model_config_dict)
+        self._url = url or os.environ.get("ZHIPUAI_API_BASE_URL")
+        self._api_key = api_key or os.environ.get("ZHIPUAI_API_KEY")
+        self._client = OpenAI(
+            timeout=60,
+            max_retries=3,
+            api_key=self._api_key,
+            base_url=self._url,
+        )
+        self._token_counter: Optional[BaseTokenCounter] = None
+
+    @model_api_key_required
+    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.
+        """
+        # Use OpenAI cilent as interface call ZhipuAI
+        # Reference: https://open.bigmodel.cn/dev/api#openai_sdk
+        response = self._client.chat.completions.create(
+            messages=messages,
+            model=self.model_type.value,
+            **self.model_config_dict,
+        )
+        return response
+
+    @property
+    def token_counter(self) -> BaseTokenCounter:
+        r"""Initialize the token counter for the model backend.
+
+        Returns:
+            OpenAITokenCounter: The token counter following the model's
+                tokenization style.
+        """
+
+        if not self._token_counter:
+            # It's a temporary setting for 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."
+                )
+        pass
+
+    @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/prompts/__init__.py

@@ -14,7 +14,11 @@
 from .ai_society import AISocietyPromptTemplateDict
 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
@@ -36,5 +40,7 @@ __all__ = [
     'TaskPromptTemplateDict',
     'PromptTemplateGenerator',
     'SolutionExtractionPromptTemplateDict',
+    'GenerateTextEmbeddingDataPromptTemplateDict',
     'ObjectRecognitionPromptTemplateDict',
+    'DescriptionVideoPromptTemplateDict',
 ]

camel/prompts/base.py

@@ -208,7 +208,8 @@ class TextPromptDict(Dict[Any, TextPrompt]):
     EMBODIMENT_PROMPT = TextPrompt(
         "System information :"
         + "\n".join(
-            f"{key}: {value}" for key, value in get_system_information().items()
+            f"{key}: {value}"
+            for key, value in get_system_information().items()
         )
         + "\n"
         + """You are the physical embodiment of the {role} who is working on solving a task: {task}.

camel/prompts/descripte_video_prompt.py

@@ -0,0 +1,33 @@
+# =========== 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.base import TextPrompt, TextPromptDict
+from camel.types import RoleType
+
+
+# flake8: noqa :E501
+class DescriptionVideoPromptTemplateDict(TextPromptDict):
+    ASSISTANT_PROMPT = TextPrompt(
+        """You are a master of video analysis. 
+        Please provide a shot description of the content of the current video."""
+    )
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self.update(
+            {
+                RoleType.ASSISTANT: self.ASSISTANT_PROMPT,
+            }
+        )

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