cognee 0.3.5__py3-none-any.whl → 0.3.7__py3-none-any.whl

cognee/tests/test_lancedb.py

@@ -131,20 +131,16 @@ async def main():
     dataset_name_1 = "natural_language"
     dataset_name_2 = "quantum"
 
-    explanation_file_path = os.path.join(
+    explanation_file_path_nlp = os.path.join(
         pathlib.Path(__file__).parent, "test_data/Natural_language_processing.txt"
     )
-    await cognee.add([explanation_file_path], dataset_name_1)
+    await cognee.add([explanation_file_path_nlp], dataset_name_1)
 
-    text = """A quantum computer is a computer that takes advantage of quantum mechanical phenomena.
-    At small scales, physical matter exhibits properties of both particles and waves, and quantum computing leverages this behavior, specifically quantum superposition and entanglement, using specialized hardware that supports the preparation and manipulation of quantum states.
-    Classical physics cannot explain the operation of these quantum devices, and a scalable quantum computer could perform some calculations exponentially faster (with respect to input size scaling) than any modern "classical" computer. In particular, a large-scale quantum computer could break widely used encryption schemes and aid physicists in performing physical simulations; however, the current state of the technology is largely experimental and impractical, with several obstacles to useful applications. Moreover, scalable quantum computers do not hold promise for many practical tasks, and for many important tasks quantum speedups are proven impossible.
-    The basic unit of information in quantum computing is the qubit, similar to the bit in traditional digital electronics. Unlike a classical bit, a qubit can exist in a superposition of its two "basis" states. When measuring a qubit, the result is a probabilistic output of a classical bit, therefore making quantum computers nondeterministic in general. If a quantum computer manipulates the qubit in a particular way, wave interference effects can amplify the desired measurement results. The design of quantum algorithms involves creating procedures that allow a quantum computer to perform calculations efficiently and quickly.
-    Physically engineering high-quality qubits has proven challenging. If a physical qubit is not sufficiently isolated from its environment, it suffers from quantum decoherence, introducing noise into calculations. Paradoxically, perfectly isolating qubits is also undesirable because quantum computations typically need to initialize qubits, perform controlled qubit interactions, and measure the resulting quantum states. Each of those operations introduces errors and suffers from noise, and such inaccuracies accumulate.
-    In principle, a non-quantum (classical) computer can solve the same computational problems as a quantum computer, given enough time. Quantum advantage comes in the form of time complexity rather than computability, and quantum complexity theory shows that some quantum algorithms for carefully selected tasks require exponentially fewer computational steps than the best known non-quantum algorithms. Such tasks can in theory be solved on a large-scale quantum computer whereas classical computers would not finish computations in any reasonable amount of time. However, quantum speedup is not universal or even typical across computational tasks, since basic tasks such as sorting are proven to not allow any asymptotic quantum speedup. Claims of quantum supremacy have drawn significant attention to the discipline, but are demonstrated on contrived tasks, while near-term practical use cases remain limited.
-    """
+    explanation_file_path_quantum = os.path.join(
+        pathlib.Path(__file__).parent, "test_data/Quantum_computers.txt"
+    )
 
-    await cognee.add([text], dataset_name_2)
+    await cognee.add([explanation_file_path_quantum], dataset_name_2)
 
     await cognee.cognify([dataset_name_2, dataset_name_1])
 
@@ -157,7 +153,7 @@ async def main():
     random_node_name = random_node.payload["text"]
 
     search_results = await cognee.search(
-        query_type=SearchType.INSIGHTS, query_text=random_node_name
+        query_type=SearchType.GRAPH_COMPLETION, query_text=random_node_name
     )
     assert len(search_results) != 0, "The search results list is empty."
     print("\n\nExtracted sentences are:\n")

cognee/tests/test_library.py

@@ -6,6 +6,7 @@ from cognee.modules.search.operations import get_history
 from cognee.modules.users.methods import get_default_user
 from cognee.shared.logging_utils import get_logger
 from cognee.modules.search.types import SearchType
+from cognee import update
 
 logger = get_logger()
 
@@ -42,7 +43,7 @@ async def main():
 
     await cognee.add([text], dataset_name)
 
-    await cognee.cognify([dataset_name])
+    cognify_run_info = await cognee.cognify([dataset_name])
 
     from cognee.infrastructure.databases.vector import get_vector_engine
 
@@ -51,7 +52,7 @@ async def main():
     random_node_name = random_node.payload["text"]
 
     search_results = await cognee.search(
-        query_type=SearchType.INSIGHTS, query_text=random_node_name
+        query_type=SearchType.GRAPH_COMPLETION, query_text=random_node_name
     )
     assert len(search_results) != 0, "The search results list is empty."
     print("\n\nExtracted sentences are:\n")
@@ -77,6 +78,35 @@ async def main():
 
     assert len(history) == 6, "Search history is not correct."
 
+    # Test updating of documents
+    # Get Pipeline Run object
+    pipeline_run_obj = list(cognify_run_info.values())[0]
+    for data_item in pipeline_run_obj.data_ingestion_info:
+        # Update all documents in dataset to only contain Mark and Cindy information
+        await update(
+            dataset_id=pipeline_run_obj.dataset_id,
+            data_id=data_item["data_id"],
+            data="Mark met with Cindy at a cafe.",
+        )
+
+    search_results = await cognee.search(
+        query_type=SearchType.GRAPH_COMPLETION, query_text="What information do you contain?"
+    )
+    assert "Mark" in search_results[0], (
+        "Failed to update document, no mention of Mark in search results"
+    )
+    assert "Cindy" in search_results[0], (
+        "Failed to update document, no mention of Cindy in search results"
+    )
+    assert "Artificial intelligence" not in search_results[0], (
+        "Failed to update document, Artificial intelligence still mentioned in search results"
+    )
+
+    # Test visualization
+    from cognee import visualize_graph
+
+    await visualize_graph()
+
     # Assert local data files are cleaned properly
     await cognee.prune.prune_data()
     data_root_directory = get_storage_config()["data_root_directory"]

cognee/tests/test_neo4j.py

@@ -32,23 +32,34 @@ async def main():
 
     dataset_name = "cs_explanations"
 
-    explanation_file_path = os.path.join(
+    explanation_file_path_nlp = os.path.join(
         pathlib.Path(__file__).parent, "test_data/Natural_language_processing.txt"
     )
-    await cognee.add([explanation_file_path], dataset_name)
+    from cognee.infrastructure.databases.graph import get_graph_engine
+
+    graph_engine = await get_graph_engine()
+
+    is_empty = await graph_engine.is_empty()
 
-    text = """A quantum computer is a computer that takes advantage of quantum mechanical phenomena.
-    At small scales, physical matter exhibits properties of both particles and waves, and quantum computing leverages this behavior, specifically quantum superposition and entanglement, using specialized hardware that supports the preparation and manipulation of quantum states.
-    Classical physics cannot explain the operation of these quantum devices, and a scalable quantum computer could perform some calculations exponentially faster (with respect to input size scaling) than any modern "classical" computer. In particular, a large-scale quantum computer could break widely used encryption schemes and aid physicists in performing physical simulations; however, the current state of the technology is largely experimental and impractical, with several obstacles to useful applications. Moreover, scalable quantum computers do not hold promise for many practical tasks, and for many important tasks quantum speedups are proven impossible.
-    The basic unit of information in quantum computing is the qubit, similar to the bit in traditional digital electronics. Unlike a classical bit, a qubit can exist in a superposition of its two "basis" states. When measuring a qubit, the result is a probabilistic output of a classical bit, therefore making quantum computers nondeterministic in general. If a quantum computer manipulates the qubit in a particular way, wave interference effects can amplify the desired measurement results. The design of quantum algorithms involves creating procedures that allow a quantum computer to perform calculations efficiently and quickly.
-    Physically engineering high-quality qubits has proven challenging. If a physical qubit is not sufficiently isolated from its environment, it suffers from quantum decoherence, introducing noise into calculations. Paradoxically, perfectly isolating qubits is also undesirable because quantum computations typically need to initialize qubits, perform controlled qubit interactions, and measure the resulting quantum states. Each of those operations introduces errors and suffers from noise, and such inaccuracies accumulate.
-    In principle, a non-quantum (classical) computer can solve the same computational problems as a quantum computer, given enough time. Quantum advantage comes in the form of time complexity rather than computability, and quantum complexity theory shows that some quantum algorithms for carefully selected tasks require exponentially fewer computational steps than the best known non-quantum algorithms. Such tasks can in theory be solved on a large-scale quantum computer whereas classical computers would not finish computations in any reasonable amount of time. However, quantum speedup is not universal or even typical across computational tasks, since basic tasks such as sorting are proven to not allow any asymptotic quantum speedup. Claims of quantum supremacy have drawn significant attention to the discipline, but are demonstrated on contrived tasks, while near-term practical use cases remain limited.
-    """
+    assert is_empty, "Graph has to be empty"
+
+    await cognee.add([explanation_file_path_nlp], dataset_name)
+
+    explanation_file_path_quantum = os.path.join(
+        pathlib.Path(__file__).parent, "test_data/Quantum_computers.txt"
+    )
 
-    await cognee.add([text], dataset_name)
+    await cognee.add([explanation_file_path_quantum], dataset_name)
+    is_empty = await graph_engine.is_empty()
+
+    assert is_empty, "Graph has to be empty before cognify"
 
     await cognee.cognify([dataset_name])
 
+    is_empty = await graph_engine.is_empty()
+
+    assert not is_empty, "Graph shouldn't be empty"
+
     from cognee.infrastructure.databases.vector import get_vector_engine
 
     vector_engine = get_vector_engine()
@@ -56,7 +67,7 @@ async def main():
     random_node_name = random_node.payload["text"]
 
     search_results = await cognee.search(
-        query_type=SearchType.INSIGHTS, query_text=random_node_name
+        query_type=SearchType.GRAPH_COMPLETION, query_text=random_node_name
     )
     assert len(search_results) != 0, "The search results list is empty."
     print("\n\nExtracted sentences are:\n")
@@ -121,11 +132,8 @@ async def main():
     assert not os.path.isdir(data_root_directory), "Local data files are not deleted"
 
     await cognee.prune.prune_system(metadata=True)
-    from cognee.infrastructure.databases.graph import get_graph_engine
-
-    graph_engine = await get_graph_engine()
-    nodes, edges = await graph_engine.get_graph_data()
-    assert len(nodes) == 0 and len(edges) == 0, "Neo4j graph database is not empty"
+    is_empty = await graph_engine.is_empty()
+    assert is_empty, "Neo4j graph database is not empty"
 
 
 if __name__ == "__main__":

cognee/tests/test_neptune_analytics_vector.py

@@ -38,20 +38,16 @@ async def main():
 
     dataset_name = "cs_explanations"
 
-    explanation_file_path = os.path.join(
+    explanation_file_path_nlp = os.path.join(
         pathlib.Path(__file__).parent, "test_data/Natural_language_processing.txt"
     )
-    await cognee.add([explanation_file_path], dataset_name)
+    await cognee.add([explanation_file_path_nlp], dataset_name)
 
-    text = """A quantum computer is a computer that takes advantage of quantum mechanical phenomena.
-    At small scales, physical matter exhibits properties of both particles and waves, and quantum computing leverages this behavior, specifically quantum superposition and entanglement, using specialized hardware that supports the preparation and manipulation of quantum states.
-    Classical physics cannot explain the operation of these quantum devices, and a scalable quantum computer could perform some calculations exponentially faster (with respect to input size scaling) than any modern "classical" computer. In particular, a large-scale quantum computer could break widely used encryption schemes and aid physicists in performing physical simulations; however, the current state of the technology is largely experimental and impractical, with several obstacles to useful applications. Moreover, scalable quantum computers do not hold promise for many practical tasks, and for many important tasks quantum speedups are proven impossible.
-    The basic unit of information in quantum computing is the qubit, similar to the bit in traditional digital electronics. Unlike a classical bit, a qubit can exist in a superposition of its two "basis" states. When measuring a qubit, the result is a probabilistic output of a classical bit, therefore making quantum computers nondeterministic in general. If a quantum computer manipulates the qubit in a particular way, wave interference effects can amplify the desired measurement results. The design of quantum algorithms involves creating procedures that allow a quantum computer to perform calculations efficiently and quickly.
-    Physically engineering high-quality qubits has proven challenging. If a physical qubit is not sufficiently isolated from its environment, it suffers from quantum decoherence, introducing noise into calculations. Paradoxically, perfectly isolating qubits is also undesirable because quantum computations typically need to initialize qubits, perform controlled qubit interactions, and measure the resulting quantum states. Each of those operations introduces errors and suffers from noise, and such inaccuracies accumulate.
-    In principle, a non-quantum (classical) computer can solve the same computational problems as a quantum computer, given enough time. Quantum advantage comes in the form of time complexity rather than computability, and quantum complexity theory shows that some quantum algorithms for carefully selected tasks require exponentially fewer computational steps than the best known non-quantum algorithms. Such tasks can in theory be solved on a large-scale quantum computer whereas classical computers would not finish computations in any reasonable amount of time. However, quantum speedup is not universal or even typical across computational tasks, since basic tasks such as sorting are proven to not allow any asymptotic quantum speedup. Claims of quantum supremacy have drawn significant attention to the discipline, but are demonstrated on contrived tasks, while near-term practical use cases remain limited.
-    """
+    explanation_file_path_quantum = os.path.join(
+        pathlib.Path(__file__).parent, "test_data/Quantum_computers.txt"
+    )
 
-    await cognee.add([text], dataset_name)
+    await cognee.add([explanation_file_path_quantum], dataset_name)
 
     await cognee.cognify([dataset_name])
 
@@ -60,7 +56,7 @@ async def main():
     random_node_name = random_node.payload["text"]
 
     search_results = await cognee.search(
-        query_type=SearchType.INSIGHTS, query_text=random_node_name
+        query_type=SearchType.GRAPH_COMPLETION, query_text=random_node_name
     )
     assert len(search_results) != 0, "The search results list is empty."
     print("\n\nExtracted sentences are:\n")

cognee/tests/test_permissions.py

@@ -34,25 +34,21 @@ async def main():
     await cognee.prune.prune_data()
     await cognee.prune.prune_system(metadata=True)
 
-    explanation_file_path = os.path.join(
+    explanation_file_path_nlp = os.path.join(
         pathlib.Path(__file__).parent, "test_data/Natural_language_processing.txt"
     )
 
     # Add document for default user
-    await cognee.add([explanation_file_path], dataset_name="NLP")
+    await cognee.add([explanation_file_path_nlp], dataset_name="NLP")
     default_user = await get_default_user()
 
-    text = """A quantum computer is a computer that takes advantage of quantum mechanical phenomena.
-    At small scales, physical matter exhibits properties of both particles and waves, and quantum computing leverages this behavior, specifically quantum superposition and entanglement, using specialized hardware that supports the preparation and manipulation of quantum states.
-    Classical physics cannot explain the operation of these quantum devices, and a scalable quantum computer could perform some calculations exponentially faster (with respect to input size scaling) than any modern "classical" computer. In particular, a large-scale quantum computer could break widely used encryption schemes and aid physicists in performing physical simulations; however, the current state of the technology is largely experimental and impractical, with several obstacles to useful applications. Moreover, scalable quantum computers do not hold promise for many practical tasks, and for many important tasks quantum speedups are proven impossible.
-    The basic unit of information in quantum computing is the qubit, similar to the bit in traditional digital electronics. Unlike a classical bit, a qubit can exist in a superposition of its two "basis" states. When measuring a qubit, the result is a probabilistic output of a classical bit, therefore making quantum computers nondeterministic in general. If a quantum computer manipulates the qubit in a particular way, wave interference effects can amplify the desired measurement results. The design of quantum algorithms involves creating procedures that allow a quantum computer to perform calculations efficiently and quickly.
-    Physically engineering high-quality qubits has proven challenging. If a physical qubit is not sufficiently isolated from its environment, it suffers from quantum decoherence, introducing noise into calculations. Paradoxically, perfectly isolating qubits is also undesirable because quantum computations typically need to initialize qubits, perform controlled qubit interactions, and measure the resulting quantum states. Each of those operations introduces errors and suffers from noise, and such inaccuracies accumulate.
-    In principle, a non-quantum (classical) computer can solve the same computational problems as a quantum computer, given enough time. Quantum advantage comes in the form of time complexity rather than computability, and quantum complexity theory shows that some quantum algorithms for carefully selected tasks require exponentially fewer computational steps than the best known non-quantum algorithms. Such tasks can in theory be solved on a large-scale quantum computer whereas classical computers would not finish computations in any reasonable amount of time. However, quantum speedup is not universal or even typical across computational tasks, since basic tasks such as sorting are proven to not allow any asymptotic quantum speedup. Claims of quantum supremacy have drawn significant attention to the discipline, but are demonstrated on contrived tasks, while near-term practical use cases remain limited.
-    """
+    explanation_file_path_quantum = os.path.join(
+        pathlib.Path(__file__).parent, "test_data/Quantum_computers.txt"
+    )
 
     # Add document for test user
     test_user = await create_user("user@example.com", "example")
-    await cognee.add([text], dataset_name="QUANTUM", user=test_user)
+    await cognee.add([explanation_file_path_quantum], dataset_name="QUANTUM", user=test_user)
 
     nlp_cognify_result = await cognee.cognify(["NLP"], user=default_user)
     quantum_cognify_result = await cognee.cognify(["QUANTUM"], user=test_user)
@@ -101,7 +97,7 @@ async def main():
     add_error = False
     try:
         await cognee.add(
-            [explanation_file_path],
+            [explanation_file_path_nlp],
             dataset_name="QUANTUM",
             dataset_id=test_user_dataset_id,
             user=default_user,
@@ -143,7 +139,7 @@ async def main():
 
     # Add new data to test_users dataset from default_user
     await cognee.add(
-        [explanation_file_path],
+        [explanation_file_path_nlp],
         dataset_name="QUANTUM",
         dataset_id=test_user_dataset_id,
         user=default_user,
@@ -216,7 +212,7 @@ async def main():
     )
 
     # Try deleting data from test_user dataset with default_user after getting delete permission
-    # Get the dataset data to find the ID of the remaining data item (explanation_file_path)
+    # Get the dataset data to find the ID of the remaining data item (explanation_file_path_nlp)
     test_user_dataset_data = await get_dataset_data(test_user_dataset_id)
     explanation_file_data_id = test_user_dataset_data[0].id
 

cognee/tests/test_pgvector.py

@@ -141,10 +141,10 @@ async def main():
     dataset_name_1 = "natural_language"
     dataset_name_2 = "quantum"
 
-    explanation_file_path = os.path.join(
+    explanation_file_path_nlp = os.path.join(
         pathlib.Path(__file__).parent, "test_data/Natural_language_processing.txt"
     )
-    await cognee.add([explanation_file_path], dataset_name_1)
+    await cognee.add([explanation_file_path_nlp], dataset_name_1)
 
     text = """A quantum computer is a computer that takes advantage of quantum mechanical phenomena.
     At small scales, physical matter exhibits properties of both particles and waves, and quantum computing leverages this behavior, specifically quantum superposition and entanglement, using specialized hardware that supports the preparation and manipulation of quantum states.
@@ -167,7 +167,7 @@ async def main():
     random_node_name = random_node.payload["text"]
 
     search_results = await cognee.search(
-        query_type=SearchType.INSIGHTS, query_text=random_node_name
+        query_type=SearchType.GRAPH_COMPLETION, query_text=random_node_name
     )
     assert len(search_results) != 0, "The search results list is empty."
     print("\n\nExtracted sentences are:\n")
@@ -202,7 +202,7 @@ async def main():
     history = await get_history(user.id)
     assert len(history) == 8, "Search history is not correct."
 
-    await test_local_file_deletion(text, explanation_file_path)
+    await test_local_file_deletion(text, explanation_file_path_nlp)
 
     await cognee.prune.prune_data()
     data_root_directory = get_storage_config()["data_root_directory"]

cognee/tests/test_remote_kuzu.py

@@ -42,19 +42,16 @@ async def main():
 
         dataset_name = "cs_explanations"
 
-        explanation_file_path = os.path.join(
+        explanation_file_path_nlp = os.path.join(
             pathlib.Path(__file__).parent, "test_data/Natural_language_processing.txt"
         )
-        await cognee.add([explanation_file_path], dataset_name)
+        await cognee.add([explanation_file_path_nlp], dataset_name)
 
-        text = """A quantum computer is a computer that takes advantage of quantum mechanical phenomena.
-        At small scales, physical matter exhibits properties of both particles and waves, and quantum computing leverages this behavior, specifically quantum superposition and entanglement, using specialized hardware that supports the preparation and manipulation of quantum states.
-        Classical physics cannot explain the operation of these quantum devices, and a scalable quantum computer could perform some calculations exponentially faster (with respect to input size scaling) than any modern "classical" computer. In particular, a large-scale quantum computer could break widely used encryption schemes and aid physicists in performing physical simulations; however, the current state of the technology is largely experimental and impractical, with several obstacles to useful applications. Moreover, scalable quantum computers do not hold promise for many practical tasks, and for many important tasks quantum speedups are proven impossible.
-        The basic unit of information in quantum computing is the qubit, similar to the bit in traditional digital electronics. Unlike a classical bit, a qubit can exist in a superposition of its two "basis" states. When measuring a qubit, the result is a probabilistic output of a classical bit, therefore making quantum computers nondeterministic in general. If a quantum computer manipulates the qubit in a particular way, wave interference effects can amplify the desired measurement results. The design of quantum algorithms involves creating procedures that allow a quantum computer to perform calculations efficiently and quickly.
-        Physically engineering high-quality qubits has proven challenging. If a physical qubit is not sufficiently isolated from its environment, it suffers from quantum decoherence, introducing noise into calculations. Paradoxically, perfectly isolating qubits is also undesirable because quantum computations typically need to initialize qubits, perform controlled qubit interactions, and measure the resulting quantum states. Each of those operations introduces errors and suffers from noise, and such inaccuracies accumulate.
-        In principle, a non-quantum (classical) computer can solve the same computational problems as a quantum computer, given enough time. Quantum advantage comes in the form of time complexity rather than computability, and quantum complexity theory shows that some quantum algorithms for carefully selected tasks require exponentially fewer computational steps than the best known non-quantum algorithms. Such tasks can in theory be solved on a large-scale quantum computer whereas classical computers would not finish computations in any reasonable amount of time. However, quantum speedup is not universal or even typical across computational tasks, since basic tasks such as sorting are proven to not allow any asymptotic quantum speedup. Claims of quantum supremacy have drawn significant attention to the discipline, but are demonstrated on contrived tasks, while near-term practical use cases remain limited.
-        """
-        await cognee.add([text], dataset_name)
+        explanation_file_path_quantum = os.path.join(
+            pathlib.Path(__file__).parent, "test_data/Quantum_computers.txt"
+        )
+
+        await cognee.add([explanation_file_path_quantum], dataset_name)
 
         await cognee.cognify([dataset_name])
 
@@ -65,7 +62,7 @@ async def main():
         random_node_name = random_node.payload["text"]
 
         search_results = await cognee.search(
-            query_type=SearchType.INSIGHTS, query_text=random_node_name
+            query_type=SearchType.GRAPH_COMPLETION, query_text=random_node_name
         )
         assert len(search_results) != 0, "The search results list is empty."
         print("\n\nExtracted sentences are:\n")

cognee/tests/test_s3_file_storage.py

@@ -47,7 +47,7 @@ async def main():
     random_node_name = random_node.payload["text"]
 
     search_results = await cognee.search(
-        query_type=SearchType.INSIGHTS, query_text=random_node_name
+        query_type=SearchType.GRAPH_COMPLETION, query_text=random_node_name
     )
     assert len(search_results) != 0, "The search results list is empty."
     print("\n\nExtracted sentences are:\n")

cognee/tests/test_search_db.py

@@ -1,3 +1,5 @@
+import pathlib
+import os
 import cognee
 from cognee.infrastructure.databases.graph import get_graph_engine
 from cognee.modules.graph.cognee_graph.CogneeGraphElements import Edge
@@ -27,15 +29,11 @@ async def main():
     text_1 = """Germany is located in europe right next to the Netherlands"""
     await cognee.add(text_1, dataset_name)
 
-    text = """A quantum computer is a computer that takes advantage of quantum mechanical phenomena.
-    At small scales, physical matter exhibits properties of both particles and waves, and quantum computing leverages this behavior, specifically quantum superposition and entanglement, using specialized hardware that supports the preparation and manipulation of quantum states.
-    Classical physics cannot explain the operation of these quantum devices, and a scalable quantum computer could perform some calculations exponentially faster (with respect to input size scaling) than any modern "classical" computer. In particular, a large-scale quantum computer could break widely used encryption schemes and aid physicists in performing physical simulations; however, the current state of the technology is largely experimental and impractical, with several obstacles to useful applications. Moreover, scalable quantum computers do not hold promise for many practical tasks, and for many important tasks quantum speedups are proven impossible.
-    The basic unit of information in quantum computing is the qubit, similar to the bit in traditional digital electronics. Unlike a classical bit, a qubit can exist in a superposition of its two "basis" states. When measuring a qubit, the result is a probabilistic output of a classical bit, therefore making quantum computers nondeterministic in general. If a quantum computer manipulates the qubit in a particular way, wave interference effects can amplify the desired measurement results. The design of quantum algorithms involves creating procedures that allow a quantum computer to perform calculations efficiently and quickly.
-    Physically engineering high-quality qubits has proven challenging. If a physical qubit is not sufficiently isolated from its environment, it suffers from quantum decoherence, introducing noise into calculations. Paradoxically, perfectly isolating qubits is also undesirable because quantum computations typically need to initialize qubits, perform controlled qubit interactions, and measure the resulting quantum states. Each of those operations introduces errors and suffers from noise, and such inaccuracies accumulate.
-    In principle, a non-quantum (classical) computer can solve the same computational problems as a quantum computer, given enough time. Quantum advantage comes in the form of time complexity rather than computability, and quantum complexity theory shows that some quantum algorithms for carefully selected tasks require exponentially fewer computational steps than the best known non-quantum algorithms. Such tasks can in theory be solved on a large-scale quantum computer whereas classical computers would not finish computations in any reasonable amount of time. However, quantum speedup is not universal or even typical across computational tasks, since basic tasks such as sorting are proven to not allow any asymptotic quantum speedup. Claims of quantum supremacy have drawn significant attention to the discipline, but are demonstrated on contrived tasks, while near-term practical use cases remain limited.
-    """
+    explanation_file_path_quantum = os.path.join(
+        pathlib.Path(__file__).parent, "test_data/Quantum_computers.txt"
+    )
 
-    await cognee.add([text], dataset_name)
+    await cognee.add([explanation_file_path_quantum], dataset_name)
 
     await cognee.cognify([dataset_name])
 

cognee/tests/unit/infrastructure/databases/cache/test_cache_config.py

@@ -0,0 +1,89 @@
+"""Tests for cache configuration."""
+
+import pytest
+from cognee.infrastructure.databases.cache.config import CacheConfig, get_cache_config
+
+
+def test_cache_config_defaults():
+    """Test that CacheConfig has the correct default values."""
+    config = CacheConfig()
+
+    assert config.caching is False
+    assert config.shared_kuzu_lock is False
+    assert config.cache_host == "localhost"
+    assert config.cache_port == 6379
+    assert config.agentic_lock_expire == 240
+    assert config.agentic_lock_timeout == 300
+
+
+def test_cache_config_custom_values():
+    """Test that CacheConfig accepts custom values."""
+    config = CacheConfig(
+        caching=True,
+        shared_kuzu_lock=True,
+        cache_host="redis.example.com",
+        cache_port=6380,
+        agentic_lock_expire=120,
+        agentic_lock_timeout=180,
+    )
+
+    assert config.caching is True
+    assert config.shared_kuzu_lock is True
+    assert config.cache_host == "redis.example.com"
+    assert config.cache_port == 6380
+    assert config.agentic_lock_expire == 120
+    assert config.agentic_lock_timeout == 180
+
+
+def test_cache_config_to_dict():
+    """Test the to_dict method returns all configuration values."""
+    config = CacheConfig(
+        caching=True,
+        shared_kuzu_lock=True,
+        cache_host="test-host",
+        cache_port=7000,
+        agentic_lock_expire=100,
+        agentic_lock_timeout=200,
+    )
+
+    config_dict = config.to_dict()
+
+    assert config_dict == {
+        "caching": True,
+        "shared_kuzu_lock": True,
+        "cache_host": "test-host",
+        "cache_port": 7000,
+        "cache_username": None,
+        "cache_password": None,
+        "agentic_lock_expire": 100,
+        "agentic_lock_timeout": 200,
+    }
+
+
+def test_get_cache_config_singleton():
+    """Test that get_cache_config returns the same instance."""
+    config1 = get_cache_config()
+    config2 = get_cache_config()
+
+    assert config1 is config2
+
+
+def test_cache_config_extra_fields_allowed():
+    """Test that CacheConfig allows extra fields due to extra='allow'."""
+    config = CacheConfig(extra_field="extra_value", another_field=123)
+
+    assert hasattr(config, "extra_field")
+    assert config.extra_field == "extra_value"
+    assert hasattr(config, "another_field")
+    assert config.another_field == 123
+
+
+def test_cache_config_boolean_type_validation():
+    """Test that boolean fields accept various truthy/falsy values."""
+    config1 = CacheConfig(caching="true", shared_kuzu_lock="yes")
+    assert config1.caching is True
+    assert config1.shared_kuzu_lock is True
+
+    config2 = CacheConfig(caching="false", shared_kuzu_lock="no")
+    assert config2.caching is False
+    assert config2.shared_kuzu_lock is False

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

@@ -0,0 +1,154 @@
+import pytest
+from unittest.mock import AsyncMock, patch, MagicMock
+from cognee.context_global_variables import session_user
+import importlib
+
+
+def create_mock_cache_engine(qa_history=None):
+    mock_cache = AsyncMock()
+    if qa_history is None:
+        qa_history = []
+    mock_cache.get_latest_qa = AsyncMock(return_value=qa_history)
+    mock_cache.add_qa = AsyncMock(return_value=None)
+    return mock_cache
+
+
+def create_mock_user():
+    mock_user = MagicMock()
+    mock_user.id = "test-user-id-123"
+    return mock_user
+
+
+class TestConversationHistoryUtils:
+    @pytest.mark.asyncio
+    async def test_get_conversation_history_returns_empty_when_no_history(self):
+        user = create_mock_user()
+        session_user.set(user)
+        mock_cache = create_mock_cache_engine([])
+
+        cache_module = importlib.import_module(
+            "cognee.infrastructure.databases.cache.get_cache_engine"
+        )
+
+        with patch.object(cache_module, "get_cache_engine", return_value=mock_cache):
+            from cognee.modules.retrieval.utils.session_cache import get_conversation_history
+
+            result = await get_conversation_history(session_id="test_session")
+
+        assert result == ""
+
+    @pytest.mark.asyncio
+    async def test_get_conversation_history_formats_history_correctly(self):
+        """Test get_conversation_history formats Q&A history with correct structure."""
+        user = create_mock_user()
+        session_user.set(user)
+
+        mock_history = [
+            {
+                "time": "2024-01-15 10:30:45",
+                "question": "What is AI?",
+                "context": "AI is artificial intelligence",
+                "answer": "AI stands for Artificial Intelligence",
+            }
+        ]
+        mock_cache = create_mock_cache_engine(mock_history)
+
+        # Import the real module to patch safely
+        cache_module = importlib.import_module(
+            "cognee.infrastructure.databases.cache.get_cache_engine"
+        )
+
+        with patch.object(cache_module, "get_cache_engine", return_value=mock_cache):
+            with patch(
+                "cognee.modules.retrieval.utils.session_cache.CacheConfig"
+            ) as MockCacheConfig:
+                mock_config = MagicMock()
+                mock_config.caching = True
+                MockCacheConfig.return_value = mock_config
+
+                from cognee.modules.retrieval.utils.session_cache import (
+                    get_conversation_history,
+                )
+
+                result = await get_conversation_history(session_id="test_session")
+
+                assert "Previous conversation:" in result
+                assert "[2024-01-15 10:30:45]" in result
+                assert "QUESTION: What is AI?" in result
+                assert "CONTEXT: AI is artificial intelligence" in result
+                assert "ANSWER: AI stands for Artificial Intelligence" in result
+
+    @pytest.mark.asyncio
+    async def test_save_to_session_cache_saves_correctly(self):
+        """Test save_conversation_history calls add_qa with correct parameters."""
+        user = create_mock_user()
+        session_user.set(user)
+
+        mock_cache = create_mock_cache_engine([])
+
+        cache_module = importlib.import_module(
+            "cognee.infrastructure.databases.cache.get_cache_engine"
+        )
+
+        with patch.object(cache_module, "get_cache_engine", return_value=mock_cache):
+            with patch(
+                "cognee.modules.retrieval.utils.session_cache.CacheConfig"
+            ) as MockCacheConfig:
+                mock_config = MagicMock()
+                mock_config.caching = True
+                MockCacheConfig.return_value = mock_config
+
+                from cognee.modules.retrieval.utils.session_cache import (
+                    save_conversation_history,
+                )
+
+                result = await save_conversation_history(
+                    query="What is Python?",
+                    context_summary="Python is a programming language",
+                    answer="Python is a high-level programming language",
+                    session_id="my_session",
+                )
+
+                assert result is True
+                mock_cache.add_qa.assert_called_once()
+
+                call_kwargs = mock_cache.add_qa.call_args.kwargs
+                assert call_kwargs["question"] == "What is Python?"
+                assert call_kwargs["context"] == "Python is a programming language"
+                assert call_kwargs["answer"] == "Python is a high-level programming language"
+                assert call_kwargs["session_id"] == "my_session"
+
+    @pytest.mark.asyncio
+    async def test_save_to_session_cache_uses_default_session_when_none(self):
+        """Test save_conversation_history uses 'default_session' when session_id is None."""
+        user = create_mock_user()
+        session_user.set(user)
+
+        mock_cache = create_mock_cache_engine([])
+
+        cache_module = importlib.import_module(
+            "cognee.infrastructure.databases.cache.get_cache_engine"
+        )
+
+        with patch.object(cache_module, "get_cache_engine", return_value=mock_cache):
+            with patch(
+                "cognee.modules.retrieval.utils.session_cache.CacheConfig"
+            ) as MockCacheConfig:
+                mock_config = MagicMock()
+                mock_config.caching = True
+                MockCacheConfig.return_value = mock_config
+
+                from cognee.modules.retrieval.utils.session_cache import (
+                    save_conversation_history,
+                )
+
+                result = await save_conversation_history(
+                    query="Test question",
+                    context_summary="Test context",
+                    answer="Test answer",
+                    session_id=None,
+                )
+
+                assert result is True
+                call_kwargs = mock_cache.add_qa.call_args.kwargs
+                assert call_kwargs["session_id"] == "default_session"