cognee 0.2.4__py3-none-any.whl → 0.3.0__py3-none-any.whl

cognee/tests/unit/modules/retrieval/rag_completion_retriever_test.py

@@ -1,7 +1,7 @@
 import os
+from typing import List
 import pytest
 import pathlib
-
 import cognee
 from cognee.low_level import setup
 from cognee.tasks.storage import add_data_points
@@ -10,6 +10,20 @@ from cognee.modules.chunking.models import DocumentChunk
 from cognee.modules.data.processing.document_types import TextDocument
 from cognee.modules.retrieval.exceptions.exceptions import NoDataError
 from cognee.modules.retrieval.completion_retriever import CompletionRetriever
+from cognee.infrastructure.engine import DataPoint
+from cognee.modules.data.processing.document_types import Document
+from cognee.modules.engine.models import Entity
+
+
+class DocumentChunkWithEntities(DataPoint):
+    text: str
+    chunk_size: int
+    chunk_index: int
+    cut_type: str
+    is_part_of: Document
+    contains: List[Entity] = None
+
+    metadata: dict = {"index_fields": ["text"]}
 
 
 class TestRAGCompletionRetriever:
@@ -182,7 +196,9 @@ class TestRAGCompletionRetriever:
             await retriever.get_context("Christina Mayer")
 
         vector_engine = get_vector_engine()
-        await vector_engine.create_collection("DocumentChunk_text", payload_schema=DocumentChunk)
+        await vector_engine.create_collection(
+            "DocumentChunk_text", payload_schema=DocumentChunkWithEntities
+        )
 
         context = await retriever.get_context("Christina Mayer")
         assert context == "", "Returned context should be empty on an empty graph"

cognee/tests/unit/modules/retrieval/temporal_retriever_test.py

