cognee 1.4.0.dev2__tar.gz → 1.4.0.dev4__tar.gz

{cognee-1.4.0.dev2 → cognee-1.4.0.dev4}/CLAUDE.md

@@ -449,6 +449,19 @@ this rule applies only to internal PRs.
 - **Type hints**: Encouraged (ty checks enabled)
 - **Important**: Always run `pre-commit run --all-files` before committing to catch formatting issues
 
+## Commit & PR Title Style
+- **Subject line (required):**
+  - The format is (type): (short summary)
+  - Write summary as if it is giving an instruction (e.g., "Fix bug" instead of "Fixed bug")
+  - 50 chars or less
+  - Capitalize first char of summary
+  - Do NOT end with a period
+- **Body (optional):**
+  - **Description:** Explain the motivation behind the change, what problem it solves, and any relevant background.
+  - **Use the body to explain what and why, not how.** The body of the commit message should explain why the change was made and what problem it solves. You don't need to explain how the code works, as the code itself should be clear enough for that.
+- **Include issue tracking numbers where applicable.** Reference an issue in at least the subject line (e.g., Fixes COG-24), making it easier to trace changes to their corresponding issue.
+- **Separate the subject line from the body with a blank line.** This helps differentiate the short description from the detailed explanation. Generally, all commits should have separate subject and body.
+
 ## Testing Strategy
 
 Tests are organized in `cognee/tests/`:

{cognee-1.4.0.dev2 → cognee-1.4.0.dev4}/Dockerfile

@@ -46,7 +46,7 @@ RUN --mount=type=cache,target=/root/.cache/uv \
     for extra in ${COGNEE_EXTRAS}; do \
         set -- "$@" --extra "$extra"; \
     done; \
-    uv sync "$@" --extra debug --extra api --extra postgres --extra neo4j --extra llama-index --extra ollama --extra mistral --extra groq --extra anthropic --frozen --no-install-project --no-dev --no-editable
+    uv sync "$@" --extra debug --extra api --extra postgres --extra neo4j --extra llama-index --extra aws --extra ollama --extra mistral --extra groq --extra anthropic --frozen --no-install-project --no-dev --no-editable
 
 # Then, add the rest of the project source code and install it
 # Installing separately from its dependencies allows optimal layer caching
@@ -64,7 +64,7 @@ RUN --mount=type=cache,target=/root/.cache/uv \
     for extra in ${COGNEE_EXTRAS}; do \
         set -- "$@" --extra "$extra"; \
     done; \
-    uv sync "$@" --extra debug --extra api --extra postgres --extra neo4j --extra llama-index --extra ollama --extra mistral --extra groq --extra anthropic --frozen --no-dev --no-editable
+    uv sync "$@" --extra debug --extra aws --extra api --extra postgres --extra neo4j --extra llama-index --extra ollama --extra mistral --extra groq --extra anthropic --frozen --no-dev --no-editable
 
 FROM python:3.12-slim-bookworm
 

