camel-ai 0.2.37__py3-none-any.whl → 0.2.39__py3-none-any.whl

camel/types/enums.py

@@ -217,6 +217,29 @@ class ModelType(UnifiedModelType, Enum):
     AIML_MIXTRAL_8X7B = "mistralai/Mixtral-8x7B-Instruct-v0.1"
     AIML_MISTRAL_7B_INSTRUCT = "mistralai/Mistral-7B-Instruct-v0.1"
 
+    # ModelScope models support tool calling
+    MODELSCOPE_QWEN_2_5_7B_INSTRUCT = "Qwen/Qwen2.5-7B-Instruct"
+    MODELSCOPE_QWEN_2_5_14B_INSTRUCT = "Qwen/Qwen2.5-14B-Instruct"
+    MODELSCOPE_QWEN_2_5_32B_INSTRUCT = "Qwen/Qwen2.5-32B-Instruct"
+    MODELSCOPE_QWEN_2_5_72B_INSTRUCT = "Qwen/Qwen2.5-72B-Instruct"
+    MODELSCOPE_QWEN_2_5_CODER_7B_INSTRUCT = "Qwen/Qwen2.5-Coder-7B-Instruct"
+    MODELSCOPE_QWEN_2_5_CODER_14B_INSTRUCT = "Qwen/Qwen2.5-Coder-14B-Instruct"
+    MODELSCOPE_QWEN_2_5_CODER_32B_INSTRUCT = "Qwen/Qwen2.5-Coder-32B-Instruct"
+    MODELSCOPE_QWQ_32B = "Qwen/QwQ-32B"
+    MODELSCOPE_QWQ_32B_PREVIEW = "Qwen/QwQ-32B-Preview"
+    MODELSCOPE_LLAMA_3_1_8B_INSTRUCT = (
+        "LLM-Research/Meta-Llama-3.1-8B-Instruct"
+    )
+    MODELSCOPE_LLAMA_3_1_70B_INSTRUCT = (
+        "LLM-Research/Meta-Llama-3.1-70B-Instruct"
+    )
+    MODELSCOPE_LLAMA_3_1_405B_INSTRUCT = (
+        "LLM-Research/Meta-Llama-3.1-405B-Instruct"
+    )
+    MODELSCOPE_LLAMA_3_3_70B_INSTRUCT = "LLM-Research/Llama-3.3-70B-Instruct"
+    MODELSCOPE_MINISTRAL_8B_INSTRUCT = "mistralai/Ministral-8B-Instruct-2410"
+    MODELSCOPE_DEEPSEEK_V3_0324 = "deepseek-ai/DeepSeek-V3-0324"
+
     def __str__(self):
         return self.value
 
@@ -263,6 +286,7 @@ class ModelType(UnifiedModelType, Enum):
                 self.is_sglang,
                 self.is_moonshot,
                 self.is_siliconflow,
+                self.is_modelscope,
                 self.is_zhipuai,
                 self.is_aiml,
                 self.is_azure_openai,
@@ -515,6 +539,26 @@ class ModelType(UnifiedModelType, Enum):
             ModelType.INTERNLM2_PRO_CHAT,
         }
 
