chore: import upstream snapshot with attribution

examples/database_examples/chromadb_example.py

@@ -0,0 +1,91 @@
+import asyncio
+import os
+import pathlib
+
+# ChromaDB is available as a vector adapter, but it does not have a dataset
+# database handler for backend access control yet.
+# Set os.environ before importing Cognee: Cognee reads env-backed settings at import time, so values
+# assigned later may not override defaults or `.env`. See https://docs.cognee.ai/setup-configuration/overview#using-os-environ
+os.environ["ENABLE_BACKEND_ACCESS_CONTROL"] = "False"
+
+import cognee
+from cognee import SearchType
+
+
+async def main():
+    """
+    Example script demonstrating how to use Cognee with ChromaDB
+
+    This example:
+    1. Configures Cognee to use ChromaDB as vector database
+    2. Sets up data directories
+    3. Stores sample data with remember to Cognee
+    4. Performs different types of searches
+    """
+    # Configure ChromaDB as the vector database provider
+    cognee.config.set_vector_db_config(
+        {
+            "vector_db_url": "http://localhost:8000",  # Default ChromaDB server URL
+            "vector_db_key": "",  # ChromaDB doesn't require an API key by default
+            "vector_db_provider": "chromadb",  # Specify ChromaDB as provider
+            "vector_dataset_database_handler": "chromadb",
+        }
+    )
+
+    # Set up data directories for storing documents and system files
+    # You should adjust these paths to your needs
+    current_dir = pathlib.Path(__file__).parent
+    data_directory_path = str(current_dir / "data_storage")
+    cognee.config.data_root_directory(data_directory_path)
+
+    cognee_directory_path = str(current_dir / "cognee_system")
+    cognee.config.system_root_directory(cognee_directory_path)
+
+    # Clean any existing data (optional)
+    # await cognee.forget(everything=True)
+
+    # Create a dataset
+    dataset_name = "chromadb_example"
+
+    # Add sample text to the dataset
+    sample_text = """ChromaDB is an open-source embedding database.
+    It allows users to store and query embeddings and their associated metadata.
+    ChromaDB can be deployed in various ways: in-memory, on disk via sqlite, or as a persistent service.
+    It is designed to be fast, scalable, and easy to use, making it a popular choice for AI applications.
+    The database is built to handle vector search efficiently, which is essential for semantic search applications.
+    ChromaDB supports multiple distance metrics for vector similarity search and can be integrated with various ML frameworks."""
+
+    # Add the sample text to the dataset
+    await cognee.remember([sample_text], dataset_name=dataset_name, self_improvement=False)
+
+    # Now let's perform some searches
+    # 1. Search for insights related to "ChromaDB"
+    insights_results = await cognee.recall(
+        query_type=SearchType.GRAPH_COMPLETION, query_text="ChromaDB"
+    )
+    print("\nInsights about ChromaDB:")
+    for result in insights_results:
+        print(f"- {result}")
+
+    # 2. Search for text chunks related to "vector search"
+    chunks_results = await cognee.recall(
+        query_type=SearchType.CHUNKS, query_text="vector search", datasets=[dataset_name]
+    )
+    print("\nChunks about vector search:")
+    for result in chunks_results:
+        print(f"- {result}")
+
+    # 3. Get graph completion related to databases
+    graph_completion_results = await cognee.recall(
+        query_type=SearchType.GRAPH_COMPLETION, query_text="database"
+    )
+    print("\nGraph completion for databases:")
+    for result in graph_completion_results:
+        print(f"- {result}")
+
+    # Clean up (optional)
+    # await cognee.forget(everything=True)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

examples/database_examples/ladybug_example.py

