camel-ai 0.2.60__py3-none-any.whl → 0.2.61__py3-none-any.whl

camel/__init__.py

@@ -14,7 +14,7 @@
 
 from camel.logger import disable_logging, enable_logging, set_log_level
 
-__version__ = '0.2.60'
+__version__ = '0.2.61'
 
 __all__ = [
     '__version__',

camel/agents/chat_agent.py

@@ -75,7 +75,10 @@ from camel.types import (
     RoleType,
 )
 from camel.types.agents import ToolCallingRecord
-from camel.utils import get_model_encoding
+from camel.utils import (
+    get_model_encoding,
+    model_from_json_schema,
+)
 
 if TYPE_CHECKING:
     from camel.terminators import ResponseTerminator
@@ -163,6 +166,7 @@ class ChatAgent(BaseAgent):
         model: Optional[
             Union[
                 BaseModelBackend,
+                ModelManager,
                 Tuple[str, str],
                 str,
                 ModelType,
@@ -188,12 +192,15 @@ class ChatAgent(BaseAgent):
         agent_id: Optional[str] = None,
         stop_event: Optional[threading.Event] = None,
     ) -> None:
-        # Resolve model backends and set up model manager
-        resolved_models = self._resolve_models(model)
-        self.model_backend = ModelManager(
-            resolved_models,
-            scheduling_strategy=scheduling_strategy,
-        )
+        if isinstance(model, ModelManager):
+            self.model_backend = model
+        else:
+            # Resolve model backends and set up model manager
+            resolved_models = self._resolve_models(model)
+            self.model_backend = ModelManager(
+                resolved_models,
+                scheduling_strategy=scheduling_strategy,
+            )
         self.model_type = self.model_backend.model_type
 
         # Assign unique ID
@@ -1706,3 +1713,147 @@ class ChatAgent(BaseAgent):
         return (
             f"ChatAgent({self.role_name}, {self.role_type}, {self.model_type})"
         )
+
+    def to_mcp(
+        self,
+        name: str = "CAMEL-ChatAgent",
+        description: str = "A helpful assistant using the CAMEL AI framework.",
+        dependencies: Optional[List[str]] = None,
+        host: str = "localhost",
+        port: int = 8000,
+    ):
+        r"""Expose this ChatAgent as an MCP server.
+
+        Args:
+            name (str): Name of the MCP server.
+                (default: :obj:`CAMEL-ChatAgent`)
+            description (Optional[List[str]]): Description of the agent. If
+                None, a generic description is used. (default: :obj:`A helpful
+                assistant using the CAMEL AI framework.`)
+            dependencies (Optional[List[str]]): Additional
+                dependencies for the MCP server. (default: :obj:`None`)
+            host (str): Host to bind to for HTTP transport.
+                (default: :obj:`localhost`)
+            port (int): Port to bind to for HTTP transport.
+                (default: :obj:`8000`)
+
+        Returns:
+            FastMCP: An MCP server instance that can be run.
+        """
+        try:
+            from mcp.server.fastmcp import FastMCP
+        except ImportError:
+            raise ImportError(
+                "The 'mcp' package is required to use the to_mcp method. "
+                "Install it with 'pip install mcp'."
+            )
+
+        # Combine dependencies
+        all_dependencies = ["camel-ai[all]"]
+        if dependencies:
+            all_dependencies.extend(dependencies)
+
+        mcp_server = FastMCP(
+            name,
+            dependencies=all_dependencies,
+            host=host,
+            port=port,
+        )
+
+        # Store agent reference
+        agent_instance = self
+
+        # Define functions first
+        async def step(message, response_format=None):
+            r"""Execute a single step in the chat session with the agent."""
+            format_cls = None
+            if response_format:
+                format_cls = model_from_json_schema(
+                    "DynamicResponseFormat", response_format
+                )
+            response = await agent_instance.astep(message, format_cls)
+            return {
+                "status": "success",
+                "messages": [msg.to_dict() for msg in response.msgs],
+                "terminated": response.terminated,
+                "info": response.info,
+            }
+
+        # Reset tool
+        def reset():
+            r"""Reset the chat agent to its initial state."""
+            agent_instance.reset()
+            return {"status": "success", "message": "Agent reset successfully"}
+
+        # Set language tool
+        def set_output_language(language):
+            r"""Set the output language for the chat agent."""
+            agent_instance.output_language = language
+            return {
+                "status": "success",
+                "message": f"Output language set to '{language}'",
+            }
+
+        # Agent info resource and tool
+        def get_agent_info():
+            r"""Get information about the agent."""
+            info = {
+                "agent_id": agent_instance.agent_id,
+                "model_type": str(agent_instance.model_type),
+                "role_name": agent_instance.role_name,
+                "role_type": str(agent_instance.role_type),
+                "output_language": agent_instance.output_language or "None",
+                "description": description,
+            }
+            return info
+
+        # Chat history resource and tool
+        def get_chat_history():
+            r"""Get the chat history for the agent."""
+            # Convert messages to simple serializable format
+            messages = []
+            for msg in agent_instance.chat_history:
+                # Create a simplified version of each message
+                msg_dict = {
+                    "role": msg.get("role", ""),
+                    "content": msg.get("content", ""),
+                }
+                # Include function calls if present
+                if "function_call" in msg:
+                    msg_dict["function_call"] = {
+                        "name": msg["function_call"].get("name", ""),
+                        "arguments": msg["function_call"].get("arguments", ""),
+                    }
+                messages.append(msg_dict)
+            return messages
+
+        # Available tools resource and tool
+        def get_available_tools():
+            r"""Get a list of available internal tools."""
+            tool_info = {}
+            for name, tool in agent_instance.tool_dict.items():
+                tool_info[name] = {
+                    "name": name,
+                    "description": tool.get_function_description() or "",
+                    "parameters": [
+                        {"name": param_name, "type": str(param_type)}
+                        for param_name, param_type in tool.get_parameters().items()  # noqa: E501
+                    ],
+                }
+            return tool_info
+
+        # Now register everything using decorators
+        mcp_server.tool()(step)
+        mcp_server.tool()(reset)
+        mcp_server.tool()(set_output_language)
+
+        mcp_server.resource("agent://")(get_agent_info)
+        mcp_server.tool()(get_agent_info)
+
+        mcp_server.resource("history://")(get_chat_history)
+        mcp_server.tool()(get_chat_history)
+
+        mcp_server.resource("tools://")(get_available_tools)
+        mcp_server.tool()(get_available_tools)
+
+        return mcp_server

camel/configs/anthropic_config.py

@@ -56,14 +56,14 @@ class AnthropicConfig(BaseConfig):
             metadata about the request. Can include user_id as an external
             identifier for the user associated with the request.
             (default: :obj:`None`)
-        thinking (dict, optional): Configuration for enabling
-            Claude's extended thinking. When enabled, responses include
-            thinking content blocks showing Claude's thinking process.
-            (default: :obj:`None`)
         tool_choice (dict, optional): How the model should
             use the provided tools. The model can use a specific tool, any
             available tool, decide by itself, or not use tools at all.
             (default: :obj:`None`)
+        extra_headers (Optional[dict], optional): Additional headers for the
+            request. (default: :obj:`None`)
+        extra_body (dict, optional): Extra body parameters to be passed to
+            the Anthropic API.
     """
 
     max_tokens: Optional[int] = None
@@ -73,8 +73,9 @@ class AnthropicConfig(BaseConfig):
     top_k: Optional[int] = None
     stream: Optional[bool] = None
     metadata: Optional[dict] = None
-    thinking: Optional[dict] = None
     tool_choice: Optional[dict] = None
+    extra_headers: Optional[dict] = None
+    extra_body: Optional[dict] = None
 
 
 ANTHROPIC_API_PARAMS = {param for param in AnthropicConfig.model_fields.keys()}

camel/datagen/evol_instruct/scorer.py

@@ -38,24 +38,27 @@ class BaseScorer(ABC):
 
 class MathScorer(BaseScorer):
     def __init__(self, agent: Optional[ChatAgent] = None):
-        self.system_msg = (
-            "You are an evaluator for math problems. Your task is to compare "
-            "a new math problem against a reference math problem, and rate it "
-            "in **four dimensions**, each scored from 1 to 5.\n\n"
-            "1. Diversity (1-5): How novel is the new problem compared to the "
-            "reference? 1 = very similar, 5 = completely different.\n"
-            "2. Difficulty (1-5): Rate the relative difficulty compared to the"
-            " reference problem. 1 = much less difficult, "
-            "3 = similar difficulty, 5 = much more difficult.\n"
-            "3. Validity (1-5): How well-defined and sound is the problem?"
-            "1 = very vague or flawed, 5 = very clear and rigorous.\n"
-            "4. Solvability (1-5): How likely is the problem solvable using "
-            "standard math techniques? 1 = very unsolvable or ambiguous, "
-            "5 = very clearly solvable.\n\n"
-            "Respond with a JSON object like: "
-            "{ \"diversity\": ..., \"difficulty\": ..., "
-            "\"validity\": ..., \"solvability\": ... }"
-        )
+        self.system_msg = """
+You are an evaluator for math problems. Your task is to compare a new math 
+problem against a reference math problem by trying to solve it, and rate it 
+in **three dimensions**.
+
+1. Diversity (1-5): How novel is the new problem compared to the 
+reference? 1 = almost the same, 5 = completely different.
+
+2. Difficulty (1-10): Rate the relative difficulty compared to the reference 
+problem. 1 = much less difficult, 5 = similar difficulty, 10 = much more 
+difficult. The difficulty should be based on the complexity of reasoning—i.e., 
+problems that require multi-step reasoning or clever methods to solve.
+
+3. Solvability (1-10): How likely is the problem solvable using standard math 
+techniques and only contain one question that could be answered by a number or 
+a formula? 1 = very unsolvable or ambiguous, 10 = solvable and could be 
+answered by a number or a formula.
+
+Respond with a JSON object like: 
+{ "solution": ..., "diversity": ..., "difficulty": ..., "solvability": ... }
+"""
         self.agent = agent or ChatAgent(self.system_msg)
 
     class MathScoreSchema(BaseModel):
@@ -69,10 +72,6 @@ class MathScorer(BaseScorer):
         difficulty: int = Field(
             ..., description="Score for the relative difficulty"
         )
-        validity: int = Field(
-            ...,
-            description="Score for how well-defined and sound the problem is",
-        )
         solvability: int = Field(
             ...,
             description="Score for the solvability of the problem",
@@ -95,7 +94,7 @@ class MathScorer(BaseScorer):
         query = (
             f"Reference problem:\n{reference_problem}\n\n"
             f"New problem:\n{new_problem}\n\n"
-            "Provide scores in JSON format."
+            "Try to solve the new problem. Then provide scores in JSON format."
         )
         response = self.agent.step(query, response_format=self.MathScoreSchema)
         score_data = json.loads(response.msg.content)

camel/datagen/evol_instruct/templates.py

@@ -208,54 +208,54 @@ class MathEvolInstructTemplates(BaseEvolInstructTemplates):
     r"""Contains templates for MathEvolInstruct prompt transformations."""
 
     # Meta-instructions for in-depth evolving
-    INST_IN_DEPTH = (
-        "Please act as a math expert. Your objective is to create a new math "
-        "problem that is more challenging yet concise than the given math "
-        "problem. Ensure that the mathematical content (including any "
-        "equations or figures) is preserved, and rephrase the problem to "
-        "increase its complexity and depth. The generated problem should be "
-        "clearly stated, strictly mathematical, and suitable for solving with "
-        "symbolic computation (e.g., using sympy). You will be given a method "
-        "to guide your creation. Make sure to follow the method strictly. "
-        "Consolidate any multiple parts into one integrated question that "
-        "ask for one definitive answer. Respond with your generated problem "
-        "directly. "
-        "#Original Problem#:\n{prompt}\n"
-        "#Generated Problem#:\n"
-    ).lstrip()
+    INST_IN_DEPTH = """
+Please act as a math expert. Your objective is to create a new math problem
+that is more challenging yet concise than the given math problem. Modify the
+problem to increase its complexity and depth. The generated problem should be
+clearly stated, strictly mathematical, and suitable for solving with symbolic
+computation (e.g., using sympy). You will be given a method to guide your
+creation. Make sure to follow the method strictly. Consolidate any multiple
+parts into one integrated question that ask for one definitive answer. Do not
+include multiple-choice, true/false, or proof-based questions. The final
+answer should be a number or a formula. Respond with your generated problem
+directly. The difficulty should be based on the complexity of reasoning—i.e.,
+problems that require multi-step reasoning or clever methods to solve. The
+challenge of a problem should not stem purely from computational complexity;
+while complex calculations may be involved, a problem should not be considered
+difficult solely because lengthy computations increase solving time.
+#Original Problem#:
+{prompt}
+#Generated Problem#:
+"""
 
     EVOL_METHODS = {
-        "constraints": (
-            "Add one or more significant constraints or requirements into the "
-            "'#Given Prompt#'. The added constraints must meaningfully alter "
-            "how the model would respond. For example, specify additional "
-            "rules, contexts, or limitations that demand creative adjustments."
-        ),
-        "deepening": (
-            "Increase the difficulty of the #Given Prompt# by integrating "
-            "additional layers of reasoning and rigor. Refine the problem so "
-            "that all added difficulty is consolidated into a single coherent "
-            "question requiring one final answer, avoiding fragmentation into "
-            "multiple sub-problems."
-        ),
-        "expansion": (
-            "Expand the #Given Prompt# by incorporating additional "
-            "perspectives or layers of complexity into the problem statement. "
-            "Ensure that the revised problem remains a single, unified "
-            "question with one final answer, rather than a series of separate "
-            "sub-questions."
-        ),
-        "condense": (
-            "Reformulate the given math problem into a well-structured and "
-            "formally stated mathematical question.\n"
-            "- Present the problem in a structured and rigorous mathematical "
-            "format.\n"
-            "- Removing unnecessary instructions, explanations, or hints.\n"
-            "- If the given problem contains several sub-questions, make "
-            "necessary changes to let the problem could be answered with one "
-            "number or expression by removing the sub-questions or combining "
-            "them into one."
-        ),
+        "constraints": """
+Add one or more significant constraints or requirements into the
+'#Given Prompt#'. The added constraints must meaningfully alter how the model 
+would respond. For example, specify additional rules, contexts, or limitations 
+that demand creative adjustments. This method should make the problem more 
+challenging in the reasoning and the solution of it should be clever and 
+elegant.
+""",
+        "deepening": """
+Increase the difficulty of the #Given Prompt# by integrating additional layers 
+of reasoning and rigor. Refine the problem so that all added difficulty is 
+consolidated into a single coherent question requiring one final answer, 
+avoiding fragmentation into multiple sub-problems.
+""",
+        "expansion": """
+Expand the #Given Prompt# by incorporating additional perspectives or layers 
+of complexity into the problem statement. Ensure that the revised problem 
+remains a single, unified question with one final answer, rather than a 
+series of separate sub-questions.
+""",
+        "condense": """
+Reformulate the given math problem into a well-structured and formally stated 
+mathematical question. Remove unnecessary instructions, explanations, or hints. 
+If the given problem contains several sub-questions, make necessary changes 
+to let the problem could be answered with one number or one expression by 
+removing the sub-questions or combining them into one.
+""",
     }
 
     IN_DEPTH_KEYS = ['constraints', 'deepening', 'expansion']

camel/datasets/static_dataset.py

@@ -398,3 +398,147 @@ class StaticDataset(Dataset):
                     f"got {type(item).__name__}"
                 )
         return data
+
+    def save_to_json(self, file_path: Union[str, Path]) -> None:
+        r"""Save the dataset to a local JSON file.
+
+        Args:
+            file_path (Union[str, Path]): Path to the output JSON file.
+                If a string is provided, it will be converted to a Path object.
+
+        Raises:
+            TypeError: If file_path is not a string or Path object.
+            OSError: If there's an error writing to the file.
+        """
+        if isinstance(file_path, str):
+            file_path = Path(file_path)
+        elif not isinstance(file_path, Path):
+            raise TypeError(
+                f"Expected file_path to be a string or Path object, "
+                f"got {type(file_path).__name__}"
+            )
+
+        # Convert DataPoint objects to dictionaries
+        data_dicts = [datapoint.to_dict() for datapoint in self.data]
+
+        # Ensure the parent directory exists
+        file_path.parent.mkdir(parents=True, exist_ok=True)
+
+        try:
+            logger.debug(f"Saving dataset to {file_path}")
+            with file_path.open('w', encoding='utf-8') as f:
+                json.dump(data_dicts, f, ensure_ascii=False, indent=2)
+            logger.info(
+                f"Successfully saved {len(data_dicts)} items to {file_path}"
+            )
+        except OSError as e:
+            logger.error(f"Error saving dataset to {file_path}: {e}")
+            raise
+
+    def save_to_huggingface(
+        self,
+        dataset_name: str,
+        token: Optional[str] = None,
+        filepath: str = "records/records.json",
+        private: bool = False,
+        description: Optional[str] = None,
+        license: Optional[str] = None,
+        version: Optional[str] = None,
+        tags: Optional[List[str]] = None,
+        language: Optional[List[str]] = None,
+        task_categories: Optional[List[str]] = None,
+        authors: Optional[List[str]] = None,
+        **kwargs: Any,
+    ) -> str:
+        r"""Save the dataset to the Hugging Face Hub using the project's
+        HuggingFaceDatasetManager.
+
+        Args:
+            dataset_name (str): The name of the dataset on Hugging Face Hub.
+                Should be in the format 'username/dataset_name' .
+            token (Optional[str]): The Hugging Face API token. If not provided,
+                the token will be read from the environment variable `HF_TOKEN`
+                (default: :obj:`None`)
+            filepath (str): The path in the repository where the dataset
+                will be saved.  (default: :obj:`"records/records.json"`)
+            private (bool): Whether the dataset should be private.
+                (default: :obj:`False`)
+            description (Optional[str]): A description of the dataset.
+                (default: :obj:`None`)
+            license (Optional[str]): The license of the dataset.
+                (default: :obj:`None`)
+            version (Optional[str]): The version of the dataset.
+                (default: :obj:`None`)
+            tags (Optional[List[str]]): A list of tags for the dataset.
+                (default: :obj:`None`)
+            language (Optional[List[str]]): A list of languages the dataset is
+                in. (default: :obj:`None`)
+            task_categories (Optional[List[str]]): A list of task categories.
+                (default: :obj:`None`)
+            authors (Optional[List[str]]): A list of authors of the dataset.
+                (default: :obj:`None`)
+            **kwargs (Any): Additional keyword arguments to pass to the
+                Hugging Face API.
+
+        Returns:
+            str: The URL of the dataset on the Hugging Face Hub.
+
+        Raises:
+            OSError: If there's an error uploading the dataset.
+        """
+        # lazy import to avoid heavy dependencies
+        from camel.datahubs.huggingface import HuggingFaceDatasetManager
+        from camel.datahubs.models import Record
+
+        # Initialize the HuggingFaceDatasetManager
+        manager = HuggingFaceDatasetManager(token=token)
+
+        # Convert DataPoint objects to Record objects
+        records = []
+        for datapoint in self.data:
+            datapoint_dict = datapoint.to_dict()
+
+            record_dict = {
+                "question": datapoint_dict.get("question", ""),
+                "final_answer": datapoint_dict.get("final_answer", ""),
+                "rationale": datapoint_dict.get("rationale", ""),
+                "metadata": datapoint_dict.get("metadata", {}),
+            }
+            record = Record(**record_dict)
+            records.append(record)
+
+        logger.debug(f"Creating dataset {dataset_name}")
+        try:
+            # Create the dataset
+            dataset_url = manager.create_dataset(
+                name=dataset_name, private=private, **kwargs
+            )
+
+            # Add records to the dataset
+            manager.add_records(
+                dataset_name=dataset_name,
+                records=records,
+                filepath=filepath,
+            )
+
+            # Create dataset card if description is provided
+            if description:
+                manager.create_dataset_card(
+                    dataset_name=dataset_name,
+                    description=description,
+                    license=license,
+                    version=version,
+                    tags=tags,
+                    authors=authors,
+                    language=language,
+                    task_categories=task_categories,
+                )
+
+            logger.info(
+                f"Successfully uploaded dataset to {dataset_name}, "
+                f"the url is {dataset_url}"
+            )
+            return dataset_url
+        except Exception as e:
+            logger.error(f"Error uploading dataset to Hugging Face: {e}")
+            raise

camel/loaders/__init__.py

@@ -14,12 +14,13 @@
 
 from .apify_reader import Apify
 from .base_io import File, create_file, create_file_from_raw_bytes
-from .chunkr_reader import ChunkrReader
+from .chunkr_reader import ChunkrReader, ChunkrReaderConfig
 from .crawl4ai_reader import Crawl4AI
 from .firecrawl_reader import Firecrawl
 from .jina_url_reader import JinaURLReader
 from .markitdown import MarkItDownLoader
 from .mineru_extractor import MinerU
+from .mistral_reader import MistralReader
 from .pandas_reader import PandasReader
 from .scrapegraph_reader import ScrapeGraphAI
 from .unstructured_io import UnstructuredIO
@@ -32,10 +33,12 @@ __all__ = [
     'JinaURLReader',
     'Firecrawl',
     'Apify',
-    'ChunkrReader',
     'PandasReader',
+    'ChunkrReader',
+    'ChunkrReaderConfig',
     'MinerU',
     'Crawl4AI',
     'MarkItDownLoader',
     'ScrapeGraphAI',
+    'MistralReader',
 ]