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

cognee/api/client.py

@@ -3,7 +3,6 @@
 import os
 
 import uvicorn
-import sentry_sdk
 from traceback import format_exc
 from contextlib import asynccontextmanager
 from fastapi import Request
@@ -29,6 +28,7 @@ from cognee.api.v1.add.routers import get_add_router
 from cognee.api.v1.delete.routers import get_delete_router
 from cognee.api.v1.responses.routers import get_responses_router
 from cognee.api.v1.sync.routers import get_sync_router
+from cognee.api.v1.update.routers import get_update_router
 from cognee.api.v1.users.routers import (
     get_auth_router,
     get_register_router,
@@ -42,11 +42,18 @@ from cognee.modules.users.methods.get_authenticated_user import REQUIRE_AUTHENTI
 logger = get_logger()
 
 if os.getenv("ENV", "prod") == "prod":
-    sentry_sdk.init(
-        dsn=os.getenv("SENTRY_REPORTING_URL"),
-        traces_sample_rate=1.0,
-        profiles_sample_rate=1.0,
-    )
+    try:
+        import sentry_sdk
+
+        sentry_sdk.init(
+            dsn=os.getenv("SENTRY_REPORTING_URL"),
+            traces_sample_rate=1.0,
+            profiles_sample_rate=1.0,
+        )
+    except ImportError:
+        logger.info(
+            "Sentry SDK not available. Install with 'pip install cognee\"[monitoring]\"' to enable error monitoring."
+        )
 
 
 app_environment = os.getenv("ENV", "prod")
@@ -81,7 +88,7 @@ if CORS_ALLOWED_ORIGINS:
     ]
 else:
     allowed_origins = [
-        "http://localhost:3000",
+        os.getenv("UI_APP_URL", "http://localhost:3000"),
     ]  # Block all except explicitly set origins
 
 app.add_middleware(
@@ -257,6 +264,8 @@ app.include_router(get_visualize_router(), prefix="/api/v1/visualize", tags=["vi
 
 app.include_router(get_delete_router(), prefix="/api/v1/delete", tags=["delete"])
 
+app.include_router(get_update_router(), prefix="/api/v1/update", tags=["update"])
+
 app.include_router(get_responses_router(), prefix="/api/v1/responses", tags=["responses"])
 
 app.include_router(get_sync_router(), prefix="/api/v1/sync", tags=["sync"])

cognee/api/health.py

@@ -189,12 +189,12 @@ class HealthChecker:
         start_time = time.time()
         try:
             from cognee.infrastructure.llm.config import get_llm_config
-            from cognee.infrastructure.llm import LLMGateway
 
             config = get_llm_config()
 
-            # Test actual API connection with minimal request
-            LLMGateway.show_prompt("test", "test")
+            from cognee.infrastructure.llm.utils import test_llm_connection
+
+            await test_llm_connection()
 
             response_time = int((time.time() - start_time) * 1000)
             return ComponentHealth(
@@ -217,13 +217,9 @@ class HealthChecker:
         """Check embedding service health (non-critical)."""
         start_time = time.time()
         try:
-            from cognee.infrastructure.databases.vector.embeddings.get_embedding_engine import (
-                get_embedding_engine,
-            )
+            from cognee.infrastructure.llm.utils import test_embedding_connection
 
-            # Test actual embedding generation with minimal text
-            engine = get_embedding_engine()
-            await engine.embed_text(["test"])
+            await test_embedding_connection()
 
             response_time = int((time.time() - start_time) * 1000)
             return ComponentHealth(

cognee/api/v1/add/add.py

@@ -148,7 +148,9 @@ async def add(
 
     await setup()
 
-    user, authorized_dataset = await resolve_authorized_user_dataset(dataset_id, dataset_name, user)
+    user, authorized_dataset = await resolve_authorized_user_dataset(
+        dataset_name=dataset_name, dataset_id=dataset_id, user=user
+    )
 
     await reset_dataset_pipeline_run_status(
         authorized_dataset.id, user, pipeline_names=["add_pipeline", "cognify_pipeline"]

cognee/api/v1/cognify/cognify.py

@@ -3,6 +3,7 @@ from pydantic import BaseModel
 from typing import Union, Optional
 from uuid import UUID
 
+from cognee.modules.ontology.ontology_env_config import get_ontology_env_config
 from cognee.shared.logging_utils import get_logger
 from cognee.shared.data_models import KnowledgeGraph
 from cognee.infrastructure.llm import get_max_chunk_tokens
@@ -10,7 +11,11 @@ from cognee.infrastructure.llm import get_max_chunk_tokens
 from cognee.modules.pipelines import run_pipeline
 from cognee.modules.pipelines.tasks.task import Task
 from cognee.modules.chunking.TextChunker import TextChunker
-from cognee.modules.ontology.rdf_xml.OntologyResolver import OntologyResolver
+from cognee.modules.ontology.ontology_config import Config
+from cognee.modules.ontology.get_default_ontology_resolver import (
+    get_default_ontology_resolver,
+    get_ontology_resolver_from_env,
+)
 from cognee.modules.users.models import User
 
 from cognee.tasks.documents import (
@@ -39,7 +44,7 @@ async def cognify(
     graph_model: BaseModel = KnowledgeGraph,
     chunker=TextChunker,
     chunk_size: int = None,
-    ontology_file_path: Optional[str] = None,
+    config: Config = None,
     vector_db_config: dict = None,
     graph_db_config: dict = None,
     run_in_background: bool = False,
@@ -100,8 +105,6 @@ async def cognify(
                    Formula: min(embedding_max_completion_tokens, llm_max_completion_tokens // 2)
                    Default limits: ~512-8192 tokens depending on models.
                    Smaller chunks = more granular but potentially fragmented knowledge.
-        ontology_file_path: Path to RDF/OWL ontology file for domain-specific entity types.
-                          Useful for specialized fields like medical or legal documents.
         vector_db_config: Custom vector database configuration for embeddings storage.
         graph_db_config: Custom graph database configuration for relationship storage.
         run_in_background: If True, starts processing asynchronously and returns immediately.
@@ -188,11 +191,28 @@ async def cognify(
         - LLM_RATE_LIMIT_ENABLED: Enable rate limiting (default: False)
         - LLM_RATE_LIMIT_REQUESTS: Max requests per interval (default: 60)
     """
+    if config is None:
+        ontology_config = get_ontology_env_config()
+        if (
+            ontology_config.ontology_file_path
+            and ontology_config.ontology_resolver
+            and ontology_config.matching_strategy
+        ):
+            config: Config = {
+                "ontology_config": {
+                    "ontology_resolver": get_ontology_resolver_from_env(**ontology_config.to_dict())
+                }
+            }
+        else:
+            config: Config = {
+                "ontology_config": {"ontology_resolver": get_default_ontology_resolver()}
+            }
+
     if temporal_cognify:
         tasks = await get_temporal_tasks(user, chunker, chunk_size)
     else:
         tasks = await get_default_tasks(
-            user, graph_model, chunker, chunk_size, ontology_file_path, custom_prompt
+            user, graph_model, chunker, chunk_size, config, custom_prompt
         )
 
     # 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
@@ -216,9 +236,26 @@ async def get_default_tasks(  # TODO: Find out a better way to do this (Boris's
     graph_model: BaseModel = KnowledgeGraph,
     chunker=TextChunker,
     chunk_size: int = None,
-    ontology_file_path: Optional[str] = None,
+    config: Config = None,
     custom_prompt: Optional[str] = None,
 ) -> list[Task]:
+    if config is None:
+        ontology_config = get_ontology_env_config()
+        if (
+            ontology_config.ontology_file_path
+            and ontology_config.ontology_resolver
+            and ontology_config.matching_strategy
+        ):
+            config: Config = {
+                "ontology_config": {
+                    "ontology_resolver": get_ontology_resolver_from_env(**ontology_config.to_dict())
+                }
+            }
+        else:
+            config: Config = {
+                "ontology_config": {"ontology_resolver": get_default_ontology_resolver()}
+            }
+
     default_tasks = [
         Task(classify_documents),
         Task(check_permissions_on_dataset, user=user, permissions=["write"]),
@@ -230,7 +267,7 @@ async def get_default_tasks(  # TODO: Find out a better way to do this (Boris's
         Task(
             extract_graph_from_data,
             graph_model=graph_model,
-            ontology_adapter=OntologyResolver(ontology_file=ontology_file_path),
+            config=config,
             custom_prompt=custom_prompt,
             task_config={"batch_size": 10},
         ),  # Generate knowledge graphs from the document chunks.

cognee/api/v1/permissions/routers/get_permissions_router.py

@@ -94,9 +94,11 @@ def get_permissions_router() -> APIRouter:
 
         from cognee.modules.users.roles.methods import create_role as create_role_method
 
-        await create_role_method(role_name=role_name, owner_id=user.id)
+        role_id = await create_role_method(role_name=role_name, owner_id=user.id)
 
-        return JSONResponse(status_code=200, content={"message": "Role created for tenant"})
+        return JSONResponse(
+            status_code=200, content={"message": "Role created for tenant", "role_id": str(role_id)}
+        )
 
     @permissions_router.post("/users/{user_id}/roles")
     async def add_user_to_role(
@@ -212,8 +214,10 @@ def get_permissions_router() -> APIRouter:
 
         from cognee.modules.users.tenants.methods import create_tenant as create_tenant_method
 
-        await create_tenant_method(tenant_name=tenant_name, user_id=user.id)
+        tenant_id = await create_tenant_method(tenant_name=tenant_name, user_id=user.id)
 
-        return JSONResponse(status_code=200, content={"message": "Tenant created."})
+        return JSONResponse(
+            status_code=200, content={"message": "Tenant created.", "tenant_id": str(tenant_id)}
+        )
 
     return permissions_router

cognee/api/v1/search/search.py

@@ -82,6 +82,9 @@ async def search(
             Best for: General-purpose queries or when you're unsure which search type is best.
             Returns: The results from the automatically selected search type.
 
+        **CHUNKS_LEXICAL**:
+            Token-based lexical chunk search (e.g., Jaccard). Best for: exact-term matching, stopword-aware lookups.
+            Returns: Ranked text chunks (optionally with scores).
 
     Args:
         query_text: Your question or search query in natural language.

cognee/api/v1/ui/__init__.py

@@ -1 +1 @@
-from .ui import start_ui, stop_ui, ui
+from .ui import start_ui