camel-ai 0.1.5.9__py3-none-any.whl → 0.1.6.2__py3-none-any.whl

camel/storages/vectordb_storages/base.py

@@ -13,13 +13,13 @@
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 
 from abc import ABC, abstractmethod
-from dataclasses import dataclass, field
 from typing import Any, Dict, List, Optional
 from uuid import uuid4
 
+from pydantic import BaseModel, Field
 
-@dataclass
-class VectorRecord:
+
+class VectorRecord(BaseModel):
     r"""Encapsulates information about a vector's unique identifier and its
     payload, which is primarily used as a data transfer object when saving
     to vector storage.
@@ -33,12 +33,11 @@ class VectorRecord:
     """
 
     vector: List[float]
-    id: str = field(default_factory=lambda: str(uuid4()))
+    id: str = Field(default_factory=lambda: str(uuid4()))
     payload: Optional[Dict[str, Any]] = None
 
 
-@dataclass
-class VectorDBQuery:
+class VectorDBQuery(BaseModel):
     r"""Represents a query to a vector database.
 
     Attributes:
@@ -49,11 +48,24 @@ class VectorDBQuery:
     """
 
     query_vector: List[float]
+    """The numerical representation of the query vector."""
     top_k: int = 1
+    """The number of top similar vectors to retrieve from the database."""
+
+    def __init__(
+        self, query_vector: List[float], top_k: int, **kwargs: Any
+    ) -> None:
+        """Pass in query_vector and tok_k as positional arg.
+        Args:
+            query_vector (List[float]): The numerical representation of the
+                query vector.
+            top_k (int, optional): The number of top similar vectors to
+                retrieve from the database. (default: :obj:`1`)
+        """
+        super().__init__(query_vector=query_vector, top_k=top_k, **kwargs)
 
 
-@dataclass
-class VectorDBQueryResult:
+class VectorDBQueryResult(BaseModel):
     r"""Encapsulates the result of a query against a vector database.
 
     Attributes:
@@ -66,7 +78,7 @@ class VectorDBQueryResult:
     similarity: float
 
     @classmethod
-    def construct(
+    def create(
         cls,
         similarity: float,
         vector: List[float],
@@ -75,13 +87,12 @@ class VectorDBQueryResult:
     ) -> "VectorDBQueryResult":
         r"""A class method to construct a `VectorDBQueryResult` instance."""
         return cls(
-            record=VectorRecord(vector, id, payload),
+            record=VectorRecord(vector=vector, id=id, payload=payload),
             similarity=similarity,
         )
 
 
-@dataclass
-class VectorDBStatus:
+class VectorDBStatus(BaseModel):
     r"""Vector database status.
 
     Attributes:
@@ -195,7 +206,7 @@ class BaseVectorStorage(ABC):
             List[List[Dict[str, Any]]]: A list of vector payloads retrieved
                 from the storage based on similarity to the query vector.
         """
-        results = self.query(VectorDBQuery(vector, top_k))
+        results = self.query(VectorDBQuery(query_vector=vector, top_k=top_k))
         return [
             result.record.payload
             for result in results

camel/storages/vectordb_storages/milvus.py

@@ -361,7 +361,7 @@ class MilvusStorage(BaseVectorStorage):
         query_results = []
         for point in search_result:
             query_results.append(
-                VectorDBQueryResult.construct(
+                VectorDBQueryResult.create(
                     similarity=(point[0]['distance']),
                     id=str(point[0]['id']),
                     payload=(point[0]['entity'].get('payload')),

camel/storages/vectordb_storages/qdrant.py

@@ -11,7 +11,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
-from dataclasses import asdict
 from datetime import datetime
 from typing import Any, Dict, List, Optional, Tuple, Union, cast
 
@@ -261,7 +260,7 @@ class QdrantStorage(BaseVectorStorage):
         """
         from qdrant_client.http.models import PointStruct, UpdateStatus
 
