cognee 0.3.4.dev4__py3-none-any.whl → 0.3.5__py3-none-any.whl

cognee/api/v1/update/update.py

@@ -0,0 +1,100 @@
+from uuid import UUID
+from typing import Union, BinaryIO, List, Optional
+
+from cognee.modules.users.models import User
+from cognee.api.v1.delete import delete
+from cognee.api.v1.add import add
+from cognee.api.v1.cognify import cognify
+
+
+async def update(
+    data_id: UUID,
+    data: Union[BinaryIO, list[BinaryIO], str, list[str]],
+    user: User = None,
+    node_set: Optional[List[str]] = None,
+    dataset_id: Optional[UUID] = None,
+    vector_db_config: dict = None,
+    graph_db_config: dict = None,
+    preferred_loaders: List[str] = None,
+    incremental_loading: bool = True,
+):
+    """
+    Update existing data in Cognee.
+
+    Supported Input Types:
+        - **Text strings**: Direct text content (str) - any string not starting with "/" or "file://"
+        - **File paths**: Local file paths as strings in these formats:
+            * Absolute paths: "/path/to/document.pdf"
+            * File URLs: "file:///path/to/document.pdf" or "file://relative/path.txt"
+            * S3 paths: "s3://bucket-name/path/to/file.pdf"
+        - **Binary file objects**: File handles/streams (BinaryIO)
+        - **Lists**: Multiple files or text strings in a single call
+
+    Supported File Formats:
+        - Text files (.txt, .md, .csv)
+        - PDFs (.pdf)
+        - Images (.png, .jpg, .jpeg) - extracted via OCR/vision models
+        - Audio files (.mp3, .wav) - transcribed to text
+        - Code files (.py, .js, .ts, etc.) - parsed for structure and content
+        - Office documents (.docx, .pptx)
+
+            Workflow:
+        1. **Data Resolution**: Resolves file paths and validates accessibility
+        2. **Content Extraction**: Extracts text content from various file formats
+        3. **Dataset Storage**: Stores processed content in the specified dataset
+        4. **Metadata Tracking**: Records file metadata, timestamps, and user permissions
+        5. **Permission Assignment**: Grants user read/write/delete/share permissions on dataset
+
+    Args:
+        data_id: UUID of existing data to update
+        data: The latest version of the data. Can be:
+            - Single text string: "Your text content here"
+            - Absolute file path: "/path/to/document.pdf"
+            - File URL: "file:///absolute/path/to/document.pdf" or "file://relative/path.txt"
+            - S3 path: "s3://my-bucket/documents/file.pdf"
+            - List of mixed types: ["text content", "/path/file.pdf", "file://doc.txt", file_handle]
+            - Binary file object: open("file.txt", "rb")
+        dataset_name: Name of the dataset to store data in. Defaults to "main_dataset".
+                    Create separate datasets to organize different knowledge domains.
+        user: User object for authentication and permissions. Uses default user if None.
+              Default user: "default_user@example.com" (created automatically on first use).
+              Users can only access datasets they have permissions for.
+        node_set: Optional list of node identifiers for graph organization and access control.
+                 Used for grouping related data points in the knowledge graph.
+        vector_db_config: Optional configuration for vector database (for custom setups).
+        graph_db_config: Optional configuration for graph database (for custom setups).
+        dataset_id: Optional specific dataset UUID to use instead of dataset_name.
+
+    Returns:
+        PipelineRunInfo: Information about the ingestion pipeline execution including:
+            - Pipeline run ID for tracking
+            - Dataset ID where data was stored
+            - Processing status and any errors
+            - Execution timestamps and metadata
+    """
+    await delete(
+        data_id=data_id,
+        dataset_id=dataset_id,
+        user=user,
+    )
+
+    await add(
+        data=data,
+        dataset_id=dataset_id,
+        user=user,
+        node_set=node_set,
+        vector_db_config=vector_db_config,
+        graph_db_config=graph_db_config,
+        preferred_loaders=preferred_loaders,
+        incremental_loading=incremental_loading,
+    )
+
+    cognify_run = await cognify(
+        datasets=[dataset_id],
+        user=user,
+        vector_db_config=vector_db_config,
+        graph_db_config=graph_db_config,
+        incremental_loading=incremental_loading,
+    )
+
+    return cognify_run

cognee/base_config.py

@@ -11,7 +11,7 @@ class BaseConfig(BaseSettings):
     data_root_directory: str = get_absolute_path(".data_storage")
     system_root_directory: str = get_absolute_path(".cognee_system")
     cache_root_directory: str = get_absolute_path(".cognee_cache")
