camel-ai 0.2.38__py3-none-any.whl → 0.2.40__py3-none-any.whl

camel/models/modelscope_model.py

@@ -0,0 +1,208 @@
+# ========= 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 Any, Dict, List, Optional, Type, Union
+
+from openai import AsyncOpenAI, AsyncStream, OpenAI, Stream
+from pydantic import BaseModel
+
+from camel.configs import MODELSCOPE_API_PARAMS, ModelScopeConfig
+from camel.messages import OpenAIMessage
+from camel.models import BaseModelBackend
+from camel.models._utils import try_modify_message_with_format
+from camel.types import (
+    ChatCompletion,
+    ChatCompletionChunk,
+    ModelType,
+)
+from camel.utils import (
+    BaseTokenCounter,
+    OpenAITokenCounter,
+    api_keys_required,
+)
+
+
+class ModelScopeModel(BaseModelBackend):
+    r"""ModelScope API in a unified BaseModelBackend interface.
+
+    Args:
+        model_type (Union[ModelType, str]): Model for which a backend is
+            created, one of ModelScope series.
+        model_config_dict (Optional[Dict[str, Any]], optional): A dictionary
+            that will be fed into:obj:`openai.ChatCompletion.create()`. If
+            :obj:`None`, :obj:`ModelScopeConfig().as_dict()` will be used.
+            (default: :obj:`None`)
+        api_key (Optional[str], optional): The MODELSCOPE_SDK_TOKEN for
+            authenticating with the ModelScope service. (default: :obj:`None`)
+            refer to the following link for more details:
+            https://modelscope.cn/my/myaccesstoken
+        url (Optional[str], optional): The url to the ModelScope service.
+            (default: :obj:`https://api-inference.modelscope.cn/v1/`)
+        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`)
+        timeout (Optional[float], optional): The timeout value in seconds for
+            API calls. If not provided, will fall back to the MODEL_TIMEOUT
+            environment variable or default to 180 seconds.
+            (default: :obj:`None`)
+    """
+
+    @api_keys_required(
+        [
+            ("api_key", 'MODELSCOPE_SDK_TOKEN'),
+        ]
+    )
+    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,
+        timeout: Optional[float] = None,
+    ) -> None:
+        if model_config_dict is None:
+            model_config_dict = ModelScopeConfig().as_dict()
+        api_key = api_key or os.environ.get("MODELSCOPE_SDK_TOKEN")
+        url = url or os.environ.get(
+            "MODELSCOPE_API_BASE_URL",
+            "https://api-inference.modelscope.cn/v1/",
+        )
+        timeout = timeout or float(os.environ.get("MODEL_TIMEOUT", 180))
+        super().__init__(
+            model_type, model_config_dict, api_key, url, token_counter, timeout
+        )
+        self._client = OpenAI(
+            timeout=self._timeout,
+            max_retries=3,
+            api_key=self._api_key,
+            base_url=self._url,
+        )
+        self._async_client = AsyncOpenAI(
+            timeout=self._timeout,
+            max_retries=3,
+            api_key=self._api_key,
+            base_url=self._url,
+        )
+
+    async def _arun(
+        self,
+        messages: List[OpenAIMessage],
+        response_format: Optional[Type[BaseModel]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
+        r"""Runs inference of ModelScope chat completion.
+
+        Args:
+            messages (List[OpenAIMessage]): Message list with the chat history
+                in OpenAI API format.
+
+        Returns:
+            Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
+                `ChatCompletion` in the non-stream mode, or
+                `AsyncStream[ChatCompletionChunk]` in the stream mode.
+        """
+        request_config = self._prepare_request(
+            messages, response_format, tools
+        )
+
+        response = await self._async_client.chat.completions.create(
+            messages=messages,
+            model=self.model_type,
+            **request_config,
+        )
+        return response
+
+    def _run(
+        self,
+        messages: List[OpenAIMessage],
+        response_format: Optional[Type[BaseModel]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> Union[ChatCompletion, Stream[ChatCompletionChunk]]:
+        r"""Runs inference of ModelScope 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.
+        """
+        request_config = self._prepare_request(
+            messages, response_format, tools
+        )
+
+        response = self._client.chat.completions.create(
+            messages=messages,
+            model=self.model_type,
+            **request_config,
+        )
+        return response
+
+    def _prepare_request(
+        self,
+        messages: List[OpenAIMessage],
+        response_format: Optional[Type[BaseModel]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> Dict[str, Any]:
+        request_config = self.model_config_dict.copy()
+        if tools:
+            request_config["tools"] = tools
+        elif response_format:
+            try_modify_message_with_format(messages[-1], response_format)
+            request_config["response_format"] = {"type": "json_object"}
+
+        return request_config
+
+    @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:
+            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 ModelScope API.
+
+        Raises:
+            ValueError: If the model configuration dictionary contains any
+                unexpected arguments to ModelScope API.
+        """
+        for param in self.model_config_dict:
+            if param not in MODELSCOPE_API_PARAMS:
+                raise ValueError(
+                    f"Unexpected argument `{param}` is "
+                    "input into ModelScope model backend."
+                )
+
+    @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/openai_audio_models.py

@@ -78,8 +78,8 @@ class OpenAIAudioModels(BaseAudioModel):
         Returns:
             Union[List[_legacy_response.HttpxBinaryResponseContent],
                 _legacy_response.HttpxBinaryResponseContent]: List of response
-                content object from OpenAI if input charaters more than 4096,
-                single response content if input charaters less than 4096.
+                content object from OpenAI if input characters more than 4096,
+                single response content if input characters less than 4096.
 
         Raises:
             Exception: If there's an error during the TTS API call.

camel/models/openai_model.py

@@ -104,7 +104,7 @@ class OpenAIModel(BaseModelBackend):
         )
 
     def _sanitize_config(self, config_dict: Dict[str, Any]) -> Dict[str, Any]:
-        """Sanitize the model configuration for O1 models."""
+        r"""Sanitize the model configuration for O1 models."""
 
         if self.model_type in [
             ModelType.O1,
@@ -113,7 +113,7 @@ class OpenAIModel(BaseModelBackend):
             ModelType.O3_MINI,
         ]:
             warnings.warn(
-                "Warning: You are using an O1 model (O1_MINI or O1_PREVIEW), "
+                "Warning: You are using an reasoning model (O1 or O3), "
                 "which has certain limitations, reference: "
                 "`https://platform.openai.com/docs/guides/reasoning`.",
                 UserWarning,
@@ -125,6 +125,52 @@ class OpenAIModel(BaseModelBackend):
             }
         return config_dict
 
+    def _adapt_messages_for_o1_models(
+        self, messages: List[OpenAIMessage]
+    ) -> List[OpenAIMessage]:
+        r"""Adjust message roles to comply with O1 model requirements by
+        converting 'system' or 'developer' to 'user' role.
+
+        Args:
+            messages (List[OpenAIMessage]): Message list with the chat history
+                in OpenAI API format.
+
+        Returns:
+            processed_messages (List[OpenAIMessage]): Return a new list of
+                messages to avoid mutating input.
+        """
+
+        # Define supported O1 model types as a class constant would be better
+        O1_MODEL_TYPES = {ModelType.O1_MINI, ModelType.O1_PREVIEW}
+
+        if self.model_type not in O1_MODEL_TYPES:
+            return messages.copy()
+
+        # Issue warning only once using class state
+        if not hasattr(self, "_o1_warning_issued"):
+            warnings.warn(
+                "O1 models (O1_MINI/O1_PREVIEW) have role limitations: "
+                "System or Developer messages will be converted to user role."
+                "Reference: https://community.openai.com/t/"
+                "developer-role-not-accepted-for-o1-o1-mini-o3-mini/1110750/7",
+                UserWarning,
+                stacklevel=2,
+            )
+            self._o1_warning_issued = True
+
+        # Create new message list to avoid mutating input
+        processed_messages = []
+        for message in messages:
+            processed_message = message.copy()
+            if (
+                processed_message["role"] == "system"
+                or processed_message["role"] == "developer"
+            ):
+                processed_message["role"] = "user"  # type: ignore[arg-type]
+            processed_messages.append(processed_message)
+
+        return processed_messages
+
     @property
     def token_counter(self) -> BaseTokenCounter:
         r"""Initialize the token counter for the model backend.
@@ -158,6 +204,7 @@ class OpenAIModel(BaseModelBackend):
                 `ChatCompletion` in the non-stream mode, or
                 `Stream[ChatCompletionChunk]` in the stream mode.
         """
+        messages = self._adapt_messages_for_o1_models(messages)
         response_format = response_format or self.model_config_dict.get(
             "response_format", None
         )

camel/models/togetherai_model.py

@@ -113,7 +113,7 @@ class TogetherAIModel(BaseModelBackend):
                 `ChatCompletion` in the non-stream mode, or
                 `AsyncStream[ChatCompletionChunk]` in the stream mode.
         """
-        # Use OpenAI cilent as interface call Together AI
+        # Use OpenAI client as interface call Together AI
         # Reference: https://docs.together.ai/docs/openai-api-compatibility
         response = await self._async_client.chat.completions.create(
             messages=messages,
@@ -139,7 +139,7 @@ class TogetherAIModel(BaseModelBackend):
                 `ChatCompletion` in the non-stream mode, or
                 `Stream[ChatCompletionChunk]` in the stream mode.
         """
-        # Use OpenAI cilent as interface call Together AI
+        # Use OpenAI client as interface call Together AI
         # Reference: https://docs.together.ai/docs/openai-api-compatibility
         response = self._client.chat.completions.create(
             messages=messages,

camel/models/vllm_model.py

@@ -77,7 +77,7 @@ class VLLMModel(BaseModelBackend):
         )
         if not self._url:
             self._start_server()
-        # Use OpenAI cilent as interface call vLLM
+        # Use OpenAI client as interface call vLLM
         self._client = OpenAI(
             timeout=self._timeout,
             max_retries=3,

camel/models/zhipuai_model.py

@@ -111,7 +111,7 @@ class ZhipuAIModel(BaseModelBackend):
                 `ChatCompletion` in the non-stream mode, or
                 `AsyncStream[ChatCompletionChunk]` in the stream mode.
         """
-        # Use OpenAI cilent as interface call ZhipuAI
+        # Use OpenAI client as interface call ZhipuAI
         # Reference: https://open.bigmodel.cn/dev/api#openai_sdk
         response = await self._async_client.chat.completions.create(
             messages=messages,
@@ -137,7 +137,7 @@ class ZhipuAIModel(BaseModelBackend):
                 `ChatCompletion` in the non-stream mode, or
                 `Stream[ChatCompletionChunk]` in the stream mode.
         """
-        # Use OpenAI cilent as interface call ZhipuAI
+        # Use OpenAI client as interface call ZhipuAI
         # Reference: https://open.bigmodel.cn/dev/api#openai_sdk
         response = self._client.chat.completions.create(
             messages=messages,

camel/retrievers/vector_retriever.py

@@ -224,7 +224,7 @@ class VectorRetriever(BaseRetriever):
         if top_k <= 0:
             raise ValueError("top_k must be a positive integer.")
 
-        # Load the storage incase it's hosted remote
+        # Load the storage in case it's hosted remote
         self.storage.load()
 
         query_vector = self.embedding_model.embed(obj=query)

camel/storages/graph_storages/neo4j_graph.py

@@ -69,7 +69,7 @@ class Neo4jGraph(BaseGraphStorage):
     The detailed information about Neo4j is available at:
     `Neo4j https://neo4j.com/docs/getting-started`
 
-    This module refered to the work of Langchian and Llamaindex.
+    This module referred to the work of Langchian and Llamaindex.
 
     Args:
         url (str): The URL of the Neo4j database server.

camel/storages/vectordb_storages/base.py

@@ -100,7 +100,7 @@ class VectorDBStatus(BaseModel):
     r"""Vector database status.
 
     Attributes:
-        vector_dim (int): The dimention of stored vectors.
+        vector_dim (int): The dimension of stored vectors.
         vector_count (int): The number of stored vectors.
 
     """
@@ -204,7 +204,7 @@ class BaseVectorStorage(ABC):
 
         Args:
             vector (List[float]): The search vector.
-            top_k (int): The number of top similer vectors.
+            top_k (int): The number of top similar vectors.
 
         Returns:
             List[List[Dict[str, Any]]]: A list of vector payloads retrieved

camel/storages/vectordb_storages/milvus.py

@@ -36,7 +36,7 @@ class MilvusStorage(BaseVectorStorage):
     `Milvus <https://milvus.io/docs/overview.md/>`_
 
     Args:
-        vector_dim (int): The dimenstion of storing vectors.
+        vector_dim (int): The dimension of storing vectors.
         url_and_api_key (Tuple[str, str]): Tuple containing
            the URL and API key for connecting to a remote Milvus instance.
            URL maps to Milvus uri concept, typically "endpoint:port".
@@ -136,7 +136,7 @@ class MilvusStorage(BaseVectorStorage):
         schema.add_field(
             field_name="id",
             datatype=DataType.VARCHAR,
-            descrition='A unique identifier for the vector',
+            description='A unique identifier for the vector',
             is_primary=True,
             max_length=65535,
         )

camel/storages/vectordb_storages/qdrant.py

@@ -40,7 +40,7 @@ class QdrantStorage(BaseVectorStorage):
     `Qdrant <https://qdrant.tech/>`_
 
     Args:
-        vector_dim (int): The dimenstion of storing vectors.
+        vector_dim (int): The dimension of storing vectors.
         collection_name (Optional[str], optional): Name for the collection in
             the Qdrant. If not provided, set it to the current time with iso
             format. (default: :obj:`None`)
@@ -218,7 +218,7 @@ class QdrantStorage(BaseVectorStorage):
         )
 
     def _collection_exists(self, collection_name: str) -> bool:
-        r"""Returns wether the collection exists in the database"""
+        r"""Returns whether the collection exists in the database"""
         for c in self._client.get_collections().collections:
             if collection_name == c.name:
                 return True

camel/tasks/task.py

@@ -178,7 +178,7 @@ class Task(BaseModel):
         return None
 
     def to_string(self, indent: str = "", state: bool = False) -> str:
-        r"""Convert task to a sting.
+        r"""Convert task to a string.
 
         Args:
             indent (str): The ident for hierarchical tasks.
@@ -196,7 +196,7 @@ class Task(BaseModel):
         return _str
 
     def get_result(self, indent: str = "") -> str:
-        r"""Get task result to a sting.
+        r"""Get task result to a string.
 
         Args:
             indent (str): The ident for hierarchical tasks.

camel/toolkits/__init__.py

@@ -37,6 +37,7 @@ from .github_toolkit import GithubToolkit
 from .google_scholar_toolkit import GoogleScholarToolkit
 from .arxiv_toolkit import ArxivToolkit
 from .slack_toolkit import SlackToolkit
+from .whatsapp_toolkit import WhatsAppToolkit
 from .twitter_toolkit import TwitterToolkit
 from .open_api_toolkit import OpenAPIToolkit
 from .retrieval_toolkit import RetrievalToolkit
@@ -60,6 +61,7 @@ from .browser_toolkit import BrowserToolkit
 from .file_write_toolkit import FileWriteToolkit
 from .terminal_toolkit import TerminalToolkit
 from .pubmed_toolkit import PubMedToolkit
+from .data_commons_toolkit import DataCommonsToolkit
 from .thinking_toolkit import ThinkingToolkit
 from .openai_agent_toolkit import OpenAIAgentToolkit
 from .searxng_toolkit import SearxNGToolkit
@@ -77,6 +79,7 @@ __all__ = [
     'GoogleMapsToolkit',
     'SearchToolkit',
     'SlackToolkit',
+    'WhatsAppToolkit',
     'DalleToolkit',
     'TwitterToolkit',
     'WeatherToolkit',
@@ -103,7 +106,6 @@ __all__ = [
     'MinerUToolkit',
     'MemoryToolkit',
     'MCPToolkit',
-    'MCPToolkitManager',
     'AudioAnalysisToolkit',
     'ExcelToolkit',
     'VideoAnalysisToolkit',
@@ -112,6 +114,7 @@ __all__ = [
     'FileWriteToolkit',
     'TerminalToolkit',
     'PubMedToolkit',
+    'DataCommonsToolkit',
     'ThinkingToolkit',
     'OpenAIAgentToolkit',
     'SearxNGToolkit',

camel/toolkits/arxiv_toolkit.py

@@ -17,11 +17,12 @@ from typing import Dict, Generator, List, Optional
 from camel.logger import get_logger
 from camel.toolkits.base import BaseToolkit
 from camel.toolkits.function_tool import FunctionTool
-from camel.utils import dependencies_required
+from camel.utils import MCPServer, dependencies_required
 
 logger = get_logger(__name__)
 
 
+@MCPServer()
 class ArxivToolkit(BaseToolkit):
     r"""A toolkit for interacting with the arXiv API to search and download
     academic papers.

camel/toolkits/ask_news_toolkit.py

@@ -17,6 +17,7 @@ from typing import List, Literal, Optional, Tuple, Union
 
 from camel.toolkits import FunctionTool
 from camel.toolkits.base import BaseToolkit
+from camel.utils import MCPServer, api_keys_required
 
 
 def _process_response(
@@ -55,6 +56,10 @@ def _process_response(
         raise ValueError(f"Invalid return_type: {return_type}")
 
 
+@api_keys_required(
+    [(None, "ASKNEWS_CLIENT_ID"), (None, "ASKNEWS_CLIENT_SECRET")]
+)
+@MCPServer()
 class AskNewsToolkit(BaseToolkit):
     r"""A class representing a toolkit for interacting with the AskNews API.
 
@@ -62,7 +67,10 @@ class AskNewsToolkit(BaseToolkit):
     based on user queries using the AskNews API.
     """
 
-    def __init__(self, timeout: Optional[float] = None):
+    def __init__(
+        self,
+        timeout: Optional[float] = None,
+    ):
         r"""Initialize the AskNewsToolkit with API clients.The API keys and
         credentials are retrieved from environment variables.
         """
@@ -152,7 +160,7 @@ class AskNewsToolkit(BaseToolkit):
                 each update. (default: :obj:`10`)
 
         Returns:
-            Unio[dict, str]: A dictionary containing the stories and their
+            Union[dict, str]: A dictionary containing the stories and their
                 associated data, or error message if the process fails.
         """
         try:
@@ -446,7 +454,7 @@ class AsyncAskNewsToolkit(BaseToolkit):
                 each update. (default: :obj:`10`)
 
         Returns:
-            Unio[dict, str]: A dictionary containing the stories and their
+            Union[dict, str]: A dictionary containing the stories and their
                 associated data, or error message if the process fails.
         """
         try:

camel/toolkits/audio_analysis_toolkit.py

@@ -23,6 +23,7 @@ from camel.messages import BaseMessage
 from camel.models import BaseAudioModel, BaseModelBackend, OpenAIAudioModels
 from camel.toolkits.base import BaseToolkit
 from camel.toolkits.function_tool import FunctionTool
+from camel.utils import MCPServer
 
 logger = get_logger(__name__)
 
@@ -80,6 +81,7 @@ def download_file(url: str, cache_dir: str) -> str:
     return local_path
 
 
+@MCPServer()
 class AudioAnalysisToolkit(BaseToolkit):
     r"""A toolkit for audio processing and analysis.
 

camel/toolkits/base.py

@@ -25,6 +25,9 @@ class BaseToolkit(metaclass=AgentOpsMeta):
         timeout (Optional[float]): The timeout for the toolkit.
     """
 
+    from mcp.server import FastMCP
+
+    mcp: FastMCP
     timeout: Optional[float] = None
 
     def __init__(self, timeout: Optional[float] = None):

camel/toolkits/code_execution.py

@@ -22,10 +22,12 @@ from camel.interpreters import (
 )
 from camel.toolkits import FunctionTool
 from camel.toolkits.base import BaseToolkit
+from camel.utils import MCPServer
 
 
+@MCPServer()
 class CodeExecutionToolkit(BaseToolkit):
-    r"""A tookit for code execution.
+    r"""A toolkit for code execution.
 
     Args:
         sandbox (str): The environment type used to execute code.

camel/toolkits/dappier_toolkit.py

@@ -16,9 +16,10 @@ from typing import Dict, List, Literal, Optional, Union
 
 from camel.toolkits.base import BaseToolkit
 from camel.toolkits.function_tool import FunctionTool
-from camel.utils import api_keys_required, dependencies_required
+from camel.utils import MCPServer, api_keys_required, dependencies_required
 
 
+@MCPServer()
 class DappierToolkit(BaseToolkit):
     r"""A class representing a toolkit for interacting with the Dappier API.
 

camel/toolkits/data_commons_toolkit.py

@@ -16,10 +16,12 @@ from typing import Any, Dict, List, Optional, Union
 
 from camel.toolkits import FunctionTool
 from camel.toolkits.base import BaseToolkit
+from camel.utils import MCPServer
 
 logger = logging.getLogger(__name__)
 
 
+@MCPServer()
 class DataCommonsToolkit(BaseToolkit):
     r"""A class representing a toolkit for Data Commons.
 

camel/toolkits/excel_toolkit.py

@@ -19,10 +19,12 @@ import pandas as pd
 from camel.logger import get_logger
 from camel.toolkits.base import BaseToolkit
 from camel.toolkits.function_tool import FunctionTool
+from camel.utils import MCPServer
 
 logger = get_logger(__name__)
 
 
+@MCPServer()
 class ExcelToolkit(BaseToolkit):
     r"""A class representing a toolkit for extract detailed cell information
     from an Excel file.

camel/toolkits/file_write_toolkit.py

@@ -21,6 +21,7 @@ from typing import List, Optional, Union
 from camel.logger import get_logger
 from camel.toolkits.base import BaseToolkit
 from camel.toolkits.function_tool import FunctionTool
+from camel.utils import MCPServer
 
 logger = get_logger(__name__)
 
@@ -28,6 +29,7 @@ logger = get_logger(__name__)
 DEFAULT_FORMAT = '.md'
 
 
+@MCPServer()
 class FileWriteToolkit(BaseToolkit):
     r"""A toolkit for creating, writing, and modifying text in files.