@@ -0,0 +1,225 @@
+import asyncio
+from types import SimpleNamespace
+import pytest
+
+from cognee.modules.retrieval.temporal_retriever import TemporalRetriever
+
+
+# Test TemporalRetriever initialization defaults and overrides
+def test_init_defaults_and_overrides():
+    tr = TemporalRetriever()
+    assert tr.top_k == 5
+    assert tr.user_prompt_path == "graph_context_for_question.txt"
+    assert tr.system_prompt_path == "answer_simple_question.txt"
+    assert tr.time_extraction_prompt_path == "extract_query_time.txt"
+
+    tr2 = TemporalRetriever(
+        top_k=3,
+        user_prompt_path="u.txt",
+        system_prompt_path="s.txt",
+        time_extraction_prompt_path="t.txt",
+    )
+    assert tr2.top_k == 3
+    assert tr2.user_prompt_path == "u.txt"
+    assert tr2.system_prompt_path == "s.txt"
+    assert tr2.time_extraction_prompt_path == "t.txt"
+
+
+# Test descriptions_to_string with basic and empty results
+def test_descriptions_to_string_basic_and_empty():
+    tr = TemporalRetriever()
+
+    results = [
+        {"description": "  First  "},
+        {"nope": "no description"},
+        {"description": "Second"},
+        {"description": ""},
+        {"description": "   Third line   "},
+    ]
+
+    s = tr.descriptions_to_string(results)
+    assert s == "First\n#####################\nSecond\n#####################\nThird line"
+
+    assert tr.descriptions_to_string([]) == ""
+
+
+# Test filter_top_k_events sorts and limits correctly
+@pytest.mark.asyncio
+async def test_filter_top_k_events_sorts_and_limits():
+    tr = TemporalRetriever(top_k=2)
+
+    relevant_events = [
+        {
+            "events": [
+                {"id": "e1", "description": "E1"},
+                {"id": "e2", "description": "E2"},
+                {"id": "e3", "description": "E3 - not in vector results"},
+            ]
+        }
+    ]
+
+    scored_results = [
+        SimpleNamespace(payload={"id": "e2"}, score=0.10),
+        SimpleNamespace(payload={"id": "e1"}, score=0.20),
+    ]
+
+    top = await tr.filter_top_k_events(relevant_events, scored_results)
+
+    assert [e["id"] for e in top] == ["e2", "e1"]
+    assert all("score" in e for e in top)
+    assert top[0]["score"] == 0.10
+    assert top[1]["score"] == 0.20
+
+
+# Test filter_top_k_events handles unknown ids as infinite scores
+@pytest.mark.asyncio
+async def test_filter_top_k_events_includes_unknown_as_infinite_but_not_in_top_k():
+    tr = TemporalRetriever(top_k=2)
+
+    relevant_events = [
+        {
+            "events": [
+                {"id": "known1", "description": "Known 1"},
+                {"id": "unknown", "description": "Unknown"},
+                {"id": "known2", "description": "Known 2"},
+            ]
+        }
+    ]
+
+    scored_results = [
+        SimpleNamespace(payload={"id": "known2"}, score=0.05),
+        SimpleNamespace(payload={"id": "known1"}, score=0.50),
+    ]
+
+    top = await tr.filter_top_k_events(relevant_events, scored_results)
+    assert [e["id"] for e in top] == ["known2", "known1"]
+    assert all(e["score"] != float("inf") for e in top)
+
+
+# Test descriptions_to_string with unicode and newlines
+def test_descriptions_to_string_unicode_and_newlines():
+    tr = TemporalRetriever()
+    results = [
+        {"description": "Line A\nwith newline"},
+        {"description": "This is a description"},
+    ]
+    s = tr.descriptions_to_string(results)
+    assert "Line A\nwith newline" in s
+    assert "This is a description" in s
+    assert s.count("#####################") == 1
+
+
+# Test filter_top_k_events when top_k is larger than available events
+@pytest.mark.asyncio
+async def test_filter_top_k_events_limits_when_top_k_exceeds_events():
+    tr = TemporalRetriever(top_k=10)
+    relevant_events = [{"events": [{"id": "a"}, {"id": "b"}]}]
+    scored_results = [
+        SimpleNamespace(payload={"id": "a"}, score=0.1),
+        SimpleNamespace(payload={"id": "b"}, score=0.2),
+    ]
+    out = await tr.filter_top_k_events(relevant_events, scored_results)
+    assert [e["id"] for e in out] == ["a", "b"]
+
+
+# Test filter_top_k_events when scored_results is empty
+@pytest.mark.asyncio
+async def test_filter_top_k_events_handles_empty_scored_results():
+    tr = TemporalRetriever(top_k=2)
+    relevant_events = [{"events": [{"id": "x"}, {"id": "y"}]}]
+    scored_results = []
+    out = await tr.filter_top_k_events(relevant_events, scored_results)
+    assert [e["id"] for e in out] == ["x", "y"]
+    assert all(e["score"] == float("inf") for e in out)
+
+
+# Test filter_top_k_events error handling for missing structure
+@pytest.mark.asyncio
+async def test_filter_top_k_events_error_handling():
+    tr = TemporalRetriever(top_k=2)
+    with pytest.raises((KeyError, TypeError)):
+        await tr.filter_top_k_events([{}], [])
+
+
+class _FakeRetriever(TemporalRetriever):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._calls = []
+
+    async def extract_time_from_query(self, query: str):
+        if "both" in query:
+            return "2024-01-01", "2024-12-31"
+        if "from_only" in query:
+            return "2024-01-01", None
+        if "to_only" in query:
+            return None, "2024-12-31"
+        return None, None
+
+    async def get_triplets(self, query: str):
+        self._calls.append(("get_triplets", query))
+        return [{"s": "a", "p": "b", "o": "c"}]
+
+    async def resolve_edges_to_text(self, triplets):
+        self._calls.append(("resolve_edges_to_text", len(triplets)))
+        return "edges->text"
+
+    async def _fake_graph_collect_ids(self, **kwargs):
+        return ["e1", "e2"]
+
+    async def _fake_graph_collect_events(self, ids):
+        return [
+            {
+                "events": [
+                    {"id": "e1", "description": "E1"},
+                    {"id": "e2", "description": "E2"},
+                    {"id": "e3", "description": "E3"},
+                ]
+            }
+        ]
+
+    async def _fake_vector_embed(self, texts):
+        assert isinstance(texts, list) and texts
+        return [[0.0, 1.0, 2.0]]
+
+    async def _fake_vector_search(self, **kwargs):
+        return [
+            SimpleNamespace(payload={"id": "e2"}, score=0.05),
+            SimpleNamespace(payload={"id": "e1"}, score=0.10),
+        ]
+
+    async def get_context(self, query: str):
+        time_from, time_to = await self.extract_time_from_query(query)
+
+        if not (time_from or time_to):
+            triplets = await self.get_triplets(query)
+            return await self.resolve_edges_to_text(triplets)
+
+        ids = await self._fake_graph_collect_ids(time_from=time_from, time_to=time_to)
+        relevant_events = await self._fake_graph_collect_events(ids)
+
+        _ = await self._fake_vector_embed([query])
+        vector_search_results = await self._fake_vector_search(
+            collection_name="Event_name", query_vector=[0.0], limit=0
+        )
+        top_k_events = await self.filter_top_k_events(relevant_events, vector_search_results)
+        return self.descriptions_to_string(top_k_events)
+
+
+# Test get_context fallback to triplets when no time is extracted
+@pytest.mark.asyncio
+async def test_fake_get_context_falls_back_to_triplets_when_no_time():
+    tr = _FakeRetriever(top_k=2)
+    ctx = await tr.get_context("no_time")
+    assert ctx == "edges->text"
+    assert tr._calls[0][0] == "get_triplets"
+    assert tr._calls[1][0] == "resolve_edges_to_text"
+
+
+# Test get_context when time is extracted and vector ranking is applied
+@pytest.mark.asyncio
+async def test_fake_get_context_with_time_filters_and_vector_ranking():
+    tr = _FakeRetriever(top_k=2)
+    ctx = await tr.get_context("both time")
+    assert ctx.startswith("E2")
+    assert "#####################" in ctx
+    assert "E1" in ctx and "E3" not in ctx

