fix unnecessary deps

- refactor code to multiple functions
- Added ability for users to select provider and model when uing crewai create command and ave API key to .env

docs/concepts/memory.mdx

@@ -34,7 +34,7 @@ By default, the memory system is disabled, and you can ensure it is active by se
 The memory will use OpenAI embeddings by default, but you can change it by setting `embedder` to a different model. 
 It's also possible to initialize the memory instance with your own instance.
 
-The 'embedder' only applies to **Short-Term Memory** which uses Chroma for RAG.
+The 'embedder' only applies to **Short-Term Memory** which uses Chroma for RAG using the EmbedChain package.
 The **Long-Term Memory** uses SQLite3 to store task results. Currently, there is no way to override these storage implementations.
 The data storage files are saved into a platform-specific location found using the appdirs package,
 and the name of the project can be overridden using the **CREWAI_STORAGE_DIR** environment variable.
@@ -105,9 +105,12 @@ my_crew = Crew(
     process=Process.sequential,
     memory=True,
     verbose=True,
-    embedder=embedding_functions.OpenAIEmbeddingFunction(
-            api_key=os.getenv("OPENAI_API_KEY"), model_name="text-embedding-3-small"
-        )
+    embedder={
+        "provider": "openai",
+        "config": {
+            "model": 'text-embedding-3-small'
+        }
+    }
 )
 ```
 
@@ -122,10 +125,14 @@ my_crew = Crew(
     process=Process.sequential,
     memory=True,
     verbose=True,
-    embedder=embedding_functions.OpenAIEmbeddingFunction(
-            api_key=os.getenv("OPENAI_API_KEY"),
-            model_name="text-embedding-ada-002"
-    )
+    embedder={
+        "provider": "google",
+        "config": {
+            "model": 'models/embedding-001',
+            "task_type": "retrieval_document",
+            "title": "Embeddings for Embedchain"
+        }
+    }
 )
 ```
 
@@ -140,13 +147,30 @@ my_crew = Crew(
     process=Process.sequential,
     memory=True,
     verbose=True,
-    embedder=embedding_functions.OpenAIEmbeddingFunction(
-        api_key="YOUR_API_KEY",
-        api_base="YOUR_API_BASE_PATH",
-        api_type="azure",
-        api_version="YOUR_API_VERSION",
-        model_name="text-embedding-3-small"
-    )
+    embedder={
+        "provider": "azure_openai",
+        "config": {
+            "model": 'text-embedding-ada-002',
+            "deployment_name": "your_embedding_model_deployment_name"
+        }
+    }
+)
+```
+
+### Using GPT4ALL embeddings
+
+```python Code
+from crewai import Crew, Agent, Task, Process
+
+my_crew = Crew(
+    agents=[...],
+    tasks=[...],
+    process=Process.sequential,
+    memory=True,
+    verbose=True,
+    embedder={
+        "provider": "gpt4all"
+    }
 )
 ```
 
@@ -161,12 +185,12 @@ my_crew = Crew(
     process=Process.sequential,
     memory=True,
     verbose=True,
-    embedder=embedding_functions.GoogleVertexEmbeddingFunction(
-        project_id="YOUR_PROJECT_ID",
-        region="YOUR_REGION",
-        api_key="YOUR_API_KEY",
-        model_name="textembedding-gecko"
-    )
+    embedder={
+        "provider": "vertexai",
+        "config": {
+            "model": 'textembedding-gecko'
+        }
+    }
 )
 ```
 
