cognee/tasks/chunks/chunk_by_paragraph.py (2)

21-29: 🛠️ Refactor suggestion

Fix inverted description of batch_paragraphs parameter
The text reads:
“batch_paragraphs (bool): Flag indicating whether to yield each paragraph as a separate chunk. If set to False, individual paragraphs are yielded as they are processed.”
This is contradictory. Consider updating to:

• When batch_paragraphs=True (default), paragraphs are batched into chunks up to max_chunk_size.
• When batch_paragraphs=False, each paragraph is yielded immediately upon encountering a paragraph boundary.

🤖 Prompt for AI Agents

In cognee/tasks/chunks/chunk_by_paragraph.py around lines 21 to 29, the
description of the batch_paragraphs parameter is inverted and contradictory.
Update the docstring to clarify that when batch_paragraphs is True (default),
paragraphs are batched into chunks up to max_chunk_size, and when False, each
paragraph is yielded immediately upon encountering a paragraph boundary.

---

13-19: 🛠️ Refactor suggestion

Clarify batch_paragraphs behavior in docstring summary
The current summary suggests that batch_paragraphs=True yields each paragraph separately, but in the implementation it’s actually batch_paragraphs=False that triggers per-paragraph yields. This mismatch can confuse users.

🤖 Prompt for AI Agents

In cognee/tasks/chunks/chunk_by_paragraph.py around lines 13 to 19, the
docstring summary incorrectly describes the behavior of the batch_paragraphs
flag, stating that batch_paragraphs=True yields each paragraph separately, while
the code actually yields paragraphs separately when batch_paragraphs=False.
Update the docstring summary to accurately reflect that per-paragraph yields
occur when batch_paragraphs is False to avoid user confusion.

cognee/infrastructure/llm/prompts/cot_validation_system_prompt.txt (1)

1-1: ⚠️ Potential issue

Fix grammatical error in prompt text.

The static analysis correctly identified a subject-verb disagreement. "Agent" is singular, so it should be "who is allowed" rather than "who are allowed".

-You are a helpful agent who are allowed to use only the provided question answer and context.
+You are a helpful agent who is allowed to use only the provided question answer and context.

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

You are a helpful agent who is allowed to use only the provided question answer and context.

🧰 Tools

🪛 LanguageTool

[uncategorized] ~1-~1: This verb does not appear to agree with the subject. Consider using a different form.
Context: You are a helpful agent who are allowed to use only the provided questi...

(AI_EN_LECTOR_REPLACEMENT_VERB_AGREEMENT)

🤖 Prompt for AI Agents

In cognee/infrastructure/llm/prompts/cot_validation_system_prompt.txt at line 1,
fix the grammatical error by changing "who are allowed" to "who is allowed" to
ensure subject-verb agreement with the singular subject "agent".

cognee/tests/unit/modules/search/search_methods_test.py (1)

6-6: ⚠️ Potential issue

Remove incorrect import from pylint.checkers.utils.

This import appears to be incorrect and unused. The test is checking node_type=None and node_name=None parameters in the assertion, but these are unrelated to pylint's node_type utility.

-from pylint.checkers.utils import node_type

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

🧰 Tools

🪛 Ruff (0.11.9)

6-6: pylint.checkers.utils.node_type imported but unused

Remove unused import: pylint.checkers.utils.node_type

(F401)

🪛 Pylint (3.3.7)

[warning] 6-6: Unused node_type imported from pylint.checkers.utils

(W0611)

🤖 Prompt for AI Agents

In cognee/tests/unit/modules/search/search_methods_test.py at line 6, remove the
import statement "from pylint.checkers.utils import node_type" because it is
incorrect and unused in the test file. This import is unrelated to the test
logic and should be deleted to clean up the code.

cognee/infrastructure/files/add_file_to_storage.py (1)

7-22: 💡 Verification agent

🧩 Analysis chain

Review async function declaration - no await operations performed.

The function is declared as async but doesn't use await for any operations. The storage_manager.store() call appears to be synchronous. Consider whether this function should be async or if the storage operations should be awaited.

---

🏁 Script executed:

#!/bin/bash
# Check if storage_manager.store is supposed to be async
ast-grep --pattern 'class StorageManager {
  $$$
  store($_, $_) {
    $$$
  }
  $$$
}'

Length of output: 89

---

🏁 Script executed:

#!/bin/bash
# Locate StorageManager class definition to inspect its store method
rg -n "class StorageManager" -A 20

# Search for any async store implementations
rg -n "async def store" -A 10

Length of output: 2617

---

Convert add_file_to_storage to a synchronous function or await the blocking call

Since StorageManager.store() is a synchronous method, your async def add_file_to_storage neither awaits anything nor yields control. You should either:

• Change it to a regular function:

  --- a/cognee/infrastructure/files/add_file_to_storage.py
  +++ b/cognee/infrastructure/files/add_file_to_storage.py
  @@
  -async def add_file_to_storage(file_path: str, file: BinaryIO):
  +def add_file_to_storage(file_path: str, file: BinaryIO):
      """
      Store a file in local storage.
      …
      """
      storage_manager = StorageManager(LocalStorage(get_absolute_path("data/files")))
  
      storage_manager.store(file_path, file)

• Or, if you need it to remain async, offload the blocking call:

  --- a/cognee/infrastructure/files/add_file_to_storage.py
  +++ b/cognee/infrastructure/files/add_file_to_storage.py
  @@ async def add_file_to_storage(file_path: str, file: BinaryIO):
  -   storage_manager.store(file_path, file)
  +   await asyncio.to_thread(storage_manager.store, file_path, file)

Please update the signature and call style accordingly.

Committable suggestion skipped: line range outside the PR's diff.

🤖 Prompt for AI Agents

In cognee/infrastructure/files/add_file_to_storage.py around lines 7 to 22, the
function add_file_to_storage is declared async but calls a synchronous method
storage_manager.store without awaiting. To fix this, either change the function
to a regular synchronous function by removing async from its definition or, if
it must remain async, run the blocking store call in an executor to avoid
blocking the event loop. Update the function signature and call accordingly
based on the chosen approach.