@@ -0,0 +1,81 @@
+import asyncio
+import pathlib
+
+import cognee
+from cognee import SearchType
+
+
+async def main():
+    """
+    Example script demonstrating how to use Cognee with Ladybug
+
+    This example:
+    1. Configures Cognee to use Ladybug as graph database
+    2. Sets up data directories
+    3. Stores sample data with remember to Cognee
+    4. Performs different types of searches
+    """
+    # Configure Ladybug as the graph database provider
+    cognee.config.set_graph_db_config(
+        {
+            "graph_database_provider": "ladybug",  # Specify Ladybug as provider
+        }
+    )
+
+    # Set up data directories for storing documents and system files
+    # You should adjust these paths to your needs
+    current_dir = pathlib.Path(__file__).parent
+    data_directory_path = str(current_dir / "data_storage")
+    cognee.config.data_root_directory(data_directory_path)
+
+    cognee_directory_path = str(current_dir / "cognee_system")
+    cognee.config.system_root_directory(cognee_directory_path)
+
+    # Clean any existing data (optional)
+    # await cognee.forget(everything=True)
+
+    # Create a dataset
+    dataset_name = "ladybug_example"
+
+    # Add sample text to the dataset
+    sample_text = """Ladybug is a graph database system optimized for running complex graph analytics.
+    It is designed to be a high-performance graph database for data science workloads.
+    Ladybug is built with modern hardware optimizations in mind.
+    It provides support for property graphs and offers a Cypher-like query language.
+    Ladybug can handle both transactional and analytical graph workloads.
+    The database now includes vector search capabilities for AI applications and semantic search."""
+
+    # Add the sample text to the dataset
+    await cognee.remember([sample_text], dataset_name=dataset_name, self_improvement=False)
+
+    # Now let's perform some searches
+    # 1. Search for insights related to "Ladybug"
+    insights_results = await cognee.recall(
+        query_type=SearchType.GRAPH_COMPLETION, query_text="Ladybug"
+    )
+    print("\nInsights about Ladybug:")
+    for result in insights_results:
+        print(f"- {result}")
+
+    # 2. Search for text chunks related to "graph database"
+    chunks_results = await cognee.recall(
+        query_type=SearchType.CHUNKS, query_text="graph database", datasets=[dataset_name]
+    )
+    print("\nChunks about graph database:")
+    for result in chunks_results:
+        print(f"- {result}")
+
+    # 3. Get graph completion related to databases
+    graph_completion_results = await cognee.recall(
+        query_type=SearchType.GRAPH_COMPLETION, query_text="database"
+    )
+    print("\nGraph completion for databases:")
+    for result in graph_completion_results:
+        print(f"- {result}")
+
+    # Clean up (optional)
+    # await cognee.forget(everything=True)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

examples/database_examples/neo4j_example.py

@@ -0,0 +1,118 @@
+import asyncio
+import os
+import pathlib
+
+# This example connects to one configured Neo4j instance. Cognee's backend
+# access-control mode expects the Neo4j Aura provisioning handler instead, so
+# keep it disabled here unless the caller explicitly exported another value.
+# Set os.environ before importing Cognee: Cognee reads env-backed settings at import time, so values
+# assigned later may not override defaults or `.env`. See https://docs.cognee.ai/setup-configuration/overview#using-os-environ
+os.environ.setdefault("ENABLE_BACKEND_ACCESS_CONTROL", "false")
+
+import cognee
+from cognee import SearchType
+
+
+async def main():
+    """
+    Example script demonstrating how to use Cognee with Neo4j
+
+    This example:
+    1. Configures Cognee to use Neo4j as graph database
+    2. Sets up data directories
+    3. Stores sample data with remember to Cognee
+    4. Performs different types of searches
+    """
+
+    # Set up Neo4j credentials in .env file and get the values from environment variables.
+    neo4j_url = os.getenv("GRAPH_DATABASE_URL") or os.getenv("NEO4J_URL") or "bolt://localhost:7687"
+    neo4j_user = os.getenv("GRAPH_DATABASE_USERNAME") or os.getenv("NEO4J_USERNAME") or "neo4j"
+    neo4j_pass = os.getenv("GRAPH_DATABASE_PASSWORD") or os.getenv("NEO4J_PASSWORD")
+    neo4j_database = os.getenv("GRAPH_DATABASE_NAME") or os.getenv("NEO4J_DATABASE") or "neo4j"
+
+    if not neo4j_pass:
+        raise EnvironmentError(
+            "Missing Neo4j password. Set GRAPH_DATABASE_PASSWORD or NEO4J_PASSWORD."
+        )
+
+    cognee.config.set_vector_db_config(
+        {
+            "vector_db_provider": "lancedb",
+            "vector_dataset_database_handler": "lancedb",
+        }
+    )
+
+    # Configure Neo4j as the graph database provider
+    cognee.config.set_graph_db_config(
+        {
+            "graph_database_url": neo4j_url,  # Neo4j Bolt URL
+            "graph_database_name": neo4j_database,
+            "graph_database_provider": "neo4j",  # Specify Neo4j as provider
+            "graph_database_username": neo4j_user,  # Neo4j username
+            "graph_database_password": neo4j_pass,  # Neo4j password
+        }
+    )
+
+    # Set up data directories for storing documents and system files
+    # You should adjust these paths to your needs
+    current_dir = pathlib.Path(__file__).parent
+    data_directory_path = str(current_dir / "data_storage")
+    cognee.config.data_root_directory(data_directory_path)
+
+    cognee_directory_path = str(current_dir / "cognee_system")
+    cognee.config.system_root_directory(cognee_directory_path)
+
+    # Clean any existing data (optional)
+    # await cognee.forget(everything=True)
+
+    # Create a dataset
+    dataset_name = "neo4j_example"
+
+    # Add sample text to the dataset
+    sample_text = (
+        "Neo4j is a graph database management system. "
+        "It stores data in nodes and relationships rather than tables as in traditional "
+        "relational databases. "
+        "Neo4j provides a powerful query language called Cypher for graph traversal and "
+        "analysis. "
+        "It now supports vector indexing for similarity search with the vector index plugin. "
+        "Neo4j allows embedding generation and vector search to be combined with graph "
+        "operations. "
+        "Applications can use Neo4j to connect vector search with graph context for more "
+        "meaningful results."
+    )
+
+    # Add the sample text to the dataset
+    await cognee.remember([sample_text], dataset_name=dataset_name, self_improvement=False)
+
+    # Now let's perform some searches
+    # 1. Search for insights related to "Neo4j"
+    insights_results = await cognee.recall(
+        query_type=SearchType.GRAPH_COMPLETION, query_text="Neo4j"
+    )
+    print("\nInsights about Neo4j:")
+    for result in insights_results:
+        print(f"- {result}")
+
+    # 2. Search for text chunks related to "graph database"
+    chunks_results = await cognee.recall(
+        query_type=SearchType.CHUNKS, query_text="graph database", datasets=[dataset_name]
+    )
+    print("\nChunks about graph database:")
+    for result in chunks_results:
+        print(f"- {result}")
+
+    # 3. Get graph completion related to databases
+    graph_completion_results = await cognee.recall(
+        query_type=SearchType.GRAPH_COMPLETION, query_text="database"
+    )
+    print("\nGraph completion for databases:")
+    for result in graph_completion_results:
+        print(f"- {result}")
+
+    # Clean up (optional)
+    # await cognee.forget(everything=True)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