{cognee-1.4.0.dev2 → cognee-1.4.0.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cognee
-Version: 1.4.0.dev2
+Version: 1.4.0.dev4
 Summary: Cognee - is a library for enriching LLM context with a semantic layer for better understanding and reasoning.
 Project-URL: Homepage, https://www.cognee.ai
 Project-URL: Repository, https://github.com/topoteretes/cognee
@@ -99,7 +99,6 @@ Provides-Extra: distributed
 Requires-Dist: modal<2.0.0,>=1.0.5; extra == 'distributed'
 Provides-Extra: dlt
 Requires-Dist: dlt[sqlalchemy]<2,>=1.9.0; extra == 'dlt'
-Requires-Dist: pandas<3.0.0,>=2.2.2; extra == 'dlt'
 Provides-Extra: docling
 Requires-Dist: docling>=2.54; extra == 'docling'
 Requires-Dist: transformers>=4.55; extra == 'docling'
@@ -128,12 +127,6 @@ Provides-Extra: fastembed
 Requires-Dist: fastembed<=0.8.0; extra == 'fastembed'
 Requires-Dist: onnxruntime<=1.23.2; (python_version < '3.14') and extra == 'fastembed'
 Requires-Dist: onnxruntime>=1.24.1; (python_version >= '3.14') and extra == 'fastembed'
-Provides-Extra: gmail
-Requires-Dist: dlt[sqlalchemy]<2,>=1.9.0; extra == 'gmail'
-Requires-Dist: google-api-python-client<3,>=2.100.0; extra == 'gmail'
-Requires-Dist: google-auth-oauthlib<2,>=1.1.0; extra == 'gmail'
-Requires-Dist: google-auth<3,>=2.23.0; extra == 'gmail'
-Requires-Dist: pandas<3.0.0,>=2.2.2; extra == 'gmail'
 Provides-Extra: graphiti
 Requires-Dist: graphiti-core>=0.28.0; extra == 'graphiti'
 Provides-Extra: groq

{cognee-1.4.0.dev2 → cognee-1.4.0.dev4}/cognee/api/v1/add/add.py

@@ -250,9 +250,7 @@ async def add(
         data = await materialize_stream_for_background(data)
 
     await reset_dataset_pipeline_run_status(
-        authorized_dataset.id,
-        user,
-        pipeline_names=["add_pipeline", "cognify_pipeline", "dlt_cognify_pipeline"],
+        authorized_dataset.id, user, pipeline_names=["add_pipeline", "cognify_pipeline"]
     )
 
     pipeline_executor_func = get_pipeline_executor(run_in_background=run_in_background)

{cognee-1.4.0.dev2 → cognee-1.4.0.dev4}/cognee/api/v1/cognify/cognify.py

@@ -295,21 +295,19 @@ async def cognify(
         # By calling get pipeline executor we get a function that will have the run_pipeline run in the background or a function that we will need to wait for
         pipeline_executor_func = get_pipeline_executor(run_in_background=run_in_background)
 
-        # DLT-source manifest items run the deterministic DLT pipeline; all
-        # other data items keep the standard flow (see _plan_cognify_runs).
-        runs = await _plan_cognify_runs(datasets, user)
-
-        result = await _execute_cognify_runs(
-            runs,
-            executor=pipeline_executor_func,
-            cognify_tasks=tasks,
-            chunk_size=chunk_size,
-            chunks_per_batch=chunks_per_batch,
+        # Run the run_pipeline in the background or blocking based on executor
+        result = await pipeline_executor_func(
+            pipeline=run_pipeline,
+            tasks=tasks,
             user=user,
+            datasets=datasets,
             vector_db_config=vector_db_config,
             graph_db_config=graph_db_config,
             incremental_loading=incremental_loading,
+            use_pipeline_cache=False,
+            pipeline_name="cognify_pipeline",
             data_per_batch=data_per_batch,
+            rollback_handler=cognify_rollback_handler,
             llm_config=llm_config,
             embedding_config=embedding_config,
             data_cache=data_cache,
@@ -413,192 +411,6 @@ async def get_default_tasks(  # TODO: Find out a better way to do this (Boris's
     return default_tasks
 
 
-async def _execute_cognify_runs(
-    runs,
-    executor,
-    cognify_tasks,
-    chunk_size,
-    chunks_per_batch,
-    user,
-    vector_db_config,
-    graph_db_config,
-    incremental_loading,
-    data_per_batch,
-    llm_config,
-    embedding_config,
-    data_cache,
-):
-    """Execute the planned pipeline runs and merge their results.
-
-    Each run is (pipeline_name, datasets, items): items is an explicit data
-    subset for mixed datasets, or None to let the pipeline load the dataset
-    itself. The DLT task list is built lazily, only when a run needs it.
-    """
-    tasks_for = {"cognify_pipeline": cognify_tasks}
-    partial_results = []
-    for pipeline_name, run_datasets, items in runs:
-        if pipeline_name not in tasks_for:
-            tasks_for[pipeline_name] = await get_dlt_tasks(
-                chunk_size=chunk_size, chunks_per_batch=chunks_per_batch
-            )
-        data_kwargs = {"data": items} if items is not None else {}
-        partial_results.append(
-            await executor(
-                pipeline=run_pipeline,
-                tasks=tasks_for[pipeline_name],
-                datasets=run_datasets,
-                pipeline_name=pipeline_name,
-                user=user,
-                vector_db_config=vector_db_config,
-                graph_db_config=graph_db_config,
-                incremental_loading=incremental_loading,
-                use_pipeline_cache=False,
-                data_per_batch=data_per_batch,
-                rollback_handler=cognify_rollback_handler,
-                llm_config=llm_config,
-                embedding_config=embedding_config,
-                data_cache=data_cache,
-                **data_kwargs,
-            )
-        )
-    return _merge_pipeline_results(partial_results)
-
-
-async def _plan_cognify_runs(datasets, user) -> list[tuple[str, list, Optional[list]]]:
-    """Plan pipeline runs for cognify routing.
-
-    DLT-source manifests (external_metadata.source == "dlt_source") run the
-    DLT pipeline; all other items run the standard cognify pipeline. The split
-    is per data item, so mixed datasets get both pipelines, each with its own
-    item subset.
-
-    Returns [(pipeline_name, dataset_ids, data_or_None)]:
-    - ("dlt_cognify_pipeline", [ds_id], manifest_items) per manifest dataset
-    - ("cognify_pipeline", [ds_id], regular_items) for manifest datasets that
-      also contain non-manifest items
-    - one ("cognify_pipeline", [ids...], None) entry for all datasets without
-      manifests, items loaded by the pipeline itself (unchanged behavior)
-
-    When no dataset contains a manifest, the plan is a single standard run
-    that passes the original ``datasets`` argument through unchanged (items
-    are loaded by the pipeline itself).
-    """
-    from sqlalchemy import select
-
-    from cognee.infrastructure.databases.relational import get_relational_engine
-    from cognee.modules.data.models import Data, DatasetData
-    from cognee.modules.data.methods import get_authorized_existing_datasets, get_dataset_data
-    from cognee.modules.users.methods import get_default_user
-    from cognee.tasks.ingestion.dlt_utils import is_dlt_source_manifest
-
-    if user is None:
-        user = await get_default_user()
-
-    dataset_list = datasets if isinstance(datasets, list) or datasets is None else [datasets]
-    authorized_datasets = await get_authorized_existing_datasets(
-        datasets=dataset_list, permission_type="write", user=user
-    )
-    if not authorized_datasets:
-        return [("cognify_pipeline", datasets, None)]
-
-    # One filtered query to find which requested datasets contain a manifest,
-    # instead of loading every dataset's data items.
-    authorized_ids = [dataset.id for dataset in authorized_datasets]
-    async with get_relational_engine().get_async_session() as session:
-        manifest_dataset_ids = set(
-            (
-                await session.execute(
-                    select(DatasetData.dataset_id)
-                    .join(Data, Data.id == DatasetData.data_id)
-                    .where(
-                        DatasetData.dataset_id.in_(authorized_ids),
-                        Data.external_metadata["source"].as_string() == "dlt_source",
-                    )
-                    .distinct()
-                )
-            )
-            .scalars()
-            .all()
-        )
-
-    if not manifest_dataset_ids:
-        return [("cognify_pipeline", datasets, None)]
-
-    runs: list[tuple[str, list, Optional[list]]] = []
-    regular_ids = []
-    for dataset in authorized_datasets:
-        if dataset.id not in manifest_dataset_ids:
-            regular_ids.append(dataset.id)
-            continue
-
-        manifest_items, regular_items = [], []
-        for item in await get_dataset_data(dataset.id):
-            (manifest_items if is_dlt_source_manifest(item) else regular_items).append(item)
-
-        runs.append(("dlt_cognify_pipeline", [dataset.id], manifest_items))
-        if regular_items:
-            runs.append(("cognify_pipeline", [dataset.id], regular_items))
-
-    if regular_ids:
-        runs.append(("cognify_pipeline", regular_ids, None))
-
-    return runs
-
-
-def _merge_pipeline_results(partial_results: list) -> dict:
-    """Merge results from multiple pipeline executor calls.
-
-    Both executor modes return dicts keyed by dataset_id. For a dataset with
-    two runs (DLT + regular) the later (regular) run info wins, as it runs
-    after the DLT pipeline.
-    """
-    merged = {}
-    for partial in partial_results:
-        merged.update(partial)
-    return merged
-
-
-async def get_dlt_tasks(chunk_size: int = None, chunks_per_batch: int = None) -> list[Task]:
-    """Deterministic pipeline for DLT-source manifest datasets.
-
-    No LLM tasks: each manifest row becomes one DocumentChunk (vector-indexed
-    by add_data_points) and the graph structure comes from the relational
-    schema via extract_dlt_source_edges.
-    """
-    from cognee.tasks.ingestion.extract_dlt_source_edges import extract_dlt_source_edges
-
-    cognify_config = get_cognify_config()
-    if chunks_per_batch is None:
-        chunks_per_batch = (
-            cognify_config.chunks_per_batch if cognify_config.chunks_per_batch is not None else 100
-        )
-
-    return [
-        # EXTRACT: classify manifest Data items into DltSourceDocument objects
-        Task(classify_documents),
-        # EXTRACT: one DocumentChunk per manifest row (no text chunking)
-        Task(
-            extract_chunks_from_documents,
-            max_chunk_size=chunk_size or await get_max_chunk_tokens(),
-            chunker=TextChunker,
-        ),
-        # LOAD: persist row chunks and embeddings to graph/vector DBs
-        Task(
-            add_data_points,
-            task_config={"batch_size": chunks_per_batch},
-        ),
-        # LOAD: schema nodes and deterministic FK edges from the manifest.
-        # emitted_schema_docs and emitted_value_node_ids are shared across
-        # batches of this pipeline run so schema nodes and column value nodes
-        # are only emitted (and embedded) once per run, not once per batch.
-        Task(
-            extract_dlt_source_edges,
-            emitted_schema_docs=set(),
-            emitted_value_node_ids=set(),
-        ),
-    ]
-
-
 async def get_temporal_tasks(
     user: User = None, chunker=TextChunker, chunk_size: int = None, chunks_per_batch: int = None
 ) -> list[Task]:

{cognee-1.4.0.dev2 → cognee-1.4.0.dev4}/cognee/api/v1/config/config.py

@@ -457,7 +457,8 @@ class config:
             Valid keys include: embedding_provider, embedding_model,
             embedding_dimensions, embedding_endpoint, embedding_api_key,
             embedding_api_version, embedding_max_completion_tokens,
-            embedding_batch_size, huggingface_tokenizer.
+            embedding_batch_size, embedding_max_concurrent_data_points,
+            huggingface_tokenizer.
 
         Example
         -------

{cognee-1.4.0.dev2 → cognee-1.4.0.dev4}/cognee/context_global_variables.py

@@ -68,10 +68,14 @@ def multi_user_support_possible():
             f"Supported dataset to database handlers: {list(supported_dataset_database_handlers.keys())}\n"
         )
 
-    if (
-        supported_dataset_database_handlers[graph_handler]["handler_provider"]
-        != graph_db_config.graph_database_provider
-    ):
+    def compatible_providers(handler_name):
+        # handler_provider is a plain string, or a tuple when a handler works
+        # with multiple providers (e.g. ladybug/kuzu). Normalize the string so
+        # membership below never falls into substring matching.
+        providers = supported_dataset_database_handlers[handler_name]["handler_provider"]
+        return (providers,) if isinstance(providers, str) else providers
+
+    if graph_db_config.graph_database_provider not in compatible_providers(graph_handler):
         raise EnvironmentError(
             "The selected graph dataset to database handler does not work with the configured graph database provider. Cannot add support for multi-user access control mode. Please use a supported graph dataset to database handler or set the environment variables ENABLE_BACKEND_ACCESS_CONTROL to false to switch off multi-user access control mode.\n"
             f"Selected graph database provider: {graph_db_config.graph_database_provider}\n"
@@ -79,10 +83,7 @@ def multi_user_support_possible():
             f"Supported dataset to database handlers: {list(supported_dataset_database_handlers.keys())}\n"
         )
 
-    if (
-        supported_dataset_database_handlers[vector_handler]["handler_provider"]
-        != vector_db_config.vector_db_provider
-    ):
+    if vector_db_config.vector_db_provider not in compatible_providers(vector_handler):
         raise EnvironmentError(
             "The selected vector dataset to database handler does not work with the configured vector database provider. Cannot add support for multi-user access control mode. Please use a supported vector dataset to database handler or set the environment variables ENABLE_BACKEND_ACCESS_CONTROL to false to switch off multi-user access control mode.\n"
             f"Selected vector database provider: {vector_db_config.vector_db_provider}\n"

{cognee-1.4.0.dev2 → cognee-1.4.0.dev4}/cognee/infrastructure/databases/dataset_database_handler/supported_dataset_database_handlers.py

@@ -23,6 +23,8 @@ from cognee.infrastructure.databases.graph.turso.TursoGraphDatasetDatabaseHandle
     TursoGraphDatasetDatabaseHandler,
 )
 
+# handler_provider is the database provider a handler works with: a plain string,
+# or a tuple only when the handler is compatible with multiple providers.
 supported_dataset_database_handlers = {
     "neo4j_aura_dev": {
         "handler_instance": Neo4jAuraDevDatasetDatabaseHandler,
@@ -45,11 +47,15 @@ supported_dataset_database_handlers = {
         "handler_instance": PostgresGraphDatasetDatabaseHandler,
         "handler_provider": "postgres",
     },
+    # Ladybug is the renamed Kuzu engine — either provider name works with either handler.
     "ladybug": {
         "handler_instance": LadybugDatasetDatabaseHandler,
-        "handler_provider": "ladybug",
+        "handler_provider": ("ladybug", "kuzu"),
+    },
+    "kuzu": {
+        "handler_instance": LadybugDatasetDatabaseHandler,
+        "handler_provider": ("ladybug", "kuzu"),
     },
-    "kuzu": {"handler_instance": LadybugDatasetDatabaseHandler, "handler_provider": "kuzu"},
     "turso_graph": {
         "handler_instance": TursoGraphDatasetDatabaseHandler,
         "handler_provider": "turso",

{cognee-1.4.0.dev2 → cognee-1.4.0.dev4}/cognee/infrastructure/databases/graph/graph_db_interface.py

@@ -45,6 +45,12 @@ class GraphDBInterface(ABC):
     - get_connections
     """
 
+    # Whether this backend executes raw Cypher through ``query()``. Declared on
+    # the adapter class so callers (CYPHER / NATURAL_LANGUAGE retrievers) can
+    # check the capability on the engine instance they already hold, without
+    # importing optional backend packages that slim images do not ship.
+    supports_cypher_queries: bool = True
+
     @abstractmethod
     async def is_empty(self) -> bool:
         """Return True when the graph contains no nodes."""

{cognee-1.4.0.dev2 → cognee-1.4.0.dev4}/cognee/infrastructure/databases/graph/postgres/adapter.py

@@ -102,6 +102,9 @@ def _provenance_conflict_set(table, inputs: ProvenanceAttachInputs) -> Dict[str,
 class PostgresAdapter(GraphDBInterface):
     """Graph-as-tables adapter backed by Postgres, accessed via SQLAlchemy async sessions."""
 
+    # ``query()`` executes SQL against the graph tables, not Cypher.
+    supports_cypher_queries = False
+
     _ALLOWED_FILTER_ATTRS = {"id", "name", "type"}
 
     def __init__(self, connection_string: str) -> None:

{cognee-1.4.0.dev2 → cognee-1.4.0.dev4}/cognee/infrastructure/databases/graph/turso/adapter.py

@@ -50,6 +50,9 @@ def _id_subquery(prefix: str, ids: List[str]) -> Tuple[str, Dict[str, str]]:
 class TursoAdapter(GraphDBInterface):
     """Graph-as-tables adapter backed by Turso/libSQL, accessed via SQLAlchemy async sessions."""
 
+    # ``query()`` executes SQL against the graph tables, not Cypher.
+    supports_cypher_queries = False
+
     _ALLOWED_FILTER_ATTRS = {"id", "name", "type"}
 
     def __init__(self, connection_string: str) -> None:

{cognee-1.4.0.dev2 → cognee-1.4.0.dev4}/cognee/infrastructure/databases/hybrid/postgres/adapter.py

@@ -55,6 +55,9 @@ class PostgresHybridAdapter(GraphDBInterface, VectorDBInterface):
     collection tables.
     """
 
+    # Graph queries run as SQL via the wrapped PostgresAdapter, not Cypher.
+    supports_cypher_queries = False
+
     def __init__(
         self,
         graph_adapter: "PostgresAdapter",

{cognee-1.4.0.dev2 → cognee-1.4.0.dev4}/cognee/infrastructure/databases/vector/embeddings/config.py

@@ -80,6 +80,9 @@ class EmbeddingConfig(BaseSettings):
     embedding_api_version: Optional[str] = None
     embedding_max_completion_tokens: Optional[int] = 8191
     embedding_batch_size: Optional[int] = None
+    # Total data points allowed in flight to the embedding engine during indexing.
+    # Concurrent embedding requests = max(1, this // embedding_batch_size).
+    embedding_max_concurrent_data_points: int = 150
     huggingface_tokenizer: Optional[str] = None
     # Rate-limiting for embedding requests. Lives here (not in LLMConfig) so the
     # knobs sit with the embedding settings they govern.
@@ -131,6 +134,7 @@ class EmbeddingConfig(BaseSettings):
             "embedding_max_completion_tokens": self.embedding_max_completion_tokens,
             "huggingface_tokenizer": self.huggingface_tokenizer,
             "embedding_batch_size": self.embedding_batch_size,
+            "embedding_max_concurrent_data_points": self.embedding_max_concurrent_data_points,
             "embedding_rate_limit_enabled": self.embedding_rate_limit_enabled,
             "embedding_rate_limit_requests": self.embedding_rate_limit_requests,
             "embedding_rate_limit_interval": self.embedding_rate_limit_interval,

{cognee-1.4.0.dev2 → cognee-1.4.0.dev4}/cognee/infrastructure/llm/config.py

@@ -245,6 +245,13 @@ class LLMConfig(BaseSettings):
                 f"for LLM usage (LLM_MODEL, LLM_ENDPOINT, LLM_API_KEY). Missing: {missing_llm}"
             )
 
+        # Check model support matrix if LLM_MODEL is configured
+        model_name = os.environ.get("LLM_MODEL") or self.llm_model
+        if model_name:
+            from cognee.infrastructure.llm.ollama_support import check_model_support
+
+            check_model_support(model_name)
+
         return self
 
     def to_dict(self) -> dict[str, Any]:

cognee-1.4.0.dev4/cognee/infrastructure/llm/ollama_support.py

@@ -0,0 +1,89 @@
+import re
+from typing import Optional
+from cognee.shared.logging_utils import get_logger
+
+logger = get_logger("ollama_support")
+
+# Isolated Ollama model support matrix
+OLLAMA_MODEL_CLASSIFICATIONS = {
+    # Recommended models
+    "llama3": "recommended",
+    "llama3.1": "recommended",
+    "llama3.2": "recommended",
+    "llama3.3": "recommended",
+    # Problematic / known limitations
+    "mistral": "problematic",
+    "phi3": "problematic",
+    "phi3.5": "problematic",
+}
+
+_warned_models = set()
+
+
+def normalize_model_name(model_name: str) -> str:
+    """Normalize provider prefixes and version/parameter tags from the model name."""
+    if not model_name:
+        return ""
+    normalized = model_name.strip().lower()
+    # Remove provider prefix (e.g., "ollama/")
+    if normalized.startswith("ollama/"):
+        normalized = normalized[len("ollama/") :]
+    return normalized
+
+
+def classify_model(normalized_name: str) -> str:
+    """Classify normalized model into 'recommended', 'problematic', or 'unknown'."""
+    # Remove version/parameter tags (e.g., ":8b", ":latest") for dictionary lookup
+    base_name = normalized_name.split(":")[0] if ":" in normalized_name else normalized_name
+
+    # Handle Qwen 2.5 classification based on parameter size
+    if "qwen2.5" in normalized_name:
+        if ":" in normalized_name:
+            tag = normalized_name.split(":")[1]
+            match = re.search(r"(\d+(\.\d+)?)\s*b", tag)
+            if match:
+                try:
+                    size = float(match.group(1))
+                    if size >= 14.0:
+                        return "recommended"
+                    else:
+                        return "problematic"
+                except ValueError:
+                    pass
+        # Default fallback for qwen2.5 if tag is missing or not parseable
+        return "problematic"
+
+    if base_name in OLLAMA_MODEL_CLASSIFICATIONS:
+        return OLLAMA_MODEL_CLASSIFICATIONS[base_name]
+
+    return "unknown"
+
+
+def emit_warning(classification: str, model_name: str) -> None:
+    """Emits an advisory warning once per model name configuration."""
+    if model_name in _warned_models:
+        return
+    _warned_models.add(model_name)
+
+    if classification == "problematic":
+        logger.warning(
+            f"Model '{model_name}' has known limitations when used for structured graph extraction "
+            "(such as schema validation errors or silent drops). Cognee will continue execution, "
+            "but we recommend using a validated model (like Llama 3.1 or Llama 3.2). "
+            "See docs/ollama_models.md for details."
+        )
+    elif classification == "unknown":
+        logger.warning(
+            f"Model '{model_name}' has not been validated for structured graph extraction. "
+            "Cognee will continue execution, but extraction quality may vary. "
+            "See docs/ollama_models.md for recommended models."
+        )
+
+
+def check_model_support(model_name: Optional[str]) -> None:
+    """Check the model name support matrix and emit an advisory warning if necessary."""
+    if not model_name:
+        return
+    normalized = normalize_model_name(model_name)
+    classification = classify_model(normalized)
+    emit_warning(classification, model_name)

{cognee-1.4.0.dev2 → cognee-1.4.0.dev4}/cognee/modules/cognify/estimator.py

@@ -369,7 +369,13 @@ def _path_candidate(value: str) -> Optional[Path]:
             # Mirror the ACCEPT_LOCAL_FILE_PATH gate: an existing *absolute* file
             # path is rejected, while an existing *relative* path falls through to
             # raw text (save_data_item_to_storage has no reject branch for it).
-            if value.startswith("/"):
+            # Absolute-path detection matches save_data_item_to_storage exactly,
+            # including Windows drive-letter paths (C:\...), which "/"-prefix
+            # checking alone misses.
+            is_absolute_path = (
+                value.startswith("/") or (os.name == "nt" and len(value) > 1 and value[1] == ":")
+            ) and Path(os.path.normpath(value)).is_absolute()
+            if is_absolute_path:
                 raise ValueError(f"Local files are not accepted, got {value!r}.")
             return None
         return path

{cognee-1.4.0.dev2 → cognee-1.4.0.dev4}/cognee/modules/data/methods/get_unique_data_id.py

@@ -66,31 +66,3 @@ async def get_unique_data_id(data_identifier: str, user: User) -> UUID:
         if not legacy_data_point:
             return data_id["modern_data_id"]
         return data_id["legacy_data_id"]
-
-
-async def get_unique_data_ids(data_identifiers: list[str], user: User) -> list[UUID]:
-    """Batch variant of get_unique_data_id: resolves all identifiers with a single
-    query. Returns one id per identifier, preserving input order — the legacy id
-    where a Data record with it exists, otherwise the modern id.
-
-    The id formulas mirror get_unique_data_id's internal helpers exactly.
-    """
-    if not data_identifiers:
-        return []
-
-    legacy_ids = [
-        uuid5(NAMESPACE_OID, f"{identifier}{str(user.id)}") for identifier in data_identifiers
-    ]
-
-    db_engine = get_relational_engine()
-    async with db_engine.get_async_session() as session:
-        existing_legacy_ids = set(
-            (await session.execute(select(Data.id).filter(Data.id.in_(legacy_ids)))).scalars().all()
-        )
-
-    return [
-        legacy_id
-        if legacy_id in existing_legacy_ids
-        else uuid5(NAMESPACE_OID, f"{identifier}{str(user.id)}{str(user.tenant_id)}")
-        for identifier, legacy_id in zip(data_identifiers, legacy_ids)
-    ]

{cognee-1.4.0.dev2 → cognee-1.4.0.dev4}/cognee/modules/data/processing/document_types/DltRowDocument.py

@@ -8,9 +8,6 @@ from .Document import Document
 class DltRowDocument(Document):
     """Document type for DLT-ingested relational rows.
 
-    Legacy: pre-manifest per-row DLT records; superseded by DltSourceDocument
-    manifests.
-
     Skips chunking entirely — yields a single DocumentChunk containing
     the enriched schema context text. The graph for DLT data is built
     deterministically by extract_dlt_fk_edges, so no LLM extraction

{cognee-1.4.0.dev2 → cognee-1.4.0.dev4}/cognee/modules/data/processing/document_types/__init__.py

@@ -6,4 +6,3 @@ from .AudioDocument import AudioDocument
 from .UnstructuredDocument import UnstructuredDocument
 from .CsvDocument import CsvDocument
 from .DltRowDocument import DltRowDocument
-from .DltSourceDocument import DltSourceDocument

{cognee-1.4.0.dev2 → cognee-1.4.0.dev4}/cognee/modules/migration/sources/letta.py

@@ -45,7 +45,16 @@ def _first_list(container: Dict[str, Any], *keys: str) -> List[Dict[str, Any]]:
 
 
 def _message_text(message: Dict[str, Any]) -> str:
-    content = message.get("content", message.get("text"))
+    """Return the text of a message, from ``content`` or the ``text`` alias.
+
+    ``content`` is optional in the message schema, and a serializer that keeps
+    unset fields writes it as null instead of omitting it. ``dict.get``'s
+    default only fires on a missing key, so the fallback has to be explicit or
+    a null content silently yields no text and the message is dropped.
+    """
+    content = message.get("content")
+    if content is None:
+        content = message.get("text")
     if isinstance(content, str):
         return content
     if isinstance(content, list):

{cognee-1.4.0.dev2 → cognee-1.4.0.dev4}/cognee/modules/retrieval/cypher_search_retriever.py

@@ -34,16 +34,14 @@ class CypherSearchRetriever(BaseRetriever):
         try:
             graph_engine = await get_graph_engine()
 
-            # Postgres backends do not support raw Cypher queries
-            from cognee.infrastructure.databases.graph.postgres.adapter import PostgresAdapter
-            from cognee.infrastructure.databases.hybrid.postgres.adapter import (
-                PostgresHybridAdapter,
-            )
-
-            if isinstance(graph_engine, (PostgresAdapter, PostgresHybridAdapter)):
+            # Cypher support is declared on the adapter class
+            # (GraphDBInterface.supports_cypher_queries), so the check needs no
+            # imports of optional backend packages absent from slim images.
+            if not getattr(graph_engine, "supports_cypher_queries", True):
                 raise SearchTypeNotSupported(
-                    "Cypher search is not supported with the Postgres graph backend. "
-                    "Use a Cypher-capable graph backend (Neo4j, Ladybug) for raw Cypher queries."
+                    f"Cypher search is not supported with the "
+                    f"{type(graph_engine).__name__} graph backend. Use a "
+                    "Cypher-capable graph backend (Neo4j, Ladybug) for raw Cypher queries."
                 )
 
             is_empty = await graph_engine.is_empty()