cognee/api/v1/config/config.py (1)

158-158: ⚠️ Potential issue

Fix inconsistent error handling across methods.

This change creates inconsistency within the class. Other similar methods (lines 91-93, 130-132, 144-146, 170-172) use InvalidAttributeError with the message= parameter, while this method now uses the built-in AttributeError without the message= parameter.

For consistency, either revert this change to match other methods:

-                raise AttributeError(f"'{key}' is not a valid attribute of the config.")
+                raise InvalidAttributeError(
+                    message=f"'{key}' is not a valid attribute of the config."
+                )

Or update all methods to use the same error handling pattern consistently.

🤖 Prompt for AI Agents

In cognee/api/v1/config/config.py at line 158, the error raised uses the
built-in AttributeError instead of the custom InvalidAttributeError with a
message= parameter as used in other methods (lines 91-93, 130-132, 144-146,
170-172). To fix this inconsistency, replace the AttributeError with
InvalidAttributeError and pass the error message using the message= parameter to
align with the existing error handling pattern in the class.

cognee/infrastructure/databases/vector/use_vector_adapter.py (1)

4-5: 🛠️ Refactor suggestion

Add comprehensive documentation and improve robustness.

This function lacks documentation despite the PR's focus on documentation improvements. Additionally, consider adding input validation and addressing potential thread safety issues.

Apply these improvements:

+def use_vector_adapter(vector_db_name: str, vector_db_adapter) -> None:
+    """
+    Register or update a vector database adapter in the global registry.
+    
+    This function allows dynamic registration of vector database adapters by
+    updating the global supported_databases dictionary. This enables
+    extensibility for supporting new vector database implementations.
+    
+    Parameters:
+    -----------
+    vector_db_name : str
+        The name identifier for the vector database adapter
+    vector_db_adapter : object
+        The adapter class or instance for the vector database
+        
+    Note:
+    -----
+    This function modifies global state and may not be thread-safe.
+    Consider synchronization if used in multi-threaded environments.
+    """
+    if not isinstance(vector_db_name, str) or not vector_db_name.strip():
+        raise ValueError("vector_db_name must be a non-empty string")
+    if vector_db_adapter is None:
+        raise ValueError("vector_db_adapter cannot be None")
+        
-def use_vector_adapter(vector_db_name, vector_db_adapter):
     supported_databases[vector_db_name] = vector_db_adapter

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

def use_vector_adapter(vector_db_name: str, vector_db_adapter) -> None:
    """
    Register or update a vector database adapter in the global registry.
    
    This function allows dynamic registration of vector database adapters by
    updating the global supported_databases dictionary. This enables
    extensibility for supporting new vector database implementations.
    
    Parameters:
    -----------
    vector_db_name : str
        The name identifier for the vector database adapter
    vector_db_adapter : object
        The adapter class or instance for the vector database
        
    Note:
    -----
    This function modifies global state and may not be thread-safe.
    Consider synchronization if used in multi-threaded environments.
    """
    if not isinstance(vector_db_name, str) or not vector_db_name.strip():
        raise ValueError("vector_db_name must be a non-empty string")
    if vector_db_adapter is None:
        raise ValueError("vector_db_adapter cannot be None")
    
    supported_databases[vector_db_name] = vector_db_adapter

🤖 Prompt for AI Agents

In cognee/infrastructure/databases/vector/use_vector_adapter.py at lines 4 to 5,
add a clear docstring to the use_vector_adapter function explaining its purpose,
parameters, and behavior. Implement input validation to ensure vector_db_name
and vector_db_adapter are of expected types and not None. To address thread
safety, protect the update to supported_databases with appropriate
synchronization, such as using a threading.Lock, to prevent race conditions in
concurrent environments.

cognee/tasks/summarization/summarize_text.py (1)

37-39: ⚠️ Potential issue

Type mismatch on empty input
Returning data_chunks (a list of DocumentChunk) when data_chunks is empty conflicts with the declared return type (List[TextSummary]). To maintain type consistency, change this to:

-    if len(data_chunks) == 0:
-        return data_chunks
+    if not data_chunks:
+        return []

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

    if not data_chunks:
        return []

🤖 Prompt for AI Agents

In cognee/tasks/summarization/summarize_text.py around lines 37 to 39, the
function returns data_chunks (a list of DocumentChunk) when it is empty, which
conflicts with the declared return type List[TextSummary]. To fix this, return
an empty list of TextSummary instead of data_chunks when data_chunks is empty to
maintain type consistency.

cognee/infrastructure/engine/utils/parse_id.py (1)

4-4: 🛠️ Refactor suggestion

Refactor parameter name and type hint
Using id shadows the built-in function. Rename the parameter (e.g., identifier) and update the type hint to Any (capital “A”, imported from typing):

-def parse_id(id: any):
+from typing import Any
+def parse_id(identifier: Any) -> Any:

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

-from cognee.infrastructure.engine.utils.parse_id.py
+from typing import Any

-def parse_id(id: any):
+def parse_id(identifier: Any) -> Any:

🧰 Tools

🪛 Pylint (3.3.7)

[warning] 4-4: Redefining built-in 'id'

(W0622)

🤖 Prompt for AI Agents

In cognee/infrastructure/engine/utils/parse_id.py at line 4, rename the function
parameter from `id` to `identifier` to avoid shadowing the built-in function.
Also, update the type hint from `any` to `Any` with a capital "A" and ensure
`Any` is imported from the `typing` module.

cognee/infrastructure/databases/graph/use_graph_adapter.py (1)

4-5: 🛠️ Refactor suggestion

Add type hints, documentation, and input validation.

The function lacks type hints, documentation, and input validation. Consider these improvements:

+from typing import Any
+
+def use_graph_adapter(vector_db_name: str, vector_db_adapter: Any) -> None:
+    """
+    Register or update a graph database adapter for a given vector database name.
+    
+    Parameters:
+    -----------
+    vector_db_name : str
+        The name of the vector database to associate with the adapter.
+    vector_db_adapter : Any
+        The graph adapter instance to register.
+    """
+    if not isinstance(vector_db_name, str) or not vector_db_name.strip():
+        raise ValueError("vector_db_name must be a non-empty string")
+    
-def use_graph_adapter(vector_db_name, vector_db_adapter):
     supported_databases[vector_db_name] = vector_db_adapter

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

from typing import Any

def use_graph_adapter(vector_db_name: str, vector_db_adapter: Any) -> None:
    """
    Register or update a graph database adapter for a given vector database name.
    
    Parameters:
    -----------
    vector_db_name : str
        The name of the vector database to associate with the adapter.
    vector_db_adapter : Any
        The graph adapter instance to register.
    """
    if not isinstance(vector_db_name, str) or not vector_db_name.strip():
        raise ValueError("vector_db_name must be a non-empty string")
    
    supported_databases[vector_db_name] = vector_db_adapter

🤖 Prompt for AI Agents

In cognee/infrastructure/databases/graph/use_graph_adapter.py at lines 4 to 5,
the function use_graph_adapter lacks type hints, a docstring, and input
validation. Add appropriate type hints for the parameters and return type, write
a concise docstring explaining the function's purpose and parameters, and
include input validation to check that vector_db_name is a string and
vector_db_adapter is of the expected type before adding them to
supported_databases.

cognee/tasks/ingestion/get_dlt_destination.py (1)

11-26: ⚠️ Potential issue

Return type annotation mismatch
The signature -> Union[type[dlt.destinations.sqlalchemy], None] suggests returning a class, but the code returns an instance of dlt.destinations.sqlalchemy (or None). Update it to something like -> Optional[dlt.destinations.sqlalchemy] (or the appropriate DLT destination type) and adjust the docstring Returns section accordingly.

🤖 Prompt for AI Agents

In cognee/tasks/ingestion/get_dlt_destination.py around lines 11 to 26, the
return type annotation currently indicates returning a class type or None, but
the function actually returns an instance of dlt.destinations.sqlalchemy or
None. Change the return type annotation to Optional[dlt.destinations.sqlalchemy]
(or the correct instance type) and update the Returns section in the docstring
to reflect that an instance is returned, not a class.

cognee-mcp/entrypoint.sh (1)

17-29: 💡 Verification agent

🧩 Analysis chain

Improved migration handling with better error management

The changes enhance the migration process by:

• Capturing both output and exit code for better error analysis
• Adding specific handling for expected "UserAlreadyExists" errors
• Providing clear success confirmation messages

The logic correctly distinguishes between expected user existence errors and actual migration failures.

However, please verify that the alembic command is available in the container environment since uv run was removed:

---

🏁 Script executed:

#!/bin/bash
# Check if alembic is available in the Docker image or deployment environment
# Look for Dockerfile or requirements that install alembic
fd -t f "Dockerfile|requirements|pyproject.toml|poetry.lock" | xargs grep -l "alembic"

Length of output: 146

---

🏁 Script executed:

#!/bin/bash
for f in Dockerfile cognee-mcp/Dockerfile deployment/helm/Dockerfile; do
  echo "=== $f ==="
  grep -n -C3 "alembic" "$f" || echo "No alembic references here"
done

Length of output: 1533

---

🏁 Script executed:

#!/bin/bash
# Display the section of the root Dockerfile around the dependency installation to verify how alembic is installed
grep -n -C5 "uv sync" Dockerfile || echo "uv sync not found"

Length of output: 1226

---

🏁 Script executed:

#!/bin/bash
# Verify that alembic is declared as a project dependency
grep -n "alembic" pyproject.toml || echo "alembic not found in pyproject.toml"

Length of output: 161

---

🏁 Script executed:

#!/bin/bash
# Check if alembic is declared in the lockfile to ensure it's installed via uv sync
fd -t f uv.lock | xargs grep -n "alembic" || echo "alembic not declared in uv.lock"

Length of output: 114

---

Missing Alembic installation in your dependency layers

The new entrypoint invokes alembic directly, but our scans did not find it being installed:

• All three Dockerfiles copy alembic.ini and the alembic/ folder…
• …yet no alembic entry appears in your uv.lock.
• A grep for “alembic” in the root pyproject.toml (and any requirements*.txt) turned up empty.

Please declare alembic as a direct dependency (e.g. in pyproject.toml or your requirements file) so that your uv sync layers install the CLI. Once added, rebuild the image and confirm which alembic returns the expected path before running the migration step.

🤖 Prompt for AI Agents

In cognee-mcp/entrypoint.sh around lines 17 to 29, the script calls the alembic
command but alembic is not installed or declared as a dependency in the project
files or Docker images. To fix this, add alembic as a direct dependency in your
pyproject.toml or requirements file so it gets installed during the build
process. Then rebuild the Docker image and verify alembic is available by
running which alembic before executing the migration step in the entrypoint
script.

cognee/shared/logging_utils.py (1)

7-12: ⚠️ Potential issue

Fix import ordering and remove unused import.

The import organization doesn't follow PEP8 conventions, and importlib.metadata appears to be unused in this file.

Apply this diff to fix the import issues:

-import platform
 from datetime import datetime
 from pathlib import Path
-import importlib.metadata
-
+import platform
+
 from cognee import __version__ as cognee_version

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

from datetime import datetime
from pathlib import Path
import platform

from cognee import __version__ as cognee_version

🧰 Tools

🪛 Ruff (0.11.9)

10-10: importlib.metadata imported but unused

Remove unused import: importlib.metadata

(F401)

🪛 Pylint (3.3.7)

[convention] 7-7: standard import "platform" should be placed before third party import "structlog"

(C0411)

---

[convention] 8-8: standard import "datetime.datetime" should be placed before third party import "structlog"

(C0411)

---

[convention] 9-9: standard import "pathlib.Path" should be placed before third party import "structlog"

