AWS + Neo4j: Connected Context for Grounded Enterprise AI

Neo4j graph, knowledge, and memory integrated with AWS data and agent services

AWS provides the foundation for governed enterprise AI

Neo4j adds connected context across the AWS platform

AWS provides cloud-scale services; Neo4j provides connected context

AWS Neo4j
Store: Keep authoritative records, documents, tables, and operational history. Connect: Represent important entities, relationships, and investigation context.
Govern: Control access through catalogs, policies, identities, and platform services. Explain: Link data to business terms, policies, typologies, and prior decisions.
Analyze: Use SQL, Spark, streaming, and ML for activity at scale. Traverse: Find paths, communities, shared identifiers, and network patterns.
Run AI: Supply models, agent runtimes, gateways, and application infrastructure. Ground AI: Give agents connected facts, semantic routing, tools, and memory.

Neo4j connection patterns for AWS

Integration path AWS home Description
Neo4j Spark Connector Amazon EMR Exchange data between Spark DataFrames and Neo4j graphs.
Neo4j Connector for AWS Glue AWS Glue Load data from AWS sources into Neo4j with managed ETL jobs.
Neo4j Connector for Kafka Amazon MSK Stream events into Neo4j and publish graph changes to Kafka.
Neo4j drivers Lambda, ECS, EKS, EC2 Connect new or existing AWS applications to Neo4j.
Neo4j MCP tools Amazon Bedrock AgentCore and Strands Agents Connect AWS-hosted agents to Neo4j graph retrieval tools.

Sources: Neo4j Spark Connector, Kafka Connector, connectors and drivers, and Neo4j MCP

AWS Glue stays tabular while Neo4j receives Cypher

Runtime path

Glue Visual ETL
  └─ SQL / JDBC → connector + translator
                         └─ Cypher / Bolt → Neo4j
  • Driver: org.neo4j.jdbc.Neo4jDriver
  • Enable: enableSQLTranslation=true

The mapping in practice

Movie                     → (:Movie)
title                     → .title
Person_ACTED_IN_Movie     →
(:Person)-[:ACTED_IN]->(:Movie)
SELECT m.title FROM Movie m
MATCH (m:Movie)
RETURN m.title
Model first: Glue expects queryable metadata. Create a blueprint graph with the labels, relationship types, and properties; load nodes before relationships. Only supported SQL constructs are translated.

Sources: Neo4j Connector for AWS Glue, Getting Started, JDBC SQL-to-Cypher translation, and connector announcement

Enterprise Knowledge Layer

Ten agents should not create ten versions of the business

Definitions copied into prompts, tools, and retrieval pipelines drift independently.

  • Private meaning: Each agent carries its own interpretation of the business.
  • Private routing: Each agent decides which source or tool is authoritative.
  • Private policy: Rules are repeated across prompts and integrations.
  • Silent drift: Every answer can sound reasonable while the enterprise loses a consistent view.

Same term, different meanings

"active customer"

Agent A → signed in within 30 days
Agent B → current paid contract
Agent C → open account balance
The problem: Copies change separately, so inconsistency grows with every new agent.

A shared Knowledge Layer makes connected context reusable

Keep meaning in one governed layer so every agent uses consistent definitions, relationships, and rules.

  • One shared layer: Maintain enterprise knowledge once and reuse it across consumers.
  • Connected context: Link concepts to data, policies, owners, and processes.
  • Current by design: Query the layer while work is happening instead of copying it into prompts.
  • Lighter agents: Keep task logic in the agent and enterprise meaning in the shared layer.

Enterprise knowledge becomes queryable and actionable

The Knowledge Layer is shared, governed, executable software that sits between enterprise systems and their consumers.

  • Shared: Reuse business meaning and operating knowledge across consumers.
  • Governed: Keep sources, policies, ownership, and accountability explicit.
  • Queryable: Retrieve the exact context required for each request.
  • Actionable: Map intent to authoritative sources, permitted tools, and executable queries.

Three components ground every request

Combine a governed model of the business, authoritative facts, and experience from previous work.

  • Knowledge Layer ontology: Defines what things mean, how they connect, where their data lives, what rules apply, and who is accountable.
  • Enterprise data: Supplies authoritative facts about what is true now.
  • Memory: Captures previous actions, decisions, outcomes, and reasoning.
Ontology holds what is possible; memory holds what is proven.

“Ontology” has a narrow and a broad meaning

