camel-ai 0.2.73a4__py3-none-any.whl → 0.2.80a2__py3-none-any.whl

camel/toolkits/minimax_mcp_toolkit.py

@@ -0,0 +1,195 @@
+# ========= 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
+
+from camel.toolkits import BaseToolkit, FunctionTool
+
+from .mcp_toolkit import MCPToolkit
+
+
+class MinimaxMCPToolkit(BaseToolkit):
+    r"""MinimaxMCPToolkit provides an interface for interacting with
+    MiniMax AI services using the MiniMax MCP server.
+
+    This toolkit enables access to MiniMax's multimedia generation
+    capabilities including text-to-audio, voice cloning, video generation,
+    image generation, music generation, and voice design.
+
+    This toolkit can be used as an async context manager for automatic
+    connection management:
+
+        # Using explicit API key
+        async with MinimaxMCPToolkit(api_key="your-key") as toolkit:
+            tools = toolkit.get_tools()
+            # Toolkit is automatically disconnected when exiting
+
+        # Using environment variables (recommended for security)
+        # Set MINIMAX_API_KEY=your-key in environment
+        async with MinimaxMCPToolkit() as toolkit:
+            tools = toolkit.get_tools()
+
+    Environment Variables:
+        MINIMAX_API_KEY: MiniMax API key for authentication
+        MINIMAX_API_HOST: API host URL (default: https://api.minimax.io)
+        MINIMAX_MCP_BASE_PATH: Base path for output files
+
+    Attributes:
+        timeout (Optional[float]): Connection timeout in seconds.
+            (default: :obj:`None`)
+    """
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        api_host: str = "https://api.minimax.io",
+        base_path: Optional[str] = None,
+        timeout: Optional[float] = None,
+    ) -> None:
+        r"""Initializes the MinimaxMCPToolkit.
+
+        Args:
+            api_key (Optional[str]): MiniMax API key for authentication.
+                If None, will attempt to read from MINIMAX_API_KEY
+                environment variable. (default: :obj:`None`)
+            api_host (str): MiniMax API host URL. Can be either
+                "https://api.minimax.io" (global) or
+                "https://api.minimaxi.com" (mainland China).
+                Can also be read from MINIMAX_API_HOST environment variable.
+                (default: :obj:`"https://api.minimax.io"`)
+            base_path (Optional[str]): Base path for output files.
+                If None, uses current working directory. Can also be read
+                from MINIMAX_MCP_BASE_PATH environment variable.
+                (default: :obj:`None`)
+            timeout (Optional[float]): Connection timeout in seconds.
+                (default: :obj:`None`)
+        """
+        super().__init__(timeout=timeout)
+
+        # Read API key from parameter or environment variable
+        if api_key is None:
+            api_key = os.getenv("MINIMAX_API_KEY")
+
+        if not api_key:
+            raise ValueError(
+                "api_key must be provided either as a parameter or through "
+                "the MINIMAX_API_KEY environment variable"
+            )
+
+        # Read API host from environment variable if not overridden
+        env_api_host = os.getenv("MINIMAX_API_HOST")
+        if env_api_host:
+            api_host = env_api_host
+
+        # Read base path from environment variable if not provided
+        if base_path is None:
+            base_path = os.getenv("MINIMAX_MCP_BASE_PATH")
+
+        # Set up environment variables for the MCP server
+        env = {
+            "MINIMAX_API_KEY": api_key,
+            "MINIMAX_API_HOST": api_host,
+        }
+
+        if base_path:
+            env["MINIMAX_MCP_BASE_PATH"] = base_path
+
+        self._mcp_toolkit = MCPToolkit(
+            config_dict={
+                "mcpServers": {
+                    "minimax": {
+                        "command": "uvx",
+                        "args": ["minimax-mcp", "-y"],
+                        "env": env,
+                    }
+                }
+            },
+            timeout=timeout,
+        )
+
+    async def connect(self):
+        r"""Explicitly connect to the MiniMax MCP server."""
+        await self._mcp_toolkit.connect()
+
+    async def disconnect(self):
+        r"""Explicitly disconnect from the MiniMax MCP server."""
+        await self._mcp_toolkit.disconnect()
+
+    @property
+    def is_connected(self) -> bool:
+        r"""Check if the toolkit is connected to the MCP server.
+
+        Returns:
+            bool: True if connected, False otherwise.
+        """
+        return self._mcp_toolkit.is_connected
+
+    async def __aenter__(self) -> "MinimaxMCPToolkit":
+        r"""Async context manager entry point.
+
+        Returns:
+            MinimaxMCPToolkit: The connected toolkit instance.
+
+        Example:
+            async with MinimaxMCPToolkit(api_key="your-key") as toolkit:
+                tools = toolkit.get_tools()
+        """
+        await self.connect()
+        return self
+
+    async def __aexit__(self, _exc_type, _exc_val, _exc_tb) -> None:
+        r"""Async context manager exit point.
+
+        Automatically disconnects from the MiniMax MCP server.
+        """
+        await self.disconnect()
+
+    def get_tools(self) -> List[FunctionTool]:
+        r"""Returns a list of tools provided by the MiniMax MCP server.
+
+        This includes tools for:
+        - Text-to-audio conversion
+        - Voice cloning
+        - Video generation
+        - Image generation
+        - Music generation
+        - Voice design
+
+        Returns:
+            List[FunctionTool]: List of available MiniMax AI tools.
+        """
+        return self._mcp_toolkit.get_tools()
+
+    def get_text_tools(self) -> str:
+        r"""Returns a string containing the descriptions of the tools.
+
+        Returns:
+            str: A string containing the descriptions of all MiniMax tools.
+        """
+        return self._mcp_toolkit.get_text_tools()
+
+    async def call_tool(
+        self, tool_name: str, tool_args: Dict[str, Any]
+    ) -> Any:
+        r"""Call a MiniMax tool by name.
+
+        Args:
+            tool_name (str): Name of the tool to call.
+            tool_args (Dict[str, Any]): Arguments to pass to the tool.
+
+        Returns:
+            Any: The result of the tool call.
+        """
+        return await self._mcp_toolkit.call_tool(tool_name, tool_args)