(C0411)

---

[convention] 10-10: standard import "importlib.metadata" should be placed before third party import "structlog"

(C0411)

---

[warning] 10-10: Unused import importlib.metadata

(W0611)

🤖 Prompt for AI Agents

In cognee/shared/logging_utils.py around lines 7 to 12, the imports are not
ordered according to PEP8 standards and the importlib.metadata module is unused.
Reorder the imports to group standard library imports first (platform, datetime,
pathlib), followed by third-party or local imports, and remove the unused
importlib.metadata line entirely.

cognee/eval_framework/answer_generation/answer_generation_executor.py (1)

15-15: 🛠️ Refactor suggestion

Reconsider weakening type annotation from BaseRetriever to Any.

Changing the type annotation from Dict[str, BaseRetriever] to Dict[str, Any] removes valuable type safety. If the new retriever classes inherit from BaseRetriever, this change may not be necessary.

If the new retrievers inherit from BaseRetriever, consider reverting this change:

-retriever_options: Dict[str, Any] = {
+retriever_options: Dict[str, BaseRetriever] = {

If they don't inherit from BaseRetriever, consider creating a union type or common base interface instead of using Any.

🤖 Prompt for AI Agents

In cognee/eval_framework/answer_generation/answer_generation_executor.py at line
15, the type annotation for retriever_options was changed from Dict[str,
BaseRetriever] to Dict[str, Any], which reduces type safety. To fix this, revert
the annotation back to Dict[str, BaseRetriever] if all retriever classes inherit
from BaseRetriever. If not, define a union type or a common base interface for
the retriever classes and use that in the annotation instead of Any.

cognee/infrastructure/databases/vector/create_vector_engine.py (1)

42-49: ⚠️ Potential issue

Fix critical typo in parameter name.

There's a typo on line 46 where utl is used instead of url. This will cause a runtime error when the supported_databases code path is executed.

Apply this fix:

         return adapter(
-            utl=vector_db_url,
+            url=vector_db_url,
             api_key=vector_db_key,
             embedding_engine=embedding_engine,
         )

🤖 Prompt for AI Agents

In cognee/infrastructure/databases/vector/create_vector_engine.py around lines
42 to 49, the parameter name 'utl' is a typo and should be corrected to 'url' in
the adapter call. Change 'utl=vector_db_url' to 'url=vector_db_url' to fix the
runtime error caused by the incorrect parameter name.

cognee/api/v1/responses/routers/get_responses_router.py (2)

72-147: 🛠️ Refactor suggestion

Refactor to reduce complexity and improve error handling.

The function has too many local variables (18/15) and catches overly broad exceptions. Consider breaking it into smaller functions and improving error handling.

+    async def _process_function_calls(self, output: List[Dict]) -> List[ResponseToolCall]:
+        """Process function calls from OpenAI response output."""
+        processed_tool_calls = []
+        
+        for item in output:
+            if isinstance(item, dict) and item.get("type") == "function_call":
+                processed_call = await self._execute_single_function_call(item)
+                processed_tool_calls.append(processed_call)
+        
+        return processed_tool_calls
+    
+    async def _execute_single_function_call(self, item: Dict) -> ResponseToolCall:
+        """Execute a single function call and return the result."""
+        function_name = item.get("name", "")
+        arguments_str = item.get("arguments", "{}")
+        call_id = item.get("call_id", f"call_{uuid.uuid4().hex}")
+        
+        tool_call = {
+            "id": call_id,
+            "function": {"name": function_name, "arguments": arguments_str},
+            "type": "function",
+        }
+        
+        try:
+            function_result = await dispatch_function(tool_call)
+            output_status = "success"
+        except (ValueError, KeyError) as e:
+            logger.error("Invalid function call %s: %s", function_name, e)
+            function_result = f"Invalid function call {function_name}: {str(e)}"
+            output_status = "error"
+        except Exception as e:
+            logger.exception("Unexpected error executing function %s: %s", function_name, e)
+            function_result = f"Unexpected error executing {function_name}: {str(e)}"
+            output_status = "error"
+        
+        return ResponseToolCall(
+            id=call_id,
+            type="function",
+            function=FunctionCall(name=function_name, arguments=arguments_str),
+            output=ToolCallOutput(status=output_status, data={"result": function_result}),
+        )

Committable suggestion skipped: line range outside the PR's diff.

🧰 Tools

🪛 Ruff (0.11.9)

74-74: Do not perform function call Depends in argument defaults; instead, perform the call within the function, or read the default from a module-level singleton variable

(B008)

🪛 Pylint (3.3.7)

[refactor] 72-72: Too many local variables (18/15)

(R0914)

---

[warning] 118-118: Catching too general exception Exception

(W0718)

---

[warning] 119-119: Use lazy % formatting in logging functions

(W1203)

---

[warning] 74-74: Unused argument 'user'

(W0613)

🤖 Prompt for AI Agents

In cognee/api/v1/responses/routers/get_responses_router.py around lines 72 to
147, the create_response function is too complex with many local variables and
uses a broad exception catch. Refactor by extracting the function call
processing loop into a separate async helper function that handles dispatching
and error catching more specifically. This will reduce local variables in
create_response and isolate error handling to the helper, improving readability
and maintainability.

---

43-49: ⚠️ Potential issue

Fix dangerous default argument.

Using a mutable default argument (DEFAULT_TOOLS) can lead to shared state between function calls, which may cause unexpected behavior.

-async def call_openai_api_for_model(
-    input_text: str,
-    model: str,
-    tools: Optional[List[Dict[str, Any]]] = DEFAULT_TOOLS,
-    tool_choice: Any = "auto",
-    temperature: float = 1.0,
-) -> Dict[str, Any]:
+async def call_openai_api_for_model(
+    input_text: str,
+    model: str,
+    tools: Optional[List[Dict[str, Any]]] = None,
+    tool_choice: Any = "auto",
+    temperature: float = 1.0,
+) -> Dict[str, Any]:

Then update the function body to handle the None case:

+    if tools is None:
+        tools = DEFAULT_TOOLS

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

    async def call_openai_api_for_model(
        input_text: str,
        model: str,
        tools: Optional[List[Dict[str, Any]]] = None,
        tool_choice: Any = "auto",
        temperature: float = 1.0,
    ) -> Dict[str, Any]:
        if tools is None:
            tools = DEFAULT_TOOLS
        # ... rest of function body ...

🧰 Tools

🪛 Pylint (3.3.7)

[warning] 43-43: Dangerous default value DEFAULT_TOOLS (builtins.list) as argument

(W0102)

🤖 Prompt for AI Agents

In cognee/api/v1/responses/routers/get_responses_router.py around lines 43 to
49, the function call_openai_api_for_model uses a mutable default argument
DEFAULT_TOOLS for the parameter tools, which can cause shared state issues
across calls. Change the default value of tools to None, then inside the
function check if tools is None and if so, assign it to DEFAULT_TOOLS. This
prevents unintended side effects from mutable default arguments.

notebooks/cognee_openai_compatable_demo.ipynb (1)

16-16: 🛠️ Refactor suggestion

Replace hardcoded API key with environment variable for security.

The notebook uses a hardcoded API key "COGNEE_API_KEY" which poses a security risk if this code is shared or committed to version control.

Consider this improvement:

-client = OpenAI(api_key="COGNEE_API_KEY", base_url="http://localhost:8000/api/v1/")
+import os
+client = OpenAI(api_key=os.getenv("COGNEE_API_KEY"), base_url="http://localhost:8000/api/v1/")

Alternatively, add a clear comment that users should replace this with their actual API key.

Also applies to: 57-57

🤖 Prompt for AI Agents

In notebooks/cognee_openai_compatable_demo.ipynb at lines 16 and 57, replace the
hardcoded API key string "COGNEE_API_KEY" with code that reads the API key from
an environment variable to avoid exposing sensitive information. Use a method to
fetch the environment variable securely, such as os.getenv, and add a comment
instructing users to set their API key in the environment before running the
notebook.

cognee/infrastructure/llm/tokenizer/Gemini/adapter.py (1)

48-59: 🛠️ Refactor suggestion

Address parameter name inconsistency with interface.

The interface defines decode_single_token(self, token: int) but this implementation uses encoding: int. While other implementations also vary, it's better to match the interface definition for consistency.

-    def decode_single_token(self, encoding: int):
+    def decode_single_token(self, token: int):
        """
        Raise NotImplementedError when called, as Gemini tokenizer does not support decoding of
        tokens.

        Parameters:
        -----------

-            - encoding (int): The token encoding to decode.
+            - token (int): The token to decode.
        """

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

    def decode_single_token(self, token: int):
        """
        Raise NotImplementedError when called, as Gemini tokenizer does not support decoding of
        tokens.

        Parameters:
        -----------

            - token (int): The token to decode.
        """
        # Gemini tokenizer doesn't have the option to decode tokens
        raise NotImplementedError

🧰 Tools

🪛 Pylint (3.3.7)

[warning] 48-48: Parameter 'token' has been renamed to 'encoding' in overriding 'GeminiTokenizer.decode_single_token' method

(W0237)

🤖 Prompt for AI Agents

In cognee/infrastructure/llm/tokenizer/Gemini/adapter.py around lines 48 to 59,
the method decode_single_token uses the parameter name encoding instead of token
as defined in the interface. Rename the parameter from encoding to token to
ensure consistency with the interface definition.

cognee/infrastructure/engine/models/DataPoint.py (2)

159-176: 🛠️ Refactor suggestion

Fix classmethod signature to use cls instead of self
Per Pylint convention, classmethods should have cls as the first parameter. Please apply:

- @classmethod
- def from_json(self, json_str: str):
+ @classmethod
+ def from_json(cls, json_str: str):

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

    @classmethod
    def from_json(cls, json_str: str):
        """
        Deserialize a DataPoint instance from a JSON string.

        The method transforms the input JSON string back into a DataPoint instance using model
        validation.

        Parameters:
        -----------

            - json_str (str): The JSON string representation of a DataPoint instance to be
              deserialized.

        Returns:
        --------

            A new DataPoint instance created from the JSON data.
        """

🧰 Tools

🪛 Pylint (3.3.7)

[convention] 159-159: Class method from_json should have 'cls' as first argument

(C0202)

🤖 Prompt for AI Agents

In cognee/infrastructure/engine/models/DataPoint.py around lines 159 to 176, the
from_json method is defined as a classmethod but incorrectly uses 'self' as the
first parameter. Change the first parameter from 'self' to 'cls' to follow the
proper classmethod convention.

---

195-212: 🛠️ Refactor suggestion

Fix classmethod signature for from_pickle to use cls
Align with the Pylint convention by renaming self to cls:

- @classmethod
- def from_pickle(self, pickled_data: bytes):
+ @classmethod
+ def from_pickle(cls, pickled_data: bytes):

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

    @classmethod
    def from_pickle(cls, pickled_data: bytes):
        """
        Deserialize a DataPoint instance from a pickled byte stream.

        The method converts the byte stream back into a DataPoint instance by loading the data
        and validating it through the model's constructor.

        Parameters:
        -----------

            - pickled_data (bytes): The bytes representation of a pickled DataPoint instance to
              be deserialized.

        Returns:
        --------

            A new DataPoint instance created from the pickled data.
        """

🧰 Tools

🪛 Pylint (3.3.7)

[convention] 195-195: Class method from_pickle should have 'cls' as first argument

(C0202)

🤖 Prompt for AI Agents

In cognee/infrastructure/engine/models/DataPoint.py around lines 195 to 212, the
from_pickle method is defined as an instance method using self, but it should be
a classmethod using cls to properly create a new instance. Change the method
signature to use cls instead of self and add the @classmethod decorator above
the method definition to follow Pylint conventions and correct usage.

cognee/infrastructure/databases/exceptions/exceptions.py (1)

69-86: ⚠️ Potential issue

Fix constructor inconsistency in new exception class.

The new NodesetFilterNotSupportedError class has the same constructor pattern issue as EntityNotFoundError - it doesn't call the parent class constructor, missing out on the automatic logging and proper initialization provided by CogneeApiError.

Apply this fix for consistency:

def __init__(
    self,
    message: str = "The nodeset filter is not supported in the current graph database.",
    name: str = "NodeSetFilterNotSupportedError",
    status_code=status.HTTP_404_NOT_FOUND,
):
-    self.message = message
-    self.name = name
-    self.status_code = status_code
+    super().__init__(message, name, status_code)

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

class NodesetFilterNotSupportedError(CogneeApiError):
    """
    Raise an exception when a nodeset filter is not supported by the current database.

    This exception inherits from `CogneeApiError` and is designed to provide information
    about the specific issue of unsupported nodeset filters in the context of graph
    databases.
    """

    def __init__(
        self,
        message: str = "The nodeset filter is not supported in the current graph database.",
        name: str = "NodeSetFilterNotSupportedError",
        status_code=status.HTTP_404_NOT_FOUND,
    ):
        super().__init__(message, name, status_code)

🧰 Tools

🪛 Pylint (3.3.7)

[warning] 78-78: init method from base class 'CogneeApiError' is not called

(W0231)

🤖 Prompt for AI Agents

In cognee/infrastructure/databases/exceptions/exceptions.py around lines 69 to
86, the constructor of NodesetFilterNotSupportedError does not call the parent
CogneeApiError constructor, causing missed initialization and logging. Fix this
by adding a call to super().__init__ with the message, name, and status_code
parameters inside the constructor to ensure proper inheritance behavior.

cognee/infrastructure/databases/graph/memgraph/memgraph_adapter.py (1)

750-750: ⚠️ Potential issue

Fix dangerous default mutable argument.

Using a mutable default argument (dict()) can lead to shared state between function calls, which is a common Python gotcha.

Apply this diff to fix the issue:

-    def serialize_properties(self, properties=dict()):
+    def serialize_properties(self, properties=None):
+        if properties is None:
+            properties = {}

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

    def serialize_properties(self, properties=None):
        if properties is None:
            properties = {}

🧰 Tools

🪛 Ruff (0.11.9)

750-750: Do not use mutable data structures for argument defaults

Replace with None; initialize within function

(B006)

🪛 Pylint (3.3.7)

[warning] 750-750: Dangerous default value dict() (builtins.dict) as argument

(W0102)

---

[refactor] 750-750: Consider using '{}' instead of a call to 'dict'.

(R1735)

🤖 Prompt for AI Agents

In cognee/infrastructure/databases/graph/memgraph/memgraph_adapter.py at line
750, the method serialize_properties uses a mutable default argument (dict()),
which can cause shared state issues across calls. Change the default argument to
None and inside the method, initialize properties to an empty dictionary if it
is None. This prevents unintended side effects from mutable default arguments.

cognee/eval_framework/modal_eval_dashboard.py (1)

35-41: 🛠️ Refactor suggestion

Use context manager for subprocess execution.

The current implementation uses subprocess.Popen without proper resource management. Consider using subprocess.run or a context manager approach.

-    cmd = (
-        "streamlit run /root/serve_dashboard.py "
-        "--server.port 8000 "
-        "--server.enableCORS=false "
-        "--server.enableXsrfProtection=false"
-    )
-    subprocess.Popen(cmd, shell=True)
+    cmd = [
+        "streamlit", "run", "/root/serve_dashboard.py",
+        "--server.port", "8000",
+        "--server.enableCORS=false",
+        "--server.enableXsrfProtection=false"
+    ]
+    subprocess.run(cmd, check=True)

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

    cmd = [
        "streamlit", "run", "/root/serve_dashboard.py",
        "--server.port", "8000",
        "--server.enableCORS=false",
        "--server.enableXsrfProtection=false"
    ]
    subprocess.run(cmd, check=True)

🧰 Tools

🪛 Pylint (3.3.7)

[refactor] 41-41: Consider using 'with' for resource-allocating operations

(R1732)

🤖 Prompt for AI Agents

In cognee/eval_framework/modal_eval_dashboard.py around lines 35 to 41, the
subprocess.Popen call is used without proper resource management. Replace
subprocess.Popen with subprocess.run inside a context manager or use
subprocess.run directly to ensure the subprocess resources are properly managed
and cleaned up after execution. Adjust the code to handle the command execution
synchronously if appropriate, or manage the process lifecycle correctly.

cognee/modules/retrieval/graph_completion_cot_retriever.py (1)

96-117: 🛠️ Refactor suggestion

Repeated prompt-file I/O inside the loop affects latency

read_query_prompt/render_prompt are executed in every iteration although the template files are immutable.
Caching them outside the loop (or at class level) will reduce disk I/O and JSON parsing overhead in long-running sessions.

-        for round_idx in range(max_iter + 1):
-            ...
-            valid_user_prompt = render_prompt(...)
-            valid_system_prompt = read_query_prompt(...)
+        validation_system_prompt = read_query_prompt(self.validation_system_prompt_path)
+        followup_system_prompt  = read_query_prompt(self.followup_system_prompt_path)
+
+        for round_idx in range(max_iter + 1):
+            ...
+            valid_user_prompt = render_prompt(..., context=valid_args)

Committable suggestion skipped: line range outside the PR's diff.

🤖 Prompt for AI Agents

In cognee/modules/retrieval/graph_completion_cot_retriever.py around lines 96 to
117, the code reads prompt files and renders prompts inside a loop, causing
repeated disk I/O and parsing overhead. To fix this, move the calls to
read_query_prompt for system prompts and render_prompt for user prompts outside
the loop, caching their results either as class-level attributes or local
variables before the loop starts, then reuse these cached prompts inside the
loop to avoid redundant file reads and rendering.

cognee/eval_framework/modal_run_eval.py (2)

80-83: 🛠️ Refactor suggestion

Specify encoding and use os.path.join when writing answers file

Missing encoding parameter raises Pylint W1514 and can break on non-UTF-8 systems; string concatenation bypasses os.path utilities.

-    with open("/data/" + answers_filename, "w") as f:
+    answers_path = os.path.join("/data", answers_filename)
+    with open(answers_path, "w", encoding="utf-8") as f:

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

    answers_path = os.path.join("/data", answers_filename)
    with open(answers_path, "w", encoding="utf-8") as f:
        json.dump(answers, f, ensure_ascii=False, indent=4)
    vol.commit()

🧰 Tools

🪛 Pylint (3.3.7)

[warning] 80-80: Using open without explicitly specifying an encoding

(W1514)

🤖 Prompt for AI Agents

In cognee/eval_framework/modal_run_eval.py around lines 80 to 83, the file open
call for writing the answers file lacks an explicit encoding parameter and uses
string concatenation for the file path. Fix this by specifying encoding='utf-8'
in the open function and replace the string concatenation with os.path.join to
construct the file path properly and avoid cross-platform issues.

---

84-96: ⚠️ Potential issue

html_output may be undefined – guard file writing block

html_output is set only when eval_params["dashboard"] is truthy, yet always written afterwards.
If dashboards are disabled, this raises UnboundLocalError.

-    with open("/data/" + html_filename, "w") as f:
-        f.write(html_output)
-    vol.commit()
+    if eval_params.get("dashboard"):
+        html_path = os.path.join("/data", html_filename)
+        with open(html_path, "w", encoding="utf-8") as f:
+            f.write(html_output)
+        vol.commit()

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

    if eval_params.get("dashboard"):
        logger.info("Generating dashboard...")
        html_output = create_dashboard(
            metrics_path=eval_params["metrics_path"],
            aggregate_metrics_path=eval_params["aggregate_metrics_path"],
            output_file=eval_params["dashboard_path"],
            benchmark=eval_params["benchmark"],
        )
+       html_path = os.path.join("/data", html_filename)
+       with open(html_path, "w", encoding="utf-8") as f:
+           f.write(html_output)
+       vol.commit()

🧰 Tools

🪛 Pylint (3.3.7)

[warning] 93-93: Using open without explicitly specifying an encoding

(W1514)

---

[error] 94-94: Possibly using variable 'html_output' before assignment

(E0606)

🤖 Prompt for AI Agents

In cognee/eval_framework/modal_run_eval.py around lines 84 to 96, the variable
html_output is assigned only if eval_params["dashboard"] is true, but the code
attempts to write html_output to a file unconditionally, which can cause an
UnboundLocalError if the dashboard is disabled. To fix this, wrap the file
writing block and vol.commit() call inside the same if condition that checks
eval_params["dashboard"], ensuring html_output is defined before use.

cognee/api/v1/responses/dispatch_function.py (1)

19-45: 🛠️ Refactor suggestion

Improve error handling and code structure.

Several issues need attention:

1. JSON parsing without error handling - Line 31 could raise json.JSONDecodeError
2. Unnecessary elif structure - Lines 37-44 can be simplified
3. Logging format - Line 33 should use lazy formatting

-    arguments = json.loads(arguments_str)
+    try:
+        arguments = json.loads(arguments_str)
+    except json.JSONDecodeError as e:
+        logger.error("Failed to parse function arguments: %s", str(e))
+        return f"Error: Invalid JSON in function arguments: {arguments_str}"

-    logger.info(f"Dispatching function: {function_name} with args: {arguments}")
+    logger.info("Dispatching function: %s with args: %s", function_name, arguments)

     user = await get_default_user()

     if function_name == "search":
         return await handle_search(arguments, user)
-    elif function_name == "cognify":
+    if function_name == "cognify":
         return await handle_cognify(arguments, user)
-    elif function_name == "prune":
+    if function_name == "prune":
         return await handle_prune(arguments, user)
-    else:
-        return f"Error: Unknown function {function_name}"
+    
+    return f"Error: Unknown function {function_name}"

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

async def dispatch_function(tool_call: Union[ToolCall, Dict[str, Any]]) -> str:
    """
    Dispatches a function call to the appropriate Cognee function.
    """
    if isinstance(tool_call, dict):
        function_data = tool_call.get("function", {})
        function_name = function_data.get("name", "")
        arguments_str = function_data.get("arguments", "{}")
    else:
        function_name = tool_call.function.name
        arguments_str = tool_call.function.arguments

    try:
        arguments = json.loads(arguments_str)
    except json.JSONDecodeError as e:
        logger.error("Failed to parse function arguments: %s", str(e))
        return f"Error: Invalid JSON in function arguments: {arguments_str}"

    logger.info("Dispatching function: %s with args: %s", function_name, arguments)

    user = await get_default_user()

    if function_name == "search":
        return await handle_search(arguments, user)
    if function_name == "cognify":
        return await handle_cognify(arguments, user)
    if function_name == "prune":
        return await handle_prune(arguments, user)

    return f"Error: Unknown function {function_name}"

🧰 Tools

🪛 Pylint (3.3.7)

[warning] 33-33: Use lazy % formatting in logging functions

(W1203)

---

[refactor] 37-44: Unnecessary "elif" after "return", remove the leading "el" from "elif"

(R1705)

🤖 Prompt for AI Agents

In cognee/api/v1/responses/dispatch_function.py around lines 19 to 45, improve
error handling by wrapping the json.loads call on line 31 in a try-except block
to catch json.JSONDecodeError and handle it gracefully. Simplify the function
dispatch logic by replacing the elif chain with a dictionary mapping function
names to handler functions and calling the appropriate handler or returning an
error if not found. Update the logger.info call on line 33 to use lazy
formatting by passing the message and arguments separately instead of using
f-string interpolation.

cognee-mcp/src/server.py (1)

78-78: 💡 Verification agent

🧩 Analysis chain

Verify parameter name consistency.

The parameter name nodeset="developer_rules" may be inconsistent with the API. Based on the relevant code snippets, the cognee.add() function expects a node_set parameter.

---

🏁 Script executed:

#!/bin/bash
# Check the actual parameter name expected by cognee.add()
ast-grep --pattern 'async def add($$$, node_set: $_, $$$)'

Length of output: 60

---

🏁 Script executed:

#!/bin/bash
# Locate all definitions of the `add` method to confirm its signature
rg -n "async def add" -C 3

# Search for usages of `node_set` and `nodeset` in the codebase
rg -n "node_set" -C 2
rg -n "nodeset" -C 2

Length of output: 41427

---

Incorrect keyword argument in cognee.add call
The public cognee.add() API expects node_set, not nodeset. Update the call in cognee-mcp/src/server.py:

• File: cognee-mcp/src/server.py
Line 78

-               await cognee.add(file_path, nodeset="developer_rules")
+               await cognee.add(file_path, node_set="developer_rules")

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

                await cognee.add(file_path, node_set="developer_rules")

🤖 Prompt for AI Agents

In cognee-mcp/src/server.py at line 78, the call to cognee.add() uses the
incorrect keyword argument nodeset. Change the parameter name from nodeset to
node_set to match the expected API signature of the add() method.

cognee/infrastructure/databases/vector/chromadb/ChromaDBAdapter.py (1)

536-536: ⚠️ Potential issue

Fix missing method call.

The prune method calls self.list_collections() but this method is not defined in the ChromaDBAdapter class. This will cause an AttributeError at runtime.

-        collections = await self.list_collections()
+        collections = await self.get_collection_names()

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

        collections = await self.get_collection_names()

🧰 Tools

🪛 Pylint (3.3.7)

[error] 536-536: Instance of 'ChromaDBAdapter' has no 'list_collections' member

(E1101)

🤖 Prompt for AI Agents

In cognee/infrastructure/databases/vector/chromadb/ChromaDBAdapter.py at line
536, the prune method calls self.list_collections(), but this method is not
defined in the ChromaDBAdapter class. To fix this, define the list_collections
method within the class to return the appropriate collection list or import it
if it exists elsewhere, ensuring the method is accessible and correctly
implemented to avoid runtime AttributeError.

cognee/infrastructure/databases/graph/neo4j_driver/adapter.py (2)

620-620: ⚠️ Potential issue

Fix method name typo.

The method calls get_neighbours but the actual method is named get_neighbors. This will cause a runtime error.

-    return await self.get_neighbours(node_id)
+    return await self.get_neighbors(node_id)

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

        return await self.get_neighbors(node_id)

🧰 Tools

🪛 Pylint (3.3.7)

[error] 620-620: Instance of 'Neo4jAdapter' has no 'get_neighbours' member; maybe 'get_neighbors'?

(E1101)

🤖 Prompt for AI Agents

In cognee/infrastructure/databases/graph/neo4j_driver/adapter.py at line 620,
the method call uses the incorrect name get_neighbours instead of the correct
get_neighbors. Rename the method call to get_neighbors to match the actual
method name and prevent runtime errors.

---

778-778: ⚠️ Potential issue

Fix dangerous default mutable argument.

Using dict() as a default argument is dangerous because it creates a shared mutable object across function calls.

-def serialize_properties(self, properties=dict()):
+def serialize_properties(self, properties=None):

And update the method body:

+    if properties is None:
+        properties = {}
     serialized_properties = {}

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

    def serialize_properties(self, properties=None):
        if properties is None:
            properties = {}
        serialized_properties = {}
        # … rest of method …

🧰 Tools

🪛 Ruff (0.11.9)

778-778: Do not use mutable data structures for argument defaults

Replace with None; initialize within function

(B006)

🪛 Pylint (3.3.7)

[warning] 778-778: Dangerous default value dict() (builtins.dict) as argument

(W0102)

---

[refactor] 778-778: Consider using '{}' instead of a call to 'dict'.

(R1735)

🤖 Prompt for AI Agents

In cognee/infrastructure/databases/graph/neo4j_driver/adapter.py at line 778,
the method serialize_properties uses a mutable default argument dict(), which
can lead to shared state across calls. Change the default argument to None and
inside the method, initialize properties to an empty dictionary if it is None.
Update the method body accordingly to handle this new initialization.

cognee/infrastructure/databases/hybrid/falkordb/FalkorDBAdapter.py (2)

384-384: ⚠️ Potential issue

Implement or Remove Stub Method
Similarly, the index_data_points method is defined but only contains a pass. Please implement the intended indexing logic or raise NotImplementedError to make it clear that this is a placeholder.

🧰 Tools

🪛 Pylint (3.3.7)

[warning] 384-384: Unnecessary pass statement

(W0107)

🤖 Prompt for AI Agents

In cognee/infrastructure/databases/hybrid/falkordb/FalkorDBAdapter.py at line
384, the method index_data_points is currently a stub with only a pass
statement. Replace the pass with either the actual indexing logic intended for
this method or raise a NotImplementedError to explicitly indicate that the
method is a placeholder and not yet implemented.

---

254-254: ⚠️ Potential issue

Implement or Remove Stub Method
The create_collection method currently contains only a pass statement, which is effectively a no-op. You should either provide the actual logic to create a collection in FalkorDB or explicitly raise NotImplementedError if it's meant to be implemented later. Leaving it as pass may lead to silent failures.

🧰 Tools

🪛 Pylint (3.3.7)

[warning] 254-254: Unnecessary pass statement

(W0107)

🤖 Prompt for AI Agents

In cognee/infrastructure/databases/hybrid/falkordb/FalkorDBAdapter.py at line
254, the create_collection method is currently a stub with only a pass
statement, which can cause silent failures. You should either implement the
actual logic to create a collection in FalkorDB or replace the pass statement
with a raise NotImplementedError to explicitly indicate that this method is not
yet implemented.