@@ -181,10 +205,13 @@ my_crew = Crew(
     process=Process.sequential,
     memory=True,
     verbose=True,
-    embedder=embedding_functions.CohereEmbeddingFunction(
-        api_key=YOUR_API_KEY,
-        model_name="<model_name>"
-    )
+    embedder={
+        "provider": "cohere",
+        "config": {
+            "model": "embed-english-v3.0",
+            "vector_dimension": 1024
+        }
+    }
 )
 ```
 

docs/tools/visiontool.mdx

@@ -8,13 +8,13 @@ icon: eye
 
 ## Description
 
-This tool is used to extract text from images. When passed to the agent it will extract the text from the image and then use it to generate a response, report or any other output.
+This tool is used to extract text from images. When passed to the agent it will extract the text from the image and then use it to generate a response, report or any other output. 
 The URL or the PATH of the image should be passed to the Agent.
 
+
 ## Installation
 
 Install the crewai_tools package
-
 ```shell
 pip install 'crewai[tools]'
 ```
@@ -44,6 +44,7 @@ def researcher(self) -> Agent:
 
 The VisionTool requires the following arguments:
 
-| Argument           | Type     | Description                                                                      |
-| :----------------- | :------- | :------------------------------------------------------------------------------- |
-| **image_path_url** | `string` | **Mandatory**. The path to the image file from which text needs to be extracted. |
+| Argument       | Type     | Description                                                                                                                         |
+|:---------------|:---------|:-------------------------------------------------------------------------------------------------------------------------------------|
+| **image_path** | `string` | **Mandatory**. The path to the image file from which text needs to be extracted.                                                |
+

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "crewai"
-version = "0.74.0"
+version = "0.70.1"
 description = "Cutting-edge framework for orchestrating role-playing, autonomous AI agents. By fostering collaborative intelligence, CrewAI empowers agents to work together seamlessly, tackling complex tasks."
 readme = "README.md"
 requires-python = ">=3.10,<=3.13"
@@ -16,18 +16,19 @@ dependencies = [
     "opentelemetry-exporter-otlp-proto-http>=1.22.0",
     "instructor>=1.3.3",
     "regex>=2024.9.11",
-    "crewai-tools>=0.13.1",
+    "crewai-tools>=0.12.1",
     "click>=8.1.7",
     "python-dotenv>=1.0.0",
     "appdirs>=1.4.4",
     "jsonref>=1.1.0",
+    "agentops>=0.3.0",
+    "embedchain>=0.1.114",
     "json-repair>=0.25.2",
     "auth0-python>=4.7.1",
     "litellm>=1.44.22",
     "pyvis>=0.3.2",
     "uv>=0.4.18",
     "tomli-w>=1.1.0",
-    "chromadb>=0.4.24",
 ]
 
 [project.urls]

src/crewai/__init__.py

@@ -14,5 +14,5 @@ warnings.filterwarnings(
     category=UserWarning,
     module="pydantic.main",
 )
-__version__ = "0.74.0"
+__version__ = "0.70.1"
 __all__ = ["Agent", "Crew", "Process", "Task", "Pipeline", "Router", "LLM", "Flow"]

src/crewai/agents/agent_builder/base_agent_executor_mixin.py

@@ -17,7 +17,7 @@ if TYPE_CHECKING:
 
 class CrewAgentExecutorMixin:
     crew: Optional["Crew"]
-    agent: Optional["BaseAgent"]
+    crew_agent: Optional["BaseAgent"]
     task: Optional["Task"]
     iterations: int
     have_forced_answer: bool
@@ -33,9 +33,9 @@ class CrewAgentExecutorMixin:
         """Create and save a short-term memory item if conditions are met."""
         if (
             self.crew
-            and self.agent
+            and self.crew_agent
             and self.task
-            and "Action: Delegate work to coworker" not in output.text
+            and "Action: Delegate work to coworker" not in output.log
         ):
             try:
                 if (
@@ -43,11 +43,11 @@ class CrewAgentExecutorMixin:
                     and self.crew._short_term_memory
                 ):
                     self.crew._short_term_memory.save(
-                        value=output.text,
+                        value=output.log,
                         metadata={
                             "observation": self.task.description,
                         },
-                        agent=self.agent.role,
+                        agent=self.crew_agent.role,
                     )
             except Exception as e:
                 print(f"Failed to add to short term memory: {e}")
@@ -61,18 +61,18 @@ class CrewAgentExecutorMixin:
             and self.crew._long_term_memory
             and self.crew._entity_memory
             and self.task
-            and self.agent
+            and self.crew_agent
         ):
             try:
-                ltm_agent = TaskEvaluator(self.agent)
-                evaluation = ltm_agent.evaluate(self.task, output.text)
+                ltm_agent = TaskEvaluator(self.crew_agent)
+                evaluation = ltm_agent.evaluate(self.task, output.log)
 
                 if isinstance(evaluation, ConverterError):
                     return
 
                 long_term_memory = LongTermMemoryItem(
                     task=self.task.description,
-                    agent=self.agent.role,
+                    agent=self.crew_agent.role,
                     quality=evaluation.quality,
                     datetime=str(time.time()),
                     expected_output=self.task.expected_output,

src/crewai/agents/crew_agent_executor.py

@@ -19,7 +19,6 @@ from crewai.utilities.exceptions.context_window_exceeding_exception import (
 )
 from crewai.utilities.logger import Logger
 from crewai.utilities.training_handler import CrewTrainingHandler
-from crewai.agents.agent_builder.base_agent import BaseAgent
 
 
 class CrewAgentExecutor(CrewAgentExecutorMixin):
@@ -30,7 +29,7 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
         llm: Any,
         task: Any,
         crew: Any,
-        agent: BaseAgent,
+        agent: Any,
         prompt: dict[str, str],
         max_iter: int,
         tools: List[Any],
@@ -104,8 +103,7 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
 
             if self.crew and self.crew._train:
                 self._handle_crew_training_output(formatted_answer)
-        self._create_short_term_memory(formatted_answer)
-        self._create_long_term_memory(formatted_answer)
+
         return {"output": formatted_answer.output}
 
     def _invoke_loop(self, formatted_answer=None):
@@ -178,8 +176,6 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
         return formatted_answer
 
     def _show_start_logs(self):
-        if self.agent is None:
-            raise ValueError("Agent cannot be None")
         if self.agent.verbose or (
             hasattr(self, "crew") and getattr(self.crew, "verbose", False)
         ):
@@ -192,8 +188,6 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
             )
 
     def _show_logs(self, formatted_answer: Union[AgentAction, AgentFinish]):
-        if self.agent is None:
-            raise ValueError("Agent cannot be None")
         if self.agent.verbose or (
             hasattr(self, "crew") and getattr(self.crew, "verbose", False)
         ):
@@ -312,7 +306,7 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
         self, result: AgentFinish, human_feedback: str | None = None
     ) -> None:
         """Function to handle the process of the training data."""
-        agent_id = str(self.agent.id)  # type: ignore
+        agent_id = str(self.agent.id)
 
         # Load training data
         training_handler = CrewTrainingHandler(TRAINING_DATA_FILE)
@@ -345,7 +339,7 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
                 "initial_output": result.output,
                 "human_feedback": human_feedback,
                 "agent": agent_id,
-                "agent_role": self.agent.role,  # type: ignore
+                "agent_role": self.agent.role,
             }
             if self.crew is not None and hasattr(self.crew, "_train_iteration"):
                 train_iteration = self.crew._train_iteration

src/crewai/cli/create_crew.py

@@ -1,10 +1,9 @@
 from pathlib import Path
 import click
-from crewai.cli.utils import copy_template, load_env_vars, write_env_file
-from crewai.cli.provider import get_provider_data, select_provider, PROVIDERS
+from crewai.cli.utils import copy_template,load_env_vars, write_env_file
+from crewai.cli.provider import get_provider_data,  select_provider, select_model, PROVIDERS
 from crewai.cli.constants import ENV_VARS
 
-
 def create_folder_structure(name, parent_folder=None):
     folder_name = name.replace(" ", "_").replace("-", "_").lower()
     class_name = name.replace("_", " ").replace("-", " ").title().replace(" ", "")
@@ -36,6 +35,7 @@ def create_folder_structure(name, parent_folder=None):
     return folder_path, folder_name, class_name
 
 
+
 def copy_template_files(folder_path, name, class_name, parent_folder):
     package_dir = Path(__file__).parent
     templates_dir = package_dir / "templates" / "crew"
@@ -54,9 +54,7 @@ def copy_template_files(folder_path, name, class_name, parent_folder):
         dst_file = folder_path / file_name
         copy_template(src_file, dst_file, name, class_name, folder_path.name)
 
-    src_folder = (
-        folder_path / "src" / folder_path.name if not parent_folder else folder_path
-    )
+    src_folder = folder_path / "src" / folder_path.name if not parent_folder else folder_path
 
     for file_name in src_template_files:
         src_file = templates_dir / file_name
@@ -83,24 +81,24 @@ def create_crew(name, parent_folder=None):
         return
     provider = selected_provider
 
-    # selected_model = select_model(provider, provider_models)
-    # if not selected_model:
-    #     return
-    # model = selected_model
+    selected_model = select_model(provider, provider_models)
+    if not selected_model:
+        return
+    model = selected_model
 
     if provider in PROVIDERS:
         api_key_var = ENV_VARS[provider][0]
     else:
         api_key_var = click.prompt(
             f"Enter the environment variable name for your {provider.capitalize()} API key",
-            type=str,
+            type=str
         )
 
     env_vars = {api_key_var: "YOUR_API_KEY_HERE"}
     write_env_file(folder_path, env_vars)
 
-    # env_vars['MODEL'] = model
-    # click.secho(f"Selected model: {model}", fg="green")
+    env_vars['MODEL'] = model
+    click.secho(f"Selected model: {model}", fg="green")
 
     package_dir = Path(__file__).parent
     templates_dir = package_dir / "templates" / "crew"

src/crewai/cli/templates/crew/pyproject.toml

@@ -5,7 +5,7 @@ description = "{{name}} using crewAI"
 authors = [{ name = "Your Name", email = "you@example.com" }]
 requires-python = ">=3.10,<=3.13"
 dependencies = [
-    "crewai[tools]>=0.74.0,<1.0.0"
+    "crewai[tools]>=0.67.1,<1.0.0"
 ]
 
 [project.scripts]

src/crewai/cli/templates/flow/pyproject.toml

@@ -5,7 +5,7 @@ description = "{{name}} using crewAI"
 authors = [{ name = "Your Name", email = "you@example.com" }]
 requires-python = ">=3.10,<=3.13"
 dependencies = [
-    "crewai[tools]>=0.74.0,<1.0.0",
+    "crewai[tools]>=0.67.1,<1.0.0",
     "asyncio"
 ]
 

src/crewai/cli/templates/pipeline/pyproject.toml

@@ -6,7 +6,7 @@ authors = ["Your Name <you@example.com>"]
 
 [tool.poetry.dependencies]
 python = ">=3.10,<=3.13"
-crewai = { extras = ["tools"], version = ">=0.74.0,<1.0.0" }
+crewai = { extras = ["tools"], version = ">=0.70.1,<1.0.0" }
 asyncio = "*"
 
 [tool.poetry.scripts]

src/crewai/cli/templates/pipeline_router/pyproject.toml

@@ -5,7 +5,7 @@ description = "{{name}} using crewAI"
 authors = ["Your Name <you@example.com>"]
 requires-python = ">=3.10,<=3.13"
 dependencies = [
-    "crewai[tools]>=0.74.0,<1.0.0"
+    "crewai[tools]>=0.67.1,<1.0.0"
 ]
 
 [project.scripts]

src/crewai/cli/templates/tool/pyproject.toml

@@ -5,6 +5,6 @@ description = "Power up your crews with {{folder_name}}"
 readme = "README.md"
 requires-python = ">=3.10,<=3.13"
 dependencies = [
-    "crewai[tools]>=0.74.0"
+    "crewai[tools]>=0.70.1"
 ]
 

src/crewai/cli/update_crew.py

@@ -1,4 +1,3 @@
-import os
 import shutil
 
 import tomli_w
@@ -95,15 +94,6 @@ def migrate_pyproject(input_file, output_file):
     shutil.copy2(input_file, backup_file)
     print(f"Original pyproject.toml backed up as {backup_file}")
 
-    # Rename the poetry.lock file
-    lock_file = "poetry.lock"
-    lock_backup = "poetry-old.lock"
-    if os.path.exists(lock_file):
-        os.rename(lock_file, lock_backup)
-        print(f"Original poetry.lock renamed to {lock_backup}")
-    else:
-        print("No poetry.lock file found to rename.")
-
     # Write the new pyproject.toml
     with open(output_file, "wb") as f:
         tomli_w.dump(new_pyproject, f)

src/crewai/crew.py

@@ -126,8 +126,8 @@ class Crew(BaseModel):
         default=None,
         description="An Instance of the EntityMemory to be used by the Crew",
     )
-    embedder: Optional[Any] = Field(
-        default=None,
+    embedder: Optional[dict] = Field(
+        default={"provider": "openai"},
         description="Configuration for the embedder to be used for the crew.",
     )
     usage_metrics: Optional[UsageMetrics] = Field(
@@ -774,9 +774,7 @@ class Crew(BaseModel):
 
     def _log_task_start(self, task: Task, role: str = "None"):
         if self.output_log_file:
-            self._file_handler.log(
-                task_name=task.name, task=task.description, agent=role, status="started"
-            )
+            self._file_handler.log(task_name=task.name, task=task.description, agent=role, status="started")
 
     def _update_manager_tools(self, task: Task):
         if self.manager_agent:
@@ -798,13 +796,7 @@ class Crew(BaseModel):
     def _process_task_result(self, task: Task, output: TaskOutput) -> None:
         role = task.agent.role if task.agent is not None else "None"
         if self.output_log_file:
-            self._file_handler.log(
-                task_name=task.name,
-                task=task.description,
-                agent=role,
-                status="completed",
-                output=output.raw,
-            )
+            self._file_handler.log(task_name=task.name, task=task.description, agent=role, status="completed", output=output.raw)
 
     def _create_crew_output(self, task_outputs: List[TaskOutput]) -> CrewOutput:
         if len(task_outputs) != 1:

src/crewai/memory/contextual/contextual_memory.py

@@ -31,9 +31,7 @@ class ContextualMemory:
         formatted as bullet points.
         """
         stm_results = self.stm.search(query)
-        formatted_results = "\n".join(
-            [f"- {result['context']}" for result in stm_results]
-        )
+        formatted_results = "\n".join([f"- {result}" for result in stm_results])
         return f"Recent Insights:\n{formatted_results}" if stm_results else ""
 
     def _fetch_ltm_context(self, task) -> Optional[str]:

src/crewai/memory/long_term/long_term_memory.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, List
+from typing import Any, Dict
 
 from crewai.memory.long_term.long_term_memory_item import LongTermMemoryItem
 from crewai.memory.memory import Memory
@@ -28,7 +28,7 @@ class LongTermMemory(Memory):
             datetime=item.datetime,
         )
 
-    def search(self, task: str, latest_n: int = 3) -> List[Dict[str, Any]]:  # type: ignore # signature of "search" incompatible with supertype "Memory"
+    def search(self, task: str, latest_n: int = 3) -> Dict[str, Any]:
         return self.storage.load(task, latest_n)  # type: ignore # BUG?: "Storage" has no attribute "load"
 
     def reset(self) -> None:

src/crewai/memory/memory.py

@@ -1,6 +1,6 @@
-from typing import Any, Dict, Optional, List
+from typing import Any, Dict, Optional
 
-from crewai.memory.storage.rag_storage import RAGStorage
+from crewai.memory.storage.interface import Storage
 
 
 class Memory:
@@ -8,7 +8,7 @@ class Memory:
     Base class for memory, now supporting agent tags and generic metadata.
     """
 
-    def __init__(self, storage: RAGStorage):
+    def __init__(self, storage: Storage):
         self.storage = storage
 
     def save(
@@ -23,5 +23,5 @@ class Memory:
 
         self.storage.save(value, metadata)
 
-    def search(self, query: str) -> List[Dict[str, Any]]:
+    def search(self, query: str) -> Dict[str, Any]:
         return self.storage.search(query)

src/crewai/memory/storage/base_rag_storage.py

@@ -1,76 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import Any, Dict, List, Optional
-
-
-class BaseRAGStorage(ABC):
-    """
-    Base class for RAG-based Storage implementations.
-    """
-
-    app: Any | None = None
-
-    def __init__(
-        self,
-        type: str,
-        allow_reset: bool = True,
-        embedder_config: Optional[Any] = None,
-        crew: Any = None,
-    ):
-        self.type = type
-        self.allow_reset = allow_reset
-        self.embedder_config = embedder_config
-        self.crew = crew
-        self.agents = self._initialize_agents()
-
-    def _initialize_agents(self) -> str:
-        if self.crew:
-            return "_".join(
-                [self._sanitize_role(agent.role) for agent in self.crew.agents]
-            )
-        return ""
-
-    @abstractmethod
-    def _sanitize_role(self, role: str) -> str:
-        """Sanitizes agent roles to ensure valid directory names."""
-        pass
-
-    @abstractmethod
-    def save(self, value: Any, metadata: Dict[str, Any]) -> None:
-        """Save a value with metadata to the storage."""
-        pass
-
-    @abstractmethod
-    def search(
-        self,
-        query: str,
-        limit: int = 3,
-        filter: Optional[dict] = None,
-        score_threshold: float = 0.35,
-    ) -> List[Any]:
-        """Search for entries in the storage."""
-        pass
-
-    @abstractmethod
-    def reset(self) -> None:
-        """Reset the storage."""
-        pass
-
-    @abstractmethod
-    def _generate_embedding(
-        self, text: str, metadata: Optional[Dict[str, Any]] = None
-    ) -> Any:
-        """Generate an embedding for the given text and metadata."""
-        pass
-
-    @abstractmethod
-    def _initialize_app(self):
-        """Initialize the vector db."""
-        pass
-
-    def setup_config(self, config: Dict[str, Any]):
-        """Setup the config of the storage."""
-        pass
-
-    def initialize_client(self):
-        """Initialize the client of the storage. This should setup the app and the db collection"""
-        pass

src/crewai/memory/storage/interface.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, List
+from typing import Any, Dict
 
 
 class Storage:
@@ -7,7 +7,7 @@ class Storage:
     def save(self, value: Any, metadata: Dict[str, Any]) -> None:
         pass
 
-    def search(self, key: str) -> List[Dict[str, Any]]:  # type: ignore
+    def search(self, key: str) -> Dict[str, Any]:  # type: ignore
         pass
 
     def reset(self) -> None:

src/crewai/memory/storage/rag_storage.py

@@ -3,11 +3,10 @@ import io
 import logging
 import os
 import shutil
-import uuid
 from typing import Any, Dict, List, Optional
-from crewai.memory.storage.base_rag_storage import BaseRAGStorage
+
+from crewai.memory.storage.interface import Storage
 from crewai.utilities.paths import db_storage_path
-from chromadb.api import ClientAPI
 
 
 @contextlib.contextmanager
@@ -25,42 +24,61 @@ def suppress_logging(
     logger.setLevel(original_level)
 
 
-class RAGStorage(BaseRAGStorage):
+class RAGStorage(Storage):
     """
     Extends Storage to handle embeddings for memory entries, improving
     search efficiency.
     """
 
-    app: ClientAPI | None = None
-
     def __init__(self, type, allow_reset=True, embedder_config=None, crew=None):
-        super().__init__(type, allow_reset, embedder_config, crew)
+        super().__init__()
+        if (
+            not os.getenv("OPENAI_API_KEY")
+            and not os.getenv("OPENAI_BASE_URL") == "https://api.openai.com/v1"
+        ):
+            os.environ["OPENAI_API_KEY"] = "fake"
+
         agents = crew.agents if crew else []
         agents = [self._sanitize_role(agent.role) for agent in agents]
         agents = "_".join(agents)
-        self.agents = agents
 
+        config = {
+            "app": {
+                "config": {"name": type, "collect_metrics": False, "log_level": "ERROR"}
+            },
+            "chunker": {
+                "chunk_size": 5000,
+                "chunk_overlap": 100,
+                "length_function": "len",
+                "min_chunk_size": 150,
+            },
+            "vectordb": {
+                "provider": "chroma",
+                "config": {
+                    "collection_name": type,
+                    "dir": f"{db_storage_path()}/{type}/{agents}",
+                    "allow_reset": allow_reset,
+                },
+            },
+        }
+
+        if embedder_config:
+            config["embedder"] = embedder_config
         self.type = type
-        self.embedder_config = embedder_config or self._create_embedding_function()
+        self.config = config
         self.allow_reset = allow_reset
-        self._initialize_app()
 
     def _initialize_app(self):
-        import chromadb
+        from embedchain import App
+        from embedchain.llm.base import BaseLlm
 
-        chroma_client = chromadb.PersistentClient(
-            path=f"{db_storage_path()}/{self.type}/{self.agents}"
-        )
-        self.app = chroma_client
+        class FakeLLM(BaseLlm):
+            pass
 
-        try:
-            self.collection = self.app.get_collection(
-                name=self.type, embedding_function=self.embedder_config
-            )
-        except Exception:
-            self.collection = self.app.create_collection(
-                name=self.type, embedding_function=self.embedder_config
-            )
+        self.app = App.from_config(config=self.config)
+        self.app.llm = FakeLLM()
+        if self.allow_reset:
+            self.app.reset()
 
     def _sanitize_role(self, role: str) -> str:
         """
@@ -69,14 +87,11 @@ class RAGStorage(BaseRAGStorage):
         return role.replace("\n", "").replace(" ", "_").replace("/", "_")
 
     def save(self, value: Any, metadata: Dict[str, Any]) -> None:
-        if not hasattr(self, "app") or not hasattr(self, "collection"):
+        if not hasattr(self, "app"):
             self._initialize_app()
-        try:
-            self._generate_embedding(value, metadata)
-        except Exception as e:
-            logging.error(f"Error during {self.type} save: {str(e)}")
+        self._generate_embedding(value, metadata)
 
-    def search(
+    def search(  # type: ignore # BUG?: Signature of "search" incompatible with supertype "Storage"
         self,
         query: str,
         limit: int = 3,
@@ -85,50 +100,31 @@ class RAGStorage(BaseRAGStorage):
     ) -> List[Any]:
         if not hasattr(self, "app"):
             self._initialize_app()
+        from embedchain.vectordb.chroma import InvalidDimensionException
 
-        try:
-            with suppress_logging():
-                response = self.collection.query(query_texts=query, n_results=limit)
+        with suppress_logging():
+            try:
+                results = (
+                    self.app.search(query, limit, where=filter)
+                    if filter
+                    else self.app.search(query, limit)
+                )
+            except InvalidDimensionException:
+                self.app.reset()
+                return []
+        return [r for r in results if r["metadata"]["score"] >= score_threshold]
 
-            results = []
-            for i in range(len(response["ids"][0])):
-                result = {
-                    "id": response["ids"][0][i],
-                    "metadata": response["metadatas"][0][i],
-                    "context": response["documents"][0][i],
-                    "score": response["distances"][0][i],
-                }
-                if result["score"] >= score_threshold:
-                    results.append(result)
-
-            return results
-        except Exception as e:
-            logging.error(f"Error during {self.type} search: {str(e)}")
-            return []
-
-    def _generate_embedding(self, text: str, metadata: Dict[str, Any]) -> None:  # type: ignore
-        if not hasattr(self, "app") or not hasattr(self, "collection"):
+    def _generate_embedding(self, text: str, metadata: Dict[str, Any]) -> Any:
+        if not hasattr(self, "app"):
             self._initialize_app()
+        from embedchain.models.data_type import DataType
 
-        self.collection.add(
-            documents=[text],
-            metadatas=[metadata or {}],
-            ids=[str(uuid.uuid4())],
-        )
+        self.app.add(text, data_type=DataType.TEXT, metadata=metadata)
 
     def reset(self) -> None:
         try:
             shutil.rmtree(f"{db_storage_path()}/{self.type}")
-            if self.app:
-                self.app.reset()
         except Exception as e:
             raise Exception(
                 f"An error occurred while resetting the {self.type} memory: {e}"
             )
-
-    def _create_embedding_function(self):
-        import chromadb.utils.embedding_functions as embedding_functions
-
-        return embedding_functions.OpenAIEmbeddingFunction(
-            api_key=os.getenv("OPENAI_API_KEY"), model_name="text-embedding-3-small"
-        )

src/crewai/project/annotations.py

@@ -76,13 +76,27 @@ def crew(func) -> Callable[..., Crew]:
         instantiated_agents = []
         agent_roles = set()
 
-        # Use the preserved task and agent information
-        tasks = self._original_tasks.items()
-        agents = self._original_agents.items()
+        # Collect methods from crew in order
+        all_functions = [
+            (name, getattr(self, name))
+            for name, attr in self.__class__.__dict__.items()
+            if callable(attr)
+        ]
+        tasks = [
+            (name, method)
+            for name, method in all_functions
+            if hasattr(method, "is_task")
+        ]
+
+        agents = [
+            (name, method)
+            for name, method in all_functions
+            if hasattr(method, "is_agent")
+        ]
 
         # Instantiate tasks in order
         for task_name, task_method in tasks:
-            task_instance = task_method(self)
+            task_instance = task_method()
             instantiated_tasks.append(task_instance)
             agent_instance = getattr(task_instance, "agent", None)
             if agent_instance and agent_instance.role not in agent_roles:
@@ -91,7 +105,7 @@ def crew(func) -> Callable[..., Crew]:
 
         # Instantiate agents not included by tasks
         for agent_name, agent_method in agents:
-            agent_instance = agent_method(self)
+            agent_instance = agent_method()
             if agent_instance.role not in agent_roles:
                 instantiated_agents.append(agent_instance)
                 agent_roles.add(agent_instance.role)

src/crewai/project/crew_base.py

@@ -34,18 +34,6 @@ def CrewBase(cls: T) -> T:
             self.map_all_agent_variables()
             self.map_all_task_variables()
 
-            # Preserve task and agent information
-            self._original_tasks = {
-                name: method
-                for name, method in cls.__dict__.items()
-                if hasattr(method, "is_task") and method.is_task
-            }
-            self._original_agents = {
-                name: method
-                for name, method in cls.__dict__.items()
-                if hasattr(method, "is_agent") and method.is_agent
-            }
-
         @staticmethod
         def load_yaml(config_path: Path):
             try:

src/crewai/telemetry/telemetry.py

@@ -65,7 +65,7 @@ class Telemetry:
 
             self.provider.add_span_processor(processor)
             self.ready = True
-        except Exception as e:
+        except BaseException as e:
             if isinstance(
                 e,
                 (SystemExit, KeyboardInterrupt, GeneratorExit, asyncio.CancelledError),
@@ -83,33 +83,404 @@ class Telemetry:
                 self.ready = False
                 self.trace_set = False
 
-    def _safe_telemetry_operation(self, operation):
-        if not self.ready:
-            return
-        try:
-            operation()
-        except Exception:
-            pass
-
     def crew_creation(self, crew: Crew, inputs: dict[str, Any] | None):
         """Records the creation of a crew."""
+        if self.ready:
+            try:
+                tracer = trace.get_tracer("crewai.telemetry")
+                span = tracer.start_span("Crew Created")
+                self._add_attribute(
+                    span,
+                    "crewai_version",
+                    pkg_resources.get_distribution("crewai").version,
+                )
+                self._add_attribute(span, "python_version", platform.python_version())
+                self._add_attribute(span, "crew_key", crew.key)
+                self._add_attribute(span, "crew_id", str(crew.id))
+                self._add_attribute(span, "crew_process", crew.process)
+                self._add_attribute(span, "crew_memory", crew.memory)
+                self._add_attribute(span, "crew_number_of_tasks", len(crew.tasks))
+                self._add_attribute(span, "crew_number_of_agents", len(crew.agents))
+                if crew.share_crew:
+                    self._add_attribute(
+                        span,
+                        "crew_agents",
+                        json.dumps(
+                            [
+                                {
+                                    "key": agent.key,
+                                    "id": str(agent.id),
+                                    "role": agent.role,
+                                    "goal": agent.goal,
+                                    "backstory": agent.backstory,
+                                    "verbose?": agent.verbose,
+                                    "max_iter": agent.max_iter,
+                                    "max_rpm": agent.max_rpm,
+                                    "i18n": agent.i18n.prompt_file,
+                                    "function_calling_llm": (
+                                        agent.function_calling_llm.model
+                                        if agent.function_calling_llm
+                                        else ""
+                                    ),
+                                    "llm": agent.llm.model,
+                                    "delegation_enabled?": agent.allow_delegation,
+                                    "allow_code_execution?": agent.allow_code_execution,
+                                    "max_retry_limit": agent.max_retry_limit,
+                                    "tools_names": [
+                                        tool.name.casefold()
+                                        for tool in agent.tools or []
+                                    ],
+                                }
+                                for agent in crew.agents
+                            ]
+                        ),
+                    )
+                    self._add_attribute(
+                        span,
+                        "crew_tasks",
+                        json.dumps(
+                            [
+                                {
+                                    "key": task.key,
+                                    "id": str(task.id),
+                                    "description": task.description,
+                                    "expected_output": task.expected_output,
+                                    "async_execution?": task.async_execution,
+                                    "human_input?": task.human_input,
+                                    "agent_role": (
+                                        task.agent.role if task.agent else "None"
+                                    ),
+                                    "agent_key": task.agent.key if task.agent else None,
+                                    "context": (
+                                        [task.description for task in task.context]
+                                        if task.context
+                                        else None
+                                    ),
+                                    "tools_names": [
+                                        tool.name.casefold()
+                                        for tool in task.tools or []
+                                    ],
+                                }
+                                for task in crew.tasks
+                            ]
+                        ),
+                    )
+                    self._add_attribute(span, "platform", platform.platform())
+                    self._add_attribute(span, "platform_release", platform.release())
+                    self._add_attribute(span, "platform_system", platform.system())
+                    self._add_attribute(span, "platform_version", platform.version())
+                    self._add_attribute(span, "cpus", os.cpu_count())
+                    self._add_attribute(
+                        span, "crew_inputs", json.dumps(inputs) if inputs else None
+                    )
+                else:
+                    self._add_attribute(
+                        span,
+                        "crew_agents",
+                        json.dumps(
+                            [
+                                {
+                                    "key": agent.key,
+                                    "id": str(agent.id),
+                                    "role": agent.role,
+                                    "verbose?": agent.verbose,
+                                    "max_iter": agent.max_iter,
+                                    "max_rpm": agent.max_rpm,
+                                    "function_calling_llm": (
+                                        agent.function_calling_llm.model
+                                        if agent.function_calling_llm
+                                        else ""
+                                    ),
+                                    "llm": agent.llm.model,
+                                    "delegation_enabled?": agent.allow_delegation,
+                                    "allow_code_execution?": agent.allow_code_execution,
+                                    "max_retry_limit": agent.max_retry_limit,
+                                    "tools_names": [
+                                        tool.name.casefold()
+                                        for tool in agent.tools or []
+                                    ],
+                                }
+                                for agent in crew.agents
+                            ]
+                        ),
+                    )
+                    self._add_attribute(
+                        span,
+                        "crew_tasks",
+                        json.dumps(
+                            [
+                                {
+                                    "key": task.key,
+                                    "id": str(task.id),
+                                    "async_execution?": task.async_execution,
+                                    "human_input?": task.human_input,
+                                    "agent_role": (
+                                        task.agent.role if task.agent else "None"
+                                    ),
+                                    "agent_key": task.agent.key if task.agent else None,
+                                    "tools_names": [
+                                        tool.name.casefold()
+                                        for tool in task.tools or []
+                                    ],
+                                }
+                                for task in crew.tasks
+                            ]
+                        ),
+                    )
+                span.set_status(Status(StatusCode.OK))
+                span.end()
+            except Exception:
+                pass
 
-        def operation():
-            tracer = trace.get_tracer("crewai.telemetry")
-            span = tracer.start_span("Crew Created")
-            self._add_attribute(
-                span,
-                "crewai_version",
-                pkg_resources.get_distribution("crewai").version,
-            )
-            self._add_attribute(span, "python_version", platform.python_version())
-            self._add_attribute(span, "crew_key", crew.key)
-            self._add_attribute(span, "crew_id", str(crew.id))
-            self._add_attribute(span, "crew_process", crew.process)
-            self._add_attribute(span, "crew_memory", crew.memory)
-            self._add_attribute(span, "crew_number_of_tasks", len(crew.tasks))
-            self._add_attribute(span, "crew_number_of_agents", len(crew.agents))
-            if crew.share_crew:
+    def task_started(self, crew: Crew, task: Task) -> Span | None:
+        """Records task started in a crew."""
+        if self.ready:
+            try:
+                tracer = trace.get_tracer("crewai.telemetry")
+
+                created_span = tracer.start_span("Task Created")
+
+                self._add_attribute(created_span, "crew_key", crew.key)
+                self._add_attribute(created_span, "crew_id", str(crew.id))
+                self._add_attribute(created_span, "task_key", task.key)
+                self._add_attribute(created_span, "task_id", str(task.id))
+
+                if crew.share_crew:
+                    self._add_attribute(
+                        created_span, "formatted_description", task.description
+                    )
+                    self._add_attribute(
+                        created_span, "formatted_expected_output", task.expected_output
+                    )
+
+                created_span.set_status(Status(StatusCode.OK))
+                created_span.end()
+
+                span = tracer.start_span("Task Execution")
+
+                self._add_attribute(span, "crew_key", crew.key)
+                self._add_attribute(span, "crew_id", str(crew.id))
+                self._add_attribute(span, "task_key", task.key)
+                self._add_attribute(span, "task_id", str(task.id))
+
+                if crew.share_crew:
+                    self._add_attribute(span, "formatted_description", task.description)
+                    self._add_attribute(
+                        span, "formatted_expected_output", task.expected_output
+                    )
+
+                return span
+            except Exception:
+                pass
+
+        return None
+
+    def task_ended(self, span: Span, task: Task, crew: Crew):
+        """Records task execution in a crew."""
+        if self.ready:
+            try:
+                if crew.share_crew:
+                    self._add_attribute(
+                        span,
+                        "task_output",
+                        task.output.raw if task.output else "",
+                    )
+
+                span.set_status(Status(StatusCode.OK))
+                span.end()
+            except Exception:
+                pass
+
+    def tool_repeated_usage(self, llm: Any, tool_name: str, attempts: int):
+        """Records the repeated usage 'error' of a tool by an agent."""
+        if self.ready:
+            try:
+                tracer = trace.get_tracer("crewai.telemetry")
+                span = tracer.start_span("Tool Repeated Usage")
+                self._add_attribute(
+                    span,
+                    "crewai_version",
+                    pkg_resources.get_distribution("crewai").version,
+                )
+                self._add_attribute(span, "tool_name", tool_name)
+                self._add_attribute(span, "attempts", attempts)
+                if llm:
+                    self._add_attribute(span, "llm", llm.model)
+                span.set_status(Status(StatusCode.OK))
+                span.end()
+            except Exception:
+                pass
+
+    def tool_usage(self, llm: Any, tool_name: str, attempts: int):
+        """Records the usage of a tool by an agent."""
+        if self.ready:
+            try:
+                tracer = trace.get_tracer("crewai.telemetry")
+                span = tracer.start_span("Tool Usage")
+                self._add_attribute(
+                    span,
+                    "crewai_version",
+                    pkg_resources.get_distribution("crewai").version,
+                )
+                self._add_attribute(span, "tool_name", tool_name)
+                self._add_attribute(span, "attempts", attempts)
+                if llm:
+                    self._add_attribute(span, "llm", llm.model)
+                span.set_status(Status(StatusCode.OK))
+                span.end()
+            except Exception:
+                pass
+
+    def tool_usage_error(self, llm: Any):
+        """Records the usage of a tool by an agent."""
+        if self.ready:
+            try:
+                tracer = trace.get_tracer("crewai.telemetry")
+                span = tracer.start_span("Tool Usage Error")
+                self._add_attribute(
+                    span,
+                    "crewai_version",
+                    pkg_resources.get_distribution("crewai").version,
+                )
+                if llm:
+                    self._add_attribute(span, "llm", llm.model)
+                span.set_status(Status(StatusCode.OK))
+                span.end()
+            except Exception:
+                pass
+
+    def individual_test_result_span(
+        self, crew: Crew, quality: float, exec_time: int, model_name: str
+    ):
+        if self.ready:
+            try:
+                tracer = trace.get_tracer("crewai.telemetry")
+                span = tracer.start_span("Crew Individual Test Result")
+
+                self._add_attribute(
+                    span,
+                    "crewai_version",
+                    pkg_resources.get_distribution("crewai").version,
+                )
+                self._add_attribute(span, "crew_key", crew.key)
+                self._add_attribute(span, "crew_id", str(crew.id))
+                self._add_attribute(span, "quality", str(quality))
+                self._add_attribute(span, "exec_time", str(exec_time))
+                self._add_attribute(span, "model_name", model_name)
+                span.set_status(Status(StatusCode.OK))
+                span.end()
+            except Exception:
+                pass
+
+    def test_execution_span(
+        self,
+        crew: Crew,
+        iterations: int,
+        inputs: dict[str, Any] | None,
+        model_name: str,
+    ):
+        if self.ready:
+            try:
+                tracer = trace.get_tracer("crewai.telemetry")
+                span = tracer.start_span("Crew Test Execution")
+
+                self._add_attribute(
+                    span,
+                    "crewai_version",
+                    pkg_resources.get_distribution("crewai").version,
+                )
+                self._add_attribute(span, "crew_key", crew.key)
+                self._add_attribute(span, "crew_id", str(crew.id))
+                self._add_attribute(span, "iterations", str(iterations))
+                self._add_attribute(span, "model_name", model_name)
+
+                if crew.share_crew:
+                    self._add_attribute(
+                        span, "inputs", json.dumps(inputs) if inputs else None
+                    )
+
+                span.set_status(Status(StatusCode.OK))
+                span.end()
+            except Exception:
+                pass
+
+    def deploy_signup_error_span(self):
+        if self.ready:
+            try:
+                tracer = trace.get_tracer("crewai.telemetry")
+                span = tracer.start_span("Deploy Signup Error")
+                span.set_status(Status(StatusCode.OK))
+                span.end()
+            except Exception:
+                pass
+
+    def start_deployment_span(self, uuid: Optional[str] = None):
+        if self.ready:
+            try:
+                tracer = trace.get_tracer("crewai.telemetry")
+                span = tracer.start_span("Start Deployment")
+                if uuid:
+                    self._add_attribute(span, "uuid", uuid)
+                span.set_status(Status(StatusCode.OK))
+                span.end()
+            except Exception:
+                pass
+
+    def create_crew_deployment_span(self):
+        if self.ready:
+            try:
+                tracer = trace.get_tracer("crewai.telemetry")
+                span = tracer.start_span("Create Crew Deployment")
+                span.set_status(Status(StatusCode.OK))
+                span.end()
+            except Exception:
+                pass
+
+    def get_crew_logs_span(self, uuid: Optional[str], log_type: str = "deployment"):
+        if self.ready:
+            try:
+                tracer = trace.get_tracer("crewai.telemetry")
+                span = tracer.start_span("Get Crew Logs")
+                self._add_attribute(span, "log_type", log_type)
+                if uuid:
+                    self._add_attribute(span, "uuid", uuid)
+                span.set_status(Status(StatusCode.OK))
+                span.end()
+            except Exception:
+                pass
+
+    def remove_crew_span(self, uuid: Optional[str] = None):
+        if self.ready:
+            try:
+                tracer = trace.get_tracer("crewai.telemetry")
+                span = tracer.start_span("Remove Crew")
+                if uuid:
+                    self._add_attribute(span, "uuid", uuid)
+                span.set_status(Status(StatusCode.OK))
+                span.end()
+            except Exception:
+                pass
+
+    def crew_execution_span(self, crew: Crew, inputs: dict[str, Any] | None):
+        """Records the complete execution of a crew.
+        This is only collected if the user has opted-in to share the crew.
+        """
+        self.crew_creation(crew, inputs)
+
+        if (self.ready) and (crew.share_crew):
+            try:
+                tracer = trace.get_tracer("crewai.telemetry")
+                span = tracer.start_span("Crew Execution")
+                self._add_attribute(
+                    span,
+                    "crewai_version",
+                    pkg_resources.get_distribution("crewai").version,
+                )
+                self._add_attribute(span, "crew_key", crew.key)
+                self._add_attribute(span, "crew_id", str(crew.id))
+                self._add_attribute(
+                    span, "crew_inputs", json.dumps(inputs) if inputs else None
+                )
                 self._add_attribute(
                     span,
                     "crew_agents",
@@ -125,15 +496,8 @@ class Telemetry:
                                 "max_iter": agent.max_iter,
                                 "max_rpm": agent.max_rpm,
                                 "i18n": agent.i18n.prompt_file,
-                                "function_calling_llm": (
-                                    agent.function_calling_llm.model
-                                    if agent.function_calling_llm
-                                    else ""
-                                ),
                                 "llm": agent.llm.model,
                                 "delegation_enabled?": agent.allow_delegation,
-                                "allow_code_execution?": agent.allow_code_execution,
-                                "max_retry_limit": agent.max_retry_limit,
                                 "tools_names": [
                                     tool.name.casefold() for tool in agent.tools or []
                                 ],
@@ -148,15 +512,12 @@ class Telemetry:
                     json.dumps(
                         [
                             {
-                                "key": task.key,
                                 "id": str(task.id),
                                 "description": task.description,
                                 "expected_output": task.expected_output,
                                 "async_execution?": task.async_execution,
                                 "human_input?": task.human_input,
-                                "agent_role": (
-                                    task.agent.role if task.agent else "None"
-                                ),
+                                "agent_role": task.agent.role if task.agent else "None",
                                 "agent_key": task.agent.key if task.agent else None,
                                 "context": (
                                     [task.description for task in task.context]
@@ -171,433 +532,78 @@ class Telemetry:
                         ]
                     ),
                 )
-                self._add_attribute(span, "platform", platform.platform())
-                self._add_attribute(span, "platform_release", platform.release())
-                self._add_attribute(span, "platform_system", platform.system())
-                self._add_attribute(span, "platform_version", platform.version())
-                self._add_attribute(span, "cpus", os.cpu_count())
+                return span
+            except Exception:
+                pass
+
+    def end_crew(self, crew, final_string_output):
+        if (self.ready) and (crew.share_crew):
+            try:
                 self._add_attribute(
-                    span, "crew_inputs", json.dumps(inputs) if inputs else None
+                    crew._execution_span,
+                    "crewai_version",
+                    pkg_resources.get_distribution("crewai").version,
                 )
-            else:
                 self._add_attribute(
-                    span,
-                    "crew_agents",
+                    crew._execution_span, "crew_output", final_string_output
+                )
+                self._add_attribute(
+                    crew._execution_span,
+                    "crew_tasks_output",
                     json.dumps(
                         [
                             {
-                                "key": agent.key,
-                                "id": str(agent.id),
-                                "role": agent.role,
-                                "verbose?": agent.verbose,
-                                "max_iter": agent.max_iter,
-                                "max_rpm": agent.max_rpm,
-                                "function_calling_llm": (
-                                    agent.function_calling_llm.model
-                                    if agent.function_calling_llm
-                                    else ""
-                                ),
-                                "llm": agent.llm.model,
-                                "delegation_enabled?": agent.allow_delegation,
-                                "allow_code_execution?": agent.allow_code_execution,
-                                "max_retry_limit": agent.max_retry_limit,
-                                "tools_names": [
-                                    tool.name.casefold() for tool in agent.tools or []
-                                ],
-                            }
-                            for agent in crew.agents
-                        ]
-                    ),
-                )
-                self._add_attribute(
-                    span,
-                    "crew_tasks",
-                    json.dumps(
-                        [
-                            {
-                                "key": task.key,
                                 "id": str(task.id),
-                                "async_execution?": task.async_execution,
-                                "human_input?": task.human_input,
-                                "agent_role": (
-                                    task.agent.role if task.agent else "None"
-                                ),
-                                "agent_key": task.agent.key if task.agent else None,
-                                "tools_names": [
-                                    tool.name.casefold() for tool in task.tools or []
-                                ],
+                                "description": task.description,
+                                "output": task.output.raw_output,
                             }
                             for task in crew.tasks
                         ]
                     ),
                 )
-            span.set_status(Status(StatusCode.OK))
-            span.end()
-
-        self._safe_telemetry_operation(operation)
-
-    def task_started(self, crew: Crew, task: Task) -> Span | None:
-        """Records task started in a crew."""
-
-        def operation():
-            tracer = trace.get_tracer("crewai.telemetry")
-
-            created_span = tracer.start_span("Task Created")
-
-            self._add_attribute(created_span, "crew_key", crew.key)
-            self._add_attribute(created_span, "crew_id", str(crew.id))
-            self._add_attribute(created_span, "task_key", task.key)
-            self._add_attribute(created_span, "task_id", str(task.id))
-
-            if crew.share_crew:
-                self._add_attribute(
-                    created_span, "formatted_description", task.description
-                )
-                self._add_attribute(
-                    created_span, "formatted_expected_output", task.expected_output
-                )
-
-            created_span.set_status(Status(StatusCode.OK))
-            created_span.end()
-
-            span = tracer.start_span("Task Execution")
-
-            self._add_attribute(span, "crew_key", crew.key)
-            self._add_attribute(span, "crew_id", str(crew.id))
-            self._add_attribute(span, "task_key", task.key)
-            self._add_attribute(span, "task_id", str(task.id))
-
-            if crew.share_crew:
-                self._add_attribute(span, "formatted_description", task.description)
-                self._add_attribute(
-                    span, "formatted_expected_output", task.expected_output
-                )
-
-            return span
-
-        return self._safe_telemetry_operation(operation)
-
-    def task_ended(self, span: Span, task: Task, crew: Crew):
-        """Records task execution in a crew."""
-
-        def operation():
-            if crew.share_crew:
-                self._add_attribute(
-                    span,
-                    "task_output",
-                    task.output.raw if task.output else "",
-                )
-
-            span.set_status(Status(StatusCode.OK))
-            span.end()
-
-        self._safe_telemetry_operation(operation)
-
-    def tool_repeated_usage(self, llm: Any, tool_name: str, attempts: int):
-        """Records the repeated usage 'error' of a tool by an agent."""
-
-        def operation():
-            tracer = trace.get_tracer("crewai.telemetry")
-            span = tracer.start_span("Tool Repeated Usage")
-            self._add_attribute(
-                span,
-                "crewai_version",
-                pkg_resources.get_distribution("crewai").version,
-            )
-            self._add_attribute(span, "tool_name", tool_name)
-            self._add_attribute(span, "attempts", attempts)
-            if llm:
-                self._add_attribute(span, "llm", llm.model)
-            span.set_status(Status(StatusCode.OK))
-            span.end()
-
-        self._safe_telemetry_operation(operation)
-
-    def tool_usage(self, llm: Any, tool_name: str, attempts: int):
-        """Records the usage of a tool by an agent."""
-
-        def operation():
-            tracer = trace.get_tracer("crewai.telemetry")
-            span = tracer.start_span("Tool Usage")
-            self._add_attribute(
-                span,
-                "crewai_version",
-                pkg_resources.get_distribution("crewai").version,
-            )
-            self._add_attribute(span, "tool_name", tool_name)
-            self._add_attribute(span, "attempts", attempts)
-            if llm:
-                self._add_attribute(span, "llm", llm.model)
-            span.set_status(Status(StatusCode.OK))
-            span.end()
-
-        self._safe_telemetry_operation(operation)
-
-    def tool_usage_error(self, llm: Any):
-        """Records the usage of a tool by an agent."""
-
-        def operation():
-            tracer = trace.get_tracer("crewai.telemetry")
-            span = tracer.start_span("Tool Usage Error")
-            self._add_attribute(
-                span,
-                "crewai_version",
-                pkg_resources.get_distribution("crewai").version,
-            )
-            if llm:
-                self._add_attribute(span, "llm", llm.model)
-            span.set_status(Status(StatusCode.OK))
-            span.end()
-
-        self._safe_telemetry_operation(operation)
-
-    def individual_test_result_span(
-        self, crew: Crew, quality: float, exec_time: int, model_name: str
-    ):
-        def operation():
-            tracer = trace.get_tracer("crewai.telemetry")
-            span = tracer.start_span("Crew Individual Test Result")
-
-            self._add_attribute(
-                span,
-                "crewai_version",
-                pkg_resources.get_distribution("crewai").version,
-            )
-            self._add_attribute(span, "crew_key", crew.key)
-            self._add_attribute(span, "crew_id", str(crew.id))
-            self._add_attribute(span, "quality", str(quality))
-            self._add_attribute(span, "exec_time", str(exec_time))
-            self._add_attribute(span, "model_name", model_name)
-            span.set_status(Status(StatusCode.OK))
-            span.end()
-
-        self._safe_telemetry_operation(operation)
-
-    def test_execution_span(
-        self,
-        crew: Crew,
-        iterations: int,
-        inputs: dict[str, Any] | None,
-        model_name: str,
-    ):
-        def operation():
-            tracer = trace.get_tracer("crewai.telemetry")
-            span = tracer.start_span("Crew Test Execution")
-
-            self._add_attribute(
-                span,
-                "crewai_version",
-                pkg_resources.get_distribution("crewai").version,
-            )
-            self._add_attribute(span, "crew_key", crew.key)
-            self._add_attribute(span, "crew_id", str(crew.id))
-            self._add_attribute(span, "iterations", str(iterations))
-            self._add_attribute(span, "model_name", model_name)
-
-            if crew.share_crew:
-                self._add_attribute(
-                    span, "inputs", json.dumps(inputs) if inputs else None
-                )
-
-            span.set_status(Status(StatusCode.OK))
-            span.end()
-
-        self._safe_telemetry_operation(operation)
-
-    def deploy_signup_error_span(self):
-        def operation():
-            tracer = trace.get_tracer("crewai.telemetry")
-            span = tracer.start_span("Deploy Signup Error")
-            span.set_status(Status(StatusCode.OK))
-            span.end()
-
-        self._safe_telemetry_operation(operation)
-
-    def start_deployment_span(self, uuid: Optional[str] = None):
-        def operation():
-            tracer = trace.get_tracer("crewai.telemetry")
-            span = tracer.start_span("Start Deployment")
-            if uuid:
-                self._add_attribute(span, "uuid", uuid)
-            span.set_status(Status(StatusCode.OK))
-            span.end()
-
-        self._safe_telemetry_operation(operation)
-
-    def create_crew_deployment_span(self):
-        def operation():
-            tracer = trace.get_tracer("crewai.telemetry")
-            span = tracer.start_span("Create Crew Deployment")
-            span.set_status(Status(StatusCode.OK))
-            span.end()
-
-        self._safe_telemetry_operation(operation)
-
-    def get_crew_logs_span(self, uuid: Optional[str], log_type: str = "deployment"):
-        def operation():
-            tracer = trace.get_tracer("crewai.telemetry")
-            span = tracer.start_span("Get Crew Logs")
-            self._add_attribute(span, "log_type", log_type)
-            if uuid:
-                self._add_attribute(span, "uuid", uuid)
-            span.set_status(Status(StatusCode.OK))
-            span.end()
-
-        self._safe_telemetry_operation(operation)
-
-    def remove_crew_span(self, uuid: Optional[str] = None):
-        def operation():
-            tracer = trace.get_tracer("crewai.telemetry")
-            span = tracer.start_span("Remove Crew")
-            if uuid:
-                self._add_attribute(span, "uuid", uuid)
-            span.set_status(Status(StatusCode.OK))
-            span.end()
-
-        self._safe_telemetry_operation(operation)
-
-    def crew_execution_span(self, crew: Crew, inputs: dict[str, Any] | None):
-        """Records the complete execution of a crew.
-        This is only collected if the user has opted-in to share the crew.
-        """
-        self.crew_creation(crew, inputs)
-
-        def operation():
-            tracer = trace.get_tracer("crewai.telemetry")
-            span = tracer.start_span("Crew Execution")
-            self._add_attribute(
-                span,
-                "crewai_version",
-                pkg_resources.get_distribution("crewai").version,
-            )
-            self._add_attribute(span, "crew_key", crew.key)
-            self._add_attribute(span, "crew_id", str(crew.id))
-            self._add_attribute(
-                span, "crew_inputs", json.dumps(inputs) if inputs else None
-            )
-            self._add_attribute(
-                span,
-                "crew_agents",
-                json.dumps(
-                    [
-                        {
-                            "key": agent.key,
-                            "id": str(agent.id),
-                            "role": agent.role,
-                            "goal": agent.goal,
-                            "backstory": agent.backstory,
-                            "verbose?": agent.verbose,
-                            "max_iter": agent.max_iter,
-                            "max_rpm": agent.max_rpm,
-                            "i18n": agent.i18n.prompt_file,
-                            "llm": agent.llm.model,
-                            "delegation_enabled?": agent.allow_delegation,
-                            "tools_names": [
-                                tool.name.casefold() for tool in agent.tools or []
-                            ],
-                        }
-                        for agent in crew.agents
-                    ]
-                ),
-            )
-            self._add_attribute(
-                span,
-                "crew_tasks",
-                json.dumps(
-                    [
-                        {
-                            "id": str(task.id),
-                            "description": task.description,
-                            "expected_output": task.expected_output,
-                            "async_execution?": task.async_execution,
-                            "human_input?": task.human_input,
-                            "agent_role": task.agent.role if task.agent else "None",
-                            "agent_key": task.agent.key if task.agent else None,
-                            "context": (
-                                [task.description for task in task.context]
-                                if task.context
-                                else None
-                            ),
-                            "tools_names": [
-                                tool.name.casefold() for tool in task.tools or []
-                            ],
-                        }
-                        for task in crew.tasks
-                    ]
-                ),
-            )
-            return span
-
-        if crew.share_crew:
-            return self._safe_telemetry_operation(operation)
-        return None
-
-    def end_crew(self, crew, final_string_output):
-        def operation():
-            self._add_attribute(
-                crew._execution_span,
-                "crewai_version",
-                pkg_resources.get_distribution("crewai").version,
-            )
-            self._add_attribute(
-                crew._execution_span, "crew_output", final_string_output
-            )
-            self._add_attribute(
-                crew._execution_span,
-                "crew_tasks_output",
-                json.dumps(
-                    [
-                        {
-                            "id": str(task.id),
-                            "description": task.description,
-                            "output": task.output.raw_output,
-                        }
-                        for task in crew.tasks
-                    ]
-                ),
-            )
-            crew._execution_span.set_status(Status(StatusCode.OK))
-            crew._execution_span.end()
-
-        if crew.share_crew:
-            self._safe_telemetry_operation(operation)
+                crew._execution_span.set_status(Status(StatusCode.OK))
+                crew._execution_span.end()
+            except Exception:
+                pass
 
     def _add_attribute(self, span, key, value):
         """Add an attribute to a span."""
-
-        def operation():
+        try:
             return span.set_attribute(key, value)
-
-        self._safe_telemetry_operation(operation)
+        except Exception:
+            pass
 
     def flow_creation_span(self, flow_name: str):
-        def operation():
-            tracer = trace.get_tracer("crewai.telemetry")
-            span = tracer.start_span("Flow Creation")
-            self._add_attribute(span, "flow_name", flow_name)
-            span.set_status(Status(StatusCode.OK))
-            span.end()
-
-        self._safe_telemetry_operation(operation)
+        if self.ready:
+            try:
+                tracer = trace.get_tracer("crewai.telemetry")
+                span = tracer.start_span("Flow Creation")
+                self._add_attribute(span, "flow_name", flow_name)
+                span.set_status(Status(StatusCode.OK))
+                span.end()
+            except Exception:
+                pass
 
     def flow_plotting_span(self, flow_name: str, node_names: list[str]):
-        def operation():
-            tracer = trace.get_tracer("crewai.telemetry")
-            span = tracer.start_span("Flow Plotting")
-            self._add_attribute(span, "flow_name", flow_name)
-            self._add_attribute(span, "node_names", json.dumps(node_names))
-            span.set_status(Status(StatusCode.OK))
-            span.end()
-
-        self._safe_telemetry_operation(operation)
+        if self.ready:
+            try:
+                tracer = trace.get_tracer("crewai.telemetry")
+                span = tracer.start_span("Flow Plotting")
+                self._add_attribute(span, "flow_name", flow_name)
+                self._add_attribute(span, "node_names", json.dumps(node_names))
+                span.set_status(Status(StatusCode.OK))
+                span.end()
+            except Exception:
+                pass
 
     def flow_execution_span(self, flow_name: str, node_names: list[str]):
-        def operation():
-            tracer = trace.get_tracer("crewai.telemetry")
-            span = tracer.start_span("Flow Execution")
-            self._add_attribute(span, "flow_name", flow_name)
-            self._add_attribute(span, "node_names", json.dumps(node_names))
-            span.set_status(Status(StatusCode.OK))
-            span.end()
-
-        self._safe_telemetry_operation(operation)
+        if self.ready:
+            try:
+                tracer = trace.get_tracer("crewai.telemetry")
+                span = tracer.start_span("Flow Execution")
+                self._add_attribute(span, "flow_name", flow_name)
+                self._add_attribute(span, "node_names", json.dumps(node_names))
+                span.set_status(Status(StatusCode.OK))
+                span.end()
+            except Exception:
+                pass

tests/memory/short_term_memory_test.py

@@ -1,5 +1,5 @@
 import pytest
-from unittest.mock import patch
+
 from crewai.agent import Agent
 from crewai.crew import Crew
 from crewai.memory.short_term.short_term_memory import ShortTermMemory
@@ -26,6 +26,7 @@ def short_term_memory():
     return ShortTermMemory(crew=Crew(agents=[agent], tasks=[task]))
 
 
+@pytest.mark.vcr(filter_headers=["authorization"])
 def test_save_and_search(short_term_memory):
     memory = ShortTermMemoryItem(
         data="""test value test value test value test value test value test value
@@ -34,28 +35,12 @@ def test_save_and_search(short_term_memory):
         agent="test_agent",
         metadata={"task": "test_task"},
     )
+    short_term_memory.save(
+        value=memory.data,
+        metadata=memory.metadata,
+        agent=memory.agent,
+    )
 
-    with patch.object(ShortTermMemory, "save") as mock_save:
-        short_term_memory.save(
-            value=memory.data,
-            metadata=memory.metadata,
-            agent=memory.agent,
-        )
-
-        mock_save.assert_called_once_with(
-            value=memory.data,
-            metadata=memory.metadata,
-            agent=memory.agent,
-        )
-
-    expected_result = [
-        {
-            "context": memory.data,
-            "metadata": {"agent": "test_agent"},
-            "score": 0.95,
-        }
-    ]
-    with patch.object(ShortTermMemory, "search", return_value=expected_result):
-        find = short_term_memory.search("test value", score_threshold=0.01)[0]
-        assert find["context"] == memory.data, "Data value mismatch."
-        assert find["metadata"]["agent"] == "test_agent", "Agent value mismatch."
+    find = short_term_memory.search("test value", score_threshold=0.01)[0]
+    assert find["context"] == memory.data, "Data value mismatch."
+    assert find["metadata"]["agent"] == "test_agent", "Agent value mismatch."

uv.lock

@@ -627,14 +627,15 @@ wheels = [
 
 [[package]]
 name = "crewai"
-version = "0.74.0"
+version = "0.67.1"
 source = { editable = "." }
 dependencies = [
+    { name = "agentops" },
     { name = "appdirs" },
     { name = "auth0-python" },
-    { name = "chromadb" },
     { name = "click" },
     { name = "crewai-tools" },
+    { name = "embedchain" },
     { name = "instructor" },
     { name = "json-repair" },
     { name = "jsonref" },
@@ -682,13 +683,14 @@ dev = [
 
 [package.metadata]
 requires-dist = [
+    { name = "agentops", specifier = ">=0.3.0" },
     { name = "agentops", marker = "extra == 'agentops'", specifier = ">=0.3.0" },
     { name = "appdirs", specifier = ">=1.4.4" },
     { name = "auth0-python", specifier = ">=4.7.1" },
-    { name = "chromadb", specifier = ">=0.4.24" },
     { name = "click", specifier = ">=8.1.7" },
-    { name = "crewai-tools", specifier = ">=0.13.1" },
+    { name = "crewai-tools", specifier = ">=0.12.1" },
     { name = "crewai-tools", marker = "extra == 'tools'", specifier = ">=0.12.1" },
+    { name = "embedchain", specifier = ">=0.1.114" },
     { name = "instructor", specifier = ">=1.3.3" },
     { name = "json-repair", specifier = ">=0.25.2" },
     { name = "jsonref", specifier = ">=1.1.0" },
@@ -728,7 +730,7 @@ dev = [
 
 [[package]]
 name = "crewai-tools"
-version = "0.13.1"
+version = "0.12.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "beautifulsoup4" },
@@ -746,9 +748,9 @@ dependencies = [
     { name = "requests" },
     { name = "selenium" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/d5/81/b8a0bb984aea2af49b0072e074c87c75a6c4581902b81f3a3d46f95f01c7/crewai_tools-0.13.1.tar.gz", hash = "sha256:363c7ec717f4c6f9b61cec9314a5ec2fbd026d75e8e6278f49f715ed5915cd4d", size = 816254 }
+sdist = { url = "https://files.pythonhosted.org/packages/11/60/1860127d927939f9143cab9af059cfbe6f160839b6ba1d652a9ed4e04fa6/crewai_tools-0.12.1.tar.gz", hash = "sha256:22fa3ea57936913faed77a2a64c131371f78b2ced207e63dcc71220eac445698", size = 420190 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/09/8a/04c885da3e01d1f11478dd866d3506906bfb60d7587627dd4b132ff10f64/crewai_tools-0.13.1-py3-none-any.whl", hash = "sha256:62067e2502bf66c0ae2e3a833c60b900bd1f793a9a80895a1f10a9cfa1b5dc3c", size = 463444 },
+    { url = "https://files.pythonhosted.org/packages/23/e6/cc9acbc6ee828898956b18036643fc2150b6c1b976ab34f29b9cadc085b5/crewai_tools-0.12.1-py3-none-any.whl", hash = "sha256:e87d393dd1900834a224686644e025eb44e74171f317c4ff2df778aff6ade4b8", size = 463435 },
 ]
 
 [[package]]
@@ -919,7 +921,7 @@ wheels = [
 
 [[package]]
 name = "embedchain"
-version = "0.1.123"
+version = "0.1.122"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "alembic" },
@@ -932,7 +934,6 @@ dependencies = [
     { name = "langchain-cohere" },
     { name = "langchain-community" },
     { name = "langchain-openai" },
-    { name = "langsmith" },
     { name = "mem0ai" },
     { name = "openai" },
     { name = "posthog" },
@@ -944,9 +945,9 @@ dependencies = [
     { name = "sqlalchemy" },
     { name = "tiktoken" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/5d/6a/955b5a72fa6727db203c4d46ae0e30ac47f4f50389f663cd5ea157b0d819/embedchain-0.1.123.tar.gz", hash = "sha256:aecaf81c21de05b5cdb649b6cde95ef68ffa759c69c54f6ff2eaa667f2ad0580", size = 124797 }
+sdist = { url = "https://files.pythonhosted.org/packages/25/9b/fa14dc95f8736c672bcebd677f48990670f1a9fac8ea1631222b8b820d69/embedchain-0.1.122.tar.gz", hash = "sha256:ea0a4d00a4a1909e0d662dc499fa6a0da119783ec4773df1271da74da3e8296b", size = 124799 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a7/51/0c78d26da4afbe68370306669556b274f1021cac02f3155d8da2be407763/embedchain-0.1.123-py3-none-any.whl", hash = "sha256:1210e993b6364d7c702b6bd44b053fc244dd77f2a65ea4b90b62709114ea6c25", size = 210909 },
+    { url = "https://files.pythonhosted.org/packages/95/3f/42c97c1d3c9483076843987982a018115b6a28be02091fb475e6dbc743f2/embedchain-0.1.122-py3-none-any.whl", hash = "sha256:c137be81d0949b5ee16c689837d659837980cfabbb38643c2720cd1a794d8d27", size = 210911 },
 ]
 
 [[package]]
@@ -1550,7 +1551,7 @@ wheels = [
 
 [[package]]
 name = "httpx"
-version = "0.27.0"
+version = "0.27.2"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "anyio" },
@@ -1559,9 +1560,9 @@ dependencies = [
     { name = "idna" },
     { name = "sniffio" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/5c/2d/3da5bdf4408b8b2800061c339f240c1802f2e82d55e50bd39c5a881f47f0/httpx-0.27.0.tar.gz", hash = "sha256:a0cb88a46f32dc874e04ee956e4c2764aba2aa228f650b06788ba6bda2962ab5", size = 126413 }
+sdist = { url = "https://files.pythonhosted.org/packages/78/82/08f8c936781f67d9e6b9eeb8a0c8b4e406136ea4c3d1f89a5db71d42e0e6/httpx-0.27.2.tar.gz", hash = "sha256:f7c2be1d2f3c3c3160d441802406b206c2b76f5947b11115e6df10c6c65e66c2", size = 144189 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/41/7b/ddacf6dcebb42466abd03f368782142baa82e08fc0c1f8eaa05b4bae87d5/httpx-0.27.0-py3-none-any.whl", hash = "sha256:71d5465162c13681bff01ad59b2cc68dd838ea1f10e51574bac27103f00c91a5", size = 75590 },
+    { url = "https://files.pythonhosted.org/packages/56/95/9377bcb415797e44274b51d46e3249eba641711cf3348050f76ee7b15ffc/httpx-0.27.2-py3-none-any.whl", hash = "sha256:7bb2708e112d8fdd7829cd4243970f0c223274051cb35ee80c03301ee29a3df0", size = 76395 },
 ]
 
 [package.optional-dependencies]
@@ -1907,7 +1908,7 @@ wheels = [
 
 [[package]]
 name = "langchain"
-version = "0.3.3"
+version = "0.2.16"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "aiohttp" },
@@ -1922,31 +1923,30 @@ dependencies = [
     { name = "sqlalchemy" },
     { name = "tenacity" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/70/b2/258c6a33b5e5f817a57ecd22b1e74756f7246ac66f39d0cf6d2ef515fcb7/langchain-0.3.3.tar.gz", hash = "sha256:6435882996a029a60c61c356bbe51bab4a8f43a54210f5f03e3c4474d19d1842", size = 416891 }
+sdist = { url = "https://files.pythonhosted.org/packages/fd/53/8ebf21de8d17e7e0f0998f28d689f60d7ed420acb7ab2fba59ca04e80e54/langchain-0.2.16.tar.gz", hash = "sha256:ffb426a76a703b73ac69abad77cd16eaf03dda76b42cff55572f592d74944166", size = 414668 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/92/82/c17abaa44074ec716409305da4783f633b0eb9b09bb28ed5005220269bdb/langchain-0.3.3-py3-none-any.whl", hash = "sha256:05ac98c674853c2386d043172820e37ceac9b913aaaf1e51217f0fc424112c72", size = 1005176 },
+    { url = "https://files.pythonhosted.org/packages/0d/29/635343c0d155997569b544d26da5a2a9ebade2423baffc9cd6066b01a386/langchain-0.2.16-py3-none-any.whl", hash = "sha256:8f59ee8b45f268df4b924ea3b9c63e49286efa756d16b3f6a9de5c6e502c36e1", size = 1001195 },
 ]
 
 [[package]]
 name = "langchain-cohere"
-version = "0.3.1"
+version = "0.1.9"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "cohere" },
     { name = "langchain-core" },
     { name = "langchain-experimental" },
     { name = "pandas" },
-    { name = "pydantic" },
     { name = "tabulate" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/ae/ea/53fd2515e353cac4ddd6d7a41dbb0651dfc9ffb0924acb7a1aa7a722f29b/langchain_cohere-0.3.1.tar.gz", hash = "sha256:990bd4db68e229371c90eee98a1a78b4f4d33a32c22c8da6c2cd30b5044de9eb", size = 36739 }
+sdist = { url = "https://files.pythonhosted.org/packages/a4/a9/30462b68f8c15da886078fe5c96fab3085241168ea03d968eee1182e00a9/langchain_cohere-0.1.9.tar.gz", hash = "sha256:549620d23bc3d77f62d1045787095fe2c1cfa233dba69455139f9a2f65f952fa", size = 29987 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/64/5e/bbfb1b33703a973e7eef6582b523ae932e7e64c9b84ac7eecaa8af71475e/langchain_cohere-0.3.1-py3-none-any.whl", hash = "sha256:adf37542feb293562791b8dd1691580b0dcb2117fb987f2684f694912465f554", size = 43992 },
+    { url = "https://files.pythonhosted.org/packages/52/b1/ee8d44898cfe43703f05a0ffd95294d3ebe4c61879f19c6357c860131312/langchain_cohere-0.1.9-py3-none-any.whl", hash = "sha256:96d6a15125797319474ac84b54024e5024f3f5fc45032ebf228d95d6998c9b13", size = 35218 },
 ]
 
 [[package]]
 name = "langchain-community"
-version = "0.3.2"
+version = "0.2.17"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "aiohttp" },
@@ -1955,20 +1955,19 @@ dependencies = [
     { name = "langchain-core" },
     { name = "langsmith" },
     { name = "numpy" },
-    { name = "pydantic-settings" },
     { name = "pyyaml" },
     { name = "requests" },
     { name = "sqlalchemy" },
     { name = "tenacity" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/86/6e/119bbbd4d55ab14dc6fc4a82a2466b88f7ddb989bdbdfcf96327c5daba4e/langchain_community-0.3.2.tar.gz", hash = "sha256:469bf5357a08c915cebc4c506dca4617eec737d82a9b6e340df5f3b814dc89bc", size = 1608524 }
+sdist = { url = "https://files.pythonhosted.org/packages/1f/54/be928e3962d24b40c31899f5c5ed99b0c7ef7c3bb7601eb2fe7a6ce75dc4/langchain_community-0.2.17.tar.gz", hash = "sha256:b0745c1fcf1bd532ed4388f90b47139d6a6c6ba48a87aa68aa32d4d6bb97259d", size = 1589425 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/cc/57/a8b4826eaa29d3663c957251ab32275a0c178bdb0e262a1204ed820f430c/langchain_community-0.3.2-py3-none-any.whl", hash = "sha256:fffcd484c7674e81ceaa72a809962338bfb17ec8f9e0377ce4e9d884e6fe8ca5", size = 2367818 },
+    { url = "https://files.pythonhosted.org/packages/ac/33/c6ee472412f751062311075bb391a7870ab57cdb8da5d47f359895b2d3c2/langchain_community-0.2.17-py3-none-any.whl", hash = "sha256:d07c31b641e425fb8c3e7148ad6a62e1b54a9adac6e1173021a7dd3148266063", size = 2339964 },
 ]
 
 [[package]]
 name = "langchain-core"
-version = "0.3.12"
+version = "0.2.41"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "jsonpatch" },
@@ -1979,48 +1978,48 @@ dependencies = [
     { name = "tenacity" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/7b/15/76ec101e550e7e16de85e64fcb4ff2d281cb70cfe65c95ee6e56182a5f51/langchain_core-0.3.12.tar.gz", hash = "sha256:98a3c078e375786aa84939bfd1111263af2f3bc402bbe2cac9fa18a387459cf2", size = 327019 }
+sdist = { url = "https://files.pythonhosted.org/packages/2a/92/2ad97f0c23b5ee5043df1a93d97edd4404136003e7d22b641de081738408/langchain_core-0.2.41.tar.gz", hash = "sha256:bc12032c5a298d85be754ccb129bc13ea21ccb1d6e22f8d7ba18b8da64315bb5", size = 316952 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/ce/4a/a6499d93805c3e6316e641b6934e23c98c011d00b9a2138835d567e976e5/langchain_core-0.3.12-py3-none-any.whl", hash = "sha256:46050d34f5fa36dc57dca971c6a26f505643dd05ee0492c7ac286d0a78a82037", size = 407737 },
+    { url = "https://files.pythonhosted.org/packages/bc/02/2b2cf9550cee1a7ffa42fe60c55e2d0e7d397535609b42562611fb40e78d/langchain_core-0.2.41-py3-none-any.whl", hash = "sha256:3278fda5ba9a05defae8bb19f1226032add6aab21917db7b3bc74e750e263e84", size = 397013 },
 ]
 
 [[package]]
 name = "langchain-experimental"
-version = "0.3.2"
+version = "0.0.65"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "langchain-community" },
     { name = "langchain-core" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/bf/41/84d3eac564261aaab45bc02bdc43b5e49242439c6f2844a24b81404a17cd/langchain_experimental-0.3.2.tar.gz", hash = "sha256:d41cc28c46f58616d18a1230595929f80a58d1982c4053dc3afe7f1c03f22426", size = 139583 }
+sdist = { url = "https://files.pythonhosted.org/packages/e1/e0/d92210398a006f6e43ddd25166537f79cb3e9ccc32e316e70d349353842b/langchain_experimental-0.0.65.tar.gz", hash = "sha256:83706df07d8a7e6ec1bda74174add7e4431b5f4a8818e19b65986b94c9c99b25", size = 138516 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/63/f6/d80592aa8d335af734054f5cfe130ecd38fdfb9c4f90ba0007f0419f2fce/langchain_experimental-0.3.2-py3-none-any.whl", hash = "sha256:b6a26f2a05e056a27ad30535ed306a6b9d8cc2e3c0326d15030d11b6e7505dbb", size = 208126 },
+    { url = "https://files.pythonhosted.org/packages/97/ca/93913b7530b36869946ca8f93b161bea294ea46a367e748943a78bc3553c/langchain_experimental-0.0.65-py3-none-any.whl", hash = "sha256:2a0f268cfb8c79d43cedf9c4840f70bd8b25934e595311e6690804d0355dd7ee", size = 207160 },
 ]
 
 [[package]]
 name = "langchain-openai"
-version = "0.2.2"
+version = "0.1.25"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "langchain-core" },
     { name = "openai" },
     { name = "tiktoken" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/55/4c/0a88c51192b0aeef5212019060da7112191750ab7a185195d8b45835578c/langchain_openai-0.2.2.tar.gz", hash = "sha256:9ae8e2ec7d1ca84fd3bfa82186724528d68e1510a1dc9cdf617a7c669b7a7768", size = 42364 }
+sdist = { url = "https://files.pythonhosted.org/packages/2f/cb/98fe365f2e5eee39d0130279959a84182ab414879b666ffc2b9d69b95633/langchain_openai-0.1.25.tar.gz", hash = "sha256:eb116f744f820247a72f54313fb7c01524fba0927120d4e899e5e4ab41ad3928", size = 45224 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b0/4e/c62ce98a5412f031f7f03dda5c35b6ed474e0083986261073ca9da5554d5/langchain_openai-0.2.2-py3-none-any.whl", hash = "sha256:3a203228cb38e4711ebd8c0a3bd51854e447f1d017e8475b6467b07ce7dd3e88", size = 49687 },
+    { url = "https://files.pythonhosted.org/packages/7f/2e/a4430cad7a98e29e9612648f8b12d7449ab635a742c19bf1d62f8713ecaa/langchain_openai-0.1.25-py3-none-any.whl", hash = "sha256:f0b34a233d0d9cb8fce6006c903e57085c493c4f0e32862b99063b96eaedb109", size = 51550 },
 ]
 
 [[package]]
 name = "langchain-text-splitters"
-version = "0.3.0"
+version = "0.2.4"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "langchain-core" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/57/35/08ac1ca01c58da825f070bd1fdc9192a9ff52c0a048f74c93b05df70c127/langchain_text_splitters-0.3.0.tar.gz", hash = "sha256:f9fe0b4d244db1d6de211e7343d4abc4aa90295aa22e1f0c89e51f33c55cd7ce", size = 20234 }
+sdist = { url = "https://files.pythonhosted.org/packages/83/b3/b1ccde47c86c5fe2585dc012555cff7949c556bd6993dd9c09e49a356190/langchain_text_splitters-0.2.4.tar.gz", hash = "sha256:f7daa7a3b0aa8309ce248e2e2b6fc8115be01118d336c7f7f7dfacda0e89bf29", size = 20236 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/da/6a/d1303b722a3fa7a0a8c2f8f5307e42f0bdbded46d99cca436f3db0df5294/langchain_text_splitters-0.3.0-py3-none-any.whl", hash = "sha256:e84243e45eaff16e5b776cd9c81b6d07c55c010ebcb1965deb3d1792b7358e83", size = 25543 },
+    { url = "https://files.pythonhosted.org/packages/8f/f3/d01591229e9d0eec1e8106ed6f9b670f299beb1c94fed4aa335afa78acb0/langchain_text_splitters-0.2.4-py3-none-any.whl", hash = "sha256:2702dee5b7cbdd595ccbe43b8d38d01a34aa8583f4d6a5a68ad2305ae3e7b645", size = 25552 },
 ]
 
 [[package]]
@@ -2167,7 +2166,7 @@ wheels = [
 
 [[package]]
 name = "mem0ai"
-version = "0.1.19"
+version = "0.1.17"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "langchain-community" },
@@ -2180,9 +2179,9 @@ dependencies = [
     { name = "rank-bm25" },
     { name = "sqlalchemy" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/6e/12/23f8f250a2ce798a51841417acbbfc9c12c294d3ae427e81a0a0dbab54f6/mem0ai-0.1.19.tar.gz", hash = "sha256:faf7c198a85df2f502ac41fe2bc1593ca0383f993b431a4e4a36e0aed3fa533c", size = 51167 }
+sdist = { url = "https://files.pythonhosted.org/packages/9b/23/fc537f7125c88efeb81190b661b4e17786d039d4e00da2975ea253b45c8f/mem0ai-0.1.17.tar.gz", hash = "sha256:3b24c5904c96717c2285847f7ad98be0167421fd67b23c19771e81bef00ec2f1", size = 51167 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/7e/43/04d22bc9cac6fa19b10a405c59c21e94b8ae2a180b40307ec4a577f6ee39/mem0ai-0.1.19-py3-none-any.whl", hash = "sha256:dfff9cfe191072abd34ed8bb4fcbee2819603eed430d89611ef3181b1a46fff9", size = 73240 },
+    { url = "https://files.pythonhosted.org/packages/89/49/4fa5e5f759004e90fa9b4adbc9f224f09f09e182bf3d4dfebed69b10fe8a/mem0ai-0.1.17-py3-none-any.whl", hash = "sha256:6505bc45880c26b25edf0a17242d71939ebaab27be0ae09b77f25fd400f61b76", size = 73252 },
 ]
 
 [[package]]
@@ -2497,8 +2496,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/b2/07/8cbb75d6cfbe8712d8f7f6a5615f083c6e710ab916b748fbb20373ddb142/multiprocess-0.70.17-py311-none-any.whl", hash = "sha256:2884701445d0177aec5bd5f6ee0df296773e4fb65b11903b94c613fb46cfb7d1", size = 144346 },
     { url = "https://files.pythonhosted.org/packages/a4/69/d3f343a61a2f86ef10ed7865a26beda7c71554136ce187b0384b1c2c9ca3/multiprocess-0.70.17-py312-none-any.whl", hash = "sha256:2818af14c52446b9617d1b0755fa70ca2f77c28b25ed97bdaa2c69a22c47b46c", size = 147990 },
     { url = "https://files.pythonhosted.org/packages/c8/b7/2e9a4fcd871b81e1f2a812cd5c6fb52ad1e8da7bf0d7646c55eaae220484/multiprocess-0.70.17-py313-none-any.whl", hash = "sha256:20c28ca19079a6c879258103a6d60b94d4ffe2d9da07dda93fb1c8bc6243f522", size = 149843 },
-    { url = "https://files.pythonhosted.org/packages/ae/d7/fd7a092fc0ab1845a1a97ca88e61b9b7cc2e9d6fcf0ed24e9480590c2336/multiprocess-0.70.17-py38-none-any.whl", hash = "sha256:1d52f068357acd1e5bbc670b273ef8f81d57863235d9fbf9314751886e141968", size = 132635 },
-    { url = "https://files.pythonhosted.org/packages/f9/41/0618ac724b8a56254962c143759e04fa01c73b37aa69dd433f16643bd38b/multiprocess-0.70.17-py39-none-any.whl", hash = "sha256:c3feb874ba574fbccfb335980020c1ac631fbf2a3f7bee4e2042ede62558a021", size = 133359 },
 ]
 
 [[package]]
@@ -3182,6 +3179,8 @@ version = "5.9.8"
 source = { registry = "https://pypi.org/simple" }
 sdist = { url = "https://files.pythonhosted.org/packages/90/c7/6dc0a455d111f68ee43f27793971cf03fe29b6ef972042549db29eec39a2/psutil-5.9.8.tar.gz", hash = "sha256:6be126e3225486dff286a8fb9a06246a5253f4c7c53b475ea5f5ac934e64194c", size = 503247 }
 wheels = [
+    { url = "https://files.pythonhosted.org/packages/fe/5f/c26deb822fd3daf8fde4bdb658bf87d9ab1ffd3fca483816e89a9a9a9084/psutil-5.9.8-cp27-none-win32.whl", hash = "sha256:36f435891adb138ed3c9e58c6af3e2e6ca9ac2f365efe1f9cfef2794e6c93b4e", size = 248660 },
+    { url = "https://files.pythonhosted.org/packages/32/1d/cf66073d74d6146187e2d0081a7616df4437214afa294ee4f16f80a2f96a/psutil-5.9.8-cp27-none-win_amd64.whl", hash = "sha256:bd1184ceb3f87651a67b2708d4c3338e9b10c5df903f2e3776b62303b26cb631", size = 251966 },
     { url = "https://files.pythonhosted.org/packages/e7/e3/07ae864a636d70a8a6f58da27cb1179192f1140d5d1da10886ade9405797/psutil-5.9.8-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:aee678c8720623dc456fa20659af736241f575d79429a0e5e9cf88ae0605cc81", size = 248702 },
     { url = "https://files.pythonhosted.org/packages/b3/bd/28c5f553667116b2598b9cc55908ec435cb7f77a34f2bff3e3ca765b0f78/psutil-5.9.8-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8cb6403ce6d8e047495a701dc7c5bd788add903f8986d523e3e20b98b733e421", size = 285242 },
     { url = "https://files.pythonhosted.org/packages/c5/4f/0e22aaa246f96d6ac87fe5ebb9c5a693fbe8877f537a1022527c47ca43c5/psutil-5.9.8-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d06016f7f8625a1825ba3732081d77c94589dca78b7a3fc072194851e88461a4", size = 288191 },
@@ -3388,19 +3387,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/a9/f9/b6bcaf874f410564a78908739c80861a171788ef4d4f76f5009656672dfe/pydantic_core-2.23.4-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:9a5bce9d23aac8f0cf0836ecfc033896aa8443b501c58d0602dbfd5bd5b37753", size = 1920344 },
 ]
 
-[[package]]
-name = "pydantic-settings"
-version = "2.6.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "pydantic" },
-    { name = "python-dotenv" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/6c/66/5f1a9da10675bfb3b9da52f5b689c77e0a5612263fcce510cfac3e99a168/pydantic_settings-2.6.0.tar.gz", hash = "sha256:44a1804abffac9e6a30372bb45f6cafab945ef5af25e66b1c634c01dd39e0188", size = 75232 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/34/19/26bb6bdb9fdad5f0dfce538780814084fb667b4bc37fcb28459c14b8d3b5/pydantic_settings-2.6.0-py3-none-any.whl", hash = "sha256:4a819166f119b74d7f8c765196b165f95cc7487ce58ea27dec8a5a26be0970e0", size = 28578 },
-]
-
 [[package]]
 name = "pygments"
 version = "2.18.0"
@@ -3450,14 +3436,14 @@ wheels = [
 
 [[package]]
 name = "pypdf"
-version = "5.0.1"
+version = "4.3.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "typing-extensions", marker = "python_full_version < '3.11'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/9d/28/6bc2ca8a521512f2904e6aa3028af43a864fe2b66c77ea01bbbc97f52b98/pypdf-5.0.1.tar.gz", hash = "sha256:a361c3c372b4a659f9c8dd438d5ce29a753c79c620dc6e1fd66977651f5547ea", size = 4999113 }
+sdist = { url = "https://files.pythonhosted.org/packages/f0/65/2ed7c9e1d31d860f096061b3dd2d665f501e09faaa0409a3f0d719d2a16d/pypdf-4.3.1.tar.gz", hash = "sha256:b2f37fe9a3030aa97ca86067a56ba3f9d3565f9a791b305c7355d8392c30d91b", size = 293266 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/48/8f/9bbf22ba6a00001a45dbc54337e5bbbd43e7d8f34c8158c92cddc45736af/pypdf-5.0.1-py3-none-any.whl", hash = "sha256:ff8a32da6c7a63fea9c32fa4dd837cdd0db7966adf6c14f043e3f12592e992db", size = 294470 },
+    { url = "https://files.pythonhosted.org/packages/3c/60/eccdd92dd4af3e4bea6d6a342f7588c618a15b9bec4b968af581e498bcc4/pypdf-4.3.1-py3-none-any.whl", hash = "sha256:64b31da97eda0771ef22edb1bfecd5deee4b72c3d1736b7df2689805076d6418", size = 295825 },
 ]
 
 [[package]]