cognee 1.0.0.dev0__tar.gz → 1.0.1.dev0__tar.gz

{cognee-1.0.0.dev0 → cognee-1.0.1.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cognee
-Version: 1.0.0.dev0
+Version: 1.0.1.dev0
 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

cognee-1.0.1.dev0/cognee/alembic/versions/6ee94db7381f_remove_unique_constraint_tenant_name.py

@@ -0,0 +1,128 @@
+"""remove unique constraint tenant name
+
+Revision ID: 6ee94db7381f
+Revises: d4e5f6a7b8c9
+Create Date: 2026-04-13 18:30:04.942834
+
+"""
+
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision: str = "6ee94db7381f"
+down_revision: Union[str, None] = "d4e5f6a7b8c9"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def _unique_constraint_name(inspector: sa.Inspector, table: str, column: str) -> str | None:
+    for constraint in inspector.get_unique_constraints(table):
+        column_names = constraint.get("column_names") or []
+        if len(column_names) == 1 and column_names[0] == column:
+            return constraint.get("name")
+    return None
+
+
+def _index_name_for_column(
+    inspector: sa.Inspector, table: str, column: str, *, unique: bool | None = None
+) -> str | None:
+    for index in inspector.get_indexes(table):
+        column_names = index.get("column_names") or []
+        if len(column_names) == 1 and column_names[0] == column:
+            if unique is None or bool(index.get("unique")) is unique:
+                return index.get("name")
+    return None
+
+
+def _has_unique_on_column(inspector: sa.Inspector, table: str, column: str) -> bool:
+    return (
+        _unique_constraint_name(inspector, table, column) is not None
+        or _index_name_for_column(inspector, table, column, unique=True) is not None
+    )
+
+
+def _recreate_tenants_table_sqlite(unique_name: bool) -> None:
+    conn = op.get_bind()
+
+    op.create_table(
+        "tenants_new",
+        sa.Column("id", sa.UUID(), nullable=False),
+        sa.Column("name", sa.String(), nullable=False),
+        sa.Column("owner_id", sa.UUID(), nullable=True),
+        sa.ForeignKeyConstraint(["id"], ["principals.id"]),
+        sa.PrimaryKeyConstraint("id"),
+    )
+
+    conn.execute(
+        sa.text(
+            "INSERT INTO tenants_new (id, name, owner_id) SELECT id, name, owner_id FROM tenants"
+        )
+    )
+
+    op.drop_table("tenants")
+    op.rename_table("tenants_new", "tenants")
+
+    op.create_index("ix_tenants_owner_id", "tenants", ["owner_id"], unique=False)
+    op.create_index("ix_tenants_name", "tenants", ["name"], unique=unique_name)
+
+
+def upgrade() -> None:
+    if op.get_context().dialect.name == "sqlite":
+        conn = op.get_bind()
+
+        result = conn.execute(sa.text("PRAGMA index_list('tenants')"))
+        rows = result.fetchall()
+        # Check if there's a unique index on the name column. If third element in row is 1, it's a unique index
+        unique_auto_indexes = [row for row in rows if row[2] == 1]
+        for row in unique_auto_indexes:
+            result = conn.execute(sa.text(f"PRAGMA index_info('{row[1]}')"))
+            index_info = result.fetchall()
+            if index_info[0][2] == "name":
+                # In case a unique index exists on tenant name remove uniqueness
+                _recreate_tenants_table_sqlite(unique_name=False)
+        return
+
+    conn = op.get_bind()
+    inspector = sa.inspect(conn)
+
+    unique_constraint = _unique_constraint_name(inspector, "tenants", "name")
+
+    if unique_constraint:
+        with op.batch_alter_table("tenants", schema=None) as batch_op:
+            batch_op.drop_constraint(unique_constraint, type_="unique")
+
+    # Re-inspect after potential constraint drop to avoid stale metadata.
+    inspector = sa.inspect(conn)
+    unique_index = _index_name_for_column(inspector, "tenants", "name", unique=True)
+    if unique_index:
+        op.drop_index(unique_index, table_name="tenants")
+        op.create_index(unique_index, "tenants", ["name"], unique=False)
+
+    # Keep name indexed after removing uniqueness.
+    inspector = sa.inspect(conn)
+    if _index_name_for_column(inspector, "tenants", "name", unique=None) is None:
+        op.create_index("ix_tenants_name", "tenants", ["name"], unique=False)
+
+
+def downgrade() -> None:
+    if op.get_context().dialect.name == "sqlite":
+        _recreate_tenants_table_sqlite(unique_name=True)
+        return
+
+    conn = op.get_bind()
+    inspector = sa.inspect(conn)
+
+    if _has_unique_on_column(inspector, "tenants", "name"):
+        return
+
+    existing_name_index = _index_name_for_column(inspector, "tenants", "name", unique=False)
+    if existing_name_index:
+        op.drop_index(existing_name_index, table_name="tenants")
+        op.create_index(existing_name_index, "tenants", ["name"], unique=True)
+    else:
+        with op.batch_alter_table("tenants", schema=None) as batch_op:
+            batch_op.create_unique_constraint("tenants_name_key", ["name"])

{cognee-1.0.0.dev0 → cognee-1.0.1.dev0}/cognee/api/v1/activity/routers/get_activity_router.py

@@ -7,7 +7,11 @@ can render an activity timeline and trace viewer.
 from typing import Optional
 from uuid import UUID
 from fastapi import APIRouter, Query, Depends
+from cognee.modules.users.models import User
 from cognee.modules.users.methods.get_authenticated_user import get_authenticated_user
+from cognee.modules.users.permissions.methods.get_specific_user_permission_datasets import (
+    get_specific_user_permission_datasets,
+)
 
 
 def get_activity_router() -> APIRouter:
@@ -15,8 +19,7 @@ def get_activity_router() -> APIRouter:
 
     @router.get("/pipeline-runs")
     async def get_pipeline_runs(
-        dataset_id: Optional[UUID] = Query(None),
-        user=get_authenticated_user,
+        dataset_id: Optional[UUID] = Query(None), user: User = Depends(get_authenticated_user)
     ):
         """Return recent pipeline runs with dataset owner info for agent attribution."""
         from cognee.infrastructure.databases.relational import get_relational_engine
@@ -25,6 +28,11 @@ def get_activity_router() -> APIRouter:
         from cognee.modules.users.models import User
         from sqlalchemy import select, outerjoin
 
+        dataset_ids = await get_specific_user_permission_datasets(
+            user.id, "read", [dataset_id] if dataset_id else None
+        )
+        dataset_ids = [ds.id for ds in dataset_ids]
+
         db_engine = get_relational_engine()
         async with db_engine.get_async_session() as session:
             # Join pipeline runs → dataset → owner user for agent attribution
@@ -40,11 +48,11 @@ def get_activity_router() -> APIRouter:
                         User, Dataset.owner_id == User.id
                     )
                 )
