> ## Documentation Index
> Fetch the complete documentation index at: https://docs.cognee.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Neptune Analytics

> Store your knowledge graph and its embeddings in Amazon Neptune Analytics and search them with recall

A minimal guide to using Amazon Neptune Analytics as cognee's graph **and** vector store. It needs an AWS account rather than a local server, and one Neptune Analytics graph holds both the entities and their embeddings — so there is no separate vector database to provision.

## Before You Start

* Complete [Quickstart](/getting-started/quickstart) to understand basic operations
* Ensure you have [LLM Providers](/setup-configuration/llm-providers) configured (`LLM_API_KEY` in `.env`)
* Provision a Neptune Analytics graph in your AWS account ([AWS instructions](https://docs.aws.amazon.com/neptune-analytics/latest/userguide/create-graph-using-console.html)), and give it a vector search dimension matching your [embedding model's](/setup-configuration/embedding-providers) dimension
* Install the Neptune extra: `uv pip install "cognee[neptune]"`
* Make AWS credentials authorized for that graph available to the standard AWS SDK chain — environment variables (`AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY`, `AWS_REGION`, plus `AWS_SESSION_TOKEN` for temporary credentials), a shared profile, or an instance role. `load_dotenv()` makes `.env` values work as environment variables
* Set `GRAPH_ID` in `.env` to your graph's identifier; the script turns it into a `neptune-graph://<GRAPH_ID>` endpoint
* Read [Graph Stores](/setup-configuration/graph-stores) and [Vector Stores](/setup-configuration/vector-stores) for the rest of the backend settings

## Code in Action

```python theme={null}
import asyncio
import os
import pathlib

from dotenv import load_dotenv

import cognee
from cognee import SearchType

load_dotenv()


async def main():
    # 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())
```

<Warning>
  The `cognee.forget(everything=True)` call at the end wipes the configured graph. Do not point this script at a Neptune Analytics graph holding data you want to keep — or delete that line before running it.
</Warning>

## What Just Happened

### Step 1: Build the Graph Endpoint

```python theme={null}
# Set up Amazon credentials in .env file and get the values from environment variables
graph_endpoint_url = "neptune-graph://" + os.getenv("GRAPH_ID", "")
```

Cognee addresses a Neptune Analytics graph as `neptune-graph://<GRAPH_ID>`, so the only cloud-specific value the script needs is the graph identifier. Reading it from the environment keeps the identifier — and the AWS credentials the SDK picks up alongside it — out of the code.

### Step 2: Use One Graph as Both Stores

```python theme={null}
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>
    }
)
```

Neptune Analytics supports vector search inside graph traversals, so the same endpoint is registered as both the graph store and the vector store. Both calls take the same URL on purpose — entities, relationships, and embeddings all live in the one graph you provisioned.

### Step 3: Point Cognee at Local Directories

```python theme={null}
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)
```

The graph and the embeddings are remote, but cognee still keeps ingested documents and its relational metadata on disk. Setting both roots next to the script keeps this example's local files separate from your default cognee directories.

### Step 4: Remember the Sample Text

```python theme={null}
# 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,
)
```

`remember()` ingests both passages, extracts entities and relationships, and writes the resulting nodes, edges, and embeddings into your Neptune Analytics graph. `dataset_name` groups everything this call produces so a later search can be scoped to it.

### Step 5: Query the Graph and Its Vectors

```python theme={null}
# 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}")
```

`SearchType.GRAPH_COMPLETION` retrieves the triplets stored around the query and asks the LLM to answer from them, which exercises the graph side of the store. `SearchType.CHUNKS` returns the raw text chunks behind a query instead, exercising the vector side — together they confirm both halves of the Neptune Analytics backend are populated. `datasets=[dataset_name]` limits the second search to the dataset created above.

<Columns cols={3}>
  <Card title="Graph Stores" icon="network" href="/setup-configuration/graph-stores">
    Every graph backend cognee supports, and their settings.
  </Card>

  <Card title="Vector Stores" icon="database" href="/setup-configuration/vector-stores">
    Per-provider vector settings, including the Neptune Analytics block.
  </Card>

  <Card title="Store Configurations" icon="database" href="/guides/store-configurations">
    Copy-paste `.env` blocks for the other supported store combinations, including the local default.
  </Card>
</Columns>