cognee/tests/unit/modules/users/__init__.py

@@ -0,0 +1 @@
+# Test package for user module tests

cognee/tests/unit/modules/users/test_conditional_authentication.py

@@ -0,0 +1,277 @@
+import os
+import sys
+import pytest
+from unittest.mock import AsyncMock, patch
+from uuid import uuid4
+from types import SimpleNamespace
+import importlib
+
+
+from cognee.modules.users.models import User
+
+
+gau_mod = importlib.import_module("cognee.modules.users.methods.get_authenticated_user")
+
+
+class TestConditionalAuthentication:
+    """Test cases for conditional authentication functionality."""
+
+    @pytest.mark.asyncio
+    @patch.object(gau_mod, "get_default_user", new_callable=AsyncMock)
+    async def test_require_authentication_false_no_token_returns_default_user(
+        self, mock_get_default
+    ):
+        """Test that when REQUIRE_AUTHENTICATION=false and no token, returns default user."""
+        # Mock the default user
+        mock_default_user = SimpleNamespace(id=uuid4(), email="default@example.com", is_active=True)
+        mock_get_default.return_value = mock_default_user
+
+        # Use gau_mod.get_authenticated_user instead
+
+        # Test with None user (no authentication)
+        result = await gau_mod.get_authenticated_user(user=None)
+
+        assert result == mock_default_user
+        mock_get_default.assert_called_once()
+
+    @pytest.mark.asyncio
+    @patch.object(gau_mod, "get_default_user", new_callable=AsyncMock)
+    async def test_require_authentication_false_with_valid_user_returns_user(
+        self, mock_get_default
+    ):
+        """Test that when REQUIRE_AUTHENTICATION=false and valid user, returns that user."""
+        mock_authenticated_user = User(
+            id=uuid4(),
+            email="user@example.com",
+            hashed_password="hashed",
+            is_active=True,
+            is_verified=True,
+        )
+
+        # Use gau_mod.get_authenticated_user instead
+
+        # Test with authenticated user
+        result = await gau_mod.get_authenticated_user(user=mock_authenticated_user)
+
+        assert result == mock_authenticated_user
+        mock_get_default.assert_not_called()
+
+    @pytest.mark.asyncio
+    @patch.object(gau_mod, "get_default_user", new_callable=AsyncMock)
+    async def test_require_authentication_true_with_user_returns_user(self, mock_get_default):
+        """Test that when REQUIRE_AUTHENTICATION=true and user present, returns user."""
+        mock_authenticated_user = User(
+            id=uuid4(),
+            email="user@example.com",
+            hashed_password="hashed",
+            is_active=True,
+            is_verified=True,
+        )
+
+        # Use gau_mod.get_authenticated_user instead
+
+        result = await gau_mod.get_authenticated_user(user=mock_authenticated_user)
+
+        assert result == mock_authenticated_user
+
+
+class TestConditionalAuthenticationIntegration:
+    """Integration tests that test the full authentication flow."""
+
+    @pytest.mark.asyncio
+    async def test_fastapi_users_dependency_creation(self):
+        """Test that FastAPI Users dependency can be created correctly."""
+        from cognee.modules.users.get_fastapi_users import get_fastapi_users
+
+        fastapi_users = get_fastapi_users()
+
+        # Test that we can create optional dependency
+        optional_dependency = fastapi_users.current_user(optional=True, active=True)
+        assert callable(optional_dependency)
+
+        # Test that we can create required dependency
+        required_dependency = fastapi_users.current_user(active=True)  # optional=False by default
+        assert callable(required_dependency)
+
+    @pytest.mark.asyncio
+    async def test_conditional_authentication_function_exists(self):
+        """Test that the conditional authentication function can be imported and used."""
+        from cognee.modules.users.methods.get_authenticated_user import (
+            get_authenticated_user,
+            REQUIRE_AUTHENTICATION,
+        )
+
+        # Should be callable
+        assert callable(get_authenticated_user)
+
+        # REQUIRE_AUTHENTICATION should be a boolean
+        assert isinstance(REQUIRE_AUTHENTICATION, bool)
+
+        # Currently should be False (optional authentication)
+        assert not REQUIRE_AUTHENTICATION
+
+
+class TestConditionalAuthenticationEnvironmentVariables:
+    """Test environment variable handling."""
+
+    def test_require_authentication_default_false(self):
+        """Test that REQUIRE_AUTHENTICATION defaults to false when imported with no env vars."""
+        with patch.dict(os.environ, {}, clear=True):
+            # Remove module from cache to force fresh import
+            module_name = "cognee.modules.users.methods.get_authenticated_user"
+            if module_name in sys.modules:
+                del sys.modules[module_name]
+
+            # Import after patching environment - module will see empty environment
+            from cognee.modules.users.methods.get_authenticated_user import (
+                REQUIRE_AUTHENTICATION,
+            )
+
+            importlib.invalidate_caches()
+            assert not REQUIRE_AUTHENTICATION
+
+    def test_require_authentication_true(self):
+        """Test that REQUIRE_AUTHENTICATION=true is parsed correctly when imported."""
+        with patch.dict(os.environ, {"REQUIRE_AUTHENTICATION": "true"}):
+            # Remove module from cache to force fresh import
+            module_name = "cognee.modules.users.methods.get_authenticated_user"
+            if module_name in sys.modules:
+                del sys.modules[module_name]
+
+            # Import after patching environment - module will see REQUIRE_AUTHENTICATION=true
+            from cognee.modules.users.methods.get_authenticated_user import (
+                REQUIRE_AUTHENTICATION,
+            )
+
+            assert REQUIRE_AUTHENTICATION
+
+    def test_require_authentication_false_explicit(self):
+        """Test that REQUIRE_AUTHENTICATION=false is parsed correctly when imported."""
+        with patch.dict(os.environ, {"REQUIRE_AUTHENTICATION": "false"}):
+            # Remove module from cache to force fresh import
+            module_name = "cognee.modules.users.methods.get_authenticated_user"
+            if module_name in sys.modules:
+                del sys.modules[module_name]
+
+            # Import after patching environment - module will see REQUIRE_AUTHENTICATION=false
+            from cognee.modules.users.methods.get_authenticated_user import (
+                REQUIRE_AUTHENTICATION,
+            )
+
+            assert not REQUIRE_AUTHENTICATION
+
+    def test_require_authentication_case_insensitive(self):
+        """Test that environment variable parsing is case insensitive when imported."""
+        test_cases = ["TRUE", "True", "tRuE", "FALSE", "False", "fAlSe"]
+
+        for case in test_cases:
+            with patch.dict(os.environ, {"REQUIRE_AUTHENTICATION": case}):
+                # Remove module from cache to force fresh import
+                module_name = "cognee.modules.users.methods.get_authenticated_user"
+                if module_name in sys.modules:
+                    del sys.modules[module_name]
+
+                # Import after patching environment
+                from cognee.modules.users.methods.get_authenticated_user import (
+                    REQUIRE_AUTHENTICATION,
+                )
+
+                expected = case.lower() == "true"
+                assert REQUIRE_AUTHENTICATION == expected, f"Failed for case: {case}"
+
+    def test_current_require_authentication_value(self):
+        """Test that the current REQUIRE_AUTHENTICATION module value is as expected."""
+        from cognee.modules.users.methods.get_authenticated_user import (
+            REQUIRE_AUTHENTICATION,
+        )
+
+        # The module-level variable should currently be False (set at import time)
+        assert isinstance(REQUIRE_AUTHENTICATION, bool)
+        assert not REQUIRE_AUTHENTICATION
+
+
+class TestConditionalAuthenticationEdgeCases:
+    """Test edge cases and error scenarios."""
+
+    @pytest.mark.asyncio
+    @patch.object(gau_mod, "get_default_user", new_callable=AsyncMock)
+    async def test_get_default_user_raises_exception(self, mock_get_default):
+        """Test behavior when get_default_user raises an exception."""
+        mock_get_default.side_effect = Exception("Database error")
+
+        # This should propagate the exception
+        with pytest.raises(Exception, match="Database error"):
+            await gau_mod.get_authenticated_user(user=None)
+
+    @pytest.mark.asyncio
+    @patch.object(gau_mod, "get_default_user", new_callable=AsyncMock)
+    async def test_user_type_consistency(self, mock_get_default):
+        """Test that the function always returns the same type."""
+        mock_user = User(
+            id=uuid4(),
+            email="test@example.com",
+            hashed_password="hashed",
+            is_active=True,
+            is_verified=True,
+        )
+
+        mock_default_user = SimpleNamespace(id=uuid4(), email="default@example.com", is_active=True)
+        mock_get_default.return_value = mock_default_user
+
+        # Test with user
+        result1 = await gau_mod.get_authenticated_user(user=mock_user)
+        assert result1 == mock_user
+
+        # Test with None
+        result2 = await gau_mod.get_authenticated_user(user=None)
+        assert result2 == mock_default_user
+
+        # Both should have user-like interface
+        assert hasattr(result1, "id")
+        assert hasattr(result1, "email")
+        assert result1.id == mock_user.id
+        assert result1.email == mock_user.email
+        assert hasattr(result2, "id")
+        assert hasattr(result2, "email")
+        assert result2.id == mock_default_user.id
+        assert result2.email == mock_default_user.email
+
+
+@pytest.mark.asyncio
+class TestAuthenticationScenarios:
+    """Test specific authentication scenarios that could occur in FastAPI Users."""
+
+    @patch.object(gau_mod, "get_default_user", new_callable=AsyncMock)
+    async def test_fallback_to_default_user_scenarios(self, mock_get_default):
+        """
+        Test fallback to default user for all scenarios where FastAPI Users returns None:
+        - No JWT/Cookie present
+        - Invalid JWT/Cookie
+        - Valid JWT but user doesn't exist in database
+        - Valid JWT but user is inactive (active=True requirement)
+
+        All these scenarios result in FastAPI Users returning None when optional=True,
+        which should trigger fallback to default user.
+        """
+        mock_default_user = SimpleNamespace(id=uuid4(), email="default@example.com")
+        mock_get_default.return_value = mock_default_user
+
+        # All the above scenarios result in user=None being passed to our function
+        result = await gau_mod.get_authenticated_user(user=None)
+        assert result == mock_default_user
+        mock_get_default.assert_called_once()
+
+    async def test_scenario_valid_active_user(self):
+        """Scenario: Valid JWT and user exists and is active → returns the user."""
+        mock_user = User(
+            id=uuid4(),
+            email="active@example.com",
+            hashed_password="hashed",
+            is_active=True,
+            is_verified=True,
+        )
+
+        # Use gau_mod.get_authenticated_user instead
+
+        result = await gau_mod.get_authenticated_user(user=mock_user)
+        assert result == mock_user

