Upload 30 files

crewai/__init__.py

@@ -0,0 +1,4 @@
+from crewai.agent import Agent
+from crewai.crew import Crew
+from crewai.process import Process
+from crewai.task import Task

crewai/agent.py

@@ -0,0 +1,237 @@
+import uuid
+from typing import Any, List, Optional
+
+from langchain.agents.format_scratchpad import format_log_to_str
+from langchain.agents.agent import RunnableAgent
+from langchain.memory import ConversationSummaryMemory
+from langchain.tools.render import render_text_description
+from langchain_core.runnables.config import RunnableConfig
+from langchain_openai import ChatOpenAI
+from langchain_core.language_models import BaseLanguageModel
+from pydantic import (
+    UUID4,
+    BaseModel,
+    ConfigDict,
+    Field,
+    InstanceOf,
+    PrivateAttr,
+    field_validator,
+    model_validator,
+)
+from pydantic_core import PydanticCustomError
+
+from crewai.agents import (
+    CacheHandler,
+    CrewAgentExecutor,
+    CrewAgentOutputParser,
+    ToolsHandler,
+)
+from crewai.utilities import I18N, Logger, Prompts, RPMController
+
+
+class Agent(BaseModel):
+    """Represents an agent in a system.
+    Each agent has a role, a goal, a backstory, and an optional language model (llm).
+    The agent can also have memory, can operate in verbose mode, and can delegate tasks to other agents.
+    Attributes:
+            agent_executor: An instance of the CrewAgentExecutor class.
+            role: The role of the agent.
+            goal: The objective of the agent.
+            backstory: The backstory of the agent.
+            llm: The language model that will run the agent.
+            max_iter: Maximum number of iterations for an agent to execute a task.
+            memory: Whether the agent should have memory or not.
+            max_rpm: Maximum number of requests per minute for the agent execution to be respected.
+            verbose: Whether the agent execution should be in verbose mode.
+            allow_delegation: Whether the agent is allowed to delegate tasks to other agents.
+            tools: Tools at agents disposal
+    """
+
+    __hash__ = object.__hash__  # type: ignore
+    _logger: Logger = PrivateAttr()
+    _rpm_controller: RPMController = PrivateAttr(default=None)
+    _request_within_rpm_limit: Any = PrivateAttr(default=None)
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+    id: UUID4 = Field(
+        default_factory=uuid.uuid4,
+        frozen=True,
+        description="Unique identifier for the object, not set by user.",
+    )
+    role: str = Field(description="Role of the agent")
+    goal: str = Field(description="Objective of the agent")
+    backstory: str = Field(description="Backstory of the agent")
+    max_rpm: Optional[int] = Field(
+        default=None,
+        description="Maximum number of requests per minute for the agent execution to be respected.",
+    )
+    memory: bool = Field(
+        default=True, description="Whether the agent should have memory or not"
+    )
+    verbose: bool = Field(
+        default=False, description="Verbose mode for the Agent Execution"
+    )
+    allow_delegation: bool = Field(
+        default=True, description="Allow delegation of tasks to agents"
+    )
+    tools: List[Any] = Field(
+        default_factory=list, description="Tools at agents disposal"
+    )
+    max_iter: Optional[int] = Field(
+        default=15, description="Maximum iterations for an agent to execute a task"
+    )
+    agent_executor: InstanceOf[CrewAgentExecutor] = Field(
+        default=None, description="An instance of the CrewAgentExecutor class."
+    )
+    tools_handler: InstanceOf[ToolsHandler] = Field(
+        default=None, description="An instance of the ToolsHandler class."
+    )
+    cache_handler: InstanceOf[CacheHandler] = Field(
+        default=CacheHandler(), description="An instance of the CacheHandler class."
+    )
+    i18n: I18N = Field(default=I18N(), description="Internationalization settings.")
+    llm: Any = Field(
+        default_factory=lambda: ChatOpenAI(
+            model="gpt-4",
+        ),
+        description="Language model that will run the agent.",
+    )
+
+    @field_validator("id", mode="before")
+    @classmethod
+    def _deny_user_set_id(cls, v: Optional[UUID4]) -> None:
+        if v:
+            raise PydanticCustomError(
+                "may_not_set_field", "This field is not to be set by the user.", {}
+            )
+
+    @model_validator(mode="after")
+    def set_private_attrs(self):
+        """Set private attributes."""
+        self._logger = Logger(self.verbose)
+        if self.max_rpm and not self._rpm_controller:
+            self._rpm_controller = RPMController(
+                max_rpm=self.max_rpm, logger=self._logger
+            )
+        return self
+
+    @model_validator(mode="after")
+    def check_agent_executor(self) -> "Agent":
+        """Check if the agent executor is set."""
+        if not self.agent_executor:
+            self.set_cache_handler(self.cache_handler)
+        return self
+
+    def execute_task(
+        self,
+        task: str,
+        context: Optional[str] = None,
+        tools: Optional[List[Any]] = None,
+    ) -> str:
+        """Execute a task with the agent.
+        Args:
+            task: Task to execute.
+            context: Context to execute the task in.
+            tools: Tools to use for the task.
+        Returns:
+            Output of the agent
+        """
+
+        if context:
+            task = self.i18n.slice("task_with_context").format(
+                task=task, context=context
+            )
+
+        tools = tools or self.tools
+        self.agent_executor.tools = tools
+
+        result = self.agent_executor.invoke(
+            {
+                "input": task,
+                "tool_names": self.__tools_names(tools),
+                "tools": render_text_description(tools),
+            },
+            RunnableConfig(callbacks=[self.tools_handler]),
+        )["output"]
+
+        if self.max_rpm:
+            self._rpm_controller.stop_rpm_counter()
+
+        return result
+
+    def set_cache_handler(self, cache_handler: CacheHandler) -> None:
+        """Set the cache handler for the agent.
+        Args:
+            cache_handler: An instance of the CacheHandler class.
+        """
+        self.cache_handler = cache_handler
+        self.tools_handler = ToolsHandler(cache=self.cache_handler)
+        self.__create_agent_executor()
+
+    def set_rpm_controller(self, rpm_controller: RPMController) -> None:
+        """Set the rpm controller for the agent.
+        Args:
+            rpm_controller: An instance of the RPMController class.
+        """
+        if not self._rpm_controller:
+            self._rpm_controller = rpm_controller
+            self.__create_agent_executor()
+
+    def __create_agent_executor(self) -> None:
+        """Create an agent executor for the agent.
+        Returns:
+            An instance of the CrewAgentExecutor class.
+        """
+        agent_args = {
+            "input": lambda x: x["input"],
+            "tools": lambda x: x["tools"],
+            "tool_names": lambda x: x["tool_names"],
+            "agent_scratchpad": lambda x: format_log_to_str(x["intermediate_steps"]),
+        }
+        executor_args = {
+            "i18n": self.i18n,
+            "tools": self.tools,
+            "verbose": self.verbose,
+            "handle_parsing_errors": True,
+            "max_iterations": self.max_iter,
+        }
+
+        if self._rpm_controller:
+            executor_args["request_within_rpm_limit"] = (
+                self._rpm_controller.check_or_wait
+            )
+
+        if self.memory:
+            summary_memory = ConversationSummaryMemory(
+                llm=self.llm, input_key="input", memory_key="chat_history"
+            )
+            executor_args["memory"] = summary_memory
+            agent_args["chat_history"] = lambda x: x["chat_history"]
+            prompt = Prompts(i18n=self.i18n).task_execution_with_memory()
+        else:
+            prompt = Prompts(i18n=self.i18n).task_execution()
+
+        execution_prompt = prompt.partial(
+            goal=self.goal,
+            role=self.role,
+            backstory=self.backstory,
+        )
+
+        bind = self.llm.bind(stop=[self.i18n.slice("observation")])
+        inner_agent = (
+            agent_args
+            | execution_prompt
+            | bind
+            | CrewAgentOutputParser(
+                tools_handler=self.tools_handler,
+                cache=self.cache_handler,
+                i18n=self.i18n,
+            )
+        )
+        self.agent_executor = CrewAgentExecutor(
+            agent=RunnableAgent(runnable=inner_agent), **executor_args
+        )
+
+    @staticmethod
+    def __tools_names(tools) -> str:
+        return ", ".join([t.name for t in tools])

