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

cognee/modules/ontology/models.py

@@ -0,0 +1,20 @@
+from typing import Any
+
+
+class AttachedOntologyNode:
+    """Lightweight wrapper to be able to parse any ontology solution and generalize cognee interface."""
+
+    def __init__(self, uri: Any, category: str):
+        self.uri = uri
+        self.name = self._extract_name(uri)
+        self.category = category
+
+    @staticmethod
+    def _extract_name(uri: Any) -> str:
+        uri_str = str(uri)
+        if "#" in uri_str:
+            return uri_str.split("#")[-1]
+        return uri_str.rstrip("/").split("/")[-1]
+
+    def __repr__(self):
+        return f"AttachedOntologyNode(name={self.name}, category={self.category})"

cognee/modules/ontology/ontology_config.py

@@ -0,0 +1,24 @@
+from typing import TypedDict, Optional
+
+from cognee.modules.ontology.base_ontology_resolver import BaseOntologyResolver
+from cognee.modules.ontology.matching_strategies import MatchingStrategy
+
+
+class OntologyConfig(TypedDict, total=False):
+    """Configuration containing ontology resolver.
+
+    Attributes:
+        ontology_resolver: The ontology resolver instance to use
+    """
+
+    ontology_resolver: Optional[BaseOntologyResolver]
+
+
+class Config(TypedDict, total=False):
+    """Top-level configuration dictionary.
+
+    Attributes:
+        ontology_config: Configuration containing ontology resolver
+    """
+
+    ontology_config: Optional[OntologyConfig]

cognee/modules/ontology/ontology_env_config.py

@@ -0,0 +1,45 @@
+"""This module contains the configuration for ontology handling."""
+
+from functools import lru_cache
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class OntologyEnvConfig(BaseSettings):
+    """
+    Represents the configuration for ontology handling, including parameters for
+    ontology file storage and resolution/matching strategies.
+
+    Public methods:
+    - to_dict
+
+    Instance variables:
+    - ontology_resolver
+    - ontology_matching
+    - ontology_file_path
+    - model_config
+    """
+
+    ontology_resolver: str = "rdflib"
+    matching_strategy: str = "fuzzy"
+    ontology_file_path: str = ""
+
+    model_config = SettingsConfigDict(env_file=".env", extra="allow", populate_by_name=True)
+
+    def to_dict(self) -> dict:
+        """
+        Return the configuration as a dictionary.
+        """
+        return {
+            "ontology_resolver": self.ontology_resolver,
+            "matching_strategy": self.matching_strategy,
+            "ontology_file_path": self.ontology_file_path,
+        }
+
+
+@lru_cache
+def get_ontology_env_config():
+    """
+    Retrieve the ontology configuration. This function utilizes caching to return a
+    singleton instance of the OntologyConfig class for efficiency.
+    """
+    return OntologyEnvConfig()

cognee/modules/ontology/rdf_xml/{OntologyResolver.py → RDFLibOntologyResolver.py}

@@ -10,31 +10,26 @@ from cognee.modules.ontology.exceptions import (
     FindClosestMatchError,
     GetSubgraphError,
 )
+from cognee.modules.ontology.base_ontology_resolver import BaseOntologyResolver
+from cognee.modules.ontology.models import AttachedOntologyNode
+from cognee.modules.ontology.matching_strategies import MatchingStrategy, FuzzyMatchingStrategy
 
 logger = get_logger("OntologyAdapter")
 
 
-class AttachedOntologyNode:
-    """Lightweight wrapper to be able to parse any ontology solution and generalize cognee interface."""
+class RDFLibOntologyResolver(BaseOntologyResolver):
+    """RDFLib-based ontology resolver implementation.
 
-    def __init__(self, uri: URIRef, category: str):
-        self.uri = uri
-        self.name = self._extract_name(uri)
-        self.category = category
+    This implementation uses RDFLib to parse and work with RDF/OWL ontology files.
+    It provides fuzzy matching and subgraph extraction capabilities for ontology entities.
+    """
 
-    @staticmethod
-    def _extract_name(uri: URIRef) -> str:
-        uri_str = str(uri)
-        if "#" in uri_str:
-            return uri_str.split("#")[-1]
-        return uri_str.rstrip("/").split("/")[-1]
-
-    def __repr__(self):
-        return f"AttachedOntologyNode(name={self.name}, category={self.category})"
-
-
-class OntologyResolver:
-    def __init__(self, ontology_file: Optional[str] = None):
+    def __init__(
+        self,
+        ontology_file: Optional[str] = None,
+        matching_strategy: Optional[MatchingStrategy] = None,
+    ) -> None:
+        super().__init__(matching_strategy)
         self.ontology_file = ontology_file
         try:
             if ontology_file and os.path.exists(ontology_file):