cognee/tests/unit/processing/utils/utils_test.py

@@ -4,8 +4,9 @@ import pytest
 from unittest.mock import patch, mock_open
 from io import BytesIO
 from uuid import uuid4
+from pathlib import Path
 
-
+from cognee.root_dir import ensure_absolute_path
 from cognee.infrastructure.files.utils.get_file_content_hash import get_file_content_hash
 from cognee.shared.utils import get_anonymous_id
 
@@ -52,3 +53,21 @@ async def test_get_file_content_hash_stream():
     expected_hash = hashlib.md5(b"test_data").hexdigest()
     result = await get_file_content_hash(stream)
     assert result == expected_hash
+
+
+@pytest.mark.asyncio
+async def test_root_dir_absolute_paths():
+    """Test absolute path handling in root_dir.py"""
+    # Test with absolute path
+    abs_path = "C:/absolute/path" if os.name == "nt" else "/absolute/path"
+    result = ensure_absolute_path(abs_path)
+    assert result == str(Path(abs_path).resolve())
+
+    # Test with relative path (should fail)
+    rel_path = "relative/path"
+    with pytest.raises(ValueError, match="must be absolute"):
+        ensure_absolute_path(rel_path)
+
+    # Test with None path
+    with pytest.raises(ValueError, match="cannot be None"):
+        ensure_absolute_path(None)