crewai/agents/__init__.py

@@ -0,0 +1,4 @@
+from .cache.cache_handler import CacheHandler
+from .executor import CrewAgentExecutor
+from .output_parser import CrewAgentOutputParser
+from .tools_handler import ToolsHandler

crewai/agents/cache/__init__.py

@@ -0,0 +1,2 @@
+from .cache_handler import CacheHandler
+from .cache_hit import CacheHit

crewai/agents/cache/cache_handler.py

@@ -0,0 +1,18 @@
+from typing import Optional
+
+
+class CacheHandler:
+    """Callback handler for tool usage."""
+
+    _cache: dict = {}
+
+    def __init__(self):
+        self._cache = {}
+
+    def add(self, tool, input, output):
+        input = input.strip()
+        self._cache[f"{tool}-{input}"] = output
+
+    def read(self, tool, input) -> Optional[str]:
+        input = input.strip()
+        return self._cache.get(f"{tool}-{input}")

crewai/agents/cache/cache_hit.py

@@ -0,0 +1,18 @@
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+from .cache_handler import CacheHandler
+
+
+class CacheHit(BaseModel):
+    """Cache Hit Object."""
+
+    class Config:
+        arbitrary_types_allowed = True
+
+    # Making it Any instead of AgentAction to avoind
+    # pydantic v1 vs v2 incompatibility, langchain should
+    # soon be updated to pydantic v2
+    action: Any = Field(description="Action taken")
+    cache: CacheHandler = Field(description="Cache Handler for the tool")

crewai/agents/exceptions.py

@@ -0,0 +1,30 @@
+from langchain_core.exceptions import OutputParserException
+
+from crewai.utilities import I18N
+
+
+class TaskRepeatedUsageException(OutputParserException):
+    """Exception raised when a task is used twice in a roll."""
+
+    i18n: I18N = I18N()
+    error: str = "TaskRepeatedUsageException"
+    message: str
+
+    def __init__(self, i18n: I18N, tool: str, tool_input: str, text: str):
+        self.i18n = i18n
+        self.text = text
+        self.tool = tool
+        self.tool_input = tool_input
+        self.message = self.i18n.errors("task_repeated_usage").format(
+            tool=tool, tool_input=tool_input
+        )
+
+        super().__init__(
+            error=self.error,
+            observation=self.message,
+            send_to_llm=True,
+            llm_output=self.text,
+        )
+
+    def __str__(self):
+        return self.message

crewai/agents/executor.py