camel/toolkits/note_taking_toolkit.py

@@ -138,34 +138,43 @@ class NoteTakingToolkit(BaseToolkit):
             self.registry.append(note_name)
             self._save_registry()
 
-    def create_note(self, note_name: str, content: str = "") -> str:
+    def create_note(
+        self, note_name: str, content: str, overwrite: bool = False
+    ) -> str:
         r"""Creates a new note with a unique name.
 
         This function will create a new file for your note.
-        You must provide a `note_name` that does not already exist. If you want
-        to add content to an existing note, use the `append_note` function
-        instead.
+        By default, you must provide a `note_name` that does not already exist.
+        If you want to add content to an existing note, use the `append_note`
+        function instead. If you want to overwrite an existing note, set
+        `overwrite=True`.
 
         Args:
             note_name (str): The name for your new note (without the .md
-                extension). This name must be unique.
-            content (str, optional): The initial content to write in the note.
-                If not provided, an empty note will be created. Defaults to "".
+                extension). This name must be unique unless overwrite is True.
+            content (str): The initial content to write in the note.
+            overwrite (bool): Whether to overwrite an existing note.
+                Defaults to False.
 
         Returns:
             str: A message confirming the creation of the note or an error if
-                 the note name is not valid or already exists.
+                the note name is not valid or already exists
+                (when overwrite=False).
         """
         try:
             note_path = self.working_directory / f"{note_name}.md"
+            existed_before = note_path.exists()
 
-            if note_path.exists():
+            if existed_before and not overwrite:
                 return f"Error: Note '{note_name}.md' already exists."
 
             note_path.write_text(content, encoding="utf-8")
             self._register_note(note_name)
 
-            return f"Note '{note_name}.md' successfully created."
+            if existed_before and overwrite:
+                return f"Note '{note_name}.md' successfully overwritten."
+            else:
+                return f"Note '{note_name}.md' successfully created."
         except Exception as e:
             return f"Error creating note: {e}"
 