The difference is scope: business meaning alone, or the larger connected model that makes that meaning operational.

Narrow: Conceptual Map

  • Defines what business concepts mean and how they relate.
  • Includes concepts such as Customer, Purchase, and Product.
  • Does not refer to Salesforce, tables, APIs, or other physical systems.

Broad: Knowledge Layer ontology

  • Connects five sub-ontologies: domain, technical, process, policy, and organization.
  • Includes descriptions of technical assets and mappings from business concepts to them.
  • Does not require the actual enterprise records to be stored in the ontology.
Both uses are valid: the Conceptual Map is the meaning; the broader Knowledge Layer ontology also connects that meaning to where the data lives.

The ontology connects meaning to systems and accountability

Five connected sub-ontologies describe how the business operates.

  • Domain: Business concepts and relationships.
  • Technical: Descriptions of systems, sources, and data assets, plus mappings from business concepts to those assets.
  • Process: Tasks, decisions, workflows, and actions.
  • Policy: Access rules, conditions, constraints, and permitted actions.
  • Organization: Roles, ownership, responsibilities, and accountability.

The semantic map bridges business meaning and enterprise data

It uses ontology concepts, technical asset descriptions, and mappings to route requests to authoritative source systems.

  • Domain ontology: Provides concepts such as “Customer,” “Purchase,” and “Product.”
  • Technical ontology: Describes systems and assets such as Salesforce and its Opportunity table.
  • Semantic map: Connects the two: PURCHASE → Salesforce.Opportunity.
  • Enterprise data: Supplies the actual opportunity records from Salesforce.
The semantic map tells agents what a request means, where to find the data, and how the two connect.

Every request becomes a governed action plan

The layer grounds the request. The agent or application executes the plan.

  • Interpret intent: Resolve the business meaning of the request.
  • Assemble context: Select authoritative sources and relationships.
  • Route queries and tools: Translate concepts into calls against AWS systems.
  • Enforce policy: Apply access and action rules during resolution.
  • Explain and learn: Return evidence and lineage, then retain useful outcomes.

Every governed action leaves an inspectable decision trace

The trace links a result to the context that produced it.

  • Meaning: Concepts resolved for the request.
  • Sources: Authoritative systems, queries, and lineage.
  • Policy: Access and action checks applied.
  • Evidence: Facts supporting the current result.
  • Precedent: Prior decisions, only when they influenced the result.
  • Outcome: The result or action, observed outcome, and feedback.

Decision traces explain the current result. Agent Memory makes useful traces available to future requests.

Neo4j Agent Memory

Agent Memory supplies the historical and reasoning dimension of a Context Graph

Graph memory makes each result inspectable and reusable

What it remembers

  • Short-term: Conversations, messages, and session context.
  • Long-term: Entities, facts, preferences, relationships, and temporal context.
  • Reasoning: Tool calls, evidence, decisions, outcomes, and feedback.

What the graph adds

  • Traversable provenance: Follow a memory back to its exact source turn and evidence.
  • Canonical identity: Connect memory to the same domain entities the agent queries.
  • Actor-scoped recall: Keep each user's memory isolated across sessions.
  • Retained history: Supersede outdated memory without erasing its correction path.
Store deliberately: Entity extraction identifies what a turn is about. Policy or confirmation decides what becomes durable memory.

Agent Memory preserves facts, context, and reasoning

Long-term model: POLE+O represents Person, Object, Location, Event, and Organization. Temporal validity records when a fact was true.

Example: The Finance Agent remembers across sessions

neo4j-agentcore-agents/finance-agent adds four Strands tools: search_context, add_memory, get_user_preferences, and get_entity_graph.

  1. Cold start: A new user asks what the agent remembers; the agent reports nothing.
  2. Teach: The user states a durable portfolio or risk preference; the agent stores it with add_memory.
  3. Recall: A fresh session for the same user retrieves the preference without it being restated.
  4. Isolate: A second user asks the same question and cannot see the first user's memory.
One graph stack: The memory wrapper uses the library's user-scoped core API against the same Neo4j instance as the finance graph. Domain graph tools remain behind AgentCore Gateway and MCP.

A Context Graph is persistent connected memory for agents

It links long-term enterprise knowledge, short-term interaction state, and reasoning memory in one queryable graph.

  • Long-term knowledge: Entities, relationships, business meaning, policies, and authoritative facts.
  • Short-term state: Conversation, user intent, task, workflow state, and tool observations.
  • Reasoning memory: Decisions linked to their situation, rationale, actions, outcomes, and precedents.