@@ -0,0 +1,214 @@
+import time
+from typing import Any, Dict, Iterator, List, Optional, Tuple, Union
+
+from langchain.agents import AgentExecutor
+from langchain.agents.agent import ExceptionTool
+from langchain.agents.tools import InvalidTool
+from langchain.callbacks.manager import CallbackManagerForChainRun
+from langchain_core.agents import AgentAction, AgentFinish, AgentStep
+from langchain_core.exceptions import OutputParserException
+from langchain_core.pydantic_v1 import root_validator
+from langchain_core.tools import BaseTool
+from langchain_core.utils.input import get_color_mapping
+
+from crewai.agents.cache.cache_hit import CacheHit
+from crewai.tools.cache_tools import CacheTools
+from crewai.utilities import I18N
+
+
+class CrewAgentExecutor(AgentExecutor):
+    i18n: I18N = I18N()
+    iterations: int = 0
+    request_within_rpm_limit: Any = None
+    max_iterations: Optional[int] = 15
+    force_answer_max_iterations: Optional[int] = None
+
+    @root_validator()
+    def set_force_answer_max_iterations(cls, values: Dict) -> Dict:
+        values["force_answer_max_iterations"] = values["max_iterations"] - 2
+        return values
+
+    def _should_force_answer(self) -> bool:
+        return True if self.iterations == self.force_answer_max_iterations else False
+
+    def _force_answer(self, output: AgentAction):
+        return AgentStep(
+            action=output, observation=self.i18n.errors("force_final_answer")
+        )
+
+    def _call(
+        self,
+        inputs: Dict[str, str],
+        run_manager: Optional[CallbackManagerForChainRun] = None,
+    ) -> Dict[str, Any]:
+        """Run text through and get agent response."""
+        # Construct a mapping of tool name to tool for easy lookup
+        name_to_tool_map = {tool.name: tool for tool in self.tools}
+        # We construct a mapping from each tool to a color, used for logging.
+        color_mapping = get_color_mapping(
+            [tool.name for tool in self.tools], excluded_colors=["green", "red"]
+        )
+        intermediate_steps: List[Tuple[AgentAction, str]] = []
+        # Let's start tracking the number of iterations and time elapsed
+        self.iterations = 0
+        time_elapsed = 0.0
+        start_time = time.time()
+        # We now enter the agent loop (until it returns something).
+        while self._should_continue(self.iterations, time_elapsed):
+            if not self.request_within_rpm_limit or self.request_within_rpm_limit():
+                next_step_output = self._take_next_step(
+                    name_to_tool_map,
+                    color_mapping,
+                    inputs,
+                    intermediate_steps,
+                    run_manager=run_manager,
+                )
+                if isinstance(next_step_output, AgentFinish):
+                    return self._return(
+                        next_step_output, intermediate_steps, run_manager=run_manager
+                    )
+
+                intermediate_steps.extend(next_step_output)
+                if len(next_step_output) == 1:
+                    next_step_action = next_step_output[0]
+                    # See if tool should return directly
+                    tool_return = self._get_tool_return(next_step_action)
+                    if tool_return is not None:
+                        return self._return(
+                            tool_return, intermediate_steps, run_manager=run_manager
+                        )
+                self.iterations += 1
+                time_elapsed = time.time() - start_time
+        output = self.agent.return_stopped_response(
+            self.early_stopping_method, intermediate_steps, **inputs
+        )
+        return self._return(output, intermediate_steps, run_manager=run_manager)
+
+    def _iter_next_step(
+        self,
+        name_to_tool_map: Dict[str, BaseTool],
+        color_mapping: Dict[str, str],
+        inputs: Dict[str, str],
+        intermediate_steps: List[Tuple[AgentAction, str]],
+        run_manager: Optional[CallbackManagerForChainRun] = None,
+    ) -> Iterator[Union[AgentFinish, AgentAction, AgentStep]]:
+        """Take a single step in the thought-action-observation loop.
+
+        Override this to take control of how the agent makes and acts on choices.
+        """
+        try:
+            intermediate_steps = self._prepare_intermediate_steps(intermediate_steps)
+
+            # Call the LLM to see what to do.
+            output = self.agent.plan(
+                intermediate_steps,
+                callbacks=run_manager.get_child() if run_manager else None,
+                **inputs,
+            )
+            if self._should_force_answer():
+                if isinstance(output, AgentAction) or isinstance(output, AgentFinish):
+                    output = output
+                elif isinstance(output, CacheHit):
+                    output = output.action
+                else:
+                    raise ValueError(
+                        f"Unexpected output type from agent: {type(output)}"
+                    )
+                yield self._force_answer(output)
+                return
+
+        except OutputParserException as e:
+            if isinstance(self.handle_parsing_errors, bool):
+                raise_error = not self.handle_parsing_errors
+            else:
+                raise_error = False
+            if raise_error:
+                raise ValueError(
+                    "An output parsing error occurred. "
+                    "In order to pass this error back to the agent and have it try "
+                    "again, pass `handle_parsing_errors=True` to the AgentExecutor. "
+                    f"This is the error: {str(e)}"
+                )
+            text = str(e)
+            if isinstance(self.handle_parsing_errors, bool):
+                if e.send_to_llm:
+                    observation = str(e.observation)
+                    text = str(e.llm_output)
+                else:
+                    observation = "Invalid or incomplete response"
+            elif isinstance(self.handle_parsing_errors, str):
+                observation = self.handle_parsing_errors
+            elif callable(self.handle_parsing_errors):
+                observation = self.handle_parsing_errors(e)
+            else:
+                raise ValueError("Got unexpected type of `handle_parsing_errors`")
+            output = AgentAction("_Exception", observation, text)
+            if run_manager:
+                run_manager.on_agent_action(output, color="green")
+            tool_run_kwargs = self.agent.tool_run_logging_kwargs()
+            observation = ExceptionTool().run(
+                output.tool_input,
+                verbose=self.verbose,
+                color=None,
+                callbacks=run_manager.get_child() if run_manager else None,
+                **tool_run_kwargs,
+            )
+
+            if self._should_force_answer():
+                yield self._force_answer(output)
+                return
+
+            yield AgentStep(action=output, observation=observation)
+            return
+
+        # If the tool chosen is the finishing tool, then we end and return.
+        if isinstance(output, AgentFinish):
+            yield output
+            return
+
+        # Override tool usage to use CacheTools
+        if isinstance(output, CacheHit):
+            cache = output.cache
+            action = output.action
+            tool = CacheTools(cache_handler=cache).tool()
+            output = action.copy()
+            output.tool_input = f"tool:{action.tool}|input:{action.tool_input}"
+            output.tool = tool.name
+            name_to_tool_map[tool.name] = tool
+            color_mapping[tool.name] = color_mapping[action.tool]
+
+        actions: List[AgentAction]
+        actions = [output] if isinstance(output, AgentAction) else output
+        yield from actions
+        for agent_action in actions:
+            if run_manager:
+                run_manager.on_agent_action(agent_action, color="green")
+            # Otherwise we lookup the tool
+            if agent_action.tool in name_to_tool_map:
+                tool = name_to_tool_map[agent_action.tool]
+                return_direct = tool.return_direct
+                color = color_mapping[agent_action.tool]
+                tool_run_kwargs = self.agent.tool_run_logging_kwargs()
+                if return_direct:
+                    tool_run_kwargs["llm_prefix"] = ""
+                # We then call the tool on the tool input to get an observation
+                observation = tool.run(
+                    agent_action.tool_input,
+                    verbose=self.verbose,
+                    color=color,
+                    callbacks=run_manager.get_child() if run_manager else None,
+                    **tool_run_kwargs,
+                )
+            else:
+                tool_run_kwargs = self.agent.tool_run_logging_kwargs()
+                observation = InvalidTool().run(
+                    {
+                        "requested_tool_name": agent_action.tool,
+                        "available_tool_names": list(name_to_tool_map.keys()),
+                    },
+                    verbose=self.verbose,
+                    color=None,
+                    callbacks=run_manager.get_child() if run_manager else None,
+                    **tool_run_kwargs,
+                )
+            yield AgentStep(action=agent_action, observation=observation)

crewai/agents/output_parser.py

@@ -0,0 +1,79 @@
+import re
+from typing import Union
+
+from langchain.agents.output_parsers import ReActSingleInputOutputParser
+from langchain_core.agents import AgentAction, AgentFinish
+
+from crewai.agents.cache import CacheHandler, CacheHit
+from crewai.agents.exceptions import TaskRepeatedUsageException
+from crewai.agents.tools_handler import ToolsHandler
+from crewai.utilities import I18N
+
+FINAL_ANSWER_ACTION = "Final Answer:"
+FINAL_ANSWER_AND_PARSABLE_ACTION_ERROR_MESSAGE = (
+    "Parsing LLM output produced both a final answer and a parse-able action:"
+)
+
+
+class CrewAgentOutputParser(ReActSingleInputOutputParser):
+    """Parses ReAct-style LLM calls that have a single tool input.
+
+    Expects output to be in one of two formats.
+
+    If the output signals that an action should be taken,
+    should be in the below format. This will result in an AgentAction
+    being returned.
+
+    ```
+    Thought: agent thought here
+    Action: search
+    Action Input: what is the temperature in SF?
+    ```
+
+    If the output signals that a final answer should be given,
+    should be in the below format. This will result in an AgentFinish
+    being returned.
+
+    ```
+    Thought: agent thought here
+    Final Answer: The temperature is 100 degrees
+    ```
+
+    It also prevents tools from being reused in a roll.
+    """
+
+    class Config:
+        arbitrary_types_allowed = True
+
+    tools_handler: ToolsHandler
+    cache: CacheHandler
+    i18n: I18N
+
+    def parse(self, text: str) -> Union[AgentAction, AgentFinish, CacheHit]:
+        regex = (
+            r"Action\s*\d*\s*:[\s]*(.*?)[\s]*Action\s*\d*\s*Input\s*\d*\s*:[\s]*(.*)"
+        )
+        if action_match := re.search(regex, text, re.DOTALL):
+            action = action_match.group(1).strip()
+            action_input = action_match.group(2)
+            tool_input = action_input.strip(" ")
+            tool_input = tool_input.strip('"')
+
+            if last_tool_usage := self.tools_handler.last_used_tool:
+                usage = {
+                    "tool": action,
+                    "input": tool_input,
+                }
+                if usage == last_tool_usage:
+                    raise TaskRepeatedUsageException(
+                        text=text,
+                        tool=action,
+                        tool_input=tool_input,
+                        i18n=self.i18n,
+                    )
+
+            if self.cache.read(action, tool_input):
+                action = AgentAction(action, tool_input, text)
+                return CacheHit(action=action, cache=self.cache)
+
+        return super().parse(text)

crewai/agents/tools_handler.py

