camel-ai 0.2.59__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.59'
+__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/configs/cohere_config.py

@@ -74,4 +74,4 @@ class CohereConfig(BaseConfig):
     p: Optional[float] = None
 
 
-COHERE_API_PARAMS = {param for param in CohereConfig().model_fields.keys()}
+COHERE_API_PARAMS = {param for param in CohereConfig.model_fields.keys()}

camel/configs/mistral_config.py

@@ -76,4 +76,4 @@ class MistralConfig(BaseConfig):
         return response_format
 
 
-MISTRAL_API_PARAMS = {param for param in MistralConfig().model_fields.keys()}
+MISTRAL_API_PARAMS = {param for param in MistralConfig.model_fields.keys()}

camel/configs/openai_config.py

@@ -104,6 +104,8 @@ class ChatGPTConfig(BaseConfig):
         parallel_tool_calls (bool, optional): A parameter specifying whether
             the model should call tools in parallel or not.
             (default: :obj:`None`)
+        extra_headers: Optional[Dict[str, str]]: Extra headers to use for the
+            model. (default: :obj:`None`)
     """
 
     temperature: Optional[float] = None
@@ -120,6 +122,7 @@ class ChatGPTConfig(BaseConfig):
     tool_choice: Optional[Union[Dict[str, str], str]] = None
     reasoning_effort: Optional[str] = None
     parallel_tool_calls: Optional[bool] = None
+    extra_headers: Optional[Dict[str, str]] = None
 
 
 OPENAI_API_PARAMS = {param for param in ChatGPTConfig.model_fields.keys()}

camel/configs/reka_config.py

@@ -66,4 +66,4 @@ class RekaConfig(BaseConfig):
     use_search_engine: Optional[bool] = None
 
 
-REKA_API_PARAMS = {param for param in RekaConfig().model_fields.keys()}
+REKA_API_PARAMS = {param for param in RekaConfig.model_fields.keys()}

camel/configs/samba_config.py

@@ -65,7 +65,7 @@ class SambaVerseAPIConfig(BaseConfig):
 
 
 SAMBA_VERSE_API_PARAMS = {
-    param for param in SambaVerseAPIConfig().model_fields.keys()
+    param for param in SambaVerseAPIConfig.model_fields.keys()
 }
 
 
@@ -160,5 +160,5 @@ class SambaCloudAPIConfig(BaseConfig):
 
 
 SAMBA_CLOUD_API_PARAMS = {
-    param for param in SambaCloudAPIConfig().model_fields.keys()
+    param for param in SambaCloudAPIConfig.model_fields.keys()
 }

camel/datagen/cot_datagen.py

@@ -204,26 +204,23 @@ class CoTDataGenerator:
         logger.info("Answer verification result: %s", is_correct)
         return is_correct
 
-    def monte_carlo_tree_search(
+    def evaluate_partial_solution(
         self, question: str, partial_solution: str = ""
     ) -> float:
-        r"""Perform Monte Carlo Tree Search to find the best solution.
+        r"""Evaluate the quality of a partial solution against the
+        golden answer.
 
-        Process:
-        a. Selection: Choose promising partial solutions based on previous
-        scores
-        b. Expansion: Generate new solution steps using the generator agent
-        c. Simulation: Evaluate solution quality using similarity scores
-        d. Backpropagation: Update solution tree with new findings
+        This function generates a similarity score between the given partial
+        solution and the correct answer (golden answer).
 
         Args:
-            question (str): The question to solve.
-            partial_solution (str): The current partial solution.
+            question (str): The question being solved.
+            partial_solution (str): The partial solution generated so far.
                 (default::obj:`""`)
 
         Returns:
-            float: The similarity score between the current
-                solution and golden answer.
+            float: A similarity score between 0 and 1, indicating how close the
+                partial solution is to the golden answer.
         """
         if question not in self.golden_answers:
             raise ValueError(
@@ -293,10 +290,21 @@ class CoTDataGenerator:
         r"""Solve a question using a multi-step approach.
 
         The solution process follows these steps:
-        1. Try to solve directly - if correct, return the solution
-        2. If not correct, use Monte Carlo Tree Search to find a good solution
-        3. If the solution isn't perfect, use binary search to locate errors
-        4. Generate a new solution based on the correct part
+        1. Try to solve directly - if correct, return the solution.
+        2. If not correct, perform a search by iteratively generating
+        new solutions and evaluating their similarity scores to
+        find a good solution. The search process involves:
+            a. Generation: Generate new solution candidates using
+            the generator agent.
+            b. Evaluation: Score each solution candidate for similarity
+            to the golden answer.
+            c. Selection: Keep the best-scoring candidate found so far.
+            d. Early stopping: If a sufficiently high-scoring solution
+            is found (score > 0.9), stop early.
+        3. If the solution isn't perfect, use binary search to locate
+        errors.
+        4. Generate a new solution based on the correct part of the
+        initial solution.
 
         Args:
             question (str): The question to solve.
@@ -304,14 +312,14 @@ class CoTDataGenerator:
         Returns:
             str: The best solution found.
         """
+
         # 1. Try direct solution first
         solution = self.get_answer(question)
         if self.verify_answer(question, solution):
             logger.info("Initial solution is correct")
             return solution
 
-        # 2. If direct solution fails, try Monte Carlo Tree Search
-        # to find a solution with high similarity score
+        # 2. If direct solution fails, iteratively search for a better solution
         best_solution = ""
         best_score: float = 0.0
         for i in range(self.search_limit):
@@ -319,23 +327,10 @@ class CoTDataGenerator:
             current_solution = self.get_answer(question, best_solution)
 
             # Evaluate solution similarity score
-            prompt = (
-                f"Please evaluate this solution and "
-                f"give a score between 0-1:\n"
-                f"Question: {question}\n"
-                f"Solution: {current_solution}\n"
-                f"Correct answer: {self.golden_answers.get(question, '')}\n"
-                f"Return a JSON object with a single field 'score' containing "
-                f"a float between 0 and 1, like this: {{'score': 0.85}}\n"
-            )
-            self.generator_agent.reset()
-            response = self.generator_agent.step(prompt)
             try:
-                response = self.generator_agent.step(
-                    prompt, response_format=AgentResponse
+                score = self.evaluate_partial_solution(
+                    question, current_solution
                 )
-                agent_response = response.msgs[0].parsed.score  # type: ignore [union-attr]
-                score = agent_response
 
                 # Exit early if we find a very good solution (score > 0.9)
                 if score > 0.9:
@@ -357,7 +352,7 @@ class CoTDataGenerator:
                     best_score,
                 )
             except Exception as e:
-                logger.error("Error parsing agent response: %s", str(e))
+                logger.error("Error evaluating partial solution: %s", str(e))
                 continue
 
         # 3. If the answer is not completely correct,

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']