camel-ai 0.2.35__py3-none-any.whl → 0.2.36__py3-none-any.whl

camel/storages/key_value_storages/mem0_cloud.py

@@ -0,0 +1,224 @@
+# ========= 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 os
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+from uuid import UUID
+
+from camel.memories.records import MemoryRecord
+from camel.messages import BaseMessage
+from camel.storages.key_value_storages import BaseKeyValueStorage
+from camel.types import OpenAIBackendRole, RoleType
+
+logger = logging.getLogger(__name__)
+
+
+class Mem0Storage(BaseKeyValueStorage):
+    r"""A concrete implementation of the :obj:`BaseKeyValueStorage` using Mem0
+    as the backend. This storage system uses Mem0's text capabilities to store,
+    search, and manage text with context.
+
+    Args:
+        agent_id (str): Default agent ID to associate memories with.
+        api_key (str, optional): The API key for authentication. If not
+            provided, will try to get from environment variable MEM0_API_KEY
+            (default: :obj:`None`).
+        user_id (str, optional): Default user ID to associate memories with
+            (default: :obj:`None`).
+        metadata (Dict[str, Any], optional): Default metadata to include with
+            all memories (default: :obj:`None`).
+
+    References:
+        https://docs.mem0.ai
+    """
+
+    def __init__(
+        self,
+        agent_id: str,
+        api_key: Optional[str] = None,
+        user_id: Optional[str] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        try:
+            from mem0 import MemoryClient
+        except ImportError as exc:
+            logger.error(
+                "Please install `mem0` first. You can install it by "
+                "running `pip install mem0ai`."
+            )
+            raise exc
+
+        self.api_key = api_key or os.getenv("MEM0_API_KEY")
+        if not self.api_key:
+            raise ValueError(
+                "API key must be provided either through constructor "
+                "or MEM0_API_KEY environment variable."
+            )
+
+        self.client = MemoryClient(api_key=self.api_key)
+        self.agent_id = agent_id
+        self.user_id = user_id
+        self.metadata = metadata or {}
+
+    def _prepare_options(
+        self,
+        agent_id: Optional[str] = None,
+        user_id: Optional[str] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+        **kwargs: Any,
+    ) -> Dict[str, Any]:
+        r"""Helper method to prepare options for Mem0 API calls.
+
+        Args:
+            agent_id (Optional[str], optional): Agent ID to use (default:
+                :obj:`None`).
+            user_id (Optional[str], optional): User ID to use (default:
+                :obj:`None`).
+            metadata (Optional[Dict[str, Any]], optional): Additional metadata
+                to include (default: :obj:`None`).
+            **kwargs (Any): Additional keyword arguments.
+
+        Returns:
+            Dict[str, Any]: Prepared options dictionary for API calls.
+        """
+        options = {
+            "agent_id": agent_id or self.agent_id,
+            "user_id": user_id or self.user_id,
+            "metadata": {**self.metadata, **(metadata or {})},
+            "output_format": "v1.1",
+            **kwargs,
+        }
+        return {k: v for k, v in options.items() if v is not None}
+
+    def _prepare_filters(
+        self,
+        agent_id: Optional[str] = None,
+        user_id: Optional[str] = None,
+        filters: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        r"""Helper method to prepare filters for Mem0 API calls.
+
+        Args:
+            agent_id (Optional[str], optional): Agent ID to filter by
+                (default: :obj:`None`).
+            user_id (Optional[str], optional): User ID to filter by (default:
+                :obj:`None`).
+            filters (Optional[Dict[str, Any]], optional): Additional filters
+                (default: :obj:`None`).
+
+        Returns:
+            Dict[str, Any]: Prepared filters dictionary for API calls.
+        """
+        base_filters: Dict[str, Any] = {"AND": []}
+        if filters:
+            base_filters["AND"].append(filters)
+        if agent_id or self.agent_id:
+            base_filters["AND"].append({"agent_id": agent_id or self.agent_id})
+        if user_id or self.user_id:
+            base_filters["AND"].append({"user_id": user_id or self.user_id})
+        return base_filters if base_filters["AND"] else {}
+
+    def _prepare_messages(
+        self,
+        records: List[Dict[str, Any]],
+    ) -> List[Dict[str, Any]]:
+        r"""Prepare messages from records for Mem0 API calls.
+
+        Args:
+            records (List[Dict[str, Any]]): List of record dictionaries.
+
+        Returns:
+            List[Dict[str, Any]]: List of prepared message dictionaries.
+        """
+        messages = []
+        for record in records:
+            content = record["message"]["content"]
+            role = record["role_at_backend"].value
+            messages.append({"role": role, "content": content})
+        return messages
+
+    def save(self, records: List[Dict[str, Any]]) -> None:
+        r"""Saves a batch of records to the Mem0 storage system.
+
+        Args:
+            records (List[Dict[str, Any]]): A list of dictionaries, where each
+                dictionary represents a unique record to be stored.
+        """
+        try:
+            messages = self._prepare_messages(records)
+
+            options = self._prepare_options(
+                agent_id=self.agent_id,
+                user_id=self.user_id,
+                metadata=self.metadata,
+            )
+            self.client.add(messages, **options)
+        except Exception as e:
+            logger.error(f"Error adding memory: {e}")
+            logger.error(f"Error: {e}")
+
+    def load(self) -> List[Dict[str, Any]]:
+        r"""Loads all stored records from the Mem0 storage system.
+
+        Returns:
+            List[Dict[str, Any]]: A list of dictionaries, where each dictionary
+                represents a stored record.
+        """
+        try:
+            filters = self._prepare_filters(
+                agent_id=self.agent_id,
+                user_id=self.user_id,
+            )
+            results = self.client.get_all(version="v2", **filters)
+
+            # Transform results into MemoryRecord objects
+            transformed_results = []
+            for result in results:
+                memory_record = MemoryRecord(
+                    uuid=UUID(result["id"]),
+                    message=BaseMessage(
+                        role_name="user",
+                        role_type=RoleType.USER,
+                        meta_dict={},
+                        content=result["memory"],
+                    ),
+                    role_at_backend=OpenAIBackendRole.USER,
+                    extra_info=result.get("metadata", {}),
+                    timestamp=datetime.fromisoformat(
+                        result["created_at"]
+                    ).timestamp(),
+                    agent_id=result.get("agent_id", ""),
+                )
+                transformed_results.append(memory_record.to_dict())
+
+            return transformed_results
+        except Exception as e:
+            logger.error(f"Error searching memories: {e}")
+            return []
+
+    def clear(
+        self,
+    ) -> None:
+        r"""Removes all records from the Mem0 storage system."""
+        try:
+            filters = self._prepare_filters(
+                agent_id=self.agent_id,
+                user_id=self.user_id,
+            )
+            self.client.delete_users(**filters)
+        except Exception as e:
+            logger.error(f"Error deleting memories: {e}")
+            logger.error(f"Error: {e}")

camel/storages/vectordb_storages/qdrant.py

@@ -450,9 +450,9 @@ class QdrantStorage(BaseVectorStorage):
             search_filter = Filter(must=cast(List[Condition], must_conditions))
 
         # Execute the search with optional filter
-        search_result = self._client.search(
+        search_result = self._client.query_points(
             collection_name=self.collection_name,
-            query_vector=query.query_vector,
+            query=query.query_vector,
             with_payload=True,
             with_vectors=True,
             limit=query.top_k,
@@ -467,7 +467,7 @@ class QdrantStorage(BaseVectorStorage):
                 payload=point.payload,
                 vector=point.vector,  # type: ignore[arg-type]
             )
-            for point in search_result
+            for point in search_result.points
         ]
 
         return query_results

camel/toolkits/browser_toolkit.py

@@ -438,6 +438,7 @@ class BaseBrowser:
             sync_playwright,
         )
 
+        self._ensure_browser_installed()
         self.history: list = []
         self.headless = headless
         self.playwright = sync_playwright().start()
@@ -914,6 +915,48 @@ class BaseBrowser:
         markdown_content = html2text(html_content)
         return markdown_content
 
+    def _ensure_browser_installed(self) -> None:
+        r"""Ensure the browser is installed."""
+        import platform
+        import subprocess
+        import sys
+
+        try:
+            from playwright.sync_api import sync_playwright
+
+            with sync_playwright() as p:
+                browser = p.chromium.launch()
+                browser.close()
+        except Exception:
+            logger.info("Installing Chromium browser...")
+            try:
+                subprocess.run(
+                    [
+                        sys.executable,
+                        "-m",
+                        "playwright",
+                        "install",
+                        "chromium",
+                    ],
+                    check=True,
+                    capture_output=True,
+                )
+                if platform.system().lower() == "linux":
+                    subprocess.run(
+                        [
+                            sys.executable,
+                            "-m",
+                            "playwright",
+                            "install-deps",
+                            "chromium",
+                        ],
+                        check=True,
+                        capture_output=True,
+                    )
+                logger.info("Chromium browser installation completed")
+            except subprocess.CalledProcessError as e:
+                raise RuntimeError(f"Failed to install browser: {e.stderr}")
+
 
 class BrowserToolkit(BaseToolkit):
     r"""A class for browsing the web and interacting with web pages.

camel/toolkits/code_execution.py

@@ -29,6 +29,7 @@ class CodeExecutionToolkit(BaseToolkit):
 
     Args:
         sandbox (str): The environment type used to execute code.
+            (default: `subprocess`)
         verbose (bool): Whether to print the output of the code execution.
             (default: :obj:`False`)
         unsafe_mode (bool):  If `True`, the interpreter runs the code
@@ -43,7 +44,7 @@ class CodeExecutionToolkit(BaseToolkit):
         self,
         sandbox: Literal[
             "internal_python", "jupyter", "docker", "subprocess", "e2b"
-        ] = "internal_python",
+        ] = "subprocess",
         verbose: bool = False,
         unsafe_mode: bool = False,
         import_white_list: Optional[List[str]] = None,

camel/toolkits/mcp_toolkit.py

@@ -56,6 +56,8 @@ class _MCPServer(BaseToolkit):
         env (Dict[str, str]): Environment variables for the stdio mode command.
             (default: :obj:`'None'`)
         timeout (Optional[float]): Connection timeout. (default: :obj:`'None'`)
+        headers (Dict[str, str]): Headers for the HTTP request.
+            (default: :obj:`'None'`)
     """
 
     def __init__(
@@ -64,6 +66,7 @@ class _MCPServer(BaseToolkit):
         args: Optional[List[str]] = None,
         env: Optional[Dict[str, str]] = None,
         timeout: Optional[float] = None,
+        headers: Optional[Dict[str, str]] = None,
     ):
         from mcp import Tool
         from mcp.client.session import ClientSession
@@ -73,6 +76,7 @@ class _MCPServer(BaseToolkit):
         self.command_or_url = command_or_url
         self.args = args or []
         self.env = env or {}
+        self.headers = headers or {}
 
         self._mcp_tools: List[Tool] = []
         self._session: Optional['ClientSession'] = None
@@ -99,7 +103,10 @@ class _MCPServer(BaseToolkit):
                     read_stream,
                     write_stream,
                 ) = await self._exit_stack.enter_async_context(
-                    sse_client(self.command_or_url)
+                    sse_client(
+                        self.command_or_url,
+                        headers=self.headers,
+                    )
                 )
             else:
                 command = self.command_or_url