@@ -0,0 +1,44 @@
+from typing import Any, Dict
+
+from langchain.callbacks.base import BaseCallbackHandler
+
+from ..tools.cache_tools import CacheTools
+from .cache.cache_handler import CacheHandler
+
+
+class ToolsHandler(BaseCallbackHandler):
+    """Callback handler for tool usage."""
+
+    last_used_tool: Dict[str, Any] = {}
+    cache: CacheHandler
+
+    def __init__(self, cache: CacheHandler, **kwargs: Any):
+        """Initialize the callback handler."""
+        self.cache = cache
+        super().__init__(**kwargs)
+
+    def on_tool_start(
+        self, serialized: Dict[str, Any], input_str: str, **kwargs: Any
+    ) -> Any:
+        """Run when tool starts running."""
+        name = serialized.get("name")
+        if name not in ["invalid_tool", "_Exception"]:
+            tools_usage = {
+                "tool": name,
+                "input": input_str,
+            }
+            self.last_used_tool = tools_usage
+
+    def on_tool_end(self, output: str, **kwargs: Any) -> Any:
+        """Run when tool ends running."""
+        if (
+            "is not a valid tool" not in output
+            and "Invalid or incomplete response" not in output
+            and "Invalid Format" not in output
+        ):
+            if self.last_used_tool["tool"] != CacheTools().name:
+                self.cache.add(
+                    tool=self.last_used_tool["tool"],
+                    input=self.last_used_tool["input"],
+                    output=output,
+                )

crewai/crew.py

@@ -0,0 +1,173 @@
+import json
+import uuid
+from typing import Any, Dict, List, Optional, Union
+
+from pydantic import (
+    UUID4,
+    BaseModel,
+    ConfigDict,
+    Field,
+    InstanceOf,
+    Json,
+    PrivateAttr,
+    field_validator,
+    model_validator,
+)
+from pydantic_core import PydanticCustomError
+
+from crewai.agent import Agent
+from crewai.agents.cache import CacheHandler
+from crewai.process import Process
+from crewai.task import Task
+from crewai.tools.agent_tools import AgentTools
+from crewai.utilities import I18N, Logger, RPMController
+
+
+class Crew(BaseModel):
+    """
+    Represents a group of agents, defining how they should collaborate and the tasks they should perform.
+    Attributes:
+        tasks: List of tasks assigned to the crew.
+        agents: List of agents part of this crew.
+        process: The process flow that the crew will follow (e.g., sequential).
+        verbose: Indicates the verbosity level for logging during execution.
+        config: Configuration settings for the crew.
+        _cache_handler: Handles caching for the crew's operations.
+        max_rpm: Maximum number of requests per minute for the crew execution to be respected.
+        id: A unique identifier for the crew instance.
+    """
+
+    __hash__ = object.__hash__  # type: ignore
+    _rpm_controller: RPMController = PrivateAttr()
+    _logger: Logger = PrivateAttr()
+    _cache_handler: InstanceOf[CacheHandler] = PrivateAttr(default=CacheHandler())
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+    tasks: List[Task] = Field(default_factory=list)
+    agents: List[Agent] = Field(default_factory=list)
+    process: Process = Field(default=Process.sequential)
+    verbose: Union[int, bool] = Field(default=0)
+    config: Optional[Union[Json, Dict[str, Any]]] = Field(default=None)
+    id: UUID4 = Field(default_factory=uuid.uuid4, frozen=True)
+    max_rpm: Optional[int] = Field(
+        default=None,
+        description="Maximum number of requests per minute for the crew execution to be respected.",
+    )
+    language: str = Field(
+        default="en",
+        description="Language used for the crew, defaults to English.",
+    )
+
+    @field_validator("id", mode="before")
+    @classmethod
+    def _deny_user_set_id(cls, v: Optional[UUID4]) -> None:
+        """Prevent manual setting of the 'id' field by users."""
+        if v:
+            raise PydanticCustomError(
+                "may_not_set_field", "The 'id' field cannot be set by the user.", {}
+            )
+
+    @field_validator("config", mode="before")
+    @classmethod
+    def check_config_type(
+        cls, v: Union[Json, Dict[str, Any]]
+    ) -> Union[Json, Dict[str, Any]]:
+        """Validates that the config is a valid type.
+        Args:
+            v: The config to be validated.
+        Returns:
+            The config if it is valid.
+        """
+
+        # TODO: Improve typing
+        return json.loads(v) if isinstance(v, Json) else v  # type: ignore
+
+    @model_validator(mode="after")
+    def set_private_attrs(self) -> "Crew":
+        """Set private attributes."""
+        self._cache_handler = CacheHandler()
+        self._logger = Logger(self.verbose)
+        self._rpm_controller = RPMController(max_rpm=self.max_rpm, logger=self._logger)
+        return self
+
+    @model_validator(mode="after")
+    def check_config(self):
+        """Validates that the crew is properly configured with agents and tasks."""
+        if not self.config and not self.tasks and not self.agents:
+            raise PydanticCustomError(
+                "missing_keys",
+                "Either 'agents' and 'tasks' need to be set or 'config'.",
+                {},
+            )
+
+        if self.config:
+            self._setup_from_config()
+
+        if self.agents:
+            for agent in self.agents:
+                agent.set_cache_handler(self._cache_handler)
+                agent.set_rpm_controller(self._rpm_controller)
+        return self
+
+    def _setup_from_config(self):
+        assert self.config is not None, "Config should not be None."
+
+        """Initializes agents and tasks from the provided config."""
+        if not self.config.get("agents") or not self.config.get("tasks"):
+            raise PydanticCustomError(
+                "missing_keys_in_config", "Config should have 'agents' and 'tasks'.", {}
+            )
+
+        self.agents = [Agent(**agent) for agent in self.config["agents"]]
+        self.tasks = [self._create_task(task) for task in self.config["tasks"]]
+
+    def _create_task(self, task_config: Dict[str, Any]) -> Task:
+        """Creates a task instance from its configuration.
+        Args:
+            task_config: The configuration of the task.
+        Returns:
+            A task instance.
+        """
+        task_agent = next(
+            agt for agt in self.agents if agt.role == task_config["agent"]
+        )
+        del task_config["agent"]
+        return Task(**task_config, agent=task_agent)
+
+    def kickoff(self) -> str:
+        """Starts the crew to work on its assigned tasks."""
+        for agent in self.agents:
+            agent.i18n = I18N(language=self.language)
+
+        if self.process == Process.sequential:
+            return self._sequential_loop()
+        else:
+            raise NotImplementedError(
+                f"The process '{self.process}' is not implemented yet."
+            )
+
+    def _sequential_loop(self) -> str:
+        """Executes tasks sequentially and returns the final output."""
+        task_output = ""
+        for task in self.tasks:
+            self._prepare_and_execute_task(task)
+            task_output = task.execute(task_output)
+
+            role = task.agent.role if task.agent is not None else "None"
+            self._logger.log("debug", f"[{role}] Task output: {task_output}\n\n")
+
+        if self.max_rpm:
+            self._rpm_controller.stop_rpm_counter()
+
+        return task_output
+
+    def _prepare_and_execute_task(self, task: Task) -> None:
+        """Prepares and logs information about the task being executed.
+        Args:
+            task: The task to be executed.
+        """
+        if task.agent is not None and task.agent.allow_delegation:
+            task.tools += AgentTools(agents=self.agents).tools()
+
+        role = task.agent.role if task.agent is not None else "None"
+        self._logger.log("debug", f"Working Agent: {role}")
+        self._logger.log("info", f"Starting Task: {task.description}")

crewai/process.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+
+class Process(str, Enum):
+    """
+    Class representing the different processes that can be used to tackle tasks
+    """
+
+    sequential = "sequential"
+    # TODO: consensual = 'consensual'
+    # TODO: hierarchical = 'hierarchical'