+                .where(PipelineRun.dataset_id.in_(dataset_ids))
                 .order_by(PipelineRun.created_at.desc())
                 .limit(50)
             )
-            if dataset_id:
-                stmt = stmt.filter(PipelineRun.dataset_id == dataset_id)
+
             result = await session.execute(stmt)
             rows = result.all()
 
@@ -64,7 +72,7 @@ def get_activity_router() -> APIRouter:
         ]
 
     @router.get("/spans")
-    async def get_spans(user=get_authenticated_user):
+    async def get_spans(user: User = Depends(get_authenticated_user)):
         """Return in-memory OTEL spans from the CogneeSpanExporter buffer."""
         try:
             from cognee.modules.observability.tracing import get_exporter
@@ -100,17 +108,12 @@ def get_activity_router() -> APIRouter:
             return {"error": str(e)}
 
     @router.get("/users")
-    async def get_tenant_users(user=get_authenticated_user):
+    async def get_tenant_users(user: User = Depends(get_authenticated_user)):
         """Return users in the current tenant (includes agents as API key users)."""
         try:
             from cognee.modules.users.tenants.methods import get_users_in_tenant
-            from cognee.modules.users.methods import get_default_user
 
-            default_user = await get_default_user()
-            if not default_user or not default_user.tenant_id:
-                return []
-
-            users = await get_users_in_tenant(default_user.tenant_id)
+            users = await get_users_in_tenant(user.tenant_id)
             return [
                 {
                     "id": str(u.id),
@@ -126,7 +129,7 @@ def get_activity_router() -> APIRouter:
             return []
 
     @router.get("/agents")
-    async def get_agents(user=get_authenticated_user):
+    async def get_agents(user: User = Depends(get_authenticated_user)):
         """Return registered agents (users with @cognee.agent emails)."""
         from cognee.infrastructure.databases.relational import get_relational_engine
         from cognee.modules.users.models import User
@@ -207,6 +210,9 @@ def get_activity_router() -> APIRouter:
         from sqlalchemy import select
         from datetime import datetime, timezone
 
+        dataset_ids = await get_specific_user_permission_datasets(user.id, "read", [dataset_id])
+        dataset_id = dataset_ids[0].id
+
         db_engine = get_relational_engine()
 
         # Get dataset info

{cognee-1.0.0.dev0 → cognee-1.0.1.dev0}/cognee/api/v1/remember/remember.py

@@ -464,7 +464,7 @@ async def _remember_inner(
     client = get_remote_client()
     if client is not None:
         span.set_attribute(COGNEE_OPERATION_MODE, "cloud")
-        return await client.remember(data, dataset_name, **kwargs)
+        return await client.remember(data, dataset_name, session_id=session_id, **kwargs)
 
     # Run vector migrations lazily on the first local SDK call.
     # This ensures stale LanceDB schemas are migrated before any

{cognee-1.0.0.dev0 → cognee-1.0.1.dev0}/cognee/api/v1/remember/routers/get_remember_router.py

@@ -30,6 +30,7 @@ def get_remember_router() -> APIRouter:
         data: List[UploadFile] = File(default=None),
         datasetName: Optional[str] = Form(default=None),
         datasetId: Union[UUID, Literal[""], None] = Form(default=None, examples=[""]),
+        session_id: Optional[str] = Form(default=None),
         node_set: Optional[List[str]] = Form(default=[""], example=[""]),
         run_in_background: Optional[bool] = Form(default=False),
         custom_prompt: Optional[str] = Form(default=""),
@@ -79,6 +80,7 @@ def get_remember_router() -> APIRouter:
             result = await cognee_remember(
                 data,
                 dataset_name=datasetName,
+                session_id=session_id,
                 user=user,
                 dataset_id=datasetId if datasetId else None,
                 node_set=node_set if node_set != [""] else None,

{cognee-1.0.0.dev0 → cognee-1.0.1.dev0}/cognee/api/v1/serve/cloud_client.py

@@ -53,6 +53,8 @@ class CloudClient:
         form = aiohttp.FormData()
         form.add_field("datasetName", dataset_name)
 
+        if kwargs.get("session_id"):
+            form.add_field("session_id", kwargs["session_id"])
         if kwargs.get("run_in_background"):
             form.add_field("run_in_background", "true")
         if kwargs.get("custom_prompt"):

{cognee-1.0.0.dev0 → cognee-1.0.1.dev0}/cognee/infrastructure/databases/graph/get_graph_engine.py

@@ -1,6 +1,7 @@
 """Factory function to get the appropriate graph client based on the graph type."""
 
 from functools import lru_cache
+from cognee.shared.lru_cache import DATABASE_MAX_LRU_CACHE_SIZE
 
 from .config import get_graph_context_config
 from .graph_db_interface import GraphDBInterface
@@ -66,7 +67,7 @@ def create_graph_engine(
     )
 
 
-@lru_cache
+@lru_cache(maxsize=DATABASE_MAX_LRU_CACHE_SIZE)
 def _create_graph_engine(
     graph_database_provider,
     graph_file_path,

{cognee-1.0.0.dev0 → cognee-1.0.1.dev0}/cognee/infrastructure/databases/relational/create_relational_engine.py

@@ -1,9 +1,10 @@
 from sqlalchemy import URL
 from .sqlalchemy.SqlAlchemyAdapter import SQLAlchemyAdapter
 from functools import lru_cache
+from cognee.shared.lru_cache import DATABASE_MAX_LRU_CACHE_SIZE
 
 
-@lru_cache
+@lru_cache(maxsize=DATABASE_MAX_LRU_CACHE_SIZE)
 def create_relational_engine(
     db_path: str,
     db_name: str,

{cognee-1.0.0.dev0 → cognee-1.0.1.dev0}/cognee/infrastructure/databases/vector/create_vector_engine.py

@@ -5,6 +5,7 @@ from .embeddings import get_embedding_engine
 from cognee.infrastructure.databases.graph.config import get_graph_context_config
 
 from functools import lru_cache
+from cognee.shared.lru_cache import DATABASE_MAX_LRU_CACHE_SIZE
 
 
 def create_vector_engine(
@@ -58,7 +59,7 @@ def create_vector_engine(
     )
 
 
-@lru_cache
+@lru_cache(maxsize=DATABASE_MAX_LRU_CACHE_SIZE)
 def _create_vector_engine(
     vector_db_provider: str,
     vector_db_url: str,

{cognee-1.0.0.dev0 → cognee-1.0.1.dev0}/cognee/infrastructure/databases/vector/pgvector/PGVectorAdapter.py

@@ -5,7 +5,6 @@ from sqlalchemy.inspection import inspect
 from sqlalchemy.orm import Mapped, mapped_column
 from sqlalchemy.dialects.postgresql import insert
 from sqlalchemy import JSON, Column, Table, select, delete, MetaData, func
-from sqlalchemy.ext.asyncio import create_async_engine, async_sessionmaker
 from sqlalchemy import exc
 from sqlalchemy.exc import ProgrammingError
 from tenacity import retry, retry_if_exception_type, stop_after_attempt, wait_exponential
@@ -15,7 +14,7 @@ from sqlalchemy.engine import make_url
 from cognee.shared.logging_utils import get_logger
 from cognee.infrastructure.engine import DataPoint
 from cognee.infrastructure.engine.utils import parse_id
-from cognee.infrastructure.databases.relational import get_relational_engine
+from cognee.infrastructure.databases.relational import get_relational_engine, get_relational_config
 
 from distributed.utils import override_distributed
 from distributed.tasks.queued_add_data_points import queued_add_data_points
@@ -64,22 +63,29 @@ class PGVectorAdapter(SQLAlchemyAdapter, VectorDBInterface):
         self._metadata = MetaData()
 
         relational_db = get_relational_engine()
+        relational_config = get_relational_config()
 
         # Reuse engine and sessionmaker if the relational engine is provided and is the same database as the one configured for pgvector
         db_name1 = make_url(relational_db.db_uri).database
         db_name2 = make_url(self.db_uri).database
         if backend_access_control_enabled() and (db_name1 != db_name2):
             # If backend access control create new instances of engine and sessionmaker
-            self.engine = create_async_engine(self.db_uri)
-            self.sessionmaker = async_sessionmaker(bind=self.engine, expire_on_commit=False)
+            # To make sure we use the same pool_args as for the relational database, we create the engine via the SQLAlchemy constructor
+            super().__init__(
+                connection_string=self.db_uri,
+                pool_args=dict(relational_config.pool_args) if relational_config.pool_args else {},
+            )
         elif relational_db.engine.dialect.name == "postgresql":
             # If postgreSQL is used and not backend access control we must use the same engine and sessionmaker
             self.engine = relational_db.engine
             self.sessionmaker = relational_db.sessionmaker
         else:
             # If not postgreSQL and not backend access control create new instances of engine and sessionmaker
-            self.engine = create_async_engine(self.db_uri)
-            self.sessionmaker = async_sessionmaker(bind=self.engine, expire_on_commit=False)
+            # To make sure we use the same pool_args as for the relational database, we create the engine via the SQLAlchemy constructor
+            super().__init__(
+                connection_string=self.db_uri,
+                pool_args=dict(relational_config.pool_args) if relational_config.pool_args else {},
+            )
 
         # Has to be imported at class level
         # Functions reading tables from database need to know what a Vector column type is
@@ -87,6 +93,12 @@ class PGVectorAdapter(SQLAlchemyAdapter, VectorDBInterface):
 
         self.Vector = Vector
 
+    def reset_metadata_cache(self):
+        """
+        Reset SQLAlchemy metadata reflection cache for this adapter instance.
+        """
+        self._metadata = MetaData()
+
     async def embed_data(self, data: list[str]) -> list[list[float]]:
         """
         Embed a list of texts into vectors using the specified embedding engine.

{cognee-1.0.0.dev0 → cognee-1.0.1.dev0}/cognee/infrastructure/databases/vector/pgvector/PGVectorDatasetDatabaseHandler.py

@@ -1,12 +1,15 @@
 from uuid import UUID
 from typing import Optional
+from sqlalchemy import MetaData
 
-from cognee.infrastructure.databases.vector.create_vector_engine import create_vector_engine
 from cognee.infrastructure.databases.vector.pgvector.create_db_and_tables import delete_pg_database
 from cognee.modules.users.models import User
 from cognee.modules.users.models import DatasetDatabase
-from cognee.infrastructure.databases.vector import get_vectordb_config
+from cognee.infrastructure.databases.vector import get_vectordb_config, get_vector_engine
 from cognee.infrastructure.databases.dataset_database_handler import DatasetDatabaseHandlerInterface
+from cognee.infrastructure.databases.vector.create_vector_engine import (
+    create_vector_engine,
+)
 
 
 class PGVectorDatasetDatabaseHandler(DatasetDatabaseHandlerInterface):
@@ -74,3 +77,17 @@ class PGVectorDatasetDatabaseHandler(DatasetDatabaseHandlerInterface):
 
         # Drop entire database
         await delete_pg_database(dataset_database)
+
+        vector_engine = create_vector_engine(
+            vector_db_provider=dataset_database.vector_database_provider,
+            vector_db_url=dataset_database.vector_database_url,
+            vector_db_name=dataset_database.vector_database_name,
+            vector_db_port=dataset_database.vector_database_connection_info["port"],
+            vector_db_key=dataset_database.vector_database_key,
+            vector_db_username=dataset_database.vector_database_connection_info["username"],
+            vector_db_password=dataset_database.vector_database_connection_info["password"],
+            vector_db_host=dataset_database.vector_database_connection_info["host"],
+        )
+
+        # Reset cached metadata from the vector adapter
+        vector_engine.reset_metadata_cache()

{cognee-1.0.0.dev0 → cognee-1.0.1.dev0}/cognee/infrastructure/databases/vector/pgvector/create_db_and_tables.py

@@ -39,15 +39,17 @@ async def create_pg_database(vector_config):
         database=maintenance_db_name,
     )
     maintenance_engine = create_async_engine(maintenance_db_url)
-
-    # Connect to maintenance db in order to create new database
-    # Make sure to execute CREATE DATABASE outside of transaction block, and set AUTOCOMMIT isolation level
-    connection = await maintenance_engine.connect()
-    connection = await connection.execution_options(isolation_level="AUTOCOMMIT")
-    await connection.execute(text(f'CREATE DATABASE "{vector_config["vector_db_name"]}";'))
-
-    # Clean up resources
-    await connection.close()
+    try:
+        # Connect to maintenance db in order to create new database
+        # Make sure to execute CREATE DATABASE outside of transaction block, and set AUTOCOMMIT isolation level
+        connection = await maintenance_engine.connect()
+        try:
+            connection = await connection.execution_options(isolation_level="AUTOCOMMIT")
+            await connection.execute(text(f'CREATE DATABASE "{vector_config["vector_db_name"]}";'))
+        finally:
+            await connection.close()
+    finally:
+        await maintenance_engine.dispose()
 
     vector_engine = create_vector_engine(**vector_config)
     async with vector_engine.engine.begin() as connection:
@@ -75,17 +77,23 @@ async def delete_pg_database(dataset_database: DatasetDatabase):
     )
     maintenance_engine = create_async_engine(maintenance_db_url)
 
-    connection = await maintenance_engine.connect()
-    connection = await connection.execution_options(isolation_level="AUTOCOMMIT")
-    # We first have to kill all active sessions on the database, then delete it
-    await connection.execute(
-        text(
-            "SELECT pg_terminate_backend(pid) "
-            "FROM pg_stat_activity "
-            "WHERE datname = :db AND pid <> pg_backend_pid()"
-        ),
-        {"db": dataset_database.vector_database_name},
-    )
-    await connection.execute(text(f'DROP DATABASE "{dataset_database.vector_database_name}";'))
-
-    await connection.close()
+    try:
+        connection = await maintenance_engine.connect()
+        try:
+            connection = await connection.execution_options(isolation_level="AUTOCOMMIT")
+            # We first have to kill all active sessions on the database, then delete it
+            await connection.execute(
+                text(
+                    "SELECT pg_terminate_backend(pid) "
+                    "FROM pg_stat_activity "
+                    "WHERE datname = :db AND pid <> pg_backend_pid()"
+                ),
+                {"db": dataset_database.vector_database_name},
+            )
+            await connection.execute(
+                text(f'DROP DATABASE "{dataset_database.vector_database_name}";')
+            )
+        finally:
+            await connection.close()
+    finally:
+        await maintenance_engine.dispose()

{cognee-1.0.0.dev0 → cognee-1.0.1.dev0}/cognee/modules/data/methods/delete_dataset.py

@@ -1,5 +1,5 @@
 from cognee.modules.users.models import DatasetDatabase
-from sqlalchemy import select
+from sqlalchemy import select, text
 from sqlalchemy.orm.attributes import flag_modified
 
 from cognee.modules.data.models import Dataset, DatasetData, Data
@@ -16,6 +16,11 @@ async def delete_dataset(dataset: Dataset):
     db_engine = get_relational_engine()
 
     async with db_engine.get_async_session() as session:
+        if db_engine.engine.dialect.name == "sqlite":
+            # Foreign key constraints are disabled by default in SQLite (for backwards compatibility),
+            # so must be enabled for each database connection/session separately.
+            await session.execute(text("PRAGMA foreign_keys = ON;"))
+
         stmt = select(DatasetDatabase).where(
             DatasetDatabase.dataset_id == dataset.id,
         )
@@ -62,6 +67,11 @@ async def delete_dataset(dataset: Dataset):
     # resolves the table through SQLAlchemy metadata and triggers ORM cascades
     # (e.g. deleting related ACL rows via cascade="all, delete-orphan").
     async with db_engine.get_async_session() as session:
+        if db_engine.engine.dialect.name == "sqlite":
+            # Foreign key constraints are disabled by default in SQLite (for backwards compatibility),
+            # so must be enabled for each database connection/session separately.
+            await session.execute(text("PRAGMA foreign_keys = ON;"))
+
         dataset = await session.get(Dataset, dataset.id)
         if dataset:
             await session.delete(dataset)

{cognee-1.0.0.dev0 → cognee-1.0.1.dev0}/cognee/modules/users/models/Tenant.py

@@ -9,7 +9,7 @@ class Tenant(Principal):
     __tablename__ = "tenants"
 
     id = Column(UUID, ForeignKey("principals.id"), primary_key=True)
-    name = Column(String, unique=True, nullable=False, index=True)
+    name = Column(String, unique=False, nullable=False, index=True)
 
     owner_id = Column(UUID, index=True)
 

cognee-1.0.1.dev0/cognee/shared/lru_cache.py

@@ -0,0 +1,10 @@
+"""
+Shared cache size setting for Cognee database adapters.
+
+Set DATABASE_MAX_LRU_CACHE_SIZE in the environment to control the maxsize of the
+lru_cache used by the graph, vector, and relational DB engine factories (default: 128).
+"""
+
+import os
+
+DATABASE_MAX_LRU_CACHE_SIZE: int = int(os.getenv("DATABASE_MAX_LRU_CACHE_SIZE", "128"))

{cognee-1.0.0.dev0 → cognee-1.0.1.dev0}/cognee/tasks/storage/index_graph_edges.py

@@ -53,8 +53,7 @@ async def index_graph_edges(
     Steps:
     1. Initialize the graph engine if needed and retrieve edge data.
     2. Transform edge data into EdgeType datapoints.
-    3. Persist EdgeType nodes in the graph database for triplet search.
-    4. Index the EdgeType datapoints using the standard indexing function.
+    3. Index the EdgeType datapoints using the standard indexing function.
 
     Raises:
         RuntimeError: If initialization of the graph engine fails.
@@ -62,7 +61,6 @@ async def index_graph_edges(
     Returns:
         None
     """
-    graph_engine = None
     try:
         if edges_data is None:
             graph_engine = await get_graph_engine()
@@ -73,15 +71,6 @@ async def index_graph_edges(
 
         edge_type_datapoints = create_edge_type_datapoints(edges_data)
 
-        # Persist EdgeType nodes in the graph database so they are available for
-        # GRAPH_COMPLETION triplet search.  Without this, adapters that don't
-        # store nodes via index_data_points (e.g. FalkorDB) will have EdgeType
-        # entries without vector embeddings, causing triplet search to fail.
-        if edge_type_datapoints:
-            if graph_engine is None:
-                graph_engine = await get_graph_engine()
-            await graph_engine.add_nodes(edge_type_datapoints)
-
         await index_data_points(edge_type_datapoints, vector_engine=vector_engine)
     except Exception as e:
         logger.error("Failed to index graph edges: %s", e)

{cognee-1.0.0.dev0 → cognee-1.0.1.dev0}/cognee/tests/e2e/postgres/test_postgres_hybrid_adapter.py

@@ -50,6 +50,13 @@ async def adapter():
         embedding_engine=get_embedding_engine(),
     )
 
+    # Enable pgvector extension -- normally done by cognee's create_db_and_tables()
+    # during startup, but this test constructs adapters directly.
+    from sqlalchemy import text as sa_text
+
+    async with graph_adapter.engine.begin() as conn:
+        await conn.execute(sa_text("CREATE EXTENSION IF NOT EXISTS vector"))
+
     a = PostgresHybridAdapter(
         graph_adapter=graph_adapter,
         vector_adapter=vector_adapter,

{cognee-1.0.0.dev0 → cognee-1.0.1.dev0}/cognee/tests/integration/tasks/test_add_data_points.py

@@ -86,9 +86,10 @@ async def test_add_data_points_comprehensive(clean_test_environment):
     assert len(result_rel) == 1
 
     nodes, edges = await graph_engine.get_graph_data()
-    # 4 Persons + Employee + Company + 1 EdgeType("works_at") = 7
-    assert len(nodes) == 7
+    # 4 Persons + Employee + Company = 6
+    assert len(nodes) == 6
     assert len(edges) == 2
+    assert not any(node[1].get("type") == "EdgeType" for node in nodes)
 
     person5 = Person(name="Frank", age=40)
     person6 = Person(name="Grace", age=38)
@@ -100,8 +101,8 @@ async def test_add_data_points_comprehensive(clean_test_environment):
     assert len(result_triplet) == 2
 
     nodes, edges = await graph_engine.get_graph_data()
-    # 7 + 2 Persons = 9 (custom edge has no relationship_name in dict → no EdgeType)
-    assert len(nodes) == 9
+    # 6 + 2 Persons = 8
+    assert len(nodes) == 8
     assert len(edges) == 3
 
     batch1 = [Person(name="Leo", age=25), Person(name="Mia", age=30)]
@@ -114,8 +115,8 @@ async def test_add_data_points_comprehensive(clean_test_environment):
     assert len(result_batch2) == 2
 
     nodes, edges = await graph_engine.get_graph_data()
-    # 9 + 4 Persons = 13
-    assert len(nodes) == 13
+    # 8 + 4 Persons = 12
+    assert len(nodes) == 12
     assert len(edges) == 3
 
     person7 = Person(name="Paul", age=33)
@@ -127,8 +128,8 @@ async def test_add_data_points_comprehensive(clean_test_environment):
     assert len(result_bi) == 2
 
     nodes, edges = await graph_engine.get_graph_data()
-    # 13 + 2 Persons = 15
-    assert len(nodes) == 15
+    # 12 + 2 Persons = 14
+    assert len(nodes) == 14
     assert len(edges) == 5
 
     person_invalid = Person(name="Invalid", age=50)
@@ -139,5 +140,5 @@ async def test_add_data_points_comprehensive(clean_test_environment):
         await add_data_points(["not", "datapoints"])
 
     final_nodes, final_edges = await graph_engine.get_graph_data()
-    assert len(final_nodes) == 15
+    assert len(final_nodes) == 14
     assert len(final_edges) == 5