@@ -343,6 +350,27 @@ class MCPToolkit(BaseToolkit):
         Either `servers` or `config_path` must be provided. If both are
         provided, servers from both sources will be combined.
 
+        For web servers in the config file, you can specify authorization
+        headers using the "headers" field to connect to protected MCP server
+        endpoints.
+
+        Example configuration:
+
+        .. code-block:: json
+
+            {
+              "mcpWebServers": {
+                "protected-server": {
+                  "url": "https://example.com/mcp",
+                  "timeout": 30,
+                  "headers": {
+                    "Authorization": "Bearer YOUR_TOKEN",
+                    "X-API-Key": "YOUR_API_KEY"
+                  }
+                }
+              }
+            }
+
     Attributes:
         servers (List[_MCPServer]): List of _MCPServer instances being managed.
     """
@@ -442,6 +470,7 @@ class MCPToolkit(BaseToolkit):
             server = _MCPServer(
                 command_or_url=cfg["url"],
                 timeout=cfg.get("timeout", None),
+                headers=cfg.get("headers", {}),
             )
             all_servers.append(server)
 

camel/types/enums.py

@@ -63,6 +63,11 @@ class ModelType(UnifiedModelType, Enum):
     GROQ_MIXTRAL_8_7B = "mixtral-8x7b-32768"
     GROQ_GEMMA_2_9B_IT = "gemma2-9b-it"
 
+    # OpenRouter models
+    OPENROUTER_LLAMA_3_1_405B = "meta-llama/llama-3.3-405b-instruct"
+    OPENROUTER_LLAMA_3_1_70B = "meta-llama/llama-3.3-70b-instruct"
+    OPENROUTER_OLYMPICODER_7B = "open-r1/olympiccoder-7b:free"
+
     # TogetherAI platform models support tool calling
     TOGETHER_LLAMA_3_1_8B = "meta-llama/Meta-Llama-3.1-8B-Instruct-Turbo"
     TOGETHER_LLAMA_3_1_70B = "meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo"
@@ -253,6 +258,7 @@ class ModelType(UnifiedModelType, Enum):
                 self.is_together,
                 self.is_sambanova,
                 self.is_groq,
+                self.is_openrouter,
                 self.is_sglang,
                 self.is_moonshot,
                 self.is_siliconflow,
@@ -342,6 +348,15 @@ class ModelType(UnifiedModelType, Enum):
             ModelType.GROQ_GEMMA_2_9B_IT,
         }
 
+    @property
+    def is_openrouter(self) -> bool:
+        r"""Returns whether this type of models is served by OpenRouter."""
+        return self in {
+            ModelType.OPENROUTER_LLAMA_3_1_405B,
+            ModelType.OPENROUTER_LLAMA_3_1_70B,
+            ModelType.OPENROUTER_OLYMPICODER_7B,
+        }
+
     @property
     def is_together(self) -> bool:
         r"""Returns whether this type of models is served by Together AI."""
@@ -580,6 +595,7 @@ class ModelType(UnifiedModelType, Enum):
             ModelType.MOONSHOT_V1_8K,
             ModelType.GLM_4V_FLASH,
             ModelType.GLM_4_AIRX,
+            ModelType.OPENROUTER_OLYMPICODER_7B,
         }:
             return 8_192
         elif self in {
@@ -686,6 +702,8 @@ class ModelType(UnifiedModelType, Enum):
             ModelType.SGLANG_QWEN_2_5_7B,
             ModelType.SGLANG_QWEN_2_5_32B,
             ModelType.SGLANG_QWEN_2_5_72B,
+            ModelType.OPENROUTER_LLAMA_3_1_70B,
+            ModelType.OPENROUTER_LLAMA_3_1_405B,
         }:
             return 131_072
         elif self in {
@@ -881,6 +899,7 @@ class ModelPlatformType(Enum):
     AZURE = "azure"
     ANTHROPIC = "anthropic"
     GROQ = "groq"
+    OPENROUTER = "openrouter"
     OLLAMA = "ollama"
     LITELLM = "litellm"
     ZHIPU = "zhipuai"
@@ -931,6 +950,11 @@ class ModelPlatformType(Enum):
         r"""Returns whether this platform is groq."""
         return self is ModelPlatformType.GROQ
 
+    @property
+    def is_openrouter(self) -> bool:
+        r"""Returns whether this platform is openrouter."""
+        return self is ModelPlatformType.OPENROUTER
+
     @property
     def is_ollama(self) -> bool:
         r"""Returns whether this platform is ollama."""

camel/types/unified_model_type.py

@@ -78,6 +78,11 @@ class UnifiedModelType(str):
         r"""Returns whether the model is a Groq served model."""
         return True
 
+    @property
+    def is_openrouter(self) -> bool:
+        r"""Returns whether the model is a OpenRouter served model."""
+        return True
+
     @property
     def is_zhipuai(self) -> bool:
         r"""Returns whether the model is a Zhipuai model."""

camel/verifiers/__init__.py

@@ -12,12 +12,11 @@
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 from .base import BaseVerifier
-from .models import VerificationOutcome, VerifierInput
+from .models import VerificationOutcome
 from .python_verifier import PythonVerifier
 
 __all__ = [
     "BaseVerifier",
     "VerificationOutcome",
-    "VerifierInput",
     "PythonVerifier",
 ]