crewai/task.py

@@ -0,0 +1,86 @@
+import uuid
+from typing import Any, List, Optional
+
+from pydantic import UUID4, BaseModel, Field, field_validator, model_validator
+from pydantic_core import PydanticCustomError
+
+from crewai.agent import Agent
+from crewai.tasks.task_output import TaskOutput
+from crewai.utilities import I18N
+
+
+class Task(BaseModel):
+    """Class that represent a task to be executed."""
+
+    __hash__ = object.__hash__  # type: ignore
+    i18n: I18N = I18N()
+    description: str = Field(description="Description of the actual task.")
+    callback: Optional[Any] = Field(
+        description="Callback to be executed after the task is completed.", default=None
+    )
+    agent: Optional[Agent] = Field(
+        description="Agent responsible for executiong the task.", default=None
+    )
+    expected_output: Optional[str] = Field(
+        description="Clear definition of expected output for the task.",
+        default=None,
+    )
+    output: Optional[TaskOutput] = Field(
+        description="Task output, it's final result after being executed", default=None
+    )
+    tools: List[Any] = Field(
+        default_factory=list,
+        description="Tools the agent is limited to use for this task.",
+    )
+    id: UUID4 = Field(
+        default_factory=uuid.uuid4,
+        frozen=True,
+        description="Unique identifier for the object, not set by user.",
+    )
+
+    @field_validator("id", mode="before")
+    @classmethod
+    def _deny_user_set_id(cls, v: Optional[UUID4]) -> None:
+        if v:
+            raise PydanticCustomError(
+                "may_not_set_field", "This field is not to be set by the user.", {}
+            )
+
+    @model_validator(mode="after")
+    def check_tools(self):
+        """Check if the tools are set."""
+        if not self.tools and self.agent and self.agent.tools:
+            self.tools.extend(self.agent.tools)
+        return self
+
+    def execute(self, context: Optional[str] = None) -> str:
+        """Execute the task.
+        Returns:
+            Output of the task.
+        """
+        if not self.agent:
+            raise Exception(
+                f"The task '{self.description}' has no agent assigned, therefore it can't be executed directly and should be executed in a Crew using a specific process that support that, either consensual or hierarchical."
+            )
+
+        result = self.agent.execute_task(
+            task=self._prompt(), context=context, tools=self.tools
+        )
+
+        self.output = TaskOutput(description=self.description, result=result)
+        self.callback(self.output) if self.callback else None
+        return result
+
+    def _prompt(self) -> str:
+        """Prompt the task.
+        Returns:
+            Prompt of the task.
+        """
+        tasks_slices = [self.description]
+
+        if self.expected_output:
+            output = self.i18n.slice("expected_output").format(
+                expected_output=self.expected_output
+            )
+            tasks_slices = [self.description, output]
+        return "\n".join(tasks_slices)

crewai/tasks/task_output.py

@@ -0,0 +1,17 @@
+from typing import Optional
+
+from pydantic import BaseModel, Field, model_validator
+
+
+class TaskOutput(BaseModel):
+    """Class that represents the result of a task."""
+
+    description: str = Field(description="Description of the task")
+    summary: Optional[str] = Field(description="Summary of the task", default=None)
+    result: str = Field(description="Result of the task")
+
+    @model_validator(mode="after")
+    def set_summary(self):
+        excerpt = " ".join(self.description.split(" ")[:10])
+        self.summary = f"{excerpt}..."
+        return self

crewai/telemtry/__init__.py

@@ -0,0 +1 @@
+from .telemetry import Telemetry

crewai/tools/agent_tools.py

@@ -0,0 +1,64 @@
+from typing import List
+
+from langchain.tools import Tool
+from pydantic import BaseModel, Field
+
+from crewai.agent import Agent
+from crewai.utilities import I18N
+
+
+class AgentTools(BaseModel):
+    """Default tools around agent delegation"""
+
+    agents: List[Agent] = Field(description="List of agents in this crew.")
+    i18n: I18N = Field(default=I18N(), description="Internationalization settings.")
+
+    def tools(self):
+        return [
+            Tool.from_function(
+                func=self.delegate_work,
+                name="Delegate work to co-worker",
+                description=self.i18n.tools("delegate_work").format(
+                    coworkers=", ".join([agent.role for agent in self.agents])
+                ),
+            ),
+            Tool.from_function(
+                func=self.ask_question,
+                name="Ask question to co-worker",
+                description=self.i18n.tools("ask_question").format(
+                    coworkers=", ".join([agent.role for agent in self.agents])
+                ),
+            ),
+        ]
+
+    def delegate_work(self, command):
+        """Useful to delegate a specific task to a coworker."""
+        return self._execute(command)
+
+    def ask_question(self, command):
+        """Useful to ask a question, opinion or take from a coworker."""
+        return self._execute(command)
+
+    def _execute(self, command):
+        """Execute the command."""
+        try:
+            agent, task, context = command.split("|")
+        except ValueError:
+            return self.i18n.errors("agent_tool_missing_param")
+
+        if not agent or not task or not context:
+            return self.i18n.errors("agent_tool_missing_param")
+
+        agent = [
+            available_agent
+            for available_agent in self.agents
+            if available_agent.role == agent
+        ]
+
+        if not agent:
+            return self.i18n.errors("agent_tool_unexsiting_coworker").format(
+                coworkers=", ".join([agent.role for agent in self.agents])
+            )
+
+        agent = agent[0]
+        return agent.execute_task(task, context)

crewai/tools/cache_tools.py

@@ -0,0 +1,28 @@
+from langchain.tools import Tool
+from pydantic import BaseModel, ConfigDict, Field
+
+from crewai.agents.cache import CacheHandler
+
+
+class CacheTools(BaseModel):
+    """Default tools to hit the cache."""
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+    name: str = "Hit Cache"
+    cache_handler: CacheHandler = Field(
+        description="Cache Handler for the crew",
+        default=CacheHandler(),
+    )
+
+    def tool(self):
+        return Tool.from_function(
+            func=self.hit_cache,
+            name=self.name,
+            description="Reads directly from the cache",
+        )
+
+    def hit_cache(self, key):
+        split = key.split("tool:")
+        tool = split[1].split("|input:")[0].strip()
+        tool_input = split[1].split("|input:")[1].strip()
+        return self.cache_handler.read(tool, tool_input)

crewai/tools/gemini_tools.py