-    monitoring_tool: object = Observer.LANGFUSE
+    monitoring_tool: object = Observer.NONE
 
     @pydantic.model_validator(mode="after")
     def validate_paths(self):
@@ -30,7 +30,10 @@ class BaseConfig(BaseSettings):
         # Require absolute paths for root directories
         self.data_root_directory = ensure_absolute_path(self.data_root_directory)
         self.system_root_directory = ensure_absolute_path(self.system_root_directory)
-        self.cache_root_directory = ensure_absolute_path(self.cache_root_directory)
+        # Set monitoring tool based on available keys
+        if self.langfuse_public_key and self.langfuse_secret_key:
+            self.monitoring_tool = Observer.LANGFUSE
+
         return self
 
     langfuse_public_key: Optional[str] = os.getenv("LANGFUSE_PUBLIC_KEY")

cognee/cli/_cognee.py

@@ -183,10 +183,20 @@ def main() -> int:
 
             for pid in spawned_pids:
                 try:
-                    pgid = os.getpgid(pid)
-                    os.killpg(pgid, signal.SIGTERM)
-                    fmt.success(f"✓ Process group {pgid} (PID {pid}) terminated.")
-                except (OSError, ProcessLookupError) as e:
+                    if hasattr(os, "killpg"):
+                        # Unix-like systems: Use process groups
+                        pgid = os.getpgid(pid)
+                        os.killpg(pgid, signal.SIGTERM)
+                        fmt.success(f"✓ Process group {pgid} (PID {pid}) terminated.")
+                    else:
+                        # Windows: Use taskkill to terminate process and its children
+                        subprocess.run(
+                            ["taskkill", "/F", "/T", "/PID", str(pid)],
+                            capture_output=True,
+                            check=False,
+                        )
+                        fmt.success(f"✓ Process {pid} and its children terminated.")
+                except (OSError, ProcessLookupError, subprocess.SubprocessError) as e:
                     fmt.warning(f"Could not terminate process {pid}: {e}")
 
             sys.exit(0)
@@ -204,19 +214,27 @@ def main() -> int:
                 nonlocal spawned_pids
                 spawned_pids.append(pid)
 
+            frontend_port = 3000
+            start_backend, backend_port = True, 8000
+            start_mcp, mcp_port = True, 8001
             server_process = start_ui(
-                host="localhost",
-                port=3000,
+                pid_callback=pid_callback,
+                port=frontend_port,
                 open_browser=True,
-                start_backend=True,
                 auto_download=True,
-                pid_callback=pid_callback,
+                start_backend=start_backend,
+                backend_port=backend_port,
+                start_mcp=start_mcp,
+                mcp_port=mcp_port,
             )
 
             if server_process:
                 fmt.success("UI server started successfully!")
-                fmt.echo("The interface is available at: http://localhost:3000")
-                fmt.echo("The API backend is available at: http://localhost:8000")
+                fmt.echo(f"The interface is available at: http://localhost:{frontend_port}")
+                if start_backend:
+                    fmt.echo(f"The API backend is available at: http://localhost:{backend_port}")
+                if start_mcp:
+                    fmt.echo(f"The MCP server is available at: http://localhost:{mcp_port}")
                 fmt.note("Press Ctrl+C to stop the server...")
 
                 try:

cognee/cli/commands/delete_command.py

@@ -6,6 +6,7 @@ from cognee.cli.reference import SupportsCliCommand
 from cognee.cli import DEFAULT_DOCS_URL
 import cognee.cli.echo as fmt
 from cognee.cli.exceptions import CliCommandException, CliCommandInnerException
+from cognee.modules.data.methods.get_deletion_counts import get_deletion_counts
 
 
 class DeleteCommand(SupportsCliCommand):
@@ -41,7 +42,34 @@ Be careful with deletion operations as they are irreversible.
                 fmt.error("Please specify what to delete: --dataset-name, --user-id, or --all")
                 return
 
