WIP: test check with prints

src/crewai/agent.py

@@ -125,7 +125,7 @@ class Agent(BaseAgent):
         default="safe",
         description="Mode for code execution: 'safe' (using Docker) or 'unsafe' (direct execution).",
     )
-    embedder_config: Optional[Dict[str, Any]] = Field(
+    embedder: Optional[Dict[str, Any]] = Field(
         default=None,
         description="Embedder configuration for the agent.",
     )
@@ -164,7 +164,7 @@ class Agent(BaseAgent):
                 ):
                     self._knowledge = Knowledge(
                         sources=self.knowledge_sources,
-                        embedder_config=self.embedder_config,
+                        embedder=self.embedder,
                         collection_name=knowledge_agent_name,
                         storage=self.knowledge_storage or None,
                     )

src/crewai/agents/agent_builder/base_agent.py

@@ -266,7 +266,7 @@ class BaseAgent(ABC, BaseModel):
             "cache_handler",
             "llm",
             "knowledge_sources",
-            "_knowledge",
+            "formatting_errors",
         }
 
         # Copy llm

src/crewai/knowledge/knowledge.py

@@ -15,20 +15,20 @@ class Knowledge(BaseModel):
     Args:
         sources: List[BaseKnowledgeSource] = Field(default_factory=list)
         storage: Optional[KnowledgeStorage] = Field(default=None)
-        embedder_config: Optional[Dict[str, Any]] = None
+        embedder: Optional[Dict[str, Any]] = None
     """
 
     sources: List[BaseKnowledgeSource] = Field(default_factory=list)
     model_config = ConfigDict(arbitrary_types_allowed=True)
     storage: Optional[KnowledgeStorage] = Field(default=None)
-    embedder_config: Optional[Dict[str, Any]] = None
+    embedder: Optional[Dict[str, Any]] = None
     collection_name: Optional[str] = None
 
     def __init__(
         self,
         collection_name: str,
         sources: List[BaseKnowledgeSource],
-        embedder_config: Optional[Dict[str, Any]] = None,
+        embedder: Optional[Dict[str, Any]] = None,
         storage: Optional[KnowledgeStorage] = None,
         **data,
     ):
@@ -37,25 +37,25 @@ class Knowledge(BaseModel):
             self.storage = storage
         else:
             self.storage = KnowledgeStorage(
-                embedder_config=embedder_config, collection_name=collection_name
+                embedder=embedder, collection_name=collection_name
             )
         self.sources = sources
         self.storage.initialize_knowledge_storage()
-        for source in sources:
-            source.storage = self.storage
-            source.add()
+        print("self.storage", self.storage)
+
+        self._add_sources()
 
     def query(self, query: List[str], limit: int = 3) -> List[Dict[str, Any]]:
         """
         Query across all knowledge sources to find the most relevant information.
         Returns the top_k most relevant chunks.
-        
+
         Raises:
             ValueError: If storage is not initialized.
         """
         if self.storage is None:
             raise ValueError("Storage is not initialized.")
-            
+
         results = self.storage.search(
             query,
             limit,
@@ -63,6 +63,11 @@ class Knowledge(BaseModel):
         return results
 
     def _add_sources(self):
-        for source in self.sources:
-            source.storage = self.storage
-            source.add()
+        try:
+            print("adding sources", self.storage)
+            for source in self.sources:
+                source.storage = self.storage
+                source.add()
+        except Exception as e:
+            print("Error adding sources", e)
+            raise e

src/crewai/knowledge/source/base_file_knowledge_source.py

@@ -29,12 +29,19 @@ class BaseFileKnowledgeSource(BaseKnowledgeSource, ABC):
     def validate_file_path(cls, v, info):
         """Validate that at least one of file_path or file_paths is provided."""
         # Single check if both are None, O(1) instead of nested conditions
-        if v is None and info.data.get("file_path" if info.field_name == "file_paths" else "file_paths") is None:
+        if (
+            v is None
+            and info.data.get(
+                "file_path" if info.field_name == "file_paths" else "file_paths"
+            )
+            is None
+        ):
             raise ValueError("Either file_path or file_paths must be provided")
         return v
 
     def model_post_init(self, _):
         """Post-initialization method to load content."""
+        print("model_post_init")
         self.safe_file_paths = self._process_file_paths()
         self.validate_content()
         self.content = self.load_content()
@@ -64,6 +71,7 @@ class BaseFileKnowledgeSource(BaseKnowledgeSource, ABC):
     def _save_documents(self):
         """Save the documents to the storage."""
         if self.storage:
+            print("saving source documents to storage")
             self.storage.save(self.chunks)
         else:
             raise ValueError("No storage found to save documents.")

src/crewai/knowledge/source/base_knowledge_source.py

@@ -46,7 +46,9 @@ class BaseKnowledgeSource(BaseModel, ABC):
         Save the documents to the storage.
         This method should be called after the chunks and embeddings are generated.
         """
+        print("saving documents", self.storage)
         if self.storage:
+            print("storage found")
             self.storage.save(self.chunks)
         else:
             raise ValueError("No storage found to save documents.")

src/crewai/knowledge/storage/knowledge_storage.py

@@ -48,11 +48,11 @@ class KnowledgeStorage(BaseKnowledgeStorage):
 
     def __init__(
         self,
-        embedder_config: Optional[Dict[str, Any]] = None,
+        embedder: Optional[Dict[str, Any]] = None,
         collection_name: Optional[str] = None,
     ):
         self.collection_name = collection_name
-        self._set_embedder_config(embedder_config)
+        self._set_embedder_config(embedder)
 
     def search(
         self,
@@ -99,8 +99,9 @@ class KnowledgeStorage(BaseKnowledgeStorage):
             )
             if self.app:
                 self.collection = self.app.get_or_create_collection(
-                    name=collection_name, embedding_function=self.embedder_config
+                    name=collection_name, embedding_function=self.embedder
                 )
+                print("db initialized", self.collection)
             else:
                 raise Exception("Vector Database Client not initialized")
         except Exception:
@@ -187,17 +188,18 @@ class KnowledgeStorage(BaseKnowledgeStorage):
             api_key=os.getenv("OPENAI_API_KEY"), model_name="text-embedding-3-small"
         )
 
-    def _set_embedder_config(
-        self, embedder_config: Optional[Dict[str, Any]] = None
-    ) -> None:
+    def _set_embedder_config(self, embedder: Optional[Dict[str, Any]] = None) -> None:
         """Set the embedding configuration for the knowledge storage.
 
         Args:
             embedder_config (Optional[Dict[str, Any]]): Configuration dictionary for the embedder.
                 If None or empty, defaults to the default embedding function.
         """
-        self.embedder_config = (
-            EmbeddingConfigurator().configure_embedder(embedder_config)
-            if embedder_config
+        print("embedder", embedder)
+        self.embedder = (
+            EmbeddingConfigurator().configure_embedder(embedder)
+            if embedder
             else self._create_default_embedding_function()
         )
+        print("self.embedder", self.embedder)
+        print("type of self.embedder", type(self.embedder))

src/crewai/utilities/embedding_configurator.py

@@ -43,7 +43,10 @@ class EmbeddingConfigurator:
             raise Exception(
                 f"Unsupported embedding provider: {provider}, supported providers: {list(self.embedding_functions.keys())}"
             )
-
+        print(
+            "self.embedding_functions[provider](config, model_name)",
+            self.embedding_functions[provider](config, model_name),
+        )
         return self.embedding_functions[provider](config, model_name)
 
     @staticmethod