camel-ai 0.2.14__py3-none-any.whl → 0.2.15a0__py3-none-any.whl

camel/datagen/__init__.py

@@ -0,0 +1,17 @@
+# ========= 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 .o1datagen import O1DataGenerator
+
+__all__ = ['O1DataGenerator']

camel/datagen/o1datagen.py

@@ -0,0 +1,435 @@
+# ========= 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 json
+from datetime import datetime
+from typing import Annotated, Dict, Optional, Union
+
+from pydantic import BaseModel, Field, confloat
+
+from camel.agents import ChatAgent
+from camel.logger import get_logger
+
+# Get a logger for this module
+logger = get_logger('o1datagenerator')
+
+
+class AgentResponse(BaseModel):
+    r"""Model for structured agent responses.
+
+    A Pydantic model class that represents structured responses from agents,
+    including a similarity score that measures the quality of the response.
+
+    Args:
+        score (float): A similarity score between 0 and 1 that compares the
+            current answer to the correct answer. Must be within the range
+            [0, 1].
+    """
+
+    score: Annotated[float, confloat(ge=0, le=1)] = Field(
+        ...,
+        description="""Similarity score between 0 and 1 
+        comparing current answer to correct answer""",
+    )
+
+
+class VerificationResponse(BaseModel):
+    r"""Model for structured verification responses.
+
+    A Pydantic model class that represents verification results from agents,
+    indicating whether an answer is correct or not.
+
+    Args:
+        is_correct (bool): Boolean indicating if the answer is correct.
+    """
+
+    is_correct: bool = Field(
+        ...,
+        description="Boolean indicating if the answer is correct",
+    )
+
+
+class O1DataGenerator:
+    r"""Class for generating and managing data through chat agent interactions.
+
+    handling the generation of data by  a chat agent, managing golden answers,
+    and maintaining a solution tree for correct solution steps.
+
+    Args:
+        chat_agent (Optional[ChatAgent]): Optional single agent
+            for both tasks (legacy mode). (default::obj:`None`)
+        generator_agent (Optional[ChatAgent]): Optional specialized agent for
+            answer generation. (default::obj:`None`)
+        verifier_agent (Optional[ChatAgent]): Optional specialized agent for
+            answer verification. (default::obj:`None`)
+        golden_answers (Dict[str, str]): Dictionary containing pre-defined
+            correct answers for validation and comparison. Required for answer
+            verification.
+        search_limit (int): Maximum number of search iterations allowed.
+            (default::obj:`100`)
+    """
+
+    def __init__(
+        self,
+        chat_agent: Optional[ChatAgent] = None,
+        *,
+        generator_agent: Optional[ChatAgent] = None,
+        verifier_agent: Optional[ChatAgent] = None,
+        golden_answers: Dict[str, str],
+        search_limit: int = 100,
+    ):
+        r"""Initialize the O1DataGenerator.
+
+        This constructor supports both single-agent and dual-agent modes:
+        1. Single-agent mode (legacy): Pass a single chat_agent that will be
+        used for both generation and verification.
+        2. Dual-agent mode: Pass separate generator_agent and verifier_agent
+        for specialized tasks.
+
+        Args:
+            chat_agent (Optional[ChatAgent]): Optional single agent for both
+                tasks (legacy mode). (default::obj:`None`)
+            generator_agent (Optional[ChatAgent]): Optional specialized agent
+                for answer generation. (default::obj:`None`)
+            verifier_agent (Optional[ChatAgent]): Optional specialized agent
+                for answer verification. (default::obj:`None`)
+            golden_answers (Dict[str, str]): Dictionary containing pre-defined
+                correct answers for validation and comparison. Required for
+                answer verification.
+            search_limit (int): Maximum number of search iterations allowed.
+                (default::obj:`100`)
+        """
+        if chat_agent is not None:
+            if generator_agent is not None or verifier_agent is not None:
+                raise ValueError(
+                    "Cannot specify both chat_agent \
+                    and generator/verifier agents"
+                )
+            self.generator_agent = chat_agent
+            self.verifier_agent = chat_agent
+        else:
+            if generator_agent is None or verifier_agent is None:
+                raise ValueError(
+                    "Must specify either chat_agent or both generator and "
+                    "verifier agents"
+                )
+            self.generator_agent = generator_agent
+            self.verifier_agent = verifier_agent
+
+        self.golden_answers = golden_answers
+        self.search_limit = search_limit
+        self.solution_tree: Dict[str, Dict[str, Union[str, int]]] = {}
+        logger.info(
+            "O1DataGenerator initialized with search_limit=%d", search_limit
+        )
+
+    def get_answer(self, question: str, context: str = "") -> str:
+        r"""Get an answer from the chat agent for a given question.
+
+        Args:
+            question (str): The question to ask.
+            context (str): Additional context for the question.
+                (default::obj:`""`)
+
+        Returns:
+            str: The generated answer.
+        """
+        prompt = f"""
+        Please think step by step and solve this problem: {question}
+        Existing content: {context}
+        Requirements:
+        1. Analyze the problem requirements
+        2. List the steps to solve the problem
+        3. Execute the solution process
+        4. Provide the final answer
+        Please explain the thought process of each step in detail.
+        """
+        self.generator_agent.reset()
+        response = self.generator_agent.step(prompt)
+        answer = response.msgs[0].content
+        logger.info("AI thought process:\n%s", answer)
+        return answer
+
+    def verify_answer(self, question: str, answer: str) -> bool:
+        r"""Verify if a generated answer is semantically equivalent to
+        the golden answer for a given question.
+
+        Args:
+            question (str): The question being answered.
+            answer (str): The answer to verify.
+
+        Returns:
+            bool: True if the answer matches the golden answer based on
+                semantic equivalence (meaning the core content and meaning are
+                the same, even if the exact wording differs).
+                False in the following cases:
+                - If the provided question doesn't exist in the golden answers
+                - If the answer's meaning differs from the golden answer
+        """
+        golden_answer = self.golden_answers.get(question)
+        if not golden_answer:
+            raise ValueError(
+                f"No golden answer found for question: {question}"
+            )
+
+        prompt = (
+            f"Question: {question}\n"
+            f"Student Answer: {answer}\n"
+            f"Correct Answer: {golden_answer}\n"
+            "Is the student's answer correct? Please respond with 'true' or "
+            "'false' only."
+        )
+        self.verifier_agent.reset()
+        response = self.verifier_agent.step(
+            prompt, response_format=VerificationResponse
+        )
+        is_correct = response.msgs[0].parsed.is_correct  # type:ignore [union-attr]
+        logger.info("Answer verification result: %s", is_correct)
+        return is_correct
+
+    def monte_carlo_tree_search(
+        self, question: str, partial_solution: str = ""
+    ) -> float:
+        r"""Perform Monte Carlo Tree Search to find the best solution.
+
+        Args:
+            question (str): The question to solve.
+            partial_solution (str): The current partial solution.
+                (default::obj:`""`)
+
+        Returns:
+            float: The similarity score between the current
+                solution and golden answer.
+        """
+        if question not in self.golden_answers:
+            raise ValueError(
+                f"No golden answer found for question: {question}"
+            )
+
+        golden_answer = self.golden_answers[question]
+
+        prompt = (
+            f"Please evaluate this solution and "
+            f"give a score between 0-1:\n"
+            f"Question: {question}\n"
+            f"Solution: {partial_solution}\n"
+            f"Correct answer: {golden_answer}\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, response_format=AgentResponse
+        )
+        agent_response = response.msgs[0].parsed.score  # type: ignore [union-attr]
+
+        return agent_response
+
+    def binary_search_error(self, question: str, solution: str) -> int:
+        r"""Use binary search to locate the first error in the solution.
+        This method splits the solution into sentences using both English and
+        Chinese sentence delimiters and performs binary search to find the
+        first error.
+
+        Args:
+            question (str): The question being solved.
+            solution (str): The complete solution to analyze.
+
+        Returns:
+            int: The position of the first error found in the solution.
+                Returns -1. If no errors are found (all sentences are correct).
+        """
+        logger.info("Starting binary search for error location")
+        # Split by both English period and Chinese period
+        sentences = [
+            s.strip()
+            for s in solution.replace('。', '.').split('.')
+            if s.strip()
+        ]
+
+        # First check if the entire solution is correct
+        if self.verify_answer(question, solution):
+            return -1
+
+        left, right = 0, len(sentences)
+        while left < right:
+            mid = (left + right) // 2
+            partial_solution = '. '.join(sentences[:mid]) + '.'
+            logger.info("Checking solution fragment:\n%s", partial_solution)
+            # Verify if the current part is correct
+            is_correct = self.verify_answer(question, partial_solution)
+            if is_correct:
+                left = mid + 1
+            else:
+                right = mid
+        logger.info("First error position found: sentence %d", left)
+        return left
+
+    def solve(self, question: str) -> str:
+        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
+
+        Args:
+            question (str): The question to solve.
+
+        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
+        best_solution = ""
+        best_score: float = 0.0
+        for i in range(self.search_limit):
+            # Generate new answer
+            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
+                )
+                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:
+                    logger.info(
+                        "Found excellent solution with score %.2f. "
+                        "Stopping search early.",
+                        score,
+                    )
+                    return current_solution
+
+                if score > best_score:
+                    best_score = score
+                    best_solution = current_solution
+
+                logger.info(
+                    "Current search progress: %d/%d, best score: %.2f",
+                    i + 1,
+                    self.search_limit,
+                    best_score,
+                )
+            except Exception as e:
+                logger.error("Error parsing agent response: %s", str(e))
+                continue
+
+        # 3. If the answer is not completely correct,
+        # use binary search to locate the error
+        error_pos = self.binary_search_error(question, best_solution)
+
+        # If no errors found (error_pos == -1), return the current solution
+        if error_pos == -1:
+            logger.info("No specific errors found in the solution")
+            return best_solution
+
+        # 4. Generate new solution based on correct part
+        correct_part = '. '.join(best_solution.split('. ')[:error_pos]) + '.'
+        final_solution = self.get_answer(question, correct_part)
+        self.solution_tree[question] = {
+            "solution": final_solution,
+            "error_position": error_pos,
+        }
+        return final_solution
+
+    def import_qa_from_json(self, data: Union[str, Dict[str, str]]) -> bool:
+        r"""Import question and answer data from either a JSON file or a
+        dictionary.
+
+        Args:
+            data (Union[str, Dict[str, str]]): Either a path to a JSON file
+                containing QA pairs or a dictionary of question-answer pairs.
+                If a string is provided, it's treated as a file path.
+                The expected format is:
+                {"question1": "answer1",
+                 "question2": "answer2",
+                 ...}
+
+        Returns:
+            bool: True if import was successful, False otherwise.
+        """
+        try:
+            if isinstance(data, str):
+                logger.info("Loading QA pairs from file: %s", data)
+                with open(data, 'r', encoding='utf-8') as f:
+                    qa_data = json.load(f)
+            else:
+                logger.info("Loading QA pairs from provided dictionary")
+                qa_data = data
+
+            # Validate the data format
+            if not isinstance(qa_data, dict):
+                logger.error("Invalid data format: expected dictionary")
+                return False
+
+            # Update golden answers
+            self.golden_answers.update(qa_data)
+            logger.info("Successfully imported %d QA pairs", len(qa_data))
+            return True
+
+        except Exception as e:
+            logger.error("Error importing QA data: %s", str(e))
+            return False
+
+    def export_solutions(self, filepath: str = 'solutions.json') -> None:
+        r"""Export the solution process and results to a JSON file.
+        Exports the solution tree, golden answers,
+         and export timestamp to a JSON file.
+        The exported data includes:
+        - solutions: The solution tree
+            with intermediate steps
+        - golden_answers: The reference answers used for verification
+        - export_time: ISO format timestamp of the export
+
+        Args:
+            filepath (str, optional): Path where the JSON file will be saved.
+                (default::obj:`'solutions.json'`)
+
+        Returns:
+            None: The method writes to a file and logs the result but does not
+                return any value.
+        """
+        export_data = {
+            "solutions": self.solution_tree,
+            "golden_answers": self.golden_answers,
+            "export_time": datetime.now().isoformat(),
+        }
+        try:
+            with open(filepath, 'w', encoding='utf-8') as f:
+                json.dump(export_data, f, ensure_ascii=False, indent=2)
+            logger.info(f"Solutions exported successfully to {filepath}")
+        except Exception as e:
+            logger.error(f"Error exporting solutions: {e!s}")