{cognee-0.2.4.dist-info → cognee-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cognee
-Version: 0.2.4
+Version: 0.3.0
 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
@@ -37,7 +37,7 @@ Requires-Dist: networkx<4,>=3.4.2
 Requires-Dist: nltk<4.0.0,>=3.9.1
 Requires-Dist: numpy<=4.0.0,>=1.26.4
 Requires-Dist: onnxruntime<2.0.0,>=1.0.0
-Requires-Dist: openai<1.99.9,>=1.80.1
+Requires-Dist: openai<2.0.0,>=1.80.1
 Requires-Dist: pandas<3.0.0,>=2.2.2
 Requires-Dist: pre-commit<5,>=4.0.1
 Requires-Dist: pydantic-settings<3,>=2.2.1
@@ -183,7 +183,7 @@ Description-Content-Type: text/markdown
 
 
 
-**🚀 We launched Cogwit beta (Fully-hosted AI Memory): Sign up [here](https://platform.cognee.ai/)! 🚀** 
+**🚀 We launched Cogwit beta (Fully-hosted AI Memory): Sign up [here](https://platform.cognee.ai/)! 🚀**
 
 Build dynamic memory for Agents and replace RAG using scalable, modular ECL (Extract, Cognify, Load) pipelines.
 
@@ -219,7 +219,9 @@ More on [use-cases](https://docs.cognee.ai/use-cases) and [evals](https://github
 
 ## Get Started
 
-Get started quickly with a Google Colab  <a href="https://colab.research.google.com/drive/1jHbWVypDgCLwjE71GSXhRL3YxYhCZzG1?usp=sharing">notebook</a> , <a href="https://deepnote.com/workspace/cognee-382213d0-0444-4c89-8265-13770e333c02/project/cognee-demo-78ffacb9-5832-4611-bb1a-560386068b30/notebook/Notebook-1-75b24cda566d4c24ab348f7150792601?utm_source=share-modal&utm_medium=product-shared-content&utm_campaign=notebook&utm_content=78ffacb9-5832-4611-bb1a-560386068b30">Deepnote notebook</a> or  <a href="https://github.com/topoteretes/cognee-starter">starter repo</a>
+Get started quickly with a Google Colab  <a href="https://colab.research.google.com/drive/1jHbWVypDgCLwjE71GSXhRL3YxYhCZzG1?usp=sharing">notebook</a> , <a href="https://deepnote.com/workspace/cognee-382213d0-0444-4c89-8265-13770e333c02/project/cognee-demo-78ffacb9-5832-4611-bb1a-560386068b30/notebook/Notebook-1-75b24cda566d4c24ab348f7150792601?utm_source=share-modal&utm_medium=product-shared-content&utm_campaign=notebook&utm_content=78ffacb9-5832-4611-bb1a-560386068b30">Deepnote notebook</a> or  <a href="https://github.com/topoteretes/cognee/tree/main/cognee-starter-kit">starter repo</a>
+
+
 
 
 ## Contributing
@@ -312,9 +314,9 @@ Example output:
 
 You can also cognify your files and query using cognee UI.
 
-<img src="assets/cognee-ui-2.webp" width="100%" alt="Cognee UI 2"></a>
+<img src="assets/cognee-new-ui.webp" width="100%" alt="Cognee UI 2"></a>
 
-Try cognee UI out locally [here](https://docs.cognee.ai/how-to-guides/cognee-ui).
+Try cognee UI by runnning ``` cognee -ui ``` command on your terminal.
 
 ## Understand our architecture