-            # Build confirmation message
+            # If --force is used, skip the preview and go straight to deletion
+            if not args.force:
+                # --- START PREVIEW LOGIC ---
+                fmt.echo("Gathering data for preview...")
+                try:
+                    preview_data = asyncio.run(
+                        get_deletion_counts(
+                            dataset_name=args.dataset_name,
+                            user_id=args.user_id,
+                            all_data=args.all,
+                        )
+                    )
+                except CliCommandException as e:
+                    fmt.error(f"Error occured when fetching preview data: {str(e)}")
+                    return
+
+                if not preview_data:
+                    fmt.success("No data found to delete.")
+                    return
+
+                fmt.echo("You are about to delete:")
+                fmt.echo(
+                    f"Datasets: {preview_data.datasets}\nEntries: {preview_data.entries}\nUsers: {preview_data.users}"
+                )
+                fmt.echo("-" * 20)
+                # --- END PREVIEW LOGIC ---
+
+            # Build operation message for success/failure logging
             if args.all:
                 confirm_msg = "Delete ALL data from cognee?"
                 operation = "all data"
@@ -51,8 +79,9 @@ Be careful with deletion operations as they are irreversible.
             elif args.user_id:
                 confirm_msg = f"Delete all data for user '{args.user_id}'?"
                 operation = f"data for user '{args.user_id}'"
+            else:
+                operation = "data"
 
-            # Confirm deletion unless forced
             if not args.force:
                 fmt.warning("This operation is irreversible!")
                 if not fmt.confirm(confirm_msg):
@@ -64,6 +93,8 @@ Be careful with deletion operations as they are irreversible.
             # Run the async delete function
             async def run_delete():
                 try:
+                    # NOTE: The underlying cognee.delete() function is currently not working as expected.
+                    # This is a separate bug that this preview feature helps to expose.
                     if args.all:
                         await cognee.delete(dataset_name=None, user_id=args.user_id)
                     else:
@@ -72,6 +103,7 @@ Be careful with deletion operations as they are irreversible.
                     raise CliCommandInnerException(f"Failed to delete: {str(e)}")
 
             asyncio.run(run_delete())
+            # This success message may be inaccurate due to the underlying bug, but we leave it for now.
             fmt.success(f"Successfully deleted {operation}")
 
         except Exception as e:

cognee/eval_framework/corpus_builder/task_getters/get_default_tasks_by_indices.py

@@ -5,7 +5,7 @@ from cognee.modules.chunking.TextChunker import TextChunker
 from cognee.tasks.graph import extract_graph_from_data
 from cognee.tasks.storage import add_data_points
 from cognee.shared.data_models import KnowledgeGraph