examples/database_examples/neptune_analytics_example.py

@@ -0,0 +1,109 @@
+import asyncio
+import os
+import pathlib
+
+from dotenv import load_dotenv
+
+import cognee
+from cognee import SearchType
+
+load_dotenv()
+
+
+async def main():
+    """
+    Example script demonstrating how to use Cognee with Amazon Neptune Analytics
+
+    This example:
+    1. Configures Cognee to use Neptune Analytics as graph database
+    2. Sets up data directories
+    3. Adds sample data to Cognee
+    4. Stores data with remember
+    5. Performs different types of searches
+    """
+
+    # Set up Amazon credentials in .env file and get the values from environment variables
+    graph_endpoint_url = "neptune-graph://" + os.getenv("GRAPH_ID", "")
+
+    # Configure Neptune Analytics as the graph & vector database provider
+    cognee.config.set_graph_db_config(
+        {
+            "graph_database_provider": "neptune_analytics",  # Specify Neptune Analytics as provider
+            "graph_database_url": graph_endpoint_url,  # Neptune Analytics endpoint with the format neptune-graph://<GRAPH_ID>
+        }
+    )
+    cognee.config.set_vector_db_config(
+        {
+            "vector_db_provider": "neptune_analytics",  # Specify Neptune Analytics as provider
+            "vector_db_url": graph_endpoint_url,  # Neptune Analytics endpoint with the format neptune-graph://<GRAPH_ID>
+        }
+    )
+
+    # Set up data directories for storing documents and system files
+    # You should adjust these paths to your needs
+    current_dir = pathlib.Path(__file__).parent
+    data_directory_path = str(current_dir / "data_storage")
+    cognee.config.data_root_directory(data_directory_path)
+
+    cognee_directory_path = str(current_dir / "cognee_system")
+    cognee.config.system_root_directory(cognee_directory_path)
+
+    # Clean any existing data (optional)
+    # await cognee.forget(everything=True)
+
+    # Create a dataset
+    dataset_name = "neptune_example"
+
+    # Add sample text to the dataset
+    sample_text_1 = """Neptune Analytics is a memory-optimized graph database engine for analytics. With Neptune
+    Analytics, you can get insights and find trends by processing large amounts of graph data in seconds. To analyze
+    graph data quickly and easily, Neptune Analytics stores large graph datasets in memory. It supports a library of
+    optimized graph analytic algorithms, low-latency graph queries, and vector search capabilities within graph
+    traversals.
+    """
+
+    sample_text_2 = """Neptune Analytics is an ideal choice for investigatory, exploratory, or data-science workloads
+    that require fast iteration for data, analytical and algorithmic processing, or vector search on graph data. It
+    complements Amazon Neptune Database, a popular managed graph database. To perform intensive analysis, you can load
+    the data from a Neptune Database graph or snapshot into Neptune Analytics. You can also load graph data that's
+    stored in Amazon S3.
+    """
+
+    # Remember the sample text in the dataset
+    await cognee.remember(
+        [sample_text_1, sample_text_2],
+        dataset_name=dataset_name,
+        self_improvement=False,
+    )
+
+    # Now let's perform some searches
+    # 1. Search for insights related to "Neptune Analytics"
+    insights_results = await cognee.recall(
+        query_type=SearchType.GRAPH_COMPLETION, query_text="Neptune Analytics"
+    )
+    print("\n========Insights about Neptune Analytics========:")
+    for result in insights_results:
+        print(f"- {result}")
+
+    # 2. Search for text chunks related to "graph database"
+    chunks_results = await cognee.recall(
+        query_type=SearchType.CHUNKS, query_text="graph database", datasets=[dataset_name]
+    )
+    print("\n========Chunks about graph database========:")
+    for result in chunks_results:
+        print(f"- {result}")
+
+    # 3. Get graph completion related to databases
+    graph_completion_results = await cognee.recall(
+        query_type=SearchType.GRAPH_COMPLETION, query_text="database"
+    )
+    print("\n========Graph completion for databases========:")
+    for result in graph_completion_results:
+        print(f"- {result}")
+
+    # Clean up (optional)
+    await cognee.forget(everything=True)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