@@ -0,0 +1,66 @@
+# tools created using gemini
+
+import json
+import os
+
+import google.generativeai as genai
+from google.api_core import exceptions
+
+# Retrieve API Key from Environment Variable
+GOOGLE_AI_STUDIO = os.environ.get('GOOGLE_API_KEY')
+
+# Ensure the API key is available
+if not GOOGLE_AI_STUDIO:
+    raise ValueError("API key not found. Please set the GOOGLE_AI_STUDIO2 environment variable.")
+
+import requests
+from langchain.tools import tool
+
+# Rest of your code remains the same
+genai.configure(api_key=GOOGLE_AI_STUDIO)
+model = genai.GenerativeModel('gemini-pro')
+
+class GeminiSearchTools():
+  @tool("Gemini search the internet")
+  def gemini_search(query):
+    """
+    Searches for content based on the provided query using the Gemini model.
+    Handles DeadlineExceeded exceptions from the Google API.
+
+    Args:
+        query (str): The search query.
+
+    Returns:
+        str: The response text from the Gemini model or an error message.
+    """
+    try:
+        response = model.generate_content(query)
+        return response.text
+    except exceptions.DeadlineExceeded as e:
+        # Handle the DeadlineExceeded exception here
+        print("Error: Deadline Exceeded -", str(e))
+        # You can return a custom message or take other appropriate actions
+        return "Error: The request timed out. Please try again later."
+
+        
+
+  @tool("Gemini search news on the internet")
+  def gemini_search_news(query):
+    """
+    Searches for content based on the provided query using the Gemini model.
+    Handles DeadlineExceeded exceptions from the Google API.
+
+    Args:
+        query (str): The search query.
+
+    Returns:
+        str: The response text from the Gemini model or an error message.
+    """
+    try:
+        response = model.generate_content(query)
+        return response.text
+    except exceptions.DeadlineExceeded as e:
+        # Handle the DeadlineExceeded exception here
+        print("Error: Deadline Exceeded -", str(e))
+        # You can return a custom message or take other appropriate actions
+        return "Error: The request timed out. Please try again later."

crewai/tools/mixtral_tools.py

@@ -0,0 +1,82 @@
+# tools created using Mixtral
+
+import json
+import os
+
+from huggingface_hub import InferenceClient
+import gradio as gr
+
+client = InferenceClient(
+    "mistralai/Mixtral-8x7B-Instruct-v0.1"
+)
+
+# Helper Method
+
+def format_prompt(message, history):
+  prompt = "<s>"
+  for user_prompt, bot_response in history:
+    prompt += f"[INST] {user_prompt} [/INST]"
+    prompt += f" {bot_response}</s> "
+  prompt += f"[INST] {message} [/INST]"
+  return prompt
+
+
+import requests
+from langchain.tools import tool
+
+history = ""
+
+class MixtralSearchTools():
+  @tool("Mixtral Normal")
+  def mixtral_normal(prompt, histroy="", temperature=0.9, max_new_tokens=256, top_p=0.95, repetition_penalty=1.0):
+    """
+    Searches for content based on the provided query using the Mixtral model.
+    Args:
+        query (str): The search query.
+    Returns:
+        str: The response text from the Mixtral model or an error message.
+    """
+    generate_kwargs = {
+        "temperature": temperature,
+        "max_new_tokens": max_new_tokens,
+        "top_p": top_p,
+        "repetition_penalty": repetition_penalty,
+        "do_sample": True,
+        "seed": 42,
+    }
+
+    formatted_prompt = format_prompt(prompt, history)
+
+    stream = client.text_generation(formatted_prompt, **generate_kwargs, stream=True, details=True, return_full_text=True)
+    output = ""
+    for response in stream:
+        output += response.token.text
+        yield output
+    return output
+
+
+  @tool("Mixtral Crazy")
+  def mixtral_crazy(prompt, temperature=0.9, max_new_tokens=256, top_p=0.95, repetition_penalty=1.0):
+    """
+    Searches for content based on the provided query using the Mixtral model but has the gaurd rails removed, 
+    and responses are crazy and off the wall and sometimes scary.
+    Args:
+        query (str): The search query.
+    Returns:
+        str: The response text from the Mixtral model or an error message.
+    """
+    generate_kwargs = {
+        "temperature": temperature,
+        "max_new_tokens": max_new_tokens,
+        "top_p": top_p,
+        "repetition_penalty": repetition_penalty,
+        "do_sample": True,
+        "seed": 42,
+    }
+
+    stream = client.text_generation(prompt, **generate_kwargs, stream=True, details=True, return_full_text=True)
+    output = ""
+    for response in stream:
+        output += response.token.text
+        yield output
+    return output

crewai/tools/phi2_tools.py

@@ -0,0 +1,52 @@
+# tools created using Phi2
+
+import json
+import os
+
+import requests
+from langchain.tools import tool
+
+import spaces
+import torch
+from transformers import AutoTokenizer, AutoModelForCausalLM, TextIteratorStreamer
+from threading import Thread
+device = "cpu"
+if torch.cuda.is_available():
+    device = "cuda"
+if torch.backends.mps.is_available():
+    device = "mps"
+
+
+tokenizer = AutoTokenizer.from_pretrained("microsoft/phi-2", trust_remote_code=True)
+model = AutoModelForCausalLM.from_pretrained(
+    "microsoft/phi-2",
+    torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
+    trust_remote_code=True,
+).to(device)
+
+
+#@spaces.GPU(enable_queue=True)
+class Phi2SearchTools():
+  @tool("Phi2 Normal")
+  def phi2_search(text, temperature=.75, maxLen=2048):
+    """
+    Searches for content based on the provided query using the Gemini model.
+    Handles DeadlineExceeded exceptions from the Google API.
+    Args:
+        query (str): The search query.
+    Returns:
+        str: The response text from the Gemini model or an error message.
+    """
+    inputs = tokenizer([text], return_tensors="pt").to(device)
+    streamer = TextIteratorStreamer(tokenizer)
+    generation_kwargs = dict(inputs, streamer=streamer, max_new_tokens=maxLen, temperature=temperature)
+    thread = Thread(target=model.generate, kwargs=generation_kwargs)
+    thread.start()
+    t = ""
+    toks = 0
+    for out in streamer:
+        t += out
+        yield t
+
+
+ 

crewai/tools/zephyr_tools.py

@@ -0,0 +1,86 @@
+# tools created using Zephyr
+
+import json
+import os
+
+from huggingface_hub import InferenceClient
+import gradio as gr
+
+client = InferenceClient(
+    "HuggingFaceH4/zephyr-7b-beta"
+)
+
+# Helper Method
+
+def format_prompt(message, history):
+  prompt = "<s>"
+  for user_prompt, bot_response in history:
+    prompt += f"[INST] {user_prompt} [/INST]"
+    prompt += f" {bot_response}</s> "
+  prompt += f"[INST] {message} [/INST]"
+  return prompt
+
+
+import requests
+from langchain.tools import tool
+
+history = ""
+
+class ZephyrSearchTools():
+  @tool("Zephyr Normal")
+  def zephyr_normal(prompt, histroy="", temperature=0.9, max_new_tokens=256, top_p=0.95, repetition_penalty=1.0):
+    """
+    Searches for content based on the provided query using the Zephyr model.
+    Args:
+        query (str): The search query.
+    Returns:
+        str: The response text from the Zephyr model or an error message.
+    """
+    generate_kwargs = {
+        "temperature": temperature,
+        "max_new_tokens": max_new_tokens,
+        "top_p": top_p,
+        "repetition_penalty": repetition_penalty,
+        "do_sample": True,
+        "seed": 42,
+    }
+
+    formatted_prompt = format_prompt(prompt, history)
+
+    stream = client.text_generation(formatted_prompt, **generate_kwargs, stream=True, details=True, return_full_text=True)
+    output = ""
+    for response in stream:
+        output += response.token.text
+        yield output
+    return output
+
+
+  @tool("Zephyrl Crazy")
+  def zephyr_crazy(prompt, temperature=0.9, max_new_tokens=256, top_p=0.95, repetition_penalty=1.0):
+    """
+    Searches for content based on the provided query using the Zephyr model but has the gaurd rails removed, 
+    and responses are crazy and off the wall and sometimes scary.
+    Args:
+        query (str): The search query.
+    Returns:
+        str: The response text from the Zephyr model or an error message.
+    """
+    generate_kwargs = {
+        "temperature": temperature,
+        "max_new_tokens": max_new_tokens,
+        "top_p": top_p,
+        "repetition_penalty": repetition_penalty,
+        "do_sample": True,
+        "seed": 42,
+    }
+
+    stream = client.text_generation(prompt, **generate_kwargs, stream=True, details=True, return_full_text=True)
+    output = ""
+    for response in stream:
+        output += response.token.text
+        yield output
+    return output
+
+
+
+

