camel-ai 0.2.11__py3-none-any.whl → 0.2.13__py3-none-any.whl

camel/models/reward/evaluator.py

@@ -0,0 +1,63 @@
+# ========= Copyright 2023-2024 @ 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-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+from typing import Dict, List
+
+from camel.models.reward import BaseRewardModel
+
+
+class Evaluator:
+    r"""Evaluator class to evaluate messages using a reward model and filter
+    data based on the scores.
+
+    Args:
+        reward_model (BaseRewardModel): A reward model to evaluate messages.
+    """
+
+    def __init__(self, reward_model: BaseRewardModel):
+        self.reward_model = reward_model
+
+    def evaluate(self, messages: List[Dict[str, str]]) -> Dict[str, float]:
+        r"""Evaluate the messages using the reward model.
+
+        Args:
+            messages (List[Dict[str, str]]): A list of messages where each
+                message is a dictionary with 'role' and 'content'.
+
+        Returns:
+            Dict[str, float]: A dictionary mapping score types to their values.
+        """
+        scores = self.reward_model.evaluate(messages)
+        return scores
+
+    def filter_data(
+        self, messages: List[Dict[str, str]], thresholds: Dict[str, float]
+    ) -> bool:
+        r"""Filter messages based on the scores.
+
+        Args:
+            messages (List[Dict[str, str]]): A list of messages where each
+                message is a dictionary with 'role' and 'content'.
+            thresholds (Dict[str, float]): A dictionary mapping score types to
+                their values.
+
+        Returns:
+            bool: A boolean indicating whether the messages pass the filter.
+        """
+        scores = self.evaluate(messages)
+        for score_type, threshold in thresholds.items():
+            if score_type not in scores:
+                raise ValueError(f"Score type {score_type} not found.")
+            if scores.get(score_type, 0) < threshold:
+                return False
+        return True

camel/models/reward/nemotron_model.py

@@ -0,0 +1,112 @@
+# ========= Copyright 2023-2024 @ 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-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+import os
+from typing import Dict, List, Optional, Union
+
+from openai import OpenAI
+
+from camel.models.reward import BaseRewardModel
+from camel.types import ChatCompletion, ModelType
+from camel.utils import api_keys_required
+
+
+class NemotronRewardModel(BaseRewardModel):
+    r"""Reward model based on the Nemotron model with OpenAI compatibility.
+
+    Args:
+        model_type (Union[ModelType, str]): Model for which a backend is
+            created.
+        api_key (Optional[str], optional): The API key for authenticating
+            with the model service. (default: :obj:`None`)
+        url (Optional[str], optional): The url to the model service.
+
+    Note:
+        The Nemotron model does not support model config.
+    """
+
+    def __init__(
+        self,
+        model_type: Union[ModelType, str],
+        api_key: Optional[str] = None,
+        url: Optional[str] = None,
+    ) -> None:
+        url = url or os.environ.get(
+            "NVIDIA_API_BASE_URL", "https://integrate.api.nvidia.com/v1"
+        )
+        api_key = api_key or os.environ.get("NVIDIA_API_KEY")
+        super().__init__(model_type, api_key, url)
+        self._client = OpenAI(
+            timeout=180,
+            max_retries=3,
+            base_url=self.url,
+            api_key=self.api_key,
+        )
+
+    @api_keys_required("NVIDIA_API_KEY")
+    def evaluate(self, messages: List[Dict[str, str]]) -> Dict[str, float]:
+        r"""Evaluate the messages using the Nemotron model.
+
+        Args:
+            messages (List[Dict[str, str]]): A list of messages where each
+                message is a dictionary format.
+
+        Returns:
+            Dict[str, float]:  A dictionary mapping score types to their
+                values.
+        """
+        response = self._client.chat.completions.create(
+            messages=messages,  # type: ignore[arg-type]
+            model=self.model_type,
+        )
+        scores = self._parse_scores(response)
+        return scores
+
+    def get_scores_types(self) -> List[str]:
+        r"""Get the list of score types that the reward model can return.
+
+        Returns:
+            List[str]: A list of score types that the reward model can return.
+        """
+        return [
+            "helpfulness",
+            "correctness",
+            "coherence",
+            "complexity",
+            "verbosity",
+        ]
+
+    def _parse_scores(self, response: ChatCompletion) -> Dict[str, float]:
+        r"""Parse the scores from the response.
+
+        Args:
+            response (ChatCompletion): A ChatCompletion object with the scores.
+
+        Returns:
+            Dict[str, float]: A dictionary mapping score types to their values.
+        """
+        try:
+            choices = response.choices
+            logprobs = (
+                choices[0].logprobs.content
+                if choices and choices[0].logprobs
+                else None
+            )
+            scores = (
+                {entry.token: entry.logprob for entry in logprobs if entry}
+                if logprobs
+                else {}
+            )
+            return scores
+        except Exception as e:
+            raise ValueError(f"Failed to parse scores: {e}")

