Removing LangChain and Rebuilding Executor (#1322)

* rebuilding executor

* removing langchain

* Making all tests good

* fixing types and adding ability for nor using system prompts

* improving types

* pleasing the types gods

* pleasing the types gods

* fixing parser, tools and executor

* making sure all tests pass

* final pass

* fixing type

* Updating Docs

* preparing to cut new version

src/crewai/utilities/__init__.py

@@ -1,7 +1,7 @@
 from .converter import Converter, ConverterError
 from .file_handler import FileHandler
 from .i18n import I18N
-from .instructor import Instructor
+from .internal_instructor import InternalInstructor
 from .logger import Logger
 from .parser import YamlParser
 from .printer import Printer
@@ -16,7 +16,7 @@ __all__ = [
     "ConverterError",
     "FileHandler",
     "I18N",
-    "Instructor",
+    "InternalInstructor",
     "Logger",
     "Printer",
     "Prompts",

src/crewai/utilities/converter.py

@@ -2,8 +2,7 @@ import json
 import re
 from typing import Any, Optional, Type, Union
 
-from langchain.schema import HumanMessage, SystemMessage
-from langchain_openai import ChatOpenAI
+from crewai.llm import LLM
 from pydantic import BaseModel, ValidationError
 
 from crewai.agents.agent_builder.utilities.base_output_converter import OutputConverter
@@ -28,7 +27,12 @@ class Converter(OutputConverter):
             if self.is_gpt:
                 return self._create_instructor().to_pydantic()
             else:
-                return self._create_chain().invoke({})
+                return LLM(model=self.llm).call(
+                    [
+                        {"role": "system", "content": self.instructions},
+                        {"role": "user", "content": self.text},
+                    ]
+                )
         except Exception as e:
             if current_attempt < self.max_attempts:
                 return self.to_pydantic(current_attempt + 1)
@@ -42,7 +46,14 @@ class Converter(OutputConverter):
             if self.is_gpt:
                 return self._create_instructor().to_json()
             else:
-                return json.dumps(self._create_chain().invoke({}).model_dump())
+                return json.dumps(
+                    LLM(model=self.llm).call(
+                        [
+                            {"role": "system", "content": self.instructions},
+                            {"role": "user", "content": self.text},
+                        ]
+                    )
+                )
         except Exception as e:
             if current_attempt < self.max_attempts:
                 return self.to_json(current_attempt + 1)
@@ -50,33 +61,39 @@ class Converter(OutputConverter):
 
     def _create_instructor(self):
         """Create an instructor."""
-        from crewai.utilities import Instructor
+        from crewai.utilities import InternalInstructor
 
-        inst = Instructor(
+        inst = InternalInstructor(
             llm=self.llm,
-            max_attempts=self.max_attempts,
             model=self.model,
             content=self.text,
             instructions=self.instructions,
         )
         return inst
 
-    def _create_chain(self):
+    def _convert_with_instructions(self):
         """Create a chain."""
         from crewai.utilities.crew_pydantic_output_parser import (
             CrewPydanticOutputParser,
         )
 
         parser = CrewPydanticOutputParser(pydantic_object=self.model)
-        new_prompt = SystemMessage(content=self.instructions) + HumanMessage(
-            content=self.text
+        result = LLM(model=self.llm).call(
+            [
+                {"role": "system", "content": self.instructions},
+                {"role": "user", "content": self.text},
+            ]
         )
-        return new_prompt | self.llm | parser
+        return parser.parse_result(result)
 
     @property
     def is_gpt(self) -> bool:
         """Return if llm provided is of gpt from openai."""
-        return isinstance(self.llm, ChatOpenAI) and self.llm.openai_api_base is None
+        return (
+            "gpt" in str(self.llm).lower()
+            or "o1-preview" in str(self.llm).lower()
+            or "o1-mini" in str(self.llm).lower()
+        )
 
 
 def convert_to_model(
@@ -89,23 +106,14 @@ def convert_to_model(
     model = output_pydantic or output_json
     if model is None:
         return result
-
     try:
         escaped_result = json.dumps(json.loads(result, strict=False))
         return validate_model(escaped_result, model, bool(output_json))
-    except json.JSONDecodeError as e:
-        Printer().print(
-            content=f"Error parsing JSON: {e}. Attempting to handle partial JSON.",
-            color="yellow",
-        )
+    except json.JSONDecodeError:
         return handle_partial_json(
             result, model, bool(output_json), agent, converter_cls
         )
-    except ValidationError as e:
-        Printer().print(
-            content=f"Pydantic validation error: {e}. Attempting to handle partial JSON.",
-            color="yellow",
-        )
+    except ValidationError:
         return handle_partial_json(
             result, model, bool(output_json), agent, converter_cls
         )
@@ -140,16 +148,10 @@ def handle_partial_json(
             if is_json_output:
                 return exported_result.model_dump()
             return exported_result
-        except json.JSONDecodeError as e:
-            Printer().print(
-                content=f"Error parsing JSON: {e}. The extracted JSON-like string is not valid JSON. Attempting alternative conversion method.",
-                color="yellow",
-            )
-        except ValidationError as e:
-            Printer().print(
-                content=f"Pydantic validation error: {e}. The JSON structure doesn't match the expected model. Attempting alternative conversion method.",
-                color="yellow",
-            )
+        except json.JSONDecodeError:
+            pass
+        except ValidationError:
+            pass
         except Exception as e:
             Printer().print(
                 content=f"Unexpected error during partial JSON handling: {type(e).__name__}: {e}. Attempting alternative conversion method.",
@@ -170,7 +172,6 @@ def convert_with_instructions(
 ) -> Union[dict, BaseModel, str]:
     llm = agent.function_calling_llm or agent.llm
     instructions = get_conversion_instructions(model, llm)
-
     converter = create_converter(
         agent=agent,
         converter_cls=converter_cls,
@@ -179,6 +180,7 @@ def convert_with_instructions(
         model=model,
         instructions=instructions,
     )
+
     exported_result = (
         converter.to_pydantic() if not is_json_output else converter.to_json()
     )
@@ -202,9 +204,12 @@ def get_conversion_instructions(model: Type[BaseModel], llm: Any) -> str:
 
 
 def is_gpt(llm: Any) -> bool:
-    from langchain_openai import ChatOpenAI
-
-    return isinstance(llm, ChatOpenAI) and llm.openai_api_base is None
+    """Return if llm provided is of gpt from openai."""
+    return (
+        "gpt" in str(llm).lower()
+        or "o1-preview" in str(llm).lower()
+        or "o1-mini" in str(llm).lower()
+    )
 
 
 def create_converter(

src/crewai/utilities/crew_pydantic_output_parser.py

@@ -1,33 +1,31 @@
 import json
-from typing import Any, List, Type
-
 import regex
-from langchain.output_parsers import PydanticOutputParser
-from langchain_core.exceptions import OutputParserException
-from langchain_core.outputs import Generation
+from typing import Any, Type
+
+from crewai.agents.parser import OutputParserException
 from pydantic import BaseModel, ValidationError
 
 
-class CrewPydanticOutputParser(PydanticOutputParser):
+class CrewPydanticOutputParser:
     """Parses the text into pydantic models"""
 
     pydantic_object: Type[BaseModel]
 
-    def parse_result(self, result: List[Generation]) -> Any:
-        result[0].text = self._transform_in_valid_json(result[0].text)
+    def parse_result(self, result: str) -> Any:
+        result = self._transform_in_valid_json(result)
 
         # Treating edge case of function calling llm returning the name instead of tool_name
-        json_object = json.loads(result[0].text)
+        json_object = json.loads(result)
         if "tool_name" not in json_object:
             json_object["tool_name"] = json_object.get("name", "")
-        result[0].text = json.dumps(json_object)
+        result = json.dumps(json_object)
 
         try:
             return self.pydantic_object.model_validate(json_object)
         except ValidationError as e:
             name = self.pydantic_object.__name__
             msg = f"Failed to parse {name} from completion {json_object}. Got: {e}"
-            raise OutputParserException(msg, llm_output=json_object)
+            raise OutputParserException(error=msg)
 
     def _transform_in_valid_json(self, text) -> str:
         text = text.replace("```", "").replace("json", "")

src/crewai/utilities/evaluators/crew_evaluator_handler.py

@@ -4,7 +4,6 @@ from crewai.agent import Agent
 from crewai.task import Task
 from crewai.tasks.task_output import TaskOutput
 from crewai.telemetry import Telemetry
-from langchain_openai import ChatOpenAI
 from pydantic import BaseModel, Field
 from rich.box import HEAVY_EDGE
 from rich.console import Console
@@ -51,7 +50,7 @@ class CrewEvaluator:
             ),
             backstory="Evaluator agent for crew evaluation with precise capabilities to evaluate the performance of the agents in the crew based on the tasks they have performed",
             verbose=False,
-            llm=ChatOpenAI(model=self.openai_model_name),
+            llm=self.openai_model_name,
         )
 
     def _evaluation_task(

src/crewai/utilities/evaluators/task_evaluator.py

@@ -1,7 +1,6 @@
 import os
 from typing import List
 
-from langchain_openai import ChatOpenAI
 from pydantic import BaseModel, Field
 
 from crewai.utilities import Converter
@@ -93,7 +92,11 @@ class TaskEvaluator:
         return converter.to_pydantic()
 
     def _is_gpt(self, llm) -> bool:
-        return isinstance(llm, ChatOpenAI) and llm.openai_api_base is None
+        return (
+            "gpt" in str(self.llm).lower()
+            or "o1-preview" in str(self.llm).lower()
+            or "o1-mini" in str(self.llm).lower()
+        )
 
     def evaluate_training_data(
         self, training_data: dict, agent_id: str

src/crewai/utilities/instructor.py

@@ -1,50 +0,0 @@
-from typing import Any, Optional, Type
-
-import instructor
-from pydantic import BaseModel, Field, PrivateAttr, model_validator
-
-
-class Instructor(BaseModel):
-    """Class that wraps an agent llm with instructor."""
-
-    _client: Any = PrivateAttr()
-    content: str = Field(description="Content to be sent to the instructor.")
-    agent: Optional[Any] = Field(
-        description="The agent that needs to use instructor.", default=None
-    )
-    llm: Optional[Any] = Field(
-        description="The agent that needs to use instructor.", default=None
-    )
-    instructions: Optional[str] = Field(
-        description="Instructions to be sent to the instructor.",
-        default=None,
-    )
-    model: Type[BaseModel] = Field(
-        description="Pydantic model to be used to create an output."
-    )
-
-    @model_validator(mode="after")
-    def set_instructor(self):
-        """Set instructor."""
-        if self.agent and not self.llm:
-            self.llm = self.agent.function_calling_llm or self.agent.llm
-
-        self._client = instructor.patch(
-            self.llm.client._client,
-            mode=instructor.Mode.TOOLS,
-        )
-        return self
-
-    def to_json(self):
-        model = self.to_pydantic()
-        return model.model_dump_json(indent=2)
-
-    def to_pydantic(self):
-        messages = [{"role": "user", "content": self.content}]
-        if self.instructions:
-            messages.append({"role": "system", "content": self.instructions})
-
-        model = self._client.chat.completions.create(
-            model=self.llm.model_name, response_model=self.model, messages=messages
-        )
-        return model

src/crewai/utilities/internal_instructor.py

@@ -0,0 +1,47 @@
+from typing import Any, Optional, Type
+
+import instructor
+from litellm import completion
+
+
+class InternalInstructor:
+    """Class that wraps an agent llm with instructor."""
+
+    def __init__(
+        self,
+        content: str,
+        model: Type,
+        agent: Optional[Any] = None,
+        llm: Optional[str] = None,
+        instructions: Optional[str] = None,
+    ):
+        self.content = content
+        self.agent = agent
+        self.llm = llm
+        self.instructions = instructions
+        self.model = model
+        self._client = None
+        self.set_instructor()
+
+    def set_instructor(self):
+        """Set instructor."""
+        if self.agent and not self.llm:
+            self.llm = self.agent.function_calling_llm or self.agent.llm
+
+        self._client = instructor.from_litellm(
+            completion,
+            mode=instructor.Mode.TOOLS,
+        )
+
+    def to_json(self):
+        model = self.to_pydantic()
+        return model.model_dump_json(indent=2)
+
+    def to_pydantic(self):
+        messages = [{"role": "user", "content": self.content}]
+        if self.instructions:
+            messages.append({"role": "system", "content": self.instructions})
+        model = self._client.chat.completions.create(
+            model=self.llm, response_model=self.model, messages=messages
+        )
+        return model

src/crewai/utilities/planning_handler.py

@@ -1,6 +1,4 @@
 from typing import Any, List, Optional
-
-from langchain_openai import ChatOpenAI
 from pydantic import BaseModel, Field
 
 from crewai.agent import Agent
@@ -27,7 +25,7 @@ class CrewPlanner:
         self.tasks = tasks
 
         if planning_agent_llm is None:
-            self.planning_agent_llm = ChatOpenAI(model="gpt-4o-mini")
+            self.planning_agent_llm = "gpt-4o-mini"
         else:
             self.planning_agent_llm = planning_agent_llm
 

src/crewai/utilities/printer.py

@@ -1,5 +1,8 @@
+from typing import Optional
+
+
 class Printer:
-    def print(self, content: str, color: str):
+    def print(self, content: str, color: Optional[str] = None):
         if color == "purple":
             self._print_purple(content)
         elif color == "red":

src/crewai/utilities/prompts.py

@@ -1,8 +1,5 @@
-from typing import Any, ClassVar, Optional
-
-from langchain.prompts import BasePromptTemplate, PromptTemplate
 from pydantic import BaseModel, Field
-
+from typing import Any, Optional
 from crewai.utilities import I18N
 
 
@@ -14,27 +11,38 @@ class Prompts(BaseModel):
     system_template: Optional[str] = None
     prompt_template: Optional[str] = None
     response_template: Optional[str] = None
-    SCRATCHPAD_SLICE: ClassVar[str] = "\n{agent_scratchpad}"
+    use_system_prompt: Optional[bool] = False
+    agent: Any
 
-    def task_execution(self) -> BasePromptTemplate:
+    def task_execution(self) -> dict[str, str]:
         """Generate a standard prompt for task execution."""
         slices = ["role_playing"]
         if len(self.tools) > 0:
             slices.append("tools")
         else:
             slices.append("no_tools")
-
+        system = self._build_prompt(slices)
         slices.append("task")
 
-        if not self.system_template and not self.prompt_template:
-            return self._build_prompt(slices)
+        if (
+            not self.system_template
+            and not self.prompt_template
+            and self.use_system_prompt
+        ):
+            return {
+                "system": system,
+                "user": self._build_prompt(["task"]),
+                "prompt": self._build_prompt(slices),
+            }
         else:
-            return self._build_prompt(
-                slices,
-                self.system_template,
-                self.prompt_template,
-                self.response_template,
-            )
+            return {
+                "prompt": self._build_prompt(
+                    slices,
+                    self.system_template,
+                    self.prompt_template,
+                    self.response_template,
+                )
+            }
 
     def _build_prompt(
         self,
@@ -42,12 +50,11 @@ class Prompts(BaseModel):
         system_template=None,
         prompt_template=None,
         response_template=None,
-    ) -> BasePromptTemplate:
+    ) -> str:
         """Constructs a prompt string from specified components."""
         if not system_template and not prompt_template:
             prompt_parts = [self.i18n.slice(component) for component in components]
-            prompt_parts.append(self.SCRATCHPAD_SLICE)
-            prompt = PromptTemplate.from_template("".join(prompt_parts))
+            prompt = "".join(prompt_parts)
         else:
             prompt_parts = [
                 self.i18n.slice(component)
@@ -56,9 +63,14 @@ class Prompts(BaseModel):
             ]
             system = system_template.replace("{{ .System }}", "".join(prompt_parts))
             prompt = prompt_template.replace(
-                "{{ .Prompt }}",
-                "".join([self.i18n.slice("task"), self.SCRATCHPAD_SLICE]),
+                "{{ .Prompt }}", "".join(self.i18n.slice("task"))
             )
             response = response_template.split("{{ .Response }}")[0]
-            prompt = PromptTemplate.from_template(f"{system}\n{prompt}\n{response}")
+            prompt = f"{system}\n{prompt}\n{response}"
+
+        prompt = (
+            prompt.replace("{goal}", self.agent.goal)
+            .replace("{role}", self.agent.role)
+            .replace("{backstory}", self.agent.backstory)
+        )
         return prompt

src/crewai/utilities/rpm_controller.py

@@ -52,7 +52,7 @@ class RPMController(BaseModel):
             self._timer = None
 
     def _wait_for_next_minute(self):
-        time.sleep(60)
+        time.sleep(1)
         self._current_rpm = 0
 
     def _reset_request_count(self):

src/crewai/utilities/token_counter_callback.py

@@ -1,36 +1,17 @@
-from typing import Any, Dict, List
-
-import tiktoken
-from langchain.callbacks.base import BaseCallbackHandler
-from langchain.schema import LLMResult
-
+from litellm.integrations.custom_logger import CustomLogger
 from crewai.agents.agent_builder.utilities.base_token_process import TokenProcess
 
 
-class TokenCalcHandler(BaseCallbackHandler):
-    model_name: str = ""
-    token_cost_process: TokenProcess
-    encoding: tiktoken.Encoding
-
-    def __init__(self, model_name, token_cost_process):
-        self.model_name = model_name
+class TokenCalcHandler(CustomLogger):
+    def __init__(self, token_cost_process: TokenProcess):
         self.token_cost_process = token_cost_process
-        try:
-            self.encoding = tiktoken.encoding_for_model(self.model_name)
-        except KeyError:
-            self.encoding = tiktoken.get_encoding("cl100k_base")
 
-    def on_llm_start(
-        self, serialized: Dict[str, Any], prompts: List[str], **kwargs: Any
-    ) -> None:
+    def log_success_event(self, kwargs, response_obj, start_time, end_time):
         if self.token_cost_process is None:
             return
 
-        for prompt in prompts:
-            self.token_cost_process.sum_prompt_tokens(len(self.encoding.encode(prompt)))
-
-    async def on_llm_new_token(self, token: str, **kwargs) -> None:
-        self.token_cost_process.sum_completion_tokens(1)
-
-    def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None:
         self.token_cost_process.sum_successful_requests(1)
+        self.token_cost_process.sum_prompt_tokens(response_obj["usage"].prompt_tokens)
+        self.token_cost_process.sum_completion_tokens(
+            response_obj["usage"].completion_tokens
+        )