crewai/translations/el.json

@@ -0,0 +1,26 @@
+{
+  "hierarchical_manager_agent": {
+    "role": "Διευθυντής Ομάδας",
+    "goal": "Διαχειρίσου την ομάδα σου για να ολοκληρώσει την εργασία με τον καλύτερο δυνατό τρόπο.",
+    "backstory": "Είσαι ένας έμπειρος διευθυντής με την ικανότητα να βγάζεις το καλύτερο από την ομάδα σου.\nΕίσαι επίσης γνωστός για την ικανότητά σου να αναθέτεις εργασίες στους σωστούς ανθρώπους και να κάνεις τις σωστές ερωτήσεις για να πάρεις το καλύτερο από την ομάδα σου.\nΑκόμα κι αν δεν εκτελείς εργασίες μόνος σου, έχεις πολλή εμπειρία στον τομέα, που σου επιτρέπει να αξιολογείς σωστά τη δουλειά των μελών της ομάδας σου."
+  },
+  "slices": {
+    "observation": "\nΠαρατήρηση",
+    "task": "Αρχή! Αυτό είναι ΠΟΛΥ σημαντικό για εσάς, η δουλειά σας εξαρτάται από αυτό!\n\nΤρέχουσα εργασία: {input}",
+    "memory": "Αυτή είναι η περίληψη της μέχρι τώρα δουλειάς σας:\n{chat_history}",
+    "role_playing": "Είσαι {role}.\n{backstory}\n\nΟ προσωπικός σας στόχος είναι: {goal}",
+    "tools": "ΕΡΓΑΛΕΙΑ:\n------\nΈχετε πρόσβαση μόνο στα ακόλουθα εργαλεία:\n\n{tools}\n\nΓια να χρησιμοποιήσετε ένα εργαλείο, χρησιμοποιήστε την ακόλουθη ακριβώς μορφή:\n\n```\nΣκέψη: Χρειάζεται να χρησιμοποιήσω κάποιο εργαλείο; Ναί\nΔράση: η ενέργεια που πρέπει να γίνει, πρέπει να είναι μία από τις[{tool_names}], μόνο το όνομα.\nΕνέργεια προς εισαγωγή: η είσοδος στη δράση\nΠαρατήρηση: το αποτέλεσμα της δράσης\n```\n\nΌταν έχετε μια απάντηση για την εργασία σας ή εάν δεν χρειάζεται να χρησιμοποιήσετε ένα εργαλείο, ΠΡΕΠΕΙ να χρησιμοποιήσετε τη μορφή:\n\n```\nΣκέψη: Χρειάζεται να χρησιμοποιήσω κάποιο εργαλείο; Οχι\nΤελική απάντηση: [η απάντησή σας εδώ]```",
+    "task_with_context": "{task}\nΑυτό είναι το πλαίσιο με το οποίο εργάζεστε:\n{context}",
+    "expected_output": "Η τελική σας απάντηση πρέπει να είναι: {expected_output}"
+  },
+  "errors": {
+    "force_final_answer": "Στην πραγματικότητα, χρησιμοποίησα πάρα πολλά εργαλεία, οπότε θα σταματήσω τώρα και θα σας δώσω την απόλυτη ΚΑΛΥΤΕΡΗ τελική μου απάντηση ΤΩΡΑ, χρησιμοποιώντας την αναμενόμενη μορφή: ```\nΣκέφτηκα: Χρειάζεται να χρησιμοποιήσω ένα εργαλείο; Όχι\nΤελική απάντηση: [η απάντησή σας εδώ]```",
+    "agent_tool_missing_param": "\nΣφάλμα κατά την εκτέλεση του εργαλείου. Λείπουν ακριβώς 3 διαχωρισμένες τιμές σωλήνων (|). Για παράδειγμα, `coworker|task|context`. Πρέπει να φροντίσω να περάσω το πλαίσιο ως πλαίσιο.\n",
+    "agent_tool_unexsiting_coworker": "\nΣφάλμα κατά την εκτέλεση του εργαλείου. Ο συνάδελφος που αναφέρεται στο Ενέργεια προς εισαγωγή δεν βρέθηκε, πρέπει να είναι μία από τις ακόλουθες επιλογές: {coworkers}.\n",
+    "task_repeated_usage": "Μόλις χρησιμοποίησα το {tool} εργαλείο με είσοδο {tool_input}. Άρα ξέρω ήδη το αποτέλεσμα αυτού και δεν χρειάζεται να το χρησιμοποιήσω τώρα.\n"
+  },
+  "tools": {
+    "delegate_work": "Χρήσιμο για την ανάθεση μιας συγκεκριμένης εργασίας σε έναν από τους παρακάτω συναδέλφους: {coworkers}.\nΗ είσοδος σε αυτό το εργαλείο θα πρέπει να είναι ένα κείμενο χωρισμένο σε σωλήνα (|) μήκους 3 (τρία), που αντιπροσωπεύει τον συνάδελφο στον οποίο θέλετε να του ζητήσετε (μία από τις επιλογές), την εργασία και όλο το πραγματικό πλαί��ιο που έχετε για την εργασία .\nΓια παράδειγμα, `coworker|task|context`.",
+    "ask_question": "Χρήσιμο για να κάνετε μια ερώτηση, γνώμη ή αποδοχή από τους παρακάτω συναδέλφους: {coworkers}.\nΗ είσοδος σε αυτό το εργαλείο θα πρέπει να είναι ένα κείμενο χωρισμένο σε σωλήνα (|) μήκους 3 (τρία), που αντιπροσωπεύει τον συνάδελφο στον οποίο θέλετε να το ρωτήσετε (μία από τις επιλογές), την ερώτηση και όλο το πραγματικό πλαίσιο που έχετε για την ερώτηση.\nΓια παράδειγμα, `coworker|question|context`."
+  }
+}

crewai/translations/en.json