-        qdrant_points = [PointStruct(**asdict(p)) for p in records]
+        qdrant_points = [PointStruct(**p.model_dump()) for p in records]
         op_info = self._client.upsert(
             collection_name=self.collection_name,
             points=qdrant_points,
@@ -340,7 +339,7 @@ class QdrantStorage(BaseVectorStorage):
         query_results = []
         for point in search_result:
             query_results.append(
-                VectorDBQueryResult.construct(
+                VectorDBQueryResult.create(
                     similarity=point.score,
                     id=str(point.id),
                     payload=point.payload,

camel/tasks/__init__.py

@@ -0,0 +1,22 @@
+# =========== Copyright 2023 @ 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 @ CAMEL-AI.org. All Rights Reserved. ===========
+from .task import Task, TaskManager
+from .task_prompt import TASK_DECOMPOSE_PROMPT, TASK_EVOLVE_PROMPT
+
+__all__ = [
+    "TASK_DECOMPOSE_PROMPT",
+    "TASK_EVOLVE_PROMPT",
+    "Task",
+    "TaskManager",
+]

camel/tasks/task.py

@@ -0,0 +1,408 @@
+# =========== Copyright 2023 @ 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 @ CAMEL-AI.org. All Rights Reserved. ===========
+
+import re
+from enum import Enum
+from typing import Callable, Dict, List, Literal, Optional, Union
+
+from pydantic import BaseModel
+
+from camel.agents import ChatAgent
+from camel.messages import BaseMessage
+from camel.prompts import TextPrompt
+
+from .task_prompt import (
+    TASK_COMPOSE_PROMPT,
+    TASK_DECOMPOSE_PROMPT,
+    TASK_EVOLVE_PROMPT,
+)
+
+
+def parse_response(
+    response: str, task_id: Optional[str] = None
+) -> List["Task"]:
+    r"""Parse Tasks from a response.
+
+    Args:
+        response (str): The model response.
+        task_id (str, optional): a parent task id,
+            the default value is "0"
+
+    Returns:
+        List[Task]: A list of tasks which is :obj:`Task` instance.
+    """
+    pattern = "<task>(.*?)</task>"
+    tasks_content = re.findall(pattern, response, re.DOTALL)
+
+    tasks = []
+    if task_id is None:
+        task_id = "0"
+    for i, content in enumerate(tasks_content):
+        tasks.append(Task(content=content.strip(), id=f"{task_id}.{i}"))
+    return tasks
+
+
+class TaskState(str, Enum):
+    OPEN = "OPEN"
+    RUNNING = "RUNNING"
+    DONE = "DONE"
+    FAILED = "FAILED"
+    DELETED = "DELETED"
+
+    @classmethod
+    def states(cls):
+        return [s.value for s in cls]
+
+
+class Task(BaseModel):
+    r"""Task is specific assignment that can be passed to a agent.
+
+    Attributes:
+        content: string content for task.
+        id: An unique string identifier for the task. This should
+        ideally be provided by the provider/model which created the task.
+        state: The state which should be OPEN, RUNNING, DONE or DELETED.
+        type: task type
+        parent: The parent task, None for root task.
+        subtasks: The childrent sub-tasks for the task.
+        result: The answer for the task.
+    """
+
+    content: str
+
+    id: str = ""
+
+    state: TaskState = TaskState.OPEN
+
+    type: Optional[str] = None
+
+    parent: Optional["Task"] = None
+
+    subtasks: List["Task"] = []
+
+    result: Optional[str] = ""
+
+    @classmethod
+    def from_message(cls, message: BaseMessage) -> "Task":
+        r"""Create a task from a message.
+
+        Args:
+            message (BaseMessage): The message to the task.
+
+        Returns:
+            Task
+        """
+        return cls(content=message.content, id="0")
+
+    @staticmethod
+    def to_message():
+        r"""Convert a Task to a Message."""
+        # TODO
+        pass
+
+    def reset(self):
+        r"""Reset Task to initial state."""
+        self.state = TaskState.OPEN
+        self.result = ""
+
+    def update_result(self, result: str):
+        r"""Set task result and mark the task as DONE.
+
+        Args:
+            result (str): The task result.
+        """
+        self.result = result
+        self.set_state(TaskState.DONE)
+
+    def set_id(self, id: str):
+        self.id = id
+
+    def set_state(self, state: TaskState):
+        r"""Recursively set the state of the task and its subtasks.
+
+        Args:
+            state (TaskState): The giving state.
+        """
+        self.state = state
+        if state == TaskState.DONE:
+            for subtask in self.subtasks:
+                if subtask.state != TaskState.DELETED:
+                    subtask.set_state(state)
+        elif state == TaskState.RUNNING and self.parent:
+            self.parent.set_state(state)
+
+    def add_subtask(self, task: "Task"):
+        task.parent = self
+        self.subtasks.append(task)
+
+    def remove_subtask(self, id: str):
+        self.subtasks = [task for task in self.subtasks if task.id != id]
+
+    def get_running_task(self) -> Optional["Task"]:
+        r"""Get RUNNING task."""
+        for sub in self.subtasks:
+            if sub.state == TaskState.RUNNING:
+                return sub.get_running_task()
+        if self.state == TaskState.RUNNING:
+            return self
+        return None
+
+    def to_string(self, indent: str = "", state: bool = False) -> str:
+        r"""Convert task to a sting.
+
+        Args:
+            indent (str): The ident for hierarchical tasks.
+            state (bool): Include or not task state.
+
+        Returns:
+            str: The printable task string.
+        """
+        if state:
+            _str = f"{indent}[{self.state}] Task {self.id}: {self.content}\n"
+        else:
+            _str = f"{indent}Task {self.id}: {self.content}\n"
+        for subtask in self.subtasks:
+            _str += subtask.to_string(indent + "  ", state)
+        return _str
+
+    def get_result(self, indent: str = "") -> str:
+        r"""Get task result to a sting.
+
+        Args:
+            indent (str): The ident for hierarchical tasks.
+
+        Returns:
+            str: The printable task string.
+        """
+        _str = f"{indent}Task {self.id} result: {self.result}\n"
+        for subtask in self.subtasks:
+            _str += subtask.get_result(indent + "  ")
+        return _str
+
+    def decompose(
+        self,
+        agent: ChatAgent,
+        template: TextPrompt = TASK_DECOMPOSE_PROMPT,
+        task_parser: Callable[[str, str], List["Task"]] = parse_response,
+    ) -> List["Task"]:
+        r"""Decompose a task to a list of sub-tasks. It can be used for data
+        generation and planner of agent.
+
+        Args:
+            agent (ChatAgent): An agent that used to decompose the task.
+            template (TextPrompt): The prompt template to decompose
+                task. If not provided, the default template will be used.
+            task_parser (Callable[[str, str], List[Task]], optional): A
+                function to extract Task from response. If not provided,
+                the default parse_response will be used.
+
+        Returns:
+            List[Task]: A list of tasks which are :obj:`Task` instances.
+        """
+
+        role_name = agent.role_name
+        content = template.format(
+            role_name=role_name,
+            content=self.content,
+        )
+        msg = BaseMessage.make_user_message(
+            role_name=role_name, content=content
+        )
+        response = agent.step(msg)
+        tasks = task_parser(response.msg.content, self.id)
+        return tasks
+
+    def compose(
+        self,
+        agent: ChatAgent,
+        template: TextPrompt = TASK_COMPOSE_PROMPT,
+        result_parser: Optional[Callable[[str], str]] = None,
+    ):
+        r"""compose task result by the sub-tasks.
+
+        Args:
+            agent (ChatAgent): An agent that used to compose the task result.
+            template (TextPrompt, optional): The prompt template to compose
+                task. If not provided, the default template will be used.
+            result_parser (Callable[[str, str], List[Task]], optional): A
+                function to extract Task from response.
+        """
+
+        if not self.subtasks:
+            return
+
+        sub_tasks_result = self.get_result()
+
+        role_name = agent.role_name
+        content = template.format(
+            role_name=role_name,
+            content=self.content,
+            other_results=sub_tasks_result,
+        )
+        msg = BaseMessage.make_user_message(
+            role_name=role_name, content=content
+        )
+        response = agent.step(msg)
+        result = response.msg.content
+        if result_parser:
+            result = result_parser(result)
+        self.update_result(result)
+
+    def get_depth(self) -> int:
+        r"""Get current task depth."""
+        if self.parent is None:
+            return 1
+        return 1 + self.parent.get_depth()
+
+
+class TaskManager:
+    r"""TaskManager is used to manage tasks.
+
+    Attributes:
+        root_task: The root task.
+        tasks: The ordered tasks.
+        task_map: A map for task.id to Task.
+        current_task_id: The current "RUNNING" task.id.
+
+    Args:
+        task (Task): The root Task.
+    """
+
+    def __init__(self, task: Task):
+        self.root_task: Task = task
+        self.current_task_id: str = task.id
+        self.tasks: List[Task] = [task]
+        self.task_map: Dict[str, Task] = {task.id: task}
+
+    def gen_task_id(self) -> str:
+        r"""Generate a new task id."""
+        return f"{len(self.tasks)}"
+
+    def exist(self, task_id: str) -> bool:
+        r"""Check if a task with the given id exists."""
+        return task_id in self.task_map
+
+    @property
+    def current_task(self) -> Optional[Task]:
+        r"""Get the current task."""
+        return self.task_map.get(self.current_task_id, None)
+
+    @staticmethod
+    def topological_sort(tasks: List[Task]) -> List[Task]:
+        r"""Sort a list of tasks by topological way.
+
+        Args:
+            tasks (List[Task]): The giving list of tasks.
+
+        Returns:
+            The sorted list of tasks.
+        """
+        stack = []
+        visited = set()
+
+        # recursive visit the vertices
+        def visit(task: Task):
+            if task.id in visited:
+                return
+            visited.add(task.id)
+
+            # go deep for dependencies
+            for sub_task in task.subtasks:
+                visit(sub_task)
+
+            # add current task to stack which have no dependencies.
+            stack.append(task)
+
+        for task in tasks:
+            visit(task)
+
+        return stack
+
+    @staticmethod
+    def set_tasks_dependence(
+        root: Task,
+        others: List[Task],
+        type: Literal["serial", "parallel"] = "parallel",
+    ):
+        r"""Set relationship between root task and other tasks.
+        Two relationships are currently supported: serial and parallel.
+        `serial` :  root -> other1 -> other2
+        `parallel`: root -> other1
+                         -> other2
+
+        Args:
+            root (Task): A root task.
+            others (List[Task]): A list of tasks.
+        """
+        # filter the root task in the others to avoid self-loop dependence.
+        others = [other for other in others if other != root]
+
+        if len(others) == 0:
+            return
+        if type == "parallel":
+            for other in others:
+                root.add_subtask(other)
+        else:
+            parent = root
+            for child in others:
+                parent.add_subtask(child)
+                parent = child
+
+    def add_tasks(self, tasks: Union[Task, List[Task]]) -> None:
+        r"""self.tasks and self.task_map will be updated by the input tasks."""
+        if not tasks:
+            return
+        if not isinstance(tasks, List):
+            tasks = [tasks]
+        for task in tasks:
+            assert not self.exist(task.id), f"`{task.id}` already existed."
+        self.tasks = self.topological_sort(self.tasks + tasks)
+        self.task_map = {task.id: task for task in self.tasks}
+
+    def evolve(
+        self,
+        task: Task,
+        agent: ChatAgent,
+        template: Optional[TextPrompt] = None,
+        task_parser: Optional[Callable[[str, str], List[Task]]] = None,
+    ) -> Optional[Task]:
+        r"""Evolve a task to a new task.
+            Evolve is only used for data generation.
+        Args:
+            task (Task): A given task.
+            agent (ChatAgent): An agent that used to evolve the task.
+            template (TextPrompt, optional): A prompt template to evolve task.
+                If not provided, the default template will be used.
+            task_parser (Callable, optional): A function to extract Task from
+                response. If not provided, the default parser will be used.
+
+        Returns:
+            Task: The created :obj:`Task` instance or None.
+        """
+
+        if template is None:
+            template = TASK_EVOLVE_PROMPT
+
+        role_name = agent.role_name
+        content = template.format(role_name=role_name, content=task.content)
+        msg = BaseMessage.make_user_message(
+            role_name=role_name, content=content
+        )
+        response = agent.step(msg)
+        if task_parser is None:
+            task_parser = parse_response
+        tasks = task_parser(response.msg.content, task.id)
+        if tasks:
+            return tasks[0]
+        return None

camel/tasks/task_prompt.py

@@ -0,0 +1,65 @@
+# =========== Copyright 2023 @ 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 @ CAMEL-AI.org. All Rights Reserved. ===========
+from camel.prompts import TextPrompt
+
+# ruff: noqa: E501
+TASK_DECOMPOSE_PROMPT = TextPrompt(
+    """As a Task Decomposer with the role of {role_name}, your objective is to divide the given task into subtasks.
+You have been provided with the following objective:
+
+{content}
+
+Please format the subtasks as a numbered list within <tasks> tags, as demonstrated below:
+<tasks>
+<task>Subtask 1</task>
+<task>Subtask 2</task>
+</tasks>
+
+Each subtask should be concise, concrete, and achievable for a {role_name}.
+Ensure that the task plan is created without asking any questions.
+Be specific and clear.
+"""
+)
+
+
+TASK_COMPOSE_PROMPT = TextPrompt(
+    """As a Task composer with the role of {role_name}, your objective is to gather result from all sub tasks to get the final answer.
+The root task is:
+
+{content}
+
+The related tasks result and status:
+
+{other_results}
+
+so, the final answer of the root task is: 
+"""
+)
+
+
+TASK_EVOLVE_PROMPT = TextPrompt(
+    """As a Task Creator for {role_name}, your objective is to draw inspiration from the provided task to develop an entirely new one.
+The new task should fall within the same domain as the given task but be more complex and unique.
+It must be reasonable, understandable, and actionable by {role_name}.
+The created task must be enclosed within <task> </task> tags.
+<task>
+... created task
+</task>
+
+## given task
+{content}
+
+## created task
+"""
+)

camel/toolkits/__init__.py

@@ -27,6 +27,7 @@ from .search_toolkit import SEARCH_FUNCS, SearchToolkit
 from .twitter_toolkit import TWITTER_FUNCS, TwitterToolkit
 from .weather_toolkit import WEATHER_FUNCS, WeatherToolkit
 from .slack_toolkit import SLACK_FUNCS, SlackToolkit
+from .dalle_toolkit import DALLE_FUNCS, DalleToolkit
 
 from .base import BaseToolkit
 from .code_execution import CodeExecutionToolkit
@@ -45,12 +46,14 @@ __all__ = [
     'TWITTER_FUNCS',
     'WEATHER_FUNCS',
     'SLACK_FUNCS',
+    'DALLE_FUNCS',
     'BaseToolkit',
     'GithubToolkit',
     'MathToolkit',
     'GoogleMapsToolkit',
     'SearchToolkit',
     'SlackToolkit',
+    'DalleToolkit',
     'TwitterToolkit',
     'WeatherToolkit',
     'RetrievalToolkit',

camel/toolkits/base.py

@@ -14,9 +14,11 @@
 
 from typing import List
 
+from camel.utils import AgentOpsMeta
+
 from .openai_function import OpenAIFunction
 
 
-class BaseToolkit:
+class BaseToolkit(metaclass=AgentOpsMeta):
     def get_tools(self) -> List[OpenAIFunction]:
         raise NotImplementedError("Subclasses must implement this method.")