camel/datahubs/models.py

@@ -19,4 +19,7 @@ from pydantic import BaseModel
 class Record(BaseModel):
     id: Optional[str] = None
     metadata: Optional[Dict[str, Any]] = None
-    content: Dict[str, Any]
+    content: Optional[Dict[str, Any]] = None
+
+    class Config:
+        extra = "allow"  # Allow any additional fields

camel/messages/conversion/sharegpt/hermes/hermes_function_formatter.py

@@ -109,7 +109,10 @@ class HermesFunctionFormatter(
                 format.
         """
         tool_call_dict = {"name": func_name, "arguments": args}
-        return f"{content}\n<tool_call>\n{tool_call_dict}\n</tool_call>"
+
+        if content:
+            return f"{content}\n<tool_call>\n{tool_call_dict}\n</tool_call>"
+        return f"<tool_call>\n{tool_call_dict}\n</tool_call>"
 
     def format_tool_response(self, func_name: str, result: Any) -> str:
         r"""Formats a tool response message with the given function name and

camel/retrievers/auto_retriever.py

@@ -121,6 +121,14 @@ class AutoRetriever:
 
         collection_name = re.sub(r'[^a-zA-Z0-9]', '', content)[:20]
 
+        # Ensure the first character is either an underscore or a letter for
+        # Milvus
+        if (
+            self.storage_type == StorageType.MILVUS
+            and not collection_name[0].isalpha()
+        ):
+            collection_name = f"_{collection_name}"
+
         return collection_name
 
     def run_vector_retriever(

camel/retrievers/vector_retriever.py

@@ -161,13 +161,16 @@ class VectorRetriever(BaseRetriever):
                 # content path, chunk metadata, and chunk text
                 for vector, chunk in zip(batch_vectors, batch_chunks):
                     if isinstance(content, str):
-                        content_path_info = {"content path": content}
+                        content_path_info = {"content path": content[:100]}
                     elif isinstance(content, IOBase):
                         content_path_info = {"content path": "From file bytes"}
                     elif isinstance(content, Element):
                         content_path_info = {
-                            "content path": content.metadata.file_directory
-                            or ""
+                            "content path": content.metadata.file_directory[
+                                :100
+                            ]
+                            if content.metadata.file_directory
+                            else ""
                         }
 
                     chunk_metadata = {"metadata": chunk.metadata.to_dict()}

camel/societies/role_playing.py

@@ -509,8 +509,8 @@ class RolePlaying:
         # step and once in role play), and the model generates only one
         # response when multi-response support is enabled.
         if (
-            'n' in self.user_agent.model_config_dict.keys()
-            and self.user_agent.model_config_dict['n'] > 1
+            'n' in self.user_agent.model_backend.model_config_dict.keys()
+            and self.user_agent.model_backend.model_config_dict['n'] > 1
         ):
             self.user_agent.record_message(user_msg)
 
@@ -532,8 +532,8 @@ class RolePlaying:
         # step and once in role play), and the model generates only one
         # response when multi-response support is enabled.
         if (
-            'n' in self.assistant_agent.model_config_dict.keys()
-            and self.assistant_agent.model_config_dict['n'] > 1
+            'n' in self.assistant_agent.model_backend.model_config_dict.keys()
+            and self.assistant_agent.model_backend.model_config_dict['n'] > 1
         ):
             self.assistant_agent.record_message(assistant_msg)
 

camel/societies/workforce/workforce.py

@@ -251,7 +251,7 @@ class Workforce(BaseNode):
                 additional_info = "A Workforce node"
             elif isinstance(child, SingleAgentWorker):
                 additional_info = "tools: " + (
-                    ", ".join(child.worker.func_dict.keys())
+                    ", ".join(child.worker.tool_dict.keys())
                 )
             elif isinstance(child, RolePlayingWorker):
                 additional_info = "A Role playing node"
@@ -369,7 +369,7 @@ class Workforce(BaseNode):
             model_config_dict=model_config_dict,
         )
 
-        return ChatAgent(worker_sys_msg, model=model, tools=function_list)
+        return ChatAgent(worker_sys_msg, model=model, tools=function_list)  # type: ignore[arg-type]
 
     async def _get_returned_task(self) -> Task:
         r"""Get the task that's published by this node and just get returned

camel/storages/graph_storages/nebula_graph.py

@@ -12,9 +12,20 @@
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 
+import logging
+import re
 import time
 from typing import TYPE_CHECKING, Any, Dict, List, Tuple
 
+from camel.storages.graph_storages.base import BaseGraphStorage
+from camel.storages.graph_storages.graph_element import (
+    GraphElement,
+)
+from camel.utils.commons import dependencies_required
+
+logger = logging.getLogger(__name__)
+
+
 if TYPE_CHECKING:
     from nebula3.data.ResultSet import (  # type: ignore[import-untyped]
         ResultSet,
@@ -24,11 +35,6 @@ if TYPE_CHECKING:
         Session,
     )
 
-from camel.storages.graph_storages.base import BaseGraphStorage
-from camel.storages.graph_storages.graph_element import (
-    GraphElement,
-)
-from camel.utils.commons import dependencies_required
 
 MAX_RETRIES = 5
 RETRY_DELAY = 3
@@ -178,11 +184,21 @@ class NebulaGraph(BaseGraphStorage):
         """
         nodes = self._extract_nodes(graph_elements)
         for node in nodes:
-            self.add_node(node['id'], node['type'])
+            try:
+                self.add_node(node['id'], node['type'])
+            except Exception as e:
+                logger.warning(f"Failed to add node {node}. Error: {e}")
+                continue
 
         relationships = self._extract_relationships(graph_elements)
         for rel in relationships:
-            self.add_triplet(rel['subj']['id'], rel['obj']['id'], rel['type'])
+            try:
+                self.add_triplet(
+                    rel['subj']['id'], rel['obj']['id'], rel['type']
+                )
+            except Exception as e:
+                logger.warning(f"Failed to add relationship {rel}. Error: {e}")
+                continue
 
     def ensure_edge_type_exists(
         self,
@@ -253,6 +269,9 @@ class NebulaGraph(BaseGraphStorage):
             node_id (str): The ID of the node.
             tag_name (str): The tag name of the node.
         """
+        node_id = re.sub(r'[^a-zA-Z0-9\u4e00-\u9fa5]', '', node_id)
+        tag_name = re.sub(r'[^a-zA-Z0-9\u4e00-\u9fa5]', '', tag_name)
+
         self.ensure_tag_exists(tag_name)
 
         # Insert node without properties
@@ -409,6 +428,10 @@ class NebulaGraph(BaseGraphStorage):
             obj (str): The identifier for the object entity.
             rel (str): The relationship between the subject and object.
         """
+        subj = re.sub(r'[^a-zA-Z0-9\u4e00-\u9fa5]', '', subj)
+        obj = re.sub(r'[^a-zA-Z0-9\u4e00-\u9fa5]', '', obj)
+        rel = re.sub(r'[^a-zA-Z0-9\u4e00-\u9fa5]', '', rel)
+
         self.ensure_tag_exists(subj)
         self.ensure_tag_exists(obj)
         self.ensure_edge_type_exists(rel)

camel/types/enums.py

@@ -154,9 +154,15 @@ class ModelType(UnifiedModelType, Enum):
             return self.value
         return "gpt-4o-mini"
 
+    @property
+    def support_native_structured_output(self) -> bool:
+        return self.is_openai
+
     @property
     def support_native_tool_calling(self) -> bool:
-        return any([self.is_openai, self.is_gemini, self.is_mistral])
+        return any(
+            [self.is_openai, self.is_gemini, self.is_mistral, self.is_qwen]
+        )
 
     @property
     def is_openai(self) -> bool:

camel/types/unified_model_type.py

@@ -113,6 +113,11 @@ class UnifiedModelType(str):
         r"""Returns whether the model is a Qwen model."""
         return True
 
+    @property
+    def support_native_structured_output(self) -> bool:
+        r"""Returns whether the model supports native structured output."""
+        return False
+
     @property
     def support_native_tool_calling(self) -> bool:
         r"""Returns whether the model supports native tool calling."""

camel/utils/__init__.py

@@ -21,6 +21,7 @@ from .commons import (
     dependencies_required,
     download_tasks,
     func_string_to_callable,
+    generate_prompt_for_structured_output,
     get_first_int,
     get_prompt_template_key_words,
     get_pydantic_major_version,
@@ -78,4 +79,5 @@ __all__ = [
     "track_agent",
     "handle_http_error",
     "get_pydantic_model",
+    "generate_prompt_for_structured_output",
 ]