@@ -60,7 +55,7 @@ class OntologyResolver:
             name = uri_str.rstrip("/").split("/")[-1]
         return name.lower().replace(" ", "_").strip()
 
-    def build_lookup(self):
+    def build_lookup(self) -> None:
         try:
             classes: Dict[str, URIRef] = {}
             individuals: Dict[str, URIRef] = {}
@@ -97,7 +92,7 @@ class OntologyResolver:
             logger.error("Failed to build lookup dictionary: %s", str(e))
             raise RuntimeError("Lookup build failed") from e
 
-    def refresh_lookup(self):
+    def refresh_lookup(self) -> None:
         self.build_lookup()
         logger.info("Ontology lookup refreshed.")
 
@@ -105,13 +100,8 @@ class OntologyResolver:
         try:
             normalized_name = name.lower().replace(" ", "_").strip()
             possible_matches = list(self.lookup.get(category, {}).keys())
-            if normalized_name in possible_matches:
-                return normalized_name
 
-            best_match = difflib.get_close_matches(
-                normalized_name, possible_matches, n=1, cutoff=0.8
-            )
-            return best_match[0] if best_match else None
+            return self.matching_strategy.find_match(normalized_name, possible_matches)
         except Exception as e:
             logger.error("Error in find_closest_match: %s", str(e))
             raise FindClosestMatchError() from e
@@ -125,7 +115,9 @@ class OntologyResolver:
 
     def get_subgraph(
         self, node_name: str, node_type: str = "individuals", directed: bool = True
-    ) -> Tuple[List[Any], List[Tuple[str, str, str]], Optional[Any]]:
+    ) -> Tuple[
+        List[AttachedOntologyNode], List[Tuple[str, str, str]], Optional[AttachedOntologyNode]
+    ]:
         nodes_set = set()
         edges: List[Tuple[str, str, str]] = []
         visited = set()

cognee/modules/pipelines/layers/resolve_authorized_user_dataset.py

@@ -1,34 +1,31 @@
 from uuid import UUID
+from typing import Optional
 
-from cognee.api.v1.exceptions import DatasetNotFoundError
 from cognee.modules.users.models import User