@@ -0,0 +1,26 @@
+{
+  "hierarchical_manager_agent": {
+    "role": "Crew Manager",
+    "goal": "Manage the team to complete the task in the best way possible.",
+    "backstory": "You are a seasoned manager with a knack for getting the best out of your team.\nYou are also known for your ability to delegate work to the right people, and to ask the right questions to get the best out of your team.\nEven though you don't perform tasks by yourself, you have a lot of experience in the field, which allows you to properly evaluate the work of your team members."
+  },
+  "slices": {
+    "observation": "\nObservation",
+    "task": "Begin! This is VERY important to you, your job depends on it!\n\nCurrent Task: {input}",
+    "memory": "This is the summary of your work so far:\n{chat_history}",
+    "role_playing": "You are {role}.\n{backstory}\n\nYour personal goal is: {goal}",
+    "tools": "TOOLS:\n------\nYou have access to only the following tools:\n\n{tools}\n\nTo use a tool, please use the exact following format:\n\n```\nThought: Do I need to use a tool? Yes\nAction: the action to take, should be one of [{tool_names}], just the name.\nAction Input: the input to the action\nObservation: the result of the action\n```\n\nWhen you have a response for your task, or if you do not need to use a tool, you MUST use the format:\n\n```\nThought: Do I need to use a tool? No\nFinal Answer: [your response here]```",
+    "task_with_context": "{task}\nThis is the context you're working with:\n{context}",
+    "expected_output": "Your final answer must be: {expected_output}"
+  },
+  "errors": {
+    "force_final_answer": "Actually, I used too many tools, so I'll stop now and give you my absolute BEST Final answer NOW, using the expected format: ```\nThought: Do I need to use a tool? No\nFinal Answer: [your response here]```",
+    "agent_tool_missing_param": "\nError executing tool. Missing exact 3 pipe (|) separated values. For example, `coworker|task|context`. I need to make sure to pass context as context.\n",
+    "agent_tool_unexsiting_coworker": "\nError executing tool. Co-worker mentioned on the Action Input not found, it must to be one of the following options: {coworkers}.\n",
+    "task_repeated_usage": "I just used the {tool} tool with input {tool_input}. So I already know the result of that and don't need to use it now.\n"
+  },
+  "tools": {
+    "delegate_work": "Useful to delegate a specific task to one of the following co-workers: {coworkers}.\nThe input to this tool should be a pipe (|) separated text of length 3 (three), representing the co-worker you want to ask it to (one of the options), the task and all actual context you have for the task.\nFor example, `coworker|task|context`.",
+    "ask_question": "Useful to ask a question, opinion or take from on of the following co-workers: {coworkers}.\nThe input to this tool should be a pipe (|) separated text of length 3 (three), representing the co-worker you want to ask it to (one of the options), the question and all actual context you have for the question.\n For example, `coworker|question|context`."
+  }
+}

crewai/utilities/__init__.py

@@ -0,0 +1,4 @@
+from .i18n import I18N
+from .logger import Logger
+from .prompts import Prompts
+from .rpm_controller import RPMController

crewai/utilities/i18n.py

@@ -0,0 +1,51 @@
+import json
+import os
+from typing import Dict, Optional
+
+from pydantic import BaseModel, Field, PrivateAttr, ValidationError, model_validator
+
+
+class I18N(BaseModel):
+    _translations: Dict[str, Dict[str, str]] = PrivateAttr()
+    language: Optional[str] = Field(
+        default="en",
+        description="Language used to load translations",
+    )
+
+    @model_validator(mode="after")
+    def load_translation(self) -> "I18N":
+        """Load translations from a JSON file based on the specified language."""
+        try:
+            dir_path = os.path.dirname(os.path.realpath(__file__))
+            prompts_path = os.path.join(
+                dir_path, f"../translations/{self.language}.json"
+            )
+
+            with open(prompts_path, "r") as f:
+                self._translations = json.load(f)
+        except FileNotFoundError:
+            raise ValidationError(
+                f"Translation file for language '{self.language}' not found."
+            )
+        except json.JSONDecodeError:
+            raise ValidationError(f"Error decoding JSON from the prompts file.")
+
+        if not self._translations:
+            self._translations = {}
+
+        return self
+
+    def slice(self, slice: str) -> str:
+        return self.retrieve("slices", slice)
+
+    def errors(self, error: str) -> str:
+        return self.retrieve("errors", error)
+
+    def tools(self, error: str) -> str:
+        return self.retrieve("tools", error)
+
+    def retrieve(self, kind, key) -> str:
+        try:
+            return self._translations[kind][key]
+        except:
+            raise ValidationError(f"Translation for '{kind}':'{key}'  not found.")

crewai/utilities/logger.py

@@ -0,0 +1,11 @@
+class Logger:
+    def __init__(self, verbose_level=0):
+        verbose_level = (
+            2 if isinstance(verbose_level, bool) and verbose_level else verbose_level
+        )
+        self.verbose_level = verbose_level
+
+    def log(self, level, message):
+        level_map = {"debug": 1, "info": 2}
+        if self.verbose_level and level_map.get(level, 0) <= self.verbose_level:
+            print(f"[{level.upper()}]: {message}")

crewai/utilities/prompts.py

@@ -0,0 +1,32 @@
+from typing import ClassVar
+
+from langchain.prompts import PromptTemplate, BasePromptTemplate
+from pydantic import BaseModel, Field
+
+from crewai.utilities import I18N
+
+
+class Prompts(BaseModel):
+    """Manages and generates prompts for a generic agent with support for different languages."""
+
+    i18n: I18N = Field(default=I18N())
+
+    SCRATCHPAD_SLICE: ClassVar[str] = "\n{agent_scratchpad}"
+
+    def task_execution_with_memory(self) -> BasePromptTemplate:
+        """Generate a prompt for task execution with memory components."""
+        return self._build_prompt(["role_playing", "tools", "memory", "task"])
+
+    def task_execution_without_tools(self) -> BasePromptTemplate:
+        """Generate a prompt for task execution without tools components."""
+        return self._build_prompt(["role_playing", "task"])
+
+    def task_execution(self) -> BasePromptTemplate:
+        """Generate a standard prompt for task execution."""
+        return self._build_prompt(["role_playing", "tools", "task"])
+
+    def _build_prompt(self, components: list[str]) -> BasePromptTemplate:
+        """Constructs a prompt string from specified components."""
+        prompt_parts = [self.i18n.slice(component) for component in components]
+        prompt_parts.append(self.SCRATCHPAD_SLICE)
+        return PromptTemplate.from_template("".join(prompt_parts))

crewai/utilities/rpm_controller.py

@@ -0,0 +1,59 @@
+import threading
+import time
+from typing import Union
+
+from pydantic import BaseModel, ConfigDict, Field, PrivateAttr, model_validator
+
+from crewai.utilities.logger import Logger
+
+
+class RPMController(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+    max_rpm: Union[int, None] = Field(default=None)
+    logger: Logger = Field(default=None)
+    _current_rpm: int = PrivateAttr(default=0)
+    _timer: threading.Timer | None = PrivateAttr(default=None)
+    _lock: threading.Lock = PrivateAttr(default=None)
+    _shutdown_flag = False
+
+    @model_validator(mode="after")
+    def reset_counter(self):
+        if self.max_rpm:
+            if not self._shutdown_flag:
+                self._lock = threading.Lock()
+                self._reset_request_count()
+        return self
+
+    def check_or_wait(self):
+        if not self.max_rpm:
+            return True
+
+        with self._lock:
+            if self._current_rpm < self.max_rpm:
+                self._current_rpm += 1
+                return True
+            else:
+                self.logger.log(
+                    "info", "Max RPM reached, waiting for next minute to start."
+                )
+                self._wait_for_next_minute()
+                self._current_rpm = 1
+                return True
+
+    def stop_rpm_counter(self):
+        if self._timer:
+            self._timer.cancel()
+            self._timer = None
+
+    def _wait_for_next_minute(self):
+        time.sleep(60)
+        self._current_rpm = 0
+
+    def _reset_request_count(self):
+        with self._lock:
+            self._current_rpm = 0
+        if self._timer:
+            self._shutdown_flag = True
+            self._timer.cancel()
+        self._timer = threading.Timer(60.0, self._reset_request_count)
+        self._timer.start()