examples/database_examples/pgvector_example.py

@@ -0,0 +1,109 @@
+# ruff: noqa: E402
+import os
+import pathlib
+import asyncio
+
+from dotenv import load_dotenv
+
+load_dotenv(override=True)
+
+DB_HOST = os.environ.get("DB_HOST", "127.0.0.1")
+
+import cognee
+from cognee import SearchType
+
+
+async def main():
+    """
+    Example script demonstrating how to use Cognee with PGVector
+
+    This example:
+    1. Configures Cognee to use PostgreSQL with PGVector extension as vector database
+    2. Sets up data directories
+    3. Stores sample data with remember to Cognee
+    4. Performs different types of searches
+    """
+    # Configure PGVector as the vector database provider
+    cognee.config.set_vector_db_config(
+        {
+            "vector_db_provider": "pgvector",  # Specify PGVector as provider
+            "vector_dataset_database_handler": "pgvector",
+            "vector_db_name": "cognee_db",
+            "vector_db_host": os.environ.get("DB_HOST", "127.0.0.1"),
+            "vector_db_port": "5432",
+            "vector_db_username": "cognee",
+            "vector_db_password": "cognee",
+        }
+    )
+
+    # Configure PostgreSQL connection details
+    # These settings are required for PGVector
+    cognee.config.set_relational_db_config(
+        {
+            "db_path": "",
+            "db_name": "cognee_db",
+            "db_host": DB_HOST,
+            "db_port": "5432",
+            "db_username": "cognee",
+            "db_password": "cognee",
+            "db_provider": "postgres",
+        }
+    )
+
+    # Set up data directories for storing documents and system files
+    # You should adjust these paths to your needs
+    current_dir = pathlib.Path(__file__).parent
+    data_directory_path = str(current_dir / "data_storage")
+    cognee.config.data_root_directory(data_directory_path)
+
+    cognee_directory_path = str(current_dir / "cognee_system")
+    cognee.config.system_root_directory(cognee_directory_path)
+
+    # Clean any existing data (optional)
+    # await cognee.forget(everything=True)
+
+    # Create a dataset
+    dataset_name = "pgvector_example"
+
+    # Add sample text to the dataset
+    sample_text = """PGVector is an extension for PostgreSQL that adds vector similarity search capabilities.
+    It supports multiple indexing methods, including IVFFlat, HNSW, and brute-force search.
+    PGVector allows you to store vector embeddings directly in your PostgreSQL database.
+    It provides distance functions like L2 distance, inner product, and cosine distance.
+    Using PGVector, you can perform both metadata filtering and vector similarity search in a single query.
+    The extension is often used for applications like semantic search, recommendations, and image similarity."""
+
+    # Add the sample text to the dataset
+    await cognee.remember([sample_text], dataset_name=dataset_name, self_improvement=False)
+
+    # Now let's perform some searches
+    # 1. Search for insights related to "PGVector"
+    insights_results = await cognee.recall(
+        query_type=SearchType.GRAPH_COMPLETION, query_text="PGVector"
+    )
+    print("\nInsights about PGVector:")
+    for result in insights_results:
+        print(f"- {result}")
+
+    # 2. Search for text chunks related to "vector similarity"
+    chunks_results = await cognee.recall(
+        query_type=SearchType.CHUNKS, query_text="vector similarity", datasets=[dataset_name]
+    )
+    print("\nChunks about vector similarity:")
+    for result in chunks_results:
+        print(f"- {result}")
+
+    # 3. Get graph completion related to databases
+    graph_completion_results = await cognee.recall(
+        query_type=SearchType.GRAPH_COMPLETION, query_text="database"
+    )
+    print("\nGraph completion for databases:")
+    for result in graph_completion_results:
+        print(f"- {result}")
+
+    # Clean up (optional)
+    # await cognee.forget(everything=True)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())