camel/models/samba_model.py

@@ -95,7 +95,7 @@ class SambaModel(BaseModelBackend):
 
         if self._url == "https://api.sambanova.ai/v1":
             self._client = OpenAI(
-                timeout=60,
+                timeout=180,
                 max_retries=3,
                 base_url=self._url,
                 api_key=self._api_key,

camel/models/sglang_model.py

@@ -0,0 +1,225 @@
+# ========= Copyright 2023-2024 @ 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-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+import logging
+import threading
+import time
+from typing import Any, Dict, List, Optional, Union
+
+from openai import OpenAI, Stream
+
+from camel.configs import SGLANG_API_PARAMS, SGLangConfig
+from camel.messages import OpenAIMessage
+from camel.models import BaseModelBackend
+from camel.types import (
+    ChatCompletion,
+    ChatCompletionChunk,
+    ModelType,
+)
+from camel.utils import BaseTokenCounter, OpenAITokenCounter
+
+
+class SGLangModel(BaseModelBackend):
+    r"""SGLang service interface.
+
+    Args:
+        model_type (Union[ModelType, str]): Model for which a backend is
+            created.
+        model_config_dict (Optional[Dict[str, Any]], optional): A dictionary
+            that will be fed into:obj:`openai.ChatCompletion.create()`. If
+            :obj:`None`, :obj:`SGLangConfig().as_dict()` will be used.
+            (default: :obj:`None`)
+        api_key (Optional[str], optional): The API key for authenticating with
+            the model service. SGLang doesn't need API key, it would be ignored
+            if set. (default: :obj:`None`)
+        url (Optional[str], optional): The url to the model service. If not
+            provided, :obj:`"http://127.0.0.1:30000/v1"` will be used.
+            (default: :obj:`None`)
+        token_counter (Optional[BaseTokenCounter], optional): Token counter to
+            use for the model. If not provided, :obj:`OpenAITokenCounter(
+            ModelType.GPT_4O_MINI)` will be used.
+            (default: :obj:`None`)
+
+    Reference: https://sgl-project.github.io/backend/openai_api_completions.html
+    """
+
+    def __init__(
+        self,
+        model_type: Union[ModelType, str],
+        model_config_dict: Optional[Dict[str, Any]] = None,
+        api_key: Optional[str] = None,
+        url: Optional[str] = None,
+        token_counter: Optional[BaseTokenCounter] = None,
+    ) -> None:
+        if model_config_dict is None:
+            model_config_dict = SGLangConfig().as_dict()
+
+        self.server_process = None
+        self.last_run_time: Optional[float] = (
+            None  # Will be set when the server starts
+        )
+        self._lock = threading.Lock()
+        self._inactivity_thread: Optional[threading.Thread] = None
+
+        super().__init__(
+            model_type, model_config_dict, api_key, url, token_counter
+        )
+
+        self._client = None
+
+        if self._url:
+            # Initialize the client if an existing URL is provided
+            self._client = OpenAI(
+                timeout=180,
+                max_retries=3,
+                api_key="Set-but-ignored",  # required but ignored
+                base_url=self._url,
+            )
+
+    def _start_server(self) -> None:
+        from sglang.utils import (  # type: ignore[import-untyped]
+            execute_shell_command,
+            wait_for_server,
+        )
+
+        try:
+            if not self._url:
+                cmd = (
+                    f"python -m sglang.launch_server "
+                    f"--model-path {self.model_type} "
+                    f"--port 30000 "
+                    f"--host 0.0.0.0"
+                )
+
+                server_process = execute_shell_command(cmd)
+                wait_for_server("http://localhost:30000")
+                self._url = "http://127.0.0.1:30000/v1"
+                self.server_process = server_process
+                # Start the inactivity monitor in a background thread
+                self._inactivity_thread = threading.Thread(
+                    target=self._monitor_inactivity, daemon=True
+                )
+                self._inactivity_thread.start()
+            self.last_run_time = time.time()
+            # Initialize the client after the server starts
+            self._client = OpenAI(
+                timeout=180,
+                max_retries=3,
+                api_key="Set-but-ignored",  # required but ignored
+                base_url=self._url,
+            )
+        except Exception as e:
+            raise RuntimeError(f"Failed to start SGLang server: {e}") from e
+
+    def _ensure_server_running(self) -> None:
+        r"""Ensures that the server is running. If not, starts the server."""
+        with self._lock:
+            if self.server_process is None:
+                self._start_server()
+
+    def _monitor_inactivity(self):
+        r"""Monitor whether the server process has been inactive for over 10
+        minutes.
+        """
+        from sglang.utils import terminate_process
+
+        while True:
+            # Check every 10 seconds
+            time.sleep(10)
+            # Over 10 minutes
+            with self._lock:
+                # Over 10 minutes
+                if self.last_run_time and (
+                    time.time() - self.last_run_time > 600
+                ):
+                    if self.server_process:
+                        terminate_process(self.server_process)
+                        self.server_process = None
+                        self._client = None  # Invalidate the client
+                        logging.info(
+                            "Server process terminated due to inactivity."
+                        )
+                    break
+
+    @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.
+        """
+        if not self._token_counter:
+            self._token_counter = OpenAITokenCounter(ModelType.GPT_4O_MINI)
+        return self._token_counter
+
+    def check_model_config(self):
+        r"""Check whether the model configuration contains any
+        unexpected arguments to SGLang 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 SGLANG_API_PARAMS:
+                raise ValueError(
+                    f"Unexpected argument `{param}` is "
+                    "input into SGLang 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.
+        """
+
+        # Ensure server is running
+        self._ensure_server_running()
+
+        with self._lock:
+            # Update last run time
+            self.last_run_time = time.time()
+
+        if self._client is None:
+            raise RuntimeError(
+                "Client is not initialized. Ensure the server is running."
+            )
+
+        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/togetherai_model.py

@@ -72,7 +72,7 @@ class TogetherAIModel(BaseModelBackend):
         )
 
         self._client = OpenAI(
-            timeout=60,
+            timeout=180,
             max_retries=3,
             api_key=self._api_key,
             base_url=self._url,

camel/models/vllm_model.py

@@ -72,9 +72,9 @@ class VLLMModel(BaseModelBackend):
             self._start_server()
         # Use OpenAI cilent as interface call vLLM
         self._client = OpenAI(
-            timeout=60,
+            timeout=180,
             max_retries=3,
-            api_key="Set-but-ignored",  # required but ignored
+            api_key="EMPTY",  # required but ignored
             base_url=self._url,
         )
 

camel/models/yi_model.py

@@ -70,7 +70,7 @@ class YiModel(BaseModelBackend):
             model_type, model_config_dict, api_key, url, token_counter
         )
         self._client = OpenAI(
-            timeout=60,
+            timeout=180,
             max_retries=3,
             api_key=self._api_key,
             base_url=self._url,

camel/models/zhipuai_model.py

@@ -70,7 +70,7 @@ class ZhipuAIModel(BaseModelBackend):
             model_type, model_config_dict, api_key, url, token_counter
         )
         self._client = OpenAI(
-            timeout=60,
+            timeout=180,
             max_retries=3,
             api_key=self._api_key,
             base_url=self._url,

camel/personas/persona_hub.py

@@ -11,7 +11,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
-import ast
+import json
 import re
 import uuid
 from functools import lru_cache
@@ -130,7 +130,7 @@ class PersonaHub:
                 text_to_persona_prompt_instruction,
                 response_format=PersonaResponse,  # type: ignore[arg-type]
             )
-            parsed_content = ast.literal_eval(response.msg.content)
+            parsed_content = json.loads(response.msg.content)
             persona.name = parsed_content["persona_name"]
             persona.description = parsed_content["persona_description"]
         except Exception as e:

camel/runtime/configs.py

@@ -21,23 +21,23 @@ class TaskConfig(BaseModel):
 
     Arttributes:
         cmd (str or list): Command to be executed
-        stdout (bool): Attach to stdout. (default::obj: `True`)
-        stderr (bool): Attach to stderr. (default::obj: `True`)
-        stdin (bool): Attach to stdin. (default::obj: `False`)
-        tty (bool): Allocate a pseudo-TTY. (default::obj: `False`)
-        privileged (bool): Run as privileged. (default::obj: `False`)
-        user (str): User to execute command as. (default::obj: `""`)
+        stdout (bool): Attach to stdout. (default: :obj: `True`)
+        stderr (bool): Attach to stderr. (default: :obj: `True`)
+        stdin (bool): Attach to stdin. (default: :obj: `False`)
+        tty (bool): Allocate a pseudo-TTY. (default: :obj: `False`)
+        privileged (bool): Run as privileged. (default: :obj: `False`)
+        user (str): User to execute command as. (default: :obj: `""`)
         detach (bool): If true, detach from the exec command.
-            (default::obj: `False`)
-        stream (bool): Stream response data. (default::obj: `False`)
+            (default: :obj: `False`)
+        stream (bool): Stream response data. (default: :obj: `False`)
         socket (bool): Return the connection socket to allow custom
-            read/write operations. (default::obj: `False`)
+            read/write operations. (default: :obj: `False`)
         environment (dict or list): A dictionary or a list of strings in
             the following format ``["PASSWORD=xxx"]`` or
-            ``{"PASSWORD": "xxx"}``. (default::obj: `None`)
+            ``{"PASSWORD": "xxx"}``. (default: :obj: `None`)
         workdir (str): Path to working directory for this exec session.
-            (default::obj: `None`)
-        demux (bool): Return stdout and stderr separately. (default::obj:
+            (default: :obj: `None`)
+        demux (bool): Return stdout and stderr separately. (default: :obj:
             `False`)
     """
 

camel/runtime/docker_runtime.py

@@ -42,10 +42,10 @@ class DockerRuntime(BaseRuntime):
 
     Args:
         image (str): The name of the Docker image to use for the runtime.
-        port (int): The port number to use for the runtime API. (default::obj:
+        port (int): The port number to use for the runtime API. (default: :obj:
             `8000`)
         remove (bool): Whether to remove the container after stopping it. '
-            (default::obj: `True`)
+            (default: :obj: `True`)
         kwargs (dict): Additional keyword arguments to pass to the
             Docker client.
     """
@@ -170,7 +170,7 @@ class DockerRuntime(BaseRuntime):
 
         Args:
             time_out (int): The number of seconds to wait for the container to
-                start. (default::obj: `15`)
+                start. (default: :obj: `15`)
 
         Returns:
             DockerRuntime: The DockerRuntime instance.
@@ -259,9 +259,9 @@ class DockerRuntime(BaseRuntime):
                 list of functions to add.
             entrypoint (str): The entrypoint for the function.
             redirect_stdout (bool): Whether to return the stdout of
-                the function. (default::obj: `False`)
+                the function. (default: :obj: `False`)
             arguments (Optional[Dict[str, Any]]): The arguments for the
-                function. (default::obj: `None`)
+                function. (default: :obj: `None`)
 
         Returns:
             DockerRuntime: The DockerRuntime instance.
@@ -330,7 +330,7 @@ class DockerRuntime(BaseRuntime):
 
         Args:
             remove (Optional[bool]): Whether to remove the container
-                after stopping it. (default::obj: `None`)
+                after stopping it. (default: :obj: `None`)
 
         Returns:
             DockerRuntime: The DockerRuntime instance.
@@ -366,7 +366,7 @@ class DockerRuntime(BaseRuntime):
         r"""Wait for the API Server to be ready.
 
         Args:
-            timeout (int): The number of seconds to wait. (default::obj: `10`)
+            timeout (int): The number of seconds to wait. (default: :obj: `10`)
 
         Returns:
             bool: Whether the API Server is ready.

camel/runtime/llm_guard_runtime.py

@@ -68,9 +68,9 @@ class LLMGuardRuntime(BaseRuntime):
     Arguments:
         prompt (str): The prompt to use for the language model. (default:
             :obj:`GUARDPROMPT`)
-        model (BaseModelBackend): The language model to use. (default::obj:
+        model (BaseModelBackend): The language model to use. (default: :obj:
             `None`)
-        verbose (bool): Whether to print verbose output. (default::obj:
+        verbose (bool): Whether to print verbose output. (default: :obj:
             `False`)
     """
 
@@ -114,7 +114,7 @@ class LLMGuardRuntime(BaseRuntime):
             funcs (FunctionTool or List[FunctionTool]): The function or
                 list of functions to add.
             threshold (int): The risk threshold for functions.
-                (default::obj:`2`)
+                (default: :obj:`2`)
 
         Returns:
             LLMGuardRuntime: The current runtime.

camel/runtime/remote_http_runtime.py

@@ -36,9 +36,9 @@ class RemoteHttpRuntime(BaseRuntime):
 
     Args:
         host (str): The host of the remote server.
-        port (int): The port of the remote server. (default::obj: `8000`)
+        port (int): The port of the remote server. (default: :obj: `8000`)
         python_exec (str): The python executable to run the API server.
-            (default::obj: `python3`)
+            (default: :obj: `python3`)
     """
 
     def __init__(
@@ -90,9 +90,9 @@ class RemoteHttpRuntime(BaseRuntime):
                 list of functions to add.
             entrypoint (str): The entrypoint for the function.
             redirect_stdout (bool): Whether to return the stdout of
-                the function. (default::obj: `False`)
+                the function. (default: :obj: `False`)
             arguments (Optional[Dict[str, Any]]): The arguments for the
-                function. (default::obj: `None`)
+                function. (default: :obj: `None`)
 
         Returns:
             RemoteHttpRuntime: The current runtime.
@@ -162,7 +162,7 @@ class RemoteHttpRuntime(BaseRuntime):
         r"""Wait for the API Server to be ready.
 
         Args:
-            timeout (int): The number of seconds to wait. (default::obj: `10`)
+            timeout (int): The number of seconds to wait. (default: :obj: `10`)
 
         Returns:
             bool: Whether the API Server is ready.

camel/runtime/utils/function_risk_toolkit.py

@@ -22,7 +22,7 @@ class FunctionRiskToolkit(BaseToolkit):
 
     Args:
         verbose (Optional[bool]): Whether to print verbose output.
-            (default::obj:`False`)
+            (default: :obj:`False`)
     """
 
     def __init__(self, verbose: Optional[bool] = False):

camel/runtime/utils/ignore_risk_toolkit.py

@@ -22,9 +22,9 @@ class IgnoreRiskToolkit(BaseToolkit):
 
     Args:
         function_names (Optional[List[str]]): A list of function names to
-            ignore risks for. (default::obj:`None`)
+            ignore risks for. (default: :obj:`None`)
         verbose (Optional[bool]): Whether to print verbose output.
-            (default::obj:`False`)
+            (default: :obj:`False`)
     """
 
     def __init__(

camel/schemas/openai_converter.py

@@ -28,8 +28,8 @@ from camel.utils import (
 from .base import BaseConverter
 
 DEFAULT_CONVERTER_PROMPTS = """
-    Extract key entities and attributes from the provided text,
-        and convert them into a structured JSON format.
+    Extract key entities and attributes from the user 
+    provided text, and convert them into a structured JSON format.
 """
 
 

camel/societies/workforce/role_playing_worker.py

@@ -13,7 +13,7 @@
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 from __future__ import annotations
 
-import ast
+import json
 from typing import Dict, List, Optional
 
 from colorama import Fore
@@ -173,7 +173,7 @@ class RolePlayingWorker(Worker):
             content=prompt,
         )
         response = self.summarize_agent.step(req, response_format=TaskResult)
-        result_dict = ast.literal_eval(response.msg.content)
+        result_dict = json.loads(response.msg.content)
         task_result = TaskResult(**result_dict)
         task.result = task_result.content