-from cognee.modules.users.methods import get_default_user
-from cognee.modules.data.methods import (
-    create_authorized_dataset,
-    get_authorized_dataset,
-    get_authorized_dataset_by_name,
+from cognee.modules.pipelines.layers.resolve_authorized_user_datasets import (
+    resolve_authorized_user_datasets,
 )
 
 
-async def resolve_authorized_user_dataset(dataset_id: UUID, dataset_name: str, user: User):
-    if not user:
-        user = await get_default_user()
+async def resolve_authorized_user_dataset(
+    dataset_name: str, dataset_id: Optional[UUID] = None, user: Optional[User] = None
+):
+    """
+    Function handles creation and dataset authorization if dataset already exist for Cognee.
+    Verifies that provided user has necessary permission for provided Dataset.
+    If Dataset does not exist creates the Dataset and gives permission for the user creating the dataset.
 
-    if dataset_id:
-        authorized_dataset = await get_authorized_dataset(user, dataset_id, "write")
-    elif dataset_name:
-        authorized_dataset = await get_authorized_dataset_by_name(dataset_name, user, "write")
+    Args:
+        dataset_name: Name of the dataset.
+        dataset_id: Id of the dataset.
+        user: Cognee User request is being processed for, if None default user will be used.
 
-        if not authorized_dataset:
-            authorized_dataset = await create_authorized_dataset(
-                dataset_name=dataset_name, user=user
-            )
-    else:
-        raise ValueError("Either dataset_id or dataset_name must be provided.")
+    Returns:
+        Tuple[User, Dataset]: A tuple containing the user and the authorized dataset.
+    """
 
-    if not authorized_dataset:
-        raise DatasetNotFoundError(
-            message=f"Dataset ({str(dataset_id) or dataset_name}) not found."
-        )
+    user, authorized_datasets = await resolve_authorized_user_datasets(
+        datasets=dataset_id if dataset_id else dataset_name, user=user
+    )
 
-    return user, authorized_dataset
+    return user, authorized_datasets[0]

cognee/modules/pipelines/layers/resolve_authorized_user_datasets.py

@@ -1,5 +1,5 @@
 from uuid import UUID
-from typing import Union, Tuple, List
+from typing import Union, Tuple, List, Optional
 
 from cognee.modules.users.methods import get_default_user
 from cognee.modules.users.models import User
@@ -13,7 +13,7 @@ from cognee.modules.data.methods import (
 
 
 async def resolve_authorized_user_datasets(
-    datasets: Union[str, UUID, list[str], list[UUID]], user: User = None
+    datasets: Union[str, UUID, list[str], list[UUID]], user: Optional[User] = None
 ) -> Tuple[User, List[Dataset]]:
     """
     Function handles creation and dataset authorization if datasets already exist for Cognee.
@@ -25,7 +25,7 @@ async def resolve_authorized_user_datasets(
         datasets: Dataset names or Dataset UUID (in case Datasets already exist)
 
     Returns:
-
+        Tuple[User, List[Dataset]]: A tuple containing the user and the list of authorized datasets.
     """
     # If no user is provided use default user
     if user is None:

cognee/modules/retrieval/code_retriever.py

@@ -7,6 +7,7 @@ from cognee.shared.logging_utils import get_logger
 from cognee.modules.retrieval.base_retriever import BaseRetriever
 from cognee.infrastructure.databases.graph import get_graph_engine
 from cognee.infrastructure.databases.vector import get_vector_engine
+from cognee.infrastructure.llm.prompts import read_query_prompt
 from cognee.infrastructure.llm.LLMGateway import LLMGateway
 
 logger = get_logger("CodeRetriever")
@@ -41,7 +42,7 @@ class CodeRetriever(BaseRetriever):
             f"Processing query with LLM: '{query[:100]}{'...' if len(query) > 100 else ''}'"
         )
 
-        system_prompt = LLMGateway.read_query_prompt("codegraph_retriever_system.txt")
+        system_prompt = read_query_prompt("codegraph_retriever_system.txt")
 
         try:
             result = await LLMGateway.acreate_structured_output(

cognee/modules/retrieval/context_providers/TripletSearchContextProvider.py

@@ -42,14 +42,12 @@ class TripletSearchContextProvider(BaseContextProvider):
         self,
         entities: List[DataPoint],
         query: str,
-        user: User,
         memory_fragment: CogneeGraph,
     ) -> List:
         """Creates search tasks for valid entities."""
         tasks = [
             brute_force_triplet_search(
                 query=f"{entity_text} {query}",
-                user=user,
                 top_k=self.top_k,
                 collections=self.collections,
                 properties_to_project=self.properties_to_project,
@@ -84,9 +82,8 @@ class TripletSearchContextProvider(BaseContextProvider):
         if not entities:
             return "No entities provided for context search."
 
-        user = await get_default_user()
         memory_fragment = await get_memory_fragment(self.properties_to_project)
-        search_tasks = self._get_search_tasks(entities, query, user, memory_fragment)
+        search_tasks = self._get_search_tasks(entities, query, memory_fragment)
 
         if not search_tasks:
             return "No valid entities found for context search."

cognee/modules/retrieval/graph_completion_cot_retriever.py

@@ -1,10 +1,11 @@
-from typing import Optional, List, Type
+from typing import Optional, List, Type, Any
 from cognee.modules.graph.cognee_graph.CogneeGraphElements import Edge
 from cognee.shared.logging_utils import get_logger
 
 from cognee.modules.retrieval.graph_completion_retriever import GraphCompletionRetriever
 from cognee.modules.retrieval.utils.completion import generate_completion
 from cognee.infrastructure.llm.LLMGateway import LLMGateway
+from cognee.infrastructure.llm.prompts import render_prompt, read_query_prompt
 
 logger = get_logger()
 
@@ -106,10 +107,10 @@ class GraphCompletionCotRetriever(GraphCompletionRetriever):
             logger.info(f"Chain-of-thought: round {round_idx} - answer: {completion}")
             if round_idx < max_iter:
                 valid_args = {"query": query, "answer": completion, "context": context_text}
-                valid_user_prompt = LLMGateway.render_prompt(
+                valid_user_prompt = render_prompt(
                     filename=self.validation_user_prompt_path, context=valid_args
                 )
-                valid_system_prompt = LLMGateway.read_query_prompt(
+                valid_system_prompt = read_query_prompt(
                     prompt_file_name=self.validation_system_prompt_path
                 )
 
@@ -119,10 +120,10 @@ class GraphCompletionCotRetriever(GraphCompletionRetriever):
                     response_model=str,
                 )
                 followup_args = {"query": query, "answer": completion, "reasoning": reasoning}
-                followup_prompt = LLMGateway.render_prompt(
+                followup_prompt = render_prompt(
                     filename=self.followup_user_prompt_path, context=followup_args
                 )
-                followup_system = LLMGateway.read_query_prompt(
+                followup_system = read_query_prompt(
                     prompt_file_name=self.followup_system_prompt_path
                 )
 

cognee/modules/retrieval/graph_completion_retriever.py

@@ -93,11 +93,8 @@ class GraphCompletionRetriever(BaseGraphRetriever):
                         for field_name in index_fields:
                             vector_index_collections.append(f"{subclass.__name__}_{field_name}")
 
-        user = await get_default_user()
-
         found_triplets = await brute_force_triplet_search(
             query,
-            user=user,
             top_k=self.top_k,
             collections=vector_index_collections or None,
             node_type=self.node_type,

cognee/modules/retrieval/insights_retriever.py

@@ -25,7 +25,7 @@ class InsightsRetriever(BaseGraphRetriever):
     - top_k
     """
 
-    def __init__(self, exploration_levels: int = 1, top_k: int = 5):
+    def __init__(self, exploration_levels: int = 1, top_k: Optional[int] = 5):
         """Initialize retriever with exploration levels and search parameters."""
         self.exploration_levels = exploration_levels
         self.top_k = top_k

cognee/modules/retrieval/jaccard_retrival.py

@@ -0,0 +1,60 @@
+from cognee.modules.retrieval.lexical_retriever import LexicalRetriever
+import re
+from collections import Counter
+from typing import Optional
+
+
+class JaccardChunksRetriever(LexicalRetriever):
+    """
+    Retriever that specializes LexicalRetriever to use Jaccard similarity.
+    """
+
+    def __init__(
+        self,
+        top_k: int = 10,
+        with_scores: bool = False,
+        stop_words: Optional[list[str]] = None,
+        multiset_jaccard: bool = False,
+    ):
+        """
+        Parameters
+        ----------
+        top_k : int
+            Number of top results to return.
+        with_scores : bool
+            If True, return (payload, score) pairs. Otherwise, only payloads.
+        stop_words : list[str], optional
+            List of tokens to filter out.
+        multiset_jaccard : bool
+            If True, use multiset Jaccard (frequency aware).
+        """
+        self.stop_words = {t.lower() for t in stop_words} if stop_words else set()
+        self.multiset_jaccard = multiset_jaccard
+
+        super().__init__(
+            tokenizer=self._tokenizer, scorer=self._scorer, top_k=top_k, with_scores=with_scores
+        )
+
+    def _tokenizer(self, text: str) -> list[str]:
+        """
+        Tokenizer: lowercases, splits on word characters (w+), filters stopwords.
+        """
+        tokens = re.findall(r"\w+", text.lower())
+        return [t for t in tokens if t not in self.stop_words]
+
+    def _scorer(self, query_tokens: list[str], chunk_tokens: list[str]) -> float:
+        """
+        Jaccard similarity scorer.
+        - If multiset_jaccard=True, uses frequency-aware Jaccard.
+        - Otherwise, normal set Jaccard.
+        """
+        if self.multiset_jaccard:
+            q_counts, c_counts = Counter(query_tokens), Counter(chunk_tokens)
+            numerator = sum(min(q_counts[t], c_counts[t]) for t in set(q_counts) | set(c_counts))
+            denominator = sum(max(q_counts[t], c_counts[t]) for t in set(q_counts) | set(c_counts))
+            return numerator / denominator if denominator else 0.0
+        else:
+            q_set, c_set = set(query_tokens), set(chunk_tokens)
+            if not q_set or not c_set:
+                return 0.0
+            return len(q_set & c_set) / len(q_set | c_set)

cognee/modules/retrieval/lexical_retriever.py

@@ -0,0 +1,123 @@
+import asyncio
+from typing import Any, Callable, Optional
+from heapq import nlargest
+
+from cognee.infrastructure.databases.graph import get_graph_engine
+from cognee.modules.retrieval.base_retriever import BaseRetriever
+from cognee.modules.retrieval.exceptions.exceptions import NoDataError
+from cognee.shared.logging_utils import get_logger
+
+
+logger = get_logger("LexicalRetriever")
+
+
+class LexicalRetriever(BaseRetriever):
+    def __init__(
+        self, tokenizer: Callable, scorer: Callable, top_k: int = 10, with_scores: bool = False
+    ):
+        if not callable(tokenizer) or not callable(scorer):
+            raise TypeError("tokenizer and scorer must be callables")
+        if not isinstance(top_k, int) or top_k <= 0:
+            raise ValueError("top_k must be a positive integer")
+
+        self.tokenizer = tokenizer
+        self.scorer = scorer
+        self.top_k = top_k
+        self.with_scores = bool(with_scores)
+
+        # Cache keyed by dataset context
+        self.chunks: dict[str, Any] = {}  # {chunk_id: tokens}
+        self.payloads: dict[str, Any] = {}  # {chunk_id: original_document}
+        self._initialized = False
+        self._init_lock = asyncio.Lock()
+
+    async def initialize(self):
+        """Initialize retriever by reading all DocumentChunks from graph_engine."""
+        async with self._init_lock:
+            if self._initialized:
+                return
+
+            logger.info("Initializing LexicalRetriever by loading DocumentChunks from graph engine")
+
+            try:
+                graph_engine = await get_graph_engine()
+                nodes, _ = await graph_engine.get_filtered_graph_data([{"type": ["DocumentChunk"]}])
+            except Exception as e:
+                logger.error("Graph engine initialization failed")
+                raise NoDataError("Graph engine initialization failed") from e
+
+            chunk_count = 0
+            for node in nodes:
+                try:
+                    chunk_id, document = node
+                except Exception:
+                    logger.warning("Skipping node with unexpected shape: %r", node)
+                    continue
+
+                if document.get("type") == "DocumentChunk" and document.get("text"):
+                    try:
+                        tokens = self.tokenizer(document["text"])
+                        if not tokens:
+                            continue
+                        self.chunks[str(document.get("id", chunk_id))] = tokens
+                        self.payloads[str(document.get("id", chunk_id))] = document
+                        chunk_count += 1
+                    except Exception as e:
+                        logger.error("Tokenizer failed for chunk %s: %s", chunk_id, str(e))
+
+            if chunk_count == 0:
+                logger.error("Initialization completed but no valid chunks were loaded.")
+                raise NoDataError("No valid chunks loaded during initialization.")
+
+            self._initialized = True
+            logger.info("Initialized with %d document chunks", len(self.chunks))
+
+    async def get_context(self, query: str) -> Any:
+        """Retrieves relevant chunks for the given query."""
+        if not self._initialized:
+            await self.initialize()
+
+        if not self.chunks:
+            logger.warning("No chunks available in retriever")
+            return []
+
+        try:
+            query_tokens = self.tokenizer(query)
+        except Exception as e:
+            logger.error("Failed to tokenize query: %s", str(e))
+            return []
+
+        if not query_tokens:
+            logger.warning("Query produced no tokens")
+            return []
+
+        results = []
+        for chunk_id, chunk_tokens in self.chunks.items():
+            try:
+                score = self.scorer(query_tokens, chunk_tokens)
+                if not isinstance(score, (int, float)):
+                    logger.warning("Non-numeric score for chunk %s → treated as 0.0", chunk_id)
+                    score = 0.0
+            except Exception as e:
+                logger.error("Scorer failed for chunk %s: %s", chunk_id, str(e))
+                score = 0.0
+            results.append((chunk_id, score))
+
+        top_results = nlargest(self.top_k, results, key=lambda x: x[1])
+        logger.info(
+            "Retrieved %d/%d chunks for query (len=%d)",
+            len(top_results),
+            len(results),
+            len(query_tokens),
+        )
+
+        if self.with_scores:
+            return [(self.payloads[chunk_id], score) for chunk_id, score in top_results]
+        else:
+            return [self.payloads[chunk_id] for chunk_id, _ in top_results]
+
+    async def get_completion(self, query: str, context: Optional[Any] = None) -> Any:
+        """Returns context for the given query (retrieves if not provided)."""
+        if context is None:
+            context = await self.get_context(query)
+        return context

cognee/modules/retrieval/natural_language_retriever.py

@@ -2,6 +2,7 @@ from typing import Any, Optional
 from cognee.shared.logging_utils import get_logger
 from cognee.infrastructure.databases.graph import get_graph_engine
 from cognee.infrastructure.llm.LLMGateway import LLMGateway
+from cognee.infrastructure.llm.prompts import render_prompt
 from cognee.modules.retrieval.base_retriever import BaseRetriever
 from cognee.modules.retrieval.exceptions import SearchTypeNotSupported
 from cognee.infrastructure.databases.graph.graph_db_interface import GraphDBInterface
@@ -49,7 +50,7 @@ class NaturalLanguageRetriever(BaseRetriever):
 
     async def _generate_cypher_query(self, query: str, edge_schemas, previous_attempts=None) -> str:
         """Generate a Cypher query using LLM based on natural language query and schema information."""
-        system_prompt = LLMGateway.render_prompt(
+        system_prompt = render_prompt(
             self.system_prompt_path,
             context={
                 "edge_schemas": edge_schemas,

cognee/modules/retrieval/temporal_retriever.py

@@ -6,6 +6,7 @@ from operator import itemgetter
 from cognee.infrastructure.databases.vector import get_vector_engine
 from cognee.modules.retrieval.utils.completion import generate_completion
 from cognee.infrastructure.databases.graph import get_graph_engine
+from cognee.infrastructure.llm.prompts import render_prompt
 from cognee.infrastructure.llm import LLMGateway
 from cognee.modules.retrieval.graph_completion_retriever import GraphCompletionRetriever
 from cognee.shared.logging_utils import get_logger
@@ -72,7 +73,7 @@ class TemporalRetriever(GraphCompletionRetriever):
         else:
             base_directory = None
 
-        system_prompt = LLMGateway.render_prompt(prompt_path, {}, base_directory=base_directory)
+        system_prompt = render_prompt(prompt_path, {}, base_directory=base_directory)
 
         interval = await LLMGateway.acreate_structured_output(query, system_prompt, QueryInterval)
 
@@ -129,7 +130,7 @@ class TemporalRetriever(GraphCompletionRetriever):
         query_vector = (await vector_engine.embedding_engine.embed_text([query]))[0]
 
         vector_search_results = await vector_engine.search(
-            collection_name="Event_name", query_vector=query_vector, limit=0
+            collection_name="Event_name", query_vector=query_vector, limit=None
         )
 
         top_k_events = await self.filter_top_k_events(relevant_events, vector_search_results)

cognee/modules/retrieval/utils/brute_force_triplet_search.py

@@ -89,7 +89,6 @@ async def get_memory_fragment(
 
 async def brute_force_triplet_search(
     query: str,
-    user: User,
     top_k: int = 5,
     collections: Optional[List[str]] = None,
     properties_to_project: Optional[List[str]] = None,
@@ -102,7 +101,6 @@ async def brute_force_triplet_search(
 
     Args:
         query (str): The search query.
-        user (User): The user performing the search.
         top_k (int): The number of top results to retrieve.
         collections (Optional[List[str]]): List of collections to query.
         properties_to_project (Optional[List[str]]): List of properties to project.
@@ -139,12 +137,10 @@ async def brute_force_triplet_search(
 
     query_vector = (await vector_engine.embedding_engine.embed_text([query]))[0]
 
-    send_telemetry("cognee.brute_force_triplet_search EXECUTION STARTED", user.id)
-
     async def search_in_collection(collection_name: str):
         try:
             return await vector_engine.search(
-                collection_name=collection_name, query_vector=query_vector, limit=0
+                collection_name=collection_name, query_vector=query_vector, limit=None
             )
         except CollectionNotFoundError:
             return []
@@ -176,20 +172,14 @@ async def brute_force_triplet_search(
 
         results = await memory_fragment.calculate_top_triplet_importances(k=top_k)
 
-        send_telemetry("cognee.brute_force_triplet_search EXECUTION COMPLETED", user.id)
-
         return results
 
     except CollectionNotFoundError:
         return []
     except Exception as error:
         logger.error(
-            "Error during brute force search for user: %s, query: %s. Error: %s",
-            user.id,
+            "Error during brute force search for query: %s. Error: %s",
             query,
             error,
         )
-        send_telemetry(
-            "cognee.brute_force_triplet_search EXECUTION FAILED", user.id, {"error": str(error)}
-        )
         raise error