cognee 1.2.2.dev0__py3-none-any.whl → 1.2.2.dev2__py3-none-any.whl

cognee/api/v1/improve/improve.py

@@ -40,6 +40,7 @@ async def improve(
     node_name: Optional[List[str]] = None,
     session_ids: Optional[List[str]] = None,
     build_global_context_index: bool = False,
+    build_truth_subspace: bool = False,
     **kwargs: Unpack[ImproveKwargs],
 ):
     """Enrich an existing knowledge graph with additional context and rules.
@@ -86,6 +87,10 @@ async def improve(
             context index after default enrichment. Skipped in background
             mode because ordered background pipeline chaining is not
             supported yet.
+        build_truth_subspace: Opt-in flag (default ``False``) for building the
+            truth subspace from distilled session learnings after distillation
+            and before enrichment. Only runs when ``session_ids`` is provided.
+            Off by default = no behaviour change.
         **kwargs: Additional options -- see ``ImproveKwargs``.
 
     Returns:
@@ -113,6 +118,7 @@ async def improve(
             "session_ids": ",".join(session_ids) if session_ids else "",
             "run_in_background": run_in_background,
             "build_global_context_index": build_global_context_index,
+            "build_truth_subspace": build_truth_subspace,
             "cognee_version": cognee_version,
         },
     )
@@ -199,6 +205,26 @@ async def improve(
                 if distilled:
                     stages_run.append("distill_sessions")
 
+                # Stage 2d: build the truth subspace from distilled session
+                # learnings (opt-in, default OFF). Runs after distillation so
+                # freshly accepted lessons are available as anchors, and before
+                # enrichment. Non-fatal — never blocks the rest of improve().
+                if build_truth_subspace:
+                    try:
+                        from cognee.modules.truth_subspace.build import (
+                            build_truth_subspace as _build_truth_subspace,
+                        )
+
+                        result_ts = await _build_truth_subspace(
+                            dataset=dataset,
+                            session_ids=session_ids,
+                            user=user,
+                        )
+                        logger.info("improve: truth subspace built -> %s", result_ts)
+                        stages_run.append("build_truth_subspace")
+                    except Exception as e:
+                        logger.warning("improve: truth subspace build failed (non-fatal): %s", e)
+
             # Stage 3: default enrichment (triplet embeddings)
             from cognee.modules.memify import memify
 

cognee/api/v1/recall/recall.py

@@ -5,6 +5,7 @@ from uuid import UUID
 from pydantic import BaseModel, Field
 from typing_extensions import TypedDict
 
+from cognee.base_config import get_base_config
 from cognee.context_global_variables import set_session_user_context_variable
 from cognee.exceptions import CogneeValidationError
 from cognee.infrastructure.databases.vector.embeddings.config import EmbeddingConfig
@@ -375,7 +376,7 @@ async def recall(
     context_profile: str = "qa",
     wide_search_top_k: int | None = 100,
     triplet_distance_penalty: float | None = 6.5,
-    feedback_influence: float = 0.0,
+    feedback_influence: float = get_base_config().default_feedback_influence,
     verbose: bool = False,
     retriever_specific_config: dict | None = None,
     neighborhood_depth: int | None = None,

cognee/api/v1/search/search.py

@@ -8,6 +8,7 @@ from cognee.infrastructure.databases.vector.embeddings.config import EmbeddingCo
 from cognee.infrastructure.llm.config import LLMConfig
 from cognee.modules.search.types import SearchResult, SearchType
 from cognee.modules.users.methods import get_default_user
+from cognee.base_config import get_base_config
 from cognee.modules.search.methods import search as search_function
 from cognee.modules.data.methods import get_authorized_existing_datasets
 from cognee.modules.data.exceptions import DatasetNotFoundError
@@ -43,7 +44,7 @@ async def search(
     session_id: Optional[str] = None,
     wide_search_top_k: Optional[int] = 100,
     triplet_distance_penalty: Optional[float] = 6.5,
-    feedback_influence: float = 0.0,
+    feedback_influence: float = get_base_config().default_feedback_influence,
     verbose: bool = False,
     retriever_specific_config: Optional[dict] = None,
     neighborhood_depth: Optional[int] = None,

cognee/base_config.py

@@ -14,6 +14,9 @@ class BaseConfig(BaseSettings):
     cache_root_directory: str = get_absolute_path(".cognee_cache")
     logs_root_directory: str = os.getenv("COGNEE_LOGS_DIR", str(Path.home() / ".cognee" / "logs"))
     monitoring_tool: object = Observer.NONE
+    # Default blend weight for the learned feedback signal during graph search.
+    # Opt-in by default to preserve existing retrieval behavior.
+    default_feedback_influence: float = float(os.getenv("DEFAULT_FEEDBACK_INFLUENCE", "0.0"))
 
     @pydantic.model_validator(mode="after")
     def validate_paths(self):

cognee/context_global_variables.py

@@ -27,6 +27,7 @@ from cognee.infrastructure.databases.utils.resolve_dataset_database_connection_i
 #       for different async tasks, threads and processes
 vector_db_config = ContextVar("vector_db_config", default=None)
 graph_db_config = ContextVar("graph_db_config", default=None)
+current_dataset_id = ContextVar("current_dataset_id", default=None)
 # Note: same mechanism for LLM and embedding configs so that the LiteLLM client
 #       and the embedding engine can use per-context (e.g. per-request) configs.
 llm_config = ContextVar("llm_config", default=None)
@@ -111,7 +112,14 @@ class DatabaseContextManager:
     Note: Single-use object, should not be reused across multiple calls.
     """
 