-from cognee.modules.ontology.rdf_xml.OntologyResolver import OntologyResolver
+from cognee.modules.ontology.rdf_xml.RDFLibOntologyResolver import RDFLibOntologyResolver
 
 
 async def get_default_tasks_by_indices(
@@ -33,7 +33,7 @@ async def get_no_summary_tasks(
     # Get base tasks (0=classify, 1=check_permissions, 2=extract_chunks)
     base_tasks = await get_default_tasks_by_indices([0, 1, 2], chunk_size, chunker)
 
-    ontology_adapter = OntologyResolver(ontology_file=ontology_file_path)
+    ontology_adapter = RDFLibOntologyResolver(ontology_file=ontology_file_path)
 
     graph_task = Task(
         extract_graph_from_data,

cognee/eval_framework/evaluation/direct_llm_eval_adapter.py

@@ -3,6 +3,7 @@ from pydantic import BaseModel
 from cognee.eval_framework.evaluation.base_eval_adapter import BaseEvalAdapter
 from cognee.eval_framework.eval_config import EvalConfig
 
+from cognee.infrastructure.llm.prompts import render_prompt, read_query_prompt
 from cognee.infrastructure.llm import LLMGateway
 
 
@@ -25,8 +26,8 @@ class DirectLLMEvalAdapter(BaseEvalAdapter):
     ) -> Dict[str, Any]:
         args = {"question": question, "answer": answer, "golden_answer": golden_answer}
 
-        user_prompt = LLMGateway.render_prompt(self.eval_prompt_path, args)
-        system_prompt = LLMGateway.read_query_prompt(self.system_prompt_path)
+        user_prompt = render_prompt(self.eval_prompt_path, args)
+        system_prompt = read_query_prompt(self.system_prompt_path)
 
         evaluation = await LLMGateway.acreate_structured_output(
             text_input=user_prompt,

cognee/eval_framework/modal_eval_dashboard.py

@@ -1,6 +1,6 @@
 import os
 import json
-import pandas as pd
+
 import subprocess
 import modal
 import streamlit as st
@@ -78,6 +78,14 @@ def main():
             }
         )
 
+    try:
+        import pandas as pd
+    except ImportError:
+        st.error(
+            "Pandas is required for the evaluation dashboard. Install with 'pip install cognee\"[evals]\"' to use this feature."
+        )
+        return
+
     df = pd.DataFrame(records)
     if df.empty:
         st.warning("No JSON files found in the volume.")

cognee/infrastructure/databases/graph/config.py

@@ -50,26 +50,26 @@ class GraphConfig(BaseSettings):
     # Model validator updates graph_filename and path dynamically after class creation based on current database provider
     # If no specific graph_filename or path are provided
     @pydantic.model_validator(mode="after")
-    def fill_derived(cls, values):
-        provider = values.graph_database_provider.lower()
+    def fill_derived(self):
+        provider = self.graph_database_provider.lower()
         base_config = get_base_config()
 
         # Set default filename if no filename is provided
-        if not values.graph_filename:
-            values.graph_filename = f"cognee_graph_{provider}"
+        if not self.graph_filename:
+            self.graph_filename = f"cognee_graph_{provider}"
 
         # Handle graph file path
-        if values.graph_file_path:
+        if self.graph_file_path:
             # Check if absolute path is provided
-            values.graph_file_path = ensure_absolute_path(
-                os.path.join(values.graph_file_path, values.graph_filename)
+            self.graph_file_path = ensure_absolute_path(
+                os.path.join(self.graph_file_path, self.graph_filename)
             )
         else:
             # Default path
             databases_directory_path = os.path.join(base_config.system_root_directory, "databases")
-            values.graph_file_path = os.path.join(databases_directory_path, values.graph_filename)
+            self.graph_file_path = os.path.join(databases_directory_path, self.graph_filename)
 
-        return values
+        return self
 
     def to_dict(self) -> dict:
         """

cognee/infrastructure/databases/graph/get_graph_engine.py

@@ -44,16 +44,14 @@ def create_graph_engine(
     Parameters:
     -----------
 
-        - graph_database_provider: The type of graph database provider to use (e.g., neo4j,
-          falkordb, kuzu).
-        - graph_database_url: The URL for the graph database instance. Required for neo4j
-          and falkordb providers.
+        - graph_database_provider: The type of graph database provider to use (e.g., neo4j, falkor, kuzu).
+        - graph_database_url: The URL for the graph database instance. Required for neo4j and falkordb providers.
         - graph_database_username: The username for authentication with the graph database.
           Required for neo4j provider.
         - graph_database_password: The password for authentication with the graph database.
           Required for neo4j provider.
         - graph_database_port: The port number for the graph database connection. Required
-          for the falkordb provider.
+          for the falkordb provider
         - graph_file_path: The filesystem path to the graph file. Required for the kuzu
           provider.
 
@@ -86,21 +84,6 @@ def create_graph_engine(
             graph_database_name=graph_database_name or None,
         )
 
-    elif graph_database_provider == "falkordb":
-        if not (graph_database_url and graph_database_port):
-            raise EnvironmentError("Missing required FalkorDB credentials.")
-
-        from cognee.infrastructure.databases.vector.embeddings import get_embedding_engine
-        from cognee.infrastructure.databases.hybrid.falkordb.FalkorDBAdapter import FalkorDBAdapter
-
-        embedding_engine = get_embedding_engine()
-
-        return FalkorDBAdapter(
-            database_url=graph_database_url,
-            database_port=graph_database_port,
-            embedding_engine=embedding_engine,
-        )
-
     elif graph_database_provider == "kuzu":
         if not graph_file_path:
             raise EnvironmentError("Missing required Kuzu database path.")
@@ -179,5 +162,5 @@ def create_graph_engine(
 
     raise EnvironmentError(
         f"Unsupported graph database provider: {graph_database_provider}. "
-        f"Supported providers are: {', '.join(list(supported_databases.keys()) + ['neo4j', 'falkordb', 'kuzu', 'kuzu-remote', 'memgraph', 'neptune', 'neptune_analytics'])}"
+        f"Supported providers are: {', '.join(list(supported_databases.keys()) + ['neo4j', 'kuzu', 'kuzu-remote', 'memgraph', 'neptune', 'neptune_analytics'])}"
     )

cognee/infrastructure/databases/graph/kuzu/adapter.py

@@ -48,6 +48,29 @@ class KuzuAdapter(GraphDBInterface):
 
     def _initialize_connection(self) -> None:
         """Initialize the Kuzu database connection and schema."""
+
+        def _install_json_extension():
+            """
+            Function handles installing of the json extension for the current Kuzu version.
+            This has to be done with an empty graph db before connecting to an existing database otherwise
+            missing json extension errors will be raised.
+            """
+            try:
+                with tempfile.NamedTemporaryFile(mode="w", delete=True) as temp_file:
+                    temp_graph_file = temp_file.name
+                    tmp_db = Database(
+                        temp_graph_file,
+                        buffer_pool_size=2048 * 1024 * 1024,  # 2048MB buffer pool
+                        max_db_size=4096 * 1024 * 1024,
+                    )
+                    tmp_db.init_database()
+                    connection = Connection(tmp_db)
+                    connection.execute("INSTALL JSON;")
+            except Exception as e:
+                logger.info(f"JSON extension already installed or not needed: {e}")
+
+        _install_json_extension()
+
         try:
             if "s3://" in self.db_path:
                 with tempfile.NamedTemporaryFile(mode="w", delete=False) as temp_file:
@@ -109,11 +132,6 @@ class KuzuAdapter(GraphDBInterface):
             self.db.init_database()
             self.connection = Connection(self.db)
 
-            try:
-                self.connection.execute("INSTALL JSON;")
-            except Exception as e:
-                logger.info(f"JSON extension already installed or not needed: {e}")
-
             try:
                 self.connection.execute("LOAD EXTENSION JSON;")
                 logger.info("Loaded JSON extension")
@@ -1277,7 +1295,6 @@ class KuzuAdapter(GraphDBInterface):
             A tuple containing a list of filtered node properties and a list of filtered edge
             properties.
         """
-
         where_clauses = []
         params = {}
 
@@ -1288,16 +1305,50 @@ class KuzuAdapter(GraphDBInterface):
                 params[param_name] = values
 
         where_clause = " AND ".join(where_clauses)
-        nodes_query = f"MATCH (n:Node) WHERE {where_clause} RETURN properties(n)"
+        nodes_query = (
+            f"MATCH (n:Node) WHERE {where_clause} RETURN n.id, {{properties: n.properties}}"
+        )
         edges_query = f"""
         MATCH (n1:Node)-[r:EDGE]->(n2:Node)
         WHERE {where_clause.replace("n.", "n1.")} AND {where_clause.replace("n.", "n2.")}
-        RETURN properties(r)
+        RETURN n1.id, n2.id, r.relationship_name, r.properties
         """
         nodes, edges = await asyncio.gather(
             self.query(nodes_query, params), self.query(edges_query, params)
         )
-        return ([n[0] for n in nodes], [e[0] for e in edges])
+        formatted_nodes = []
+        for n in nodes:
+            if n[0]:
+                node_id = str(n[0])
+                props = n[1]
+                if props.get("properties"):
+                    try:
+                        additional_props = json.loads(props["properties"])
+                        props.update(additional_props)
+                        del props["properties"]
+                    except json.JSONDecodeError:
+                        logger.warning(f"Failed to parse properties JSON for node {node_id}")
+                formatted_nodes.append((node_id, props))
+        if not formatted_nodes:
+            logger.warning("No nodes found in the database")
+            return [], []
+
+        formatted_edges = []
+        for e in edges:
+            if e and len(e) >= 3:
+                source_id = str(e[0])
+                target_id = str(e[1])
+                rel_type = str(e[2])
+                props = {}
+                if len(e) > 3 and e[3]:
+                    try:
+                        props = json.loads(e[3])
+                    except (json.JSONDecodeError, TypeError):
+                        logger.warning(
+                            f"Failed to parse edge properties for {source_id}->{target_id}"
+                        )
+                formatted_edges.append((source_id, target_id, rel_type, props))
+        return formatted_nodes, formatted_edges
 
     async def get_graph_metrics(self, include_optional=False) -> Dict[str, Any]:
         """

cognee/infrastructure/databases/hybrid/neptune_analytics/NeptuneAnalyticsAdapter.py

@@ -234,7 +234,7 @@ class NeptuneAnalyticsAdapter(NeptuneGraphDB, VectorDBInterface):
         collection_name: str,
         query_text: Optional[str] = None,
         query_vector: Optional[List[float]] = None,
-        limit: int = None,
+        limit: Optional[int] = None,
         with_vector: bool = False,
     ):
         """
@@ -265,10 +265,10 @@ class NeptuneAnalyticsAdapter(NeptuneGraphDB, VectorDBInterface):
                 "Use this option only when vector data is required."
             )
 
-        # In the case of excessive limit, or zero / negative value, limit will be set to 10.
+        # In the case of excessive limit, or None / zero / negative value, limit will be set to 10.
         if not limit or limit <= self._TOPK_LOWER_BOUND or limit > self._TOPK_UPPER_BOUND:
             logger.warning(
-                "Provided limit (%s) is invalid (zero, negative, or exceeds maximum). "
+                "Provided limit (%s) is invalid (None, zero, negative, or exceeds maximum). "
                 "Defaulting to limit=10.",
                 limit,
             )

cognee/infrastructure/databases/relational/config.py

@@ -23,14 +23,14 @@ class RelationalConfig(BaseSettings):
     model_config = SettingsConfigDict(env_file=".env", extra="allow")
 
     @pydantic.model_validator(mode="after")
-    def fill_derived(cls, values):
+    def fill_derived(self):
         # Set file path based on graph database provider if no file path is provided
-        if not values.db_path:
+        if not self.db_path:
             base_config = get_base_config()
             databases_directory_path = os.path.join(base_config.system_root_directory, "databases")
-            values.db_path = databases_directory_path
+            self.db_path = databases_directory_path
 
-        return values
+        return self
 
     def to_dict(self) -> dict:
         """

cognee/infrastructure/databases/relational/create_relational_engine.py

@@ -39,8 +39,16 @@ def create_relational_engine(
         connection_string = f"sqlite+aiosqlite:///{db_path}/{db_name}"
 
     if db_provider == "postgres":
-        connection_string = (
-            f"postgresql+asyncpg://{db_username}:{db_password}@{db_host}:{db_port}/{db_name}"
-        )
+        try:
+            # Test if asyncpg is available
+            import asyncpg
+
+            connection_string = (
+                f"postgresql+asyncpg://{db_username}:{db_password}@{db_host}:{db_port}/{db_name}"
+            )
+        except ImportError:
+            raise ImportError(
+                "PostgreSQL dependencies are not installed. Please install with 'pip install cognee\"[postgres]\"' or 'pip install cognee\"[postgres-binary]\"' to use PostgreSQL functionality."
+            )
 
     return SQLAlchemyAdapter(connection_string)

cognee/infrastructure/databases/vector/chromadb/ChromaDBAdapter.py

@@ -352,7 +352,7 @@ class ChromaDBAdapter(VectorDBInterface):
         collection_name: str,
         query_text: str = None,
         query_vector: List[float] = None,
-        limit: int = 15,
+        limit: Optional[int] = 15,
         with_vector: bool = False,
         normalized: bool = True,
     ):
@@ -386,9 +386,13 @@ class ChromaDBAdapter(VectorDBInterface):
         try:
             collection = await self.get_collection(collection_name)
 
-            if limit == 0:
+            if limit is None:
                 limit = await collection.count()
 
+            # If limit is still 0, no need to do the search, just return empty results
+            if limit <= 0:
+                return []
+
             results = await collection.query(
                 query_embeddings=[query_vector],
                 include=["metadatas", "distances", "embeddings"]
@@ -428,7 +432,7 @@ class ChromaDBAdapter(VectorDBInterface):
                 for row in vector_list
             ]
         except Exception as e:
-            logger.error(f"Error in search: {str(e)}")
+            logger.warning(f"Error in search: {str(e)}")
             return []
 
     async def batch_search(

cognee/infrastructure/databases/vector/config.py

@@ -30,21 +30,21 @@ class VectorConfig(BaseSettings):
     model_config = SettingsConfigDict(env_file=".env", extra="allow")
 
     @pydantic.model_validator(mode="after")
-    def validate_paths(cls, values):
+    def validate_paths(self):
         base_config = get_base_config()
 
         # If vector_db_url is provided and is not a path skip checking if path is absolute (as it can also be a url)
-        if values.vector_db_url and Path(values.vector_db_url).exists():
+        if self.vector_db_url and Path(self.vector_db_url).exists():
             # Relative path to absolute
-            values.vector_db_url = ensure_absolute_path(
-                values.vector_db_url,
+            self.vector_db_url = ensure_absolute_path(
+                self.vector_db_url,
             )
-        elif not values.vector_db_url:
+        elif not self.vector_db_url:
             # Default path
             databases_directory_path = os.path.join(base_config.system_root_directory, "databases")
-            values.vector_db_url = os.path.join(databases_directory_path, "cognee.lancedb")
+            self.vector_db_url = os.path.join(databases_directory_path, "cognee.lancedb")
 
-        return values
+        return self
 
     def to_dict(self) -> dict:
         """