camel/toolkits/notion_mcp_toolkit.py

@@ -14,12 +14,12 @@
 
 from typing import Any, ClassVar, Dict, List, Optional, Set
 
-from camel.toolkits import BaseToolkit, FunctionTool
+from camel.toolkits import FunctionTool
 
 from .mcp_toolkit import MCPToolkit
 
 
-class NotionMCPToolkit(BaseToolkit):
+class NotionMCPToolkit(MCPToolkit):
     r"""NotionMCPToolkit provides an interface for interacting with Notion
     through the Model Context Protocol (MCP).
 
@@ -75,31 +75,21 @@ class NotionMCPToolkit(BaseToolkit):
             timeout (Optional[float]): Connection timeout in seconds.
                 (default: :obj:`None`)
         """
-        super().__init__(timeout=timeout)
-
-        self._mcp_toolkit = MCPToolkit(
-            config_dict={
-                "mcpServers": {
-                    "notionMCP": {
-                        "command": "npx",
-                        "args": [
-                            "-y",
-                            "mcp-remote",
-                            "https://mcp.notion.com/mcp",
-                        ],
-                    }
+        config_dict = {
+            "mcpServers": {
+                "notionMCP": {
+                    "command": "npx",
+                    "args": [
+                        "-y",
+                        "mcp-remote",
+                        "https://mcp.notion.com/mcp",
+                    ],
                 }
-            },
-            timeout=timeout,
-        )
-
-    async def connect(self):
-        r"""Explicitly connect to the Notion MCP server."""
-        await self._mcp_toolkit.connect()
+            }
+        }
 
-    async def disconnect(self):
-        r"""Explicitly disconnect from the Notion MCP server."""
-        await self._mcp_toolkit.disconnect()
+        # Initialize parent MCPToolkit with Notion configuration
+        super().__init__(config_dict=config_dict, timeout=timeout)
 
     def get_tools(self) -> List[FunctionTool]:
         r"""Returns a list of tools provided by the NotionMCPToolkit.
@@ -108,7 +98,7 @@ class NotionMCPToolkit(BaseToolkit):
             List[FunctionTool]: List of available tools.
         """
         all_tools = []
-        for client in self._mcp_toolkit.clients:
+        for client in self.clients:
             try:
                 original_build_schema = client._build_tool_schema
 

camel/toolkits/openbb_toolkit.py

@@ -17,7 +17,11 @@ from typing import List, Literal, Optional
 
 from camel.toolkits.base import BaseToolkit
 from camel.toolkits.function_tool import FunctionTool
-from camel.utils import MCPServer, api_keys_required, dependencies_required
+from camel.utils import (
+    MCPServer,
+    api_keys_required,
+    dependencies_required,
+)
 
 
 @MCPServer()

camel/toolkits/origene_mcp_toolkit.py

@@ -12,12 +12,12 @@
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 
-from typing import Dict, List, Optional
+from typing import Dict, Optional
 
-from camel.toolkits import BaseToolkit, FunctionTool, MCPToolkit
+from .mcp_toolkit import MCPToolkit
 
 
-class OrigeneToolkit(BaseToolkit):
+class OrigeneToolkit(MCPToolkit):
     r"""OrigeneToolkit provides an interface for interacting with
     Origene MCP server.
 
@@ -43,55 +43,14 @@ class OrigeneToolkit(BaseToolkit):
 
         Args:
             config_dict (Optional[Dict]): Configuration dictionary for MCP
-                servers. If None, uses default configuration for chembl_mcp.
-                (default: :obj:`None`)
+                servers. If None, raises ValueError as configuration is
+                required. (default: :obj:`None`)
             timeout (Optional[float]): Connection timeout in seconds.
                 (default: :obj:`None`)
         """
-        super().__init__(timeout=timeout)
-
-        # Use default configuration if none provided
+        # Validate that config_dict is provided
         if config_dict is None:
             raise ValueError("config_dict must be provided")
 
-        self._mcp_toolkit = MCPToolkit(
-            config_dict=config_dict,
-            timeout=timeout,
-        )
-
-    async def connect(self):
-        r"""Explicitly connect to the Origene MCP server."""
-        await self._mcp_toolkit.connect()
-
-    async def disconnect(self):
-        r"""Explicitly disconnect from the Origene MCP server."""
-        await self._mcp_toolkit.disconnect()
-
-    async def __aenter__(self) -> "OrigeneToolkit":
-        r"""Async context manager entry point.
-
-        Returns:
-            OrigeneToolkit: The connected toolkit instance.
-
-        Example:
-            async with OrigeneToolkit(config_dict=config) as toolkit:
-                tools = toolkit.get_tools()
-        """
-        await self.connect()
-        return self
-
-    async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:
-        r"""Async context manager exit point.
-
-        Automatically disconnects from the Origene MCP server.
-        """
-        await self.disconnect()
-        return None
-
-    def get_tools(self) -> List[FunctionTool]:
-        r"""Returns a list of tools provided by the Origene MCP server.
-
-        Returns:
-            List[FunctionTool]: List of available tools.
-        """
-        return self._mcp_toolkit.get_tools()
+        # Initialize parent MCPToolkit with provided configuration
+        super().__init__(config_dict=config_dict, timeout=timeout)

camel/toolkits/playwright_mcp_toolkit.py

@@ -14,12 +14,10 @@
 
 from typing import List, Optional
 
-from camel.toolkits import BaseToolkit, FunctionTool
-
 from .mcp_toolkit import MCPToolkit
 
 
-class PlaywrightMCPToolkit(BaseToolkit):
+class PlaywrightMCPToolkit(MCPToolkit):
     r"""PlaywrightMCPToolkit provides an interface for interacting with web
     browsers using the Playwright automation library through the Model Context
     Protocol (MCP).
@@ -51,33 +49,16 @@ class PlaywrightMCPToolkit(BaseToolkit):
                 `["--cdp-endpoint=http://localhost:9222"]`.
                 (default: :obj:`None`)
         """
-        super().__init__(timeout=timeout)
-
-        self._mcp_toolkit = MCPToolkit(
-            config_dict={
-                "mcpServers": {
-                    "playwright": {
-                        "command": "npx",
-                        "args": ["@playwright/mcp@latest"]
-                        + (additional_args or []),
-                    }
+        # Create config for Playwright MCP server
+        config_dict = {
+            "mcpServers": {
+                "playwright": {
+                    "command": "npx",
+                    "args": ["@playwright/mcp@latest"]
+                    + (additional_args or []),
                 }
-            },
-            timeout=timeout,
-        )
-
-    async def connect(self):
-        r"""Explicitly connect to the Playwright MCP server."""
-        await self._mcp_toolkit.connect()
+            }
+        }
 
-    async def disconnect(self):
-        r"""Explicitly disconnect from the Playwright MCP server."""
-        await self._mcp_toolkit.disconnect()
-
-    def get_tools(self) -> List[FunctionTool]:
-        r"""Returns a list of tools provided by the PlaywrightMCPToolkit.
-
-        Returns:
-            List[FunctionTool]: List of available tools.
-        """
-        return self._mcp_toolkit.get_tools()
+        # Initialize parent MCPToolkit with Playwright configuration
+        super().__init__(config_dict=config_dict, timeout=timeout)

camel/toolkits/resend_toolkit.py

@@ -0,0 +1,168 @@
+# ========= 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, Optional, cast
+
+from camel.toolkits.base import BaseToolkit
+from camel.toolkits.function_tool import FunctionTool
+from camel.utils import MCPServer, api_keys_required
+
+
+@MCPServer()
+class ResendToolkit(BaseToolkit):
+    r"""A toolkit for sending emails using the Resend API.
+
+    This toolkit provides functionality to send emails using Resend's
+    Python SDK.It supports sending both HTML and plain text emails,
+    with options for multiple recipients, CC, BCC, reply-to
+    addresses, and custom headers.
+
+    Notes:
+        To use this toolkit, you need to set the following environment
+        variable:
+        - RESEND_API_KEY: Your Resend API key. You can get one from
+          https://resend.com/api-keys
+
+    Example:
+        .. code-block:: python
+
+            from camel.toolkits import ResendToolkit
+
+            # Initialize the toolkit
+            toolkit = ResendToolkit()
+
+            # Get tools
+            tools = toolkit.get_tools()
+    """
+
+    @api_keys_required([(None, "RESEND_API_KEY")])
+    def send_email(
+        self,
+        to: List[str],
+        subject: str,
+        from_email: str,
+        html: Optional[str] = None,
+        text: Optional[str] = None,
+        cc: Optional[List[str]] = None,
+        bcc: Optional[List[str]] = None,
+        reply_to: Optional[str] = None,
+        tags: Optional[List[Dict[str, str]]] = None,
+        headers: Optional[Dict[str, str]] = None,
+    ) -> str:
+        r"""Send an email using the Resend API.
+
+        Args:
+            to (List[str]): List of recipient email addresses.
+            subject (str): The email subject line.
+            from_email (str): The sender email address. Must be from a verified
+                domain.
+            html (Optional[str]): The HTML content of the email. Either html or
+                text must be provided. (default: :obj:`None`)
+            text (Optional[str]): The plain text content of the email. Either
+                html or text must be provided. (default: :obj:`None`)
+            cc (Optional[List[str]]): List of CC recipient email addresses.
+                (default: :obj:`None`)
+            bcc (Optional[List[str]]): List of BCC recipient email addresses.
+                (default: :obj:`None`)
+            reply_to (Optional[str]): The reply-to email address.
+                (default: :obj:`None`)
+            tags (Optional[List[Dict[str, str]]]): List of tags to attach to
+                the email. Each tag should be a dict with 'name' and
+                'value' keys. (default: :obj:`None`)
+            headers (Optional[Dict[str, str]]): Custom headers to include in
+                the email.(default: :obj:`None`)
+
+        Returns:
+            str: A success message with the email ID if sent successfully,
+                or an error message if the send failed.
+
+        Raises:
+            ValueError: If neither html nor text content is provided.
+
+        Example:
+            .. code-block:: python
+
+                toolkit = ResendToolkit()
+                result = toolkit.send_email(
+                    to=["recipient@example.com"],
+                    subject="Hello World",
+                    from_email="sender@yourdomain.com",
+                    html="<h1>Hello, World!</h1>",
+                    text="Hello, World!"
+                )
+        """
+        import os
+
+        if not html and not text:
+            raise ValueError(
+                "Either 'html' or 'text' content must be provided"
+            )
+
+        try:
+            import resend
+        except ImportError:
+            raise ImportError(
+                "Please install the resend package first. "
+                "You can install it by running `pip install resend`."
+            )
+
+        # Set the API key
+        resend.api_key = os.getenv("RESEND_API_KEY")
+
+        # Prepare email parameters
+        params: resend.Emails.SendParams = {
+            "from": from_email,
+            "to": to,
+            "subject": subject,
+        }
+
+        # Add content
+        if html:
+            params["html"] = html
+        if text:
+            params["text"] = text
+
+        # Add optional parameters
+        if cc:
+            params["cc"] = cc
+        if bcc:
+            params["bcc"] = bcc
+        if reply_to:
+            params["reply_to"] = reply_to
+        if tags:
+            params["tags"] = cast('list[resend.emails._tag.Tag]', tags)
+        if headers:
+            params["headers"] = headers
+
+        try:
+            # Send the email
+            email = resend.Emails.send(params)
+            return (
+                f"Email sent successfully. "
+                f"Email ID: {email.get('id', 'Unknown')}"
+            )
+        except Exception as e:
+            return f"Failed to send email: {e!s}"
+
+    def get_tools(self) -> List[FunctionTool]:
+        r"""Returns a list of FunctionTool objects representing the
+        functions in the toolkit.
+
+        Returns:
+            List[FunctionTool]: A list of FunctionTool objects
+                representing the functions in the toolkit.
+        """
+        return [
+            FunctionTool(self.send_email),
+        ]