-    __slots__ = ("_dataset", "_user_id", "_llm_config", "_embedding_config", "_applied")
+    __slots__ = (
+        "_dataset",
+        "_user_id",
+        "_llm_config",
+        "_embedding_config",
+        "_applied",
+        "_dataset_token",
+    )
 
     def __init__(
         self,
@@ -125,10 +133,13 @@ class DatabaseContextManager:
         self._llm_config = llm_config
         self._embedding_config = embedding_config
         self._applied = False
+        self._dataset_token = None
 
     async def apply_database_context_variables(
         self, dataset: Union[str, UUID], user_id: UUID
     ) -> None:
+        self._dataset_token = current_dataset_id.set(str(dataset) if dataset is not None else None)
+
         # LLM and embedding configs are an explicit, caller-provided override and
         # are intentionally applied regardless of backend access control: callers
         # may want per-context LLM/embedding configs even in single-tenant mode.
@@ -255,6 +266,10 @@ class DatabaseContextManager:
         return self
 
     async def __aexit__(self, exc_type, exc, tb) -> None:
+        if self._dataset_token is not None:
+            current_dataset_id.reset(self._dataset_token)
+            self._dataset_token = None
+
         if not backend_access_control_enabled():
             return None
 

cognee/infrastructure/databases/graph/graph_db_interface.py

@@ -354,6 +354,22 @@ class GraphDBInterface(ABC):
         """
         raise NotImplementedError("set_node_feedback_weights is not implemented for this adapter")
 
+    async def get_node_truth_state(self, node_ids: List[str]) -> Dict[str, Dict[str, Any]]:
+        """
+        Retrieve node truth alignment state for multiple node ids.
+        Returns only found node ids.
+        """
+        raise NotImplementedError("get_node_truth_state is not implemented for this adapter")
+
+    async def set_node_truth_state(
+        self, node_truth_state: Dict[str, Dict[str, Any]]
+    ) -> Dict[str, bool]:
+        """
+        Persist node truth alignment state for multiple node ids.
+        Returns per-id update success.
+        """
+        raise NotImplementedError("set_node_truth_state is not implemented for this adapter")
+
     async def get_edge_feedback_weights(self, edge_object_ids: List[str]) -> Dict[str, float]:
         """
         Retrieve edge feedback weights for multiple edge_object_ids.

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

@@ -1556,6 +1556,48 @@ class LadybugAdapter(GraphDBInterface):
         rows_dicts = self._rows_to_dicts(result, ["node_id"])
         return {str(r["node_id"]) for r in rows_dicts if r.get("node_id") is not None}
 
+    def _build_node_truth_state_updates(
+        self,
+        nodes: List[Dict[str, Any]],
+        node_truth_state: Dict[str, Dict[str, Any]],
+    ) -> List[Dict[str, Any]]:
+        """Build UNWIND items for node truth state updates."""
+        updates = []
+        for node in nodes:
+            node_id = node.get("id")
+            if not isinstance(node_id, str) or node_id not in node_truth_state:
+                continue
+            state = node_truth_state[node_id]
+            properties = {
+                k: v
+                for k, v in node.items()
+                if k not in {"id", "name", "type", "created_at", "updated_at"}
+            }
+            properties["truth_alignment"] = list(state.get("truth_alignment") or [])
+            if state.get("truth_epoch") is not None:
+                properties["truth_epoch"] = int(state["truth_epoch"])
+            updates.append(
+                {"node_id": node_id, "properties": json.dumps(properties, cls=JSONEncoder)}
+            )
+        return updates
+
+    async def _execute_node_truth_state_updates(self, updates: List[Dict[str, Any]]) -> Set[str]:
+        """Run node truth state UNWIND/SET; return set of updated node_ids."""
+        if not updates:
+            return set()
+        now = datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S.%f")
+        query = """
+        UNWIND $items AS item
+        MATCH (n:Node)
+        WHERE n.id = item.node_id
+        SET n.properties = item.properties,
+            n.updated_at = timestamp($updated_at)
+        RETURN n.id AS node_id
+        """
+        result = await self.query(query, {"items": updates, "updated_at": now})
+        rows_dicts = self._rows_to_dicts(result, ["node_id"])
+        return {str(r["node_id"]) for r in rows_dicts if r.get("node_id") is not None}
+
     def _build_edge_feedback_updates(
         self,
         edge_rows: List[Dict[str, Any]],
@@ -1642,6 +1684,47 @@ class LadybugAdapter(GraphDBInterface):
         updated_ids = await self._execute_node_feedback_updates(updates)
         return {nid: (nid in updated_ids) for nid in node_ids}
 
+    async def get_node_truth_state(self, node_ids: List[str]) -> Dict[str, Dict[str, Any]]:
+        if not node_ids:
+            return {}
+        valid_node_ids = [node_id for node_id in node_ids if isinstance(node_id, str) and node_id]
+        if not valid_node_ids:
+            return {}
+        nodes = await self.get_nodes(valid_node_ids)
+        result: Dict[str, Dict[str, Any]] = {}
+        for node in nodes:
+            node_id = node.get("id")
+            if not isinstance(node_id, str):
+                continue
+            value = node.get("truth_alignment", [])
+            epoch = node.get("truth_epoch")
+            if isinstance(value, (list, tuple)):
+                alignment = list(value)
+            else:
+                alignment = []
+            try:
+                truth_epoch = int(epoch) if epoch is not None else None
+            except (TypeError, ValueError):
+                truth_epoch = None
+            result[node_id] = {"truth_alignment": alignment, "truth_epoch": truth_epoch}
+        return result
+
+    async def set_node_truth_state(
+        self, node_truth_state: Dict[str, Dict[str, Any]]
+    ) -> Dict[str, bool]:
+        if not node_truth_state:
+            return {}
+        node_ids = list(node_truth_state.keys())
+        valid_node_ids = [nid for nid in node_ids if isinstance(nid, str) and nid]
+        if not valid_node_ids:
+            return {nid: False for nid in node_ids}
+        nodes = await self.get_nodes(valid_node_ids)
+        updates = self._build_node_truth_state_updates(nodes, node_truth_state)
+        if not updates:
+            return {nid: False for nid in node_ids}
+        updated_ids = await self._execute_node_truth_state_updates(updates)
+        return {nid: (nid in updated_ids) for nid in node_ids}
+
     async def get_edge_feedback_weights(self, edge_object_ids: List[str]) -> Dict[str, float]:
         if not edge_object_ids:
             return {}

cognee/infrastructure/databases/vector/lancedb/LanceDBAdapter.py

@@ -546,6 +546,62 @@ class LanceDBAdapter(VectorDBInterface):
                 collection_name, collection, payload_schema, lance_data_points
             )
 
+    async def upsert_raw_vectors(
+        self,
+        collection_name: str,
+        points: list[dict],
+        payload_schema: Optional[type[BaseModel]] = None,
+    ) -> None:
+        """Upsert caller-provided vectors without invoking the embedding engine."""
+        if not points:
+            return
+        if payload_schema is None:
+            raise ValueError("payload_schema is required for LanceDB raw vector upserts")
+
+        vector_size = self.embedding_engine.get_vector_size()
+        LanceDataPoint = self._make_lance_datapoint_cls(payload_schema, vector_size)
+
+        if not await self.has_collection(collection_name):
+            async with self.VECTOR_DB_LOCK:
+                if not await self.has_collection(collection_name):
+                    connection = await self.get_connection()
+                    await connection.create_table(
+                        name=collection_name,
+                        schema=self._schema_for_create_table(LanceDataPoint),
+                        exist_ok=True,
+                    )
+
+        collection = await self.get_collection(collection_name)
+
+        raw_points = []
+        for point in points:
+            point_id = point.get("id")
+            vector = point.get("vector")
+            payload_value = point.get("payload")
+            if point_id is None:
+                raise ValueError("Raw vector point is missing id")
+            if not isinstance(vector, list):
+                raise ValueError("Raw vector point vector must be a list")
+            if len(vector) != vector_size:
+                raise ValueError(
+                    f"Raw vector size {len(vector)} does not match expected size {vector_size}"
+                )
+            raw_points.append(
+                LanceDataPoint(
+                    id=str(point_id),
+                    vector=vector,
+                    payload=payload_schema.model_validate(payload_value).model_dump(),
+                )
+            )
+
+        async with self.VECTOR_DB_LOCK:
+            await (
+                collection.merge_insert("id")
+                .when_matched_update_all()
+                .when_not_matched_insert_all()
+                .execute(self._records_for_write(raw_points))
+            )
+
     async def _migrate_collection_schema(
         self,
         collection_name: str,

cognee/infrastructure/databases/vector/lancedb/LanceDBDatasetDatabaseHandler.py

@@ -8,6 +8,7 @@ from cognee.modules.users.models import DatasetDatabase
 from cognee.base_config import get_base_config
 from cognee.infrastructure.databases.vector import get_vectordb_config
 from cognee.infrastructure.databases.dataset_database_handler import DatasetDatabaseHandlerInterface
+from cognee.infrastructure.files.storage.get_file_storage import get_file_storage
 
 
 class LanceDBDatasetDatabaseHandler(DatasetDatabaseHandlerInterface):
@@ -29,7 +30,7 @@ class LanceDBDatasetDatabaseHandler(DatasetDatabaseHandlerInterface):
         databases_directory_path = os.path.join(
             base_config.system_root_directory, "databases", str(user.id)
         )
-        os.makedirs(databases_directory_path, exist_ok=True)
+        await get_file_storage(databases_directory_path).ensure_directory_exists()
 
         vector_db_name = f"{dataset_id}.lance.db"
 

cognee/infrastructure/databases/vector/vector_db_interface.py

@@ -63,6 +63,21 @@ class VectorDBInterface(Protocol):
         """
         raise NotImplementedError
 
+    async def upsert_raw_vectors(
+        self,
+        collection_name: str,
+        points: list[dict],
+        payload_schema: Optional[Any] = None,
+    ) -> None:
+        """
+        Upsert already-computed vectors into the specified collection.
+
+        This is for small system-owned vector state where re-embedding from text would be
+        incorrect. Adapters that do not support raw vector writes should raise
+        NotImplementedError.
+        """
+        raise NotImplementedError("upsert_raw_vectors is not implemented for this adapter")
+
     @abstractmethod
     async def retrieve(self, collection_name: str, data_point_ids: list[str]):
         """

cognee/modules/chunking/models/DocumentChunk.py

@@ -38,4 +38,8 @@ class DocumentChunk(DataPoint):
     importance_weight: Optional[float] = 0.5
     document_id: Optional[str] = None
     document_name: Optional[str] = None
+    # Optional truth-alignment fields; never embedded (kept out of index_fields)
+    # and not part of id/dedup.
+    truth_alignment: Optional[list[float]] = None
+    truth_epoch: Optional[int] = None
     metadata: dict = {"index_fields": ["text"]}

cognee/modules/engine/models/Entity.py

@@ -9,6 +9,11 @@ class Entity(DataPoint):
     is_a: Optional[EntityType] = None
     description: str
     relations: List[tuple] = []
+    # Optional truth-alignment fields; never embedded (kept out of index_fields)
+    # and not part of id/dedup (kept out of identity_fields).
+    truth_alignment: Optional[list[float]] = None
+    truth_subspace_signature: Optional[str] = None
+    truth_epoch: Optional[int] = None
     # identity_fields makes the id deterministic and namespaced by class
     # (``Entity:<name>``) when constructed without an explicit id — the same
     # value ``Entity.id_for(name)`` produces. Prevents the random-uuid4 footgun.

cognee/modules/graph/cognee_graph/CogneeGraph.py

@@ -10,6 +10,7 @@ from cognee.modules.graph.exceptions import (
 from cognee.infrastructure.databases.graph.graph_db_interface import GraphDBInterface
 from cognee.modules.graph.cognee_graph.CogneeGraphElements import Node, Edge
 from cognee.modules.graph.cognee_graph.CogneeAbstractGraph import CogneeAbstractGraph
+from cognee.base_config import get_base_config
 import heapq
 
 logger = get_logger("CogneeGraph")
@@ -36,7 +37,7 @@ class CogneeGraph(CogneeAbstractGraph):
         self.edges_by_distance_key = {}
         self.directed = directed
         self.triplet_distance_penalty = 6.5
-        self.feedback_influence = 0.0
+        self.feedback_influence = get_base_config().default_feedback_influence
 
     def add_node(self, node: Node) -> None:
         if node.id in self.nodes:
@@ -236,7 +237,7 @@ class CogneeGraph(CogneeAbstractGraph):
         node_name_filter_operator: str = "OR",
         relevant_ids_to_filter: Optional[List[str]] = None,
         triplet_distance_penalty: float = 6.5,
-        feedback_influence: float = 0.0,
+        feedback_influence: float = get_base_config().default_feedback_influence,
     ) -> None:
         if node_dimension < 1 or edge_dimension < 1:
             raise InvalidDimensionsError()
@@ -322,7 +323,7 @@ class CogneeGraph(CogneeAbstractGraph):
         node_dimension: int = 1,
         edge_dimension: int = 1,
         triplet_distance_penalty: float = 6.5,
-        feedback_influence: float = 0.0,
+        feedback_influence: float = get_base_config().default_feedback_influence,
     ) -> None:
         """
         Project a neighborhood subgraph from the database around seed nodes.

cognee/modules/migration/import_source.py

@@ -77,6 +77,16 @@ async def import_memory_source(
     external_id, node ids from entity names) make re-running an interrupted
     or repeated import safe.
     """
+    from cognee.modules.migrations.startup import run_migrations_and_block
+
+    # Imports are writes, so they take the same migration gate as
+    # remember()/cognify() (the remember() MemorySource dispatch happens
+    # before its own gate). This also records the data-migration revision —
+    # stamping a fresh store at head — BEFORE the imported rows arrive;
+    # without it the populated store has no recorded revision and the first
+    # migration-aware startup replays the entire data chain over it.
+    await run_migrations_and_block(dataset_name, user)
+
     node_set = node_set or [f"import:{source.source_system}"]
 
     if source.mode == "preserve" and getattr(source, "replayable", False):

cognee/modules/migration/loader.py

@@ -11,6 +11,7 @@ Two targets, selected by the source's import mode:
   the source (``valid_at``/``invalid_at``) is preserved as edge properties.
 """
 
+import dataclasses
 from dataclasses import dataclass, field
 from datetime import datetime
 from types import SimpleNamespace
@@ -427,6 +428,12 @@ def _provenance_ctx(ctx):
     add_data_points stamps ledger provenance from ``ctx.data_item.id``, which
     exists on Data ORM records but not on raw ingestion DataItems. Substitute
     the DataItem's deterministic ``data_id`` so provenance still lands.
+
+    Only ``data_item`` is replaced; every other PipelineContext field is
+    carried over via ``dataclasses.replace`` so consumers that read ctx
+    attributes (e.g. ``add_data_points`` reads ``ctx.pipeline_run_id``) never
+    see a field-stripped context — a hand-copied field list here silently
+    drops any parameter later added to PipelineContext.
     """
     if ctx is None:
         return None
@@ -434,12 +441,7 @@ def _provenance_ctx(ctx):
     if data_item is None or hasattr(data_item, "id"):
         return ctx
     data_id = getattr(data_item, "data_id", None)
-    return SimpleNamespace(
-        user=getattr(ctx, "user", None),
-        dataset=getattr(ctx, "dataset", None),
-        data_item=SimpleNamespace(id=data_id) if data_id else None,
-        extras=getattr(ctx, "extras", None),
-    )
+    return dataclasses.replace(ctx, data_item=SimpleNamespace(id=data_id) if data_id else None)
 
 
 # Edge batches can run larger than node batches: edges are small tuples and

cognee/modules/migration/snapshot.py

@@ -19,7 +19,7 @@ so no property is lost.
 """
 
 import json
-from typing import Any, Dict, List, Optional, Type, Union
+from typing import Any, Dict, Iterable, List, Optional, Tuple, Type, Union
 
 from pydantic import BaseModel, ConfigDict, Field, SerializeAsAny, create_model, field_validator
 
@@ -59,13 +59,41 @@ class _DynamicDataPoint(DataPoint):
     model_config = ConfigDict(arbitrary_types_allowed=True, extra="allow")
 
 
-_dynamic_models: Dict[str, Type[DataPoint]] = {}
+_dynamic_models: Dict[Tuple[str, Tuple[str, ...], Tuple[str, ...]], Type[DataPoint]] = {}
 
 
-def _dynamic_model(type_name: str) -> Type[DataPoint]:
-    if type_name not in _dynamic_models:
-        _dynamic_models[type_name] = create_model(type_name, __base__=_DynamicDataPoint)
-    return _dynamic_models[type_name]
+def _dynamic_model(
+    type_name: str,
+    property_names: Optional[Iterable[str]] = None,
+    index_fields: Optional[List[str]] = None,
+) -> Type[DataPoint]:
+    """A DataPoint subclass named ``type_name`` that DECLARES the record's
+    properties as fields and bakes ``index_fields`` into the CLASS-level
+    metadata default.
+
+    Instance-level state is not enough on either count: downstream model
+    machinery only sees declared fields. ``get_graph_from_model`` iterates
+    declared fields when collecting node properties (``extra="allow"`` values
+    are silently dropped — imported DocumentChunk text never reached storage),
+    and rebuilds nodes through ``copy_model``, which re-applies class field
+    defaults (a plain DataPoint metadata default of ``index_fields: []``
+    dropped the embeddable-field markers, so nothing was vector-indexed).
+    """
+    extra_fields = tuple(
+        sorted(
+            name
+            for name in (property_names or ())
+            if name != "metadata" and name not in DataPoint.model_fields
+        )
+    )
+    key = (type_name, extra_fields, tuple(index_fields or ()))
+    if key not in _dynamic_models:
+        field_definitions: Dict[str, Any] = {name: (Any, None) for name in extra_fields}
+        field_definitions["metadata"] = (dict, {"index_fields": list(index_fields or [])})
+        _dynamic_models[key] = create_model(
+            type_name, __base__=_DynamicDataPoint, **field_definitions
+        )
+    return _dynamic_models[key]
 
 
 def _clean_properties(properties: Dict[str, Any]) -> Dict[str, Any]:
@@ -101,14 +129,20 @@ def rehydrate_node(
         except Exception:  # noqa: BLE001 — fall back to a dynamic model
             pass
 
+    # Carry the record's properties and embeddable fields onto the dynamic
+    # CLASS so they survive downstream field iteration and copy_model
+    # rebuilds (see _dynamic_model).
+    metadata = props.get("metadata")
+    index_fields = metadata.get("index_fields") if isinstance(metadata, dict) else None
+
     try:
         # Created lazily: only when the registered class is absent or fails.
-        return _dynamic_model(type_name)(**props)
+        return _dynamic_model(type_name, props, index_fields)(**props)
     except Exception:  # noqa: BLE001 — final fallback below
         pass
 
     base_safe = {key: value for key, value in props.items() if key in _BASE_FIELDS}
-    return _dynamic_model(type_name)(**base_safe)
+    return _dynamic_model(type_name, base_safe, index_fields)(**base_safe)
 
 
 class GraphEdge(BaseModel):

cognee/modules/retrieval/graph_completion_context_extension_retriever.py

@@ -1,6 +1,7 @@
 import asyncio
 from typing import Optional, List, Type, Union
 
+from cognee.base_config import get_base_config
 from cognee.modules.graph.cognee_graph.CogneeGraphElements import Edge
 from cognee.modules.retrieval.utils.query_state import QueryState
 from cognee.modules.retrieval.utils.validate_queries import validate_retriever_input
@@ -28,7 +29,7 @@ class GraphCompletionContextExtensionRetriever(GraphCompletionRetriever):
         node_name_filter_operator: str = "OR",
         wide_search_top_k: Optional[int] = 100,
         triplet_distance_penalty: Optional[float] = 6.5,
-        feedback_influence: float = 0.0,
+        feedback_influence: float = get_base_config().default_feedback_influence,
         context_extension_rounds: int = 4,
         session_id: Optional[str] = None,
         response_model: Type = str,

cognee/modules/retrieval/graph_completion_cot_retriever.py

@@ -4,6 +4,7 @@ from typing import Optional, List, Type, Any, Union
 
 from pydantic import BaseModel
 
+from cognee.base_config import get_base_config
 from cognee.modules.graph.cognee_graph.CogneeGraphElements import Edge
 from cognee.modules.retrieval.utils.query_state import QueryState
 from cognee.modules.retrieval.utils.validate_queries import validate_retriever_input
@@ -64,7 +65,7 @@ class GraphCompletionCotRetriever(GraphCompletionRetriever):
         node_name_filter_operator: str = "OR",
         wide_search_top_k: Optional[int] = 100,
         triplet_distance_penalty: Optional[float] = 6.5,
-        feedback_influence: float = 0.0,
+        feedback_influence: float = get_base_config().default_feedback_influence,
         max_iter: int = 4,
         session_id: Optional[str] = None,
         response_model: Type = str,

cognee/modules/retrieval/graph_completion_decomposition_retriever.py

@@ -1,6 +1,7 @@
 import asyncio
 from typing import Any, List, Optional, Type
 
+from cognee.base_config import get_base_config
 from cognee.infrastructure.databases.unified import get_unified_engine
 from cognee.infrastructure.llm.LLMGateway import LLMGateway
 from cognee.infrastructure.llm.prompts import read_query_prompt
@@ -40,7 +41,7 @@ class GraphCompletionDecompositionRetriever(GraphCompletionRetriever):
         node_name_filter_operator: str = "OR",
         wide_search_top_k: Optional[int] = 100,
         triplet_distance_penalty: Optional[float] = 6.5,
-        feedback_influence: float = 0.0,
+        feedback_influence: float = get_base_config().default_feedback_influence,
         session_id: Optional[str] = None,
         response_model: Type = str,
         neighborhood_depth: Optional[int] = None,

cognee/modules/retrieval/graph_completion_retriever.py

@@ -1,6 +1,7 @@
 import asyncio
 from typing import Any, Dict, List, Optional, Type, Union
 
+from cognee.base_config import get_base_config
 from cognee.infrastructure.engine import DataPoint
 from cognee.modules.graph.cognee_graph.CogneeGraphElements import Edge
 from cognee.modules.retrieval.utils.validate_queries import validate_retriever_input
@@ -51,7 +52,7 @@ class GraphCompletionRetriever(BaseRetriever):
         node_name_filter_operator: str = "OR",
         wide_search_top_k: Optional[int] = 100,
         triplet_distance_penalty: Optional[float] = 6.5,
-        feedback_influence: float = 0.0,
+        feedback_influence: float = get_base_config().default_feedback_influence,
         session_id: Optional[str] = None,
         response_model: Type = str,
         neighborhood_depth: Optional[int] = None,

cognee/modules/retrieval/graph_summary_completion_retriever.py

@@ -1,5 +1,6 @@
 from typing import Optional, Type, List
 
+from cognee.base_config import get_base_config
 from cognee.modules.retrieval.graph_completion_retriever import GraphCompletionRetriever
 from cognee.modules.retrieval.utils.completion import summarize_text
 
@@ -28,7 +29,7 @@ class GraphSummaryCompletionRetriever(GraphCompletionRetriever):
         node_name_filter_operator: str = "OR",
         wide_search_top_k: Optional[int] = 100,
         triplet_distance_penalty: Optional[float] = 6.5,
-        feedback_influence: float = 0.0,
+        feedback_influence: float = get_base_config().default_feedback_influence,
         session_id: Optional[str] = None,
         include_references: bool = False,
     ):