Each request retrieves relevant context and adds new state or traces. The graph persists and compounds across requests.

Virtual Graph for AWS

Planned: Query Amazon S3 Tables with Cypher through Athena

Planned AWS query path: Cypher through Athena to S3 Tables

What each component does

  • Translate: Virtual Graph turns Cypher into SQL and maps the returned rows back to a Cypher result.
  • Execute: Athena runs the SQL against the table bucket.
  • Resolve: Glue exposes each table bucket as a child federated catalog under s3tablescatalog.
  • Govern: IAM or Lake Formation permissions control access to catalog and table resources.
  • Store: S3 Tables remains the authoritative source.
Read in place: Virtual Graph queries current S3 Tables data without materializing a second copy in Neo4j.

Public preview: Snowflake, Databricks, and Google BigQuery. Planned for AWS: Athena, AWS Glue Data Catalog, and Amazon S3 Tables.

Choose the execution path that fits the workload

Workload Recommended path Execution
Query current S3 Tables data without copying it
Planned
Cypher through Virtual Graph Athena queries the table-bucket child catalog mounted in AWS Glue Data Catalog.
Run frequent, low-latency traversals or graph algorithms Materialize selected data in Neo4j Neo4j executes Cypher against the persisted graph.

Closing

From connected context to a governed AI operating model

Neo4j supports managed and self-managed AWS deployment

  • AuraDB on AWS: Use Neo4j's managed graph database in an AWS region that fits the workload.
  • AWS Marketplace: Purchase eligible Aura plans through AWS billing and marketplace terms.
  • Private connectivity: Use AWS PrivateLink with supported Aura enterprise configurations.
  • Self-managed: Deploy Neo4j on Amazon EKS or Amazon EC2 when the customer manages the runtime.

Sources: Aura through cloud marketplaces, Aura secure connections, and AgentCore supported regions

These capabilities meet inside an AWS-hosted agent workflow

Security boundary: Gateway supports OAuth 2.0 for tool traffic; targets enforce data access.

Together, connected knowledge grounds the AWS agent stack

Source: /Users/ryanknight/projects/cloud-integration/knowledge-layer/reference/knowledge-layer-official.md

Source: /Users/ryanknight/projects/cloud-integration/knowledge-layer/reference/knowledge-layer-official.md

Source: /Users/ryanknight/projects/cloud-integration/knowledge-layer/reference/knowledge-layer-official.md

Source: /Users/ryanknight/projects/cloud-integration/knowledge-layer/reference/knowledge-layer-official.md

Source: /Users/ryanknight/projects/cloud-integration/knowledge-layer/reference/knowledge-layer-official.md

Source: /Users/ryanknight/projects/cloud-integration/knowledge-layer/reference/knowledge-layer-official.md

Source: /Users/ryanknight/projects/cloud-integration/knowledge-layer/reference/knowledge-layer-official.md

Source: /Users/ryanknight/projects/cloud-integration/knowledge-layer/reference/knowledge-layer-official.md

Source: /Users/ryanknight/projects/cloud-integration/knowledge-layer/reference/knowledge-layer-official.md

Source: /Users/ryanknight/projects/aws/neo4j-aws-graphrag-workshop/site/content/06-neo4j-memory/index.en.md

Source: https://github.com/neo4j-labs/agent-memory

Sources: neo4j-agentcore-agents/finance-agent/README.md and neo4j-agentcore-agents/finance-agent/core/memory.py

Sources: https://neo4j.com/blog/agentic-ai/what-is-context-graph/, https://neo4j.com/blog/agentic-ai/context-graph-ai-agent-memory/, https://neo4j.com/blog/agentic-ai/hands-on-with-context-graphs-and-neo4j/, and /Users/ryanknight/projects/cloud-integration/knowledge-layer/reference/knowledge-layer-official.md

Sources: https://neo4j.com/blog/auradb/neo4j-virtual-graph-is-now-in-public-preview/, https://docs.aws.amazon.com/athena/latest/ug/gdc-register-s3-table-bucket-cat.html, and https://docs.aws.amazon.com/glue/latest/dg/enable-s3-tables-catalog-integration.html

Sources: https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/gateway.html and https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/gateway-target-MCPservers.html