+    @property
+    def is_modelscope(self) -> bool:
+        return self in {
+            ModelType.MODELSCOPE_QWEN_2_5_7B_INSTRUCT,
+            ModelType.MODELSCOPE_QWEN_2_5_14B_INSTRUCT,
+            ModelType.MODELSCOPE_QWEN_2_5_32B_INSTRUCT,
+            ModelType.MODELSCOPE_QWEN_2_5_72B_INSTRUCT,
+            ModelType.MODELSCOPE_QWEN_2_5_CODER_7B_INSTRUCT,
+            ModelType.MODELSCOPE_QWEN_2_5_CODER_14B_INSTRUCT,
+            ModelType.MODELSCOPE_QWEN_2_5_CODER_32B_INSTRUCT,
+            ModelType.MODELSCOPE_QWQ_32B,
+            ModelType.MODELSCOPE_QWQ_32B_PREVIEW,
+            ModelType.MODELSCOPE_LLAMA_3_1_8B_INSTRUCT,
+            ModelType.MODELSCOPE_LLAMA_3_1_70B_INSTRUCT,
+            ModelType.MODELSCOPE_LLAMA_3_1_405B_INSTRUCT,
+            ModelType.MODELSCOPE_LLAMA_3_3_70B_INSTRUCT,
+            ModelType.MODELSCOPE_MINISTRAL_8B_INSTRUCT,
+            ModelType.MODELSCOPE_DEEPSEEK_V3_0324,
+        }
+
     @property
     def is_moonshot(self) -> bool:
         return self in {
@@ -638,6 +682,21 @@ class ModelType(UnifiedModelType, Enum):
             ModelType.MOONSHOT_V1_32K,
             ModelType.AIML_MIXTRAL_8X7B,
             ModelType.AIML_MISTRAL_7B_INSTRUCT,
+            ModelType.MODELSCOPE_QWEN_2_5_7B_INSTRUCT,
+            ModelType.MODELSCOPE_QWEN_2_5_14B_INSTRUCT,
+            ModelType.MODELSCOPE_QWEN_2_5_32B_INSTRUCT,
+            ModelType.MODELSCOPE_QWEN_2_5_72B_INSTRUCT,
+            ModelType.MODELSCOPE_QWEN_2_5_CODER_7B_INSTRUCT,
+            ModelType.MODELSCOPE_QWEN_2_5_CODER_14B_INSTRUCT,
+            ModelType.MODELSCOPE_QWEN_2_5_CODER_32B_INSTRUCT,
+            ModelType.MODELSCOPE_QWQ_32B,
+            ModelType.MODELSCOPE_QWQ_32B_PREVIEW,
+            ModelType.MODELSCOPE_LLAMA_3_1_8B_INSTRUCT,
+            ModelType.MODELSCOPE_LLAMA_3_1_70B_INSTRUCT,
+            ModelType.MODELSCOPE_LLAMA_3_1_405B_INSTRUCT,
+            ModelType.MODELSCOPE_LLAMA_3_3_70B_INSTRUCT,
+            ModelType.MODELSCOPE_MINISTRAL_8B_INSTRUCT,
+            ModelType.MODELSCOPE_DEEPSEEK_V3_0324,
         }:
             return 32_768
         elif self in {
@@ -882,6 +941,7 @@ class OpenAIVisionDetailType(Enum):
 class StorageType(Enum):
     MILVUS = "milvus"
     QDRANT = "qdrant"
+    TIDB = "tidb"
 
 
 class OpenAPIName(Enum):
@@ -921,6 +981,7 @@ class ModelPlatformType(Enum):
     SGLANG = "sglang"
     INTERNLM = "internlm"
     MOONSHOT = "moonshot"
+    MODELSCOPE = "modelscope"
     SILICONFLOW = "siliconflow"
     AIML = "aiml"
     VOLCANO = "volcano"
@@ -1049,6 +1110,11 @@ class ModelPlatformType(Enum):
         r"""Returns whether this platform is Moonshot model."""
         return self is ModelPlatformType.MOONSHOT
 
+    @property
+    def is_modelscope(self) -> bool:
+        r"""Returns whether this platform is ModelScope model."""
+        return self is ModelPlatformType.MODELSCOPE
+
     @property
     def is_siliconflow(self) -> bool:
         r"""Returns whether this platform is SiliconFlow."""

camel/types/unified_model_type.py

@@ -123,6 +123,11 @@ class UnifiedModelType(str):
         r"""Returns whether the model is a InternLM model."""
         return True
 
+    @property
+    def is_modelscope(self) -> bool:
+        r"""Returns whether the model is a ModelScope serverd model."""
+        return True
+
     @property
     def is_moonshot(self) -> bool:
         r"""Returns whether this platform is Moonshot model."""

camel/utils/__init__.py

@@ -41,6 +41,7 @@ from .commons import (
 )
 from .constants import Constants
 from .deduplication import DeduplicationResult, deduplicate_internally
+from .mcp import MCPServer
 from .response_format import get_pydantic_model
 from .token_counting import (
     AnthropicTokenCounter,
@@ -88,4 +89,5 @@ __all__ = [
     "retry_on_error",
     "BatchProcessor",
     "with_timeout",
+    "MCPServer",
 ]

camel/utils/chunker/code_chunker.py

@@ -12,9 +12,10 @@
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 import re
-from typing import List, Optional
+from typing import TYPE_CHECKING, List, Optional
 
-from unstructured.documents.elements import Element, ElementMetadata
+if TYPE_CHECKING:
+    from unstructured.documents.elements import Element
 
 from camel.utils import get_model_encoding
 
@@ -23,18 +24,15 @@ from .base import BaseChunker
 
 class CodeChunker(BaseChunker):
     r"""A class for chunking code or text while respecting structure
-        and token limits.
+    and token limits.
 
-        This class ensures that structured elements such as functions,
-        classes, and regions are not arbitrarily split across chunks.
-        It also handles oversized lines and Base64-encoded images.
+    This class ensures that structured elements such as functions,
+    classes, and regions are not arbitrarily split across chunks.
+    It also handles oversized lines and Base64-encoded images.
 
     Attributes:
         chunk_size (int, optional): The maximum token size per chunk.
             (default: :obj:`8192`)
-        token_counter (BaseTokenCounter, optional): The tokenizer used for
-            token counting, if `None`, OpenAITokenCounter will be used.
-            (default: :obj:`None`)
         remove_image: (bool, optional): If the chunker should skip the images.
         model_name (str, optional): The tokenizer model name used
             for token counting. (default: :obj:`"cl100k_base"`)
@@ -108,6 +106,8 @@ class CodeChunker(BaseChunker):
         Returns:
             List[str]: A list of chunked text segments.
         """
+        from unstructured.documents.elements import Element, ElementMetadata
+
         content_str = "\n".join(map(str, content))
         chunks = []
         current_chunk: list[str] = []

camel/utils/commons.py

@@ -11,8 +11,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+import asyncio
 import functools
 import importlib
+import inspect
 import logging
 import os
 import platform
@@ -161,7 +163,7 @@ def get_task_list(task_response: str) -> List[str]:
 
 
 def check_server_running(server_url: str) -> bool:
-    r"""Check whether the port refered by the URL to the server
+    r"""Check whether the port referred by the URL to the server
     is open.
 
     Args:
@@ -978,36 +980,54 @@ def with_timeout(timeout=None):
     """
 
     def decorator(func):
-        @functools.wraps(func)
-        def wrapper(*args, **kwargs):
-            # Determine the effective timeout value
-            effective_timeout = timeout
-            if effective_timeout is None and args:
-                effective_timeout = getattr(args[0], 'timeout', None)
-
-            # If no timeout value is provided, execute function normally
-            if effective_timeout is None:
-                return func(*args, **kwargs)
-
-            # Container to hold the result of the function call
-            result_container = []
-
-            def target():
-                result_container.append(func(*args, **kwargs))
-
-            # Start the function in a new thread
-            thread = threading.Thread(target=target)
-            thread.start()
-            thread.join(effective_timeout)
-
-            # Check if the thread is still alive after the timeout
-            if thread.is_alive():
-                return (
-                    f"Function `{func.__name__}` execution timed out, "
-                    f"exceeded {effective_timeout} seconds."
+        if inspect.iscoroutinefunction(func):
+
+            @functools.wraps(func)
+            async def async_wrapper(*args, **kwargs):
+                eff_timeout = timeout
+                if eff_timeout is None and args:
+                    eff_timeout = getattr(args[0], 'timeout', None)
+
+                if eff_timeout is None:
+                    return await func(*args, **kwargs)
+
+                return await asyncio.wait_for(
+                    func(*args, **kwargs), timeout=eff_timeout
                 )
-            else:
-                return result_container[0]
+
+            return async_wrapper
+        else:
+
+            @functools.wraps(func)
+            def wrapper(*args, **kwargs):
+                # Determine the effective timeout value
+                effective_timeout = timeout
+                if effective_timeout is None and args:
+                    effective_timeout = getattr(args[0], 'timeout', None)
+
+                # If no timeout value is provided, execute function normally
+                if effective_timeout is None:
+                    return func(*args, **kwargs)
+
+                # Container to hold the result of the function call
+                result_container = []
+
+                def target():
+                    result_container.append(func(*args, **kwargs))
+
+                # Start the function in a new thread
+                thread = threading.Thread(target=target)
+                thread.start()
+                thread.join(effective_timeout)
+
+                # Check if the thread is still alive after the timeout
+                if thread.is_alive():
+                    return (
+                        f"Function `{func.__name__}` execution timed out, "
+                        f"exceeded {effective_timeout} seconds."
+                    )
+                else:
+                    return result_container[0]
 
         return wrapper
 

camel/utils/constants.py

@@ -30,8 +30,8 @@ class Constants:
     # Return response with json format
     FUNC_NAME_FOR_STRUCTURED_OUTPUT = "return_json_response"
 
-    # Default top k vaule for RAG
+    # Default top k value for RAG
     DEFAULT_TOP_K_RESULTS = 1
 
-    # Default similarity threshold vaule for RAG
+    # Default similarity threshold value for RAG
     DEFAULT_SIMILARITY_THRESHOLD = 0.7

camel/utils/mcp.py

@@ -0,0 +1,79 @@
+# ========= 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 functools
+import inspect
+from typing import Any, Callable, Optional
+
+
+class MCPServer:
+    def __init__(
+        self,
+        function_names: Optional[list[str]] = None,
+        server_name: Optional[str] = None,
+    ):
+        self.function_names = function_names
+        self.server_name = server_name
+
+    def make_wrapper(self, func: Callable[..., Any]) -> Callable[..., Any]:
+        if inspect.iscoroutinefunction(func):
+
+            @functools.wraps(func)
+            async def wrapper(*args, **kwargs):
+                return await func(*args, **kwargs)
+        else:
+
+            @functools.wraps(func)
+            def wrapper(*args, **kwargs):
+                return func(*args, **kwargs)
+
+        wrapper.__signature__ = inspect.signature(func)  # type: ignore[attr-defined]
+        return wrapper
+
+    def __call__(self, cls):
+        from mcp.server.fastmcp import FastMCP
+
+        from camel.toolkits.base import BaseToolkit
+
+        original_init = cls.__init__
+
+        def new_init(instance, *args, **kwargs):
+            original_init(instance, *args, **kwargs)
+            self.server_name = self.server_name or cls.__name__
+            instance.mcp = FastMCP(self.server_name)
+
+            if not self.function_names and not isinstance(
+                instance, BaseToolkit
+            ):
+                raise ValueError(
+                    "Please specify function names or use BaseToolkit."
+                )
+
+            function_names = self.function_names
+            if not function_names and isinstance(instance, BaseToolkit):
+                function_names = [
+                    tool.get_function_name() for tool in instance.get_tools()
+                ]
+
+            for name in function_names:
+                func = getattr(instance, name, None)
+                if func is None or not callable(func):
+                    raise ValueError(
+                        f"Method {name} not found in class {cls.__name} or "
+                        "cannot be called."
+                    )
+                wrapper = self.make_wrapper(func)
+                instance.mcp.tool(name=name)(wrapper)
+
+        cls.__init__ = new_init
+        return cls

camel/verifiers/__init__.py

@@ -12,6 +12,7 @@
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 from .base import BaseVerifier
+from .math_verifier import MathVerifier
 from .models import VerificationOutcome
 from .python_verifier import PythonVerifier
 
@@ -19,4 +20,5 @@ __all__ = [
     "BaseVerifier",
     "VerificationOutcome",
     "PythonVerifier",
+    "MathVerifier",
 ]

camel/verifiers/base.py

@@ -163,7 +163,7 @@ class BaseVerifier(ABC):
         pass
 
     async def verify(
-        self, solution: str, ground_truth: Optional[str]
+        self, solution: str, reference_answer: Optional[str]
     ) -> VerificationResult:
         r"""Perform verification with full error handling.
 
@@ -174,7 +174,7 @@ class BaseVerifier(ABC):
 
         Args:
             solution (str): The generated response that needs verification.
-            ground_truth (Optional[str]): The expected correct answer to
+            reference_answer (Optional[str]): The expected correct answer to
                 compare against.
 
         Returns:
@@ -215,13 +215,13 @@ class BaseVerifier(ABC):
                 verification_result = (
                     await asyncio.wait_for(
                         self._verify_implementation(
-                            verifiable_solution, ground_truth
+                            verifiable_solution, reference_answer
                         ),
                         timeout=self._timeout,
                     )
                     if self._timeout
                     else await self._verify_implementation(
-                        verifiable_solution, ground_truth
+                        verifiable_solution, reference_answer
                     )
                 )
 
@@ -267,7 +267,7 @@ class BaseVerifier(ABC):
 
     @abstractmethod
     async def _verify_implementation(
-        self, solution: str, ground_truth: Optional[str]
+        self, solution: str, reference_answer: Optional[str]
     ) -> VerificationResult:
         r"""Abstract method for verification logic.
 
@@ -276,7 +276,7 @@ class BaseVerifier(ABC):
 
         Args:
             solution (str): The generated response requiring verification.
-            ground_truth (Optional[str]): The expected reference output.
+            reference_answer (Optional[str]): The expected reference output.
 
         Returns:
             VerificationResult: Contains verification status and details.
@@ -293,7 +293,7 @@ class BaseVerifier(ABC):
     async def verify_batch(
         self,
         solutions: List[str],
-        ground_truths: List[Optional[str]],
+        reference_answers: List[Optional[str]],
         raise_on_error: bool = False,
     ) -> List[VerificationResult]:
         r"""Verify multiple solutions in parallel with controlled concurrency.
@@ -305,8 +305,8 @@ class BaseVerifier(ABC):
         Args:
             solutions (List[str]): A list of generated solutions to be
                 verified.
-            ground_truths (List[Optional[str]]): A list of expected outputs for
-                comparison. Each element corresponds to a solution.
+            reference_answers (List[Optional[str]]): A list of expected outputs
+                for comparison. Each element corresponds to a solution.
             raise_on_error (bool, optional): If True, raises an exception if
                 any verification fails. (default: :obj:`False`)
 
@@ -337,13 +337,13 @@ class BaseVerifier(ABC):
         semaphore = asyncio.Semaphore(max(1, max_workers))
 
         async def _verify_with_semaphore(
-            solution: str, ground_truth: Optional[str]
+            solution: str, reference_answer: Optional[str]
         ) -> VerificationResult:
             start_time = time.time()
             try:
                 async with semaphore:
                     verification_result = await self.verify(
-                        solution, ground_truth
+                        solution, reference_answer
                     )
                 processing_time = time.time() - start_time
                 success = (
@@ -368,12 +368,12 @@ class BaseVerifier(ABC):
         all_results: List[VerificationResult] = []
         for i in range(0, len(solutions), batch_size):
             batch_solutions = solutions[i : i + batch_size]
-            batch_ground_truths = ground_truths[i : i + batch_size]
+            batch_reference_answers = reference_answers[i : i + batch_size]
 
             verification_tasks = [
-                _verify_with_semaphore(solution, ground_truth)
-                for solution, ground_truth in zip(
-                    batch_solutions, batch_ground_truths
+                _verify_with_semaphore(solution, reference_answer)
+                for solution, reference_answer in zip(
+                    batch_solutions, batch_reference_answers
                 )
             ]
             try:

camel/verifiers/math_verifier.py

@@ -0,0 +1,182 @@
+# ========= 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 Optional
+
+from camel.extractors.base import BaseExtractor
+from camel.logger import get_logger
+from camel.verifiers import BaseVerifier
+from camel.verifiers.models import VerificationOutcome, VerificationResult
+
+logger = get_logger(__name__)
+
+
+class MathVerifier(BaseVerifier):
+    r"""Verifier for mathematical expressions using Math-Verify.
+
+    Features:
+    - Supports LaTeX and plain mathematical expressions
+    - Handles complex numbers, matrices, and sets
+    - Configurable precision for floating-point comparisons
+    - Optional LaTeX wrapping to ensure proper parsing and rendering
+    - Comprehensive error handling and logging
+    """
+
+    def __init__(
+        self,
+        extractor: Optional[BaseExtractor] = None,
+        timeout: Optional[float] = 30.0,
+        float_rounding: int = 6,
+        numeric_precision: int = 15,
+        enable_wrapping: Optional[bool] = False,
+        **kwargs,
+    ):
+        r"""Initializes the MathVerifier.
+
+        Args:
+            extractor (Optional[BaseExtractor], optional): The extractor to use
+                for extracting code from the solution. (default: :obj:`None`)
+            timeout (Optional[float], optional): The execution timeout in
+                seconds. (default: :obj:`30.0`)
+            float_rounding (int, optional): The number of decimal places to
+                round floating-point numbers. (default: :obj:`6`)
+            numeric_precision (int, optional): The numeric precision for
+                floating-point comparisons. (default: :obj:`15`)
+            enable_wrapping (Optional[bool], optional): Whether to wrap LaTeX
+                expressions in math mode delimiters. (default: :obj:`False`)
+        """
+        super().__init__(extractor=extractor, timeout=timeout, **kwargs)
+        self.float_rounding = float_rounding
+        self.numeric_precision = numeric_precision
+        self.enable_wrapping = enable_wrapping
+
+    @staticmethod
+    def _latex_wrapping(s: str) -> str:
+        r"""Wrap a LaTeX expression in math mode delimiters.
+
+        This function checks whether the input string is already in a LaTeX
+        math environment (e.g., $, \[, \begin{}, etc.). If not, it wraps the
+        expression in $$...$$ to ensure proper parsing and rendering as a
+        mathematical expression.
+
+        Args:
+            s (str): The input LaTeX string.
+
+        Returns:
+            str: The LaTeX string wrapped in math mode if necessary.
+        """
+        s_stripped = s.strip()
+        if (
+            not any(
+                s_stripped.startswith(prefix)
+                for prefix in ("$", "\\(", "\\[", "\\begin")
+            )
+            and "\\boxed" not in s_stripped
+        ):
+            s = f"$$ {s_stripped} $$"
+        return s
+
+    async def _setup(self, **kwargs) -> None:
+        r"""No special setup needed for math verification."""
+        pass
+
+    async def _cleanup(self) -> None:
+        r"""No cleanup needed for math verification."""
+        pass
+
+    async def _verify_implementation(
+        self, solution: str, reference_answer: Optional[str]
+    ) -> VerificationResult:
+        r"""Verify mathematical expressions using Math-Verify.
+
+        Args:
+            solution: The solution to verify
+            reference_answer: The expected answer to compare against
+
+        Returns:
+            VerificationResult containing the verification status and details
+        """
+        from math_verify import parse, verify
+        from math_verify.parser import (
+            ExprExtractionConfig,
+            LatexExtractionConfig,
+        )
+
+        if reference_answer is None:
+            return VerificationResult(
+                status=VerificationOutcome.ERROR,
+                result="",
+                error_message=(
+                    "Ground truth is required for " "mathematical verification"
+                ),
+            )
+
+        try:
+            # Apply LaTeX wrapping if enabled
+            if self.enable_wrapping:
+                solution = self._latex_wrapping(solution)
+                reference_answer = self._latex_wrapping(reference_answer)
+                logger.debug("Applied LaTeX wrapping")
+
+            # Parse both expressions with LaTeX and plain expression support
+            parsed_reference_answer = parse(
+                reference_answer,
+                extraction_config=[
+                    LatexExtractionConfig(boxed_match_priority=0),
+                    ExprExtractionConfig(),
+                ],
+            )
+            parsed_solution = parse(
+                solution,
+                extraction_config=[
+                    LatexExtractionConfig(),
+                    ExprExtractionConfig(),
+                ],
+            )
+
+            if not parsed_reference_answer or not parsed_solution:
+                return VerificationResult(
+                    status=VerificationOutcome.ERROR,
+                    result="",
+                    error_message="Failed to parse expressions",
+                )
+
+            # Order matters! reference_answer must be first argument
+            is_correct = verify(
+                parsed_reference_answer,
+                parsed_solution,
+                float_rounding=self.float_rounding,
+                numeric_precision=self.numeric_precision,
+            )
+
+            if is_correct:
+                logger.debug("Mathematical verification succeeded")
+                return VerificationResult(
+                    status=VerificationOutcome.SUCCESS, result=solution
+                )
+            else:
+                logger.debug("Mathematical verification failed")
+                return VerificationResult(
+                    status=VerificationOutcome.FAILURE,
+                    result=solution,
+                    error_message="Solution does not match ground truth",
+                )
+
+        except Exception as error:
+            logger.error(f"Mathematical verification error: {error!s}")
+            return VerificationResult(
+                status=VerificationOutcome.ERROR,
+                result="",
+                error_message=f"Mathematical verification error: {error!s}",
+            )