Neo4j Aura Agent: Create Your Own GraphRAG Agent in Minutes

Today we’re taking a major step toward making GraphRAG accessible to everyone.
We’re excited to announce that the Neo4j Aura Agent is now available in our public Early Access Program (EAP) for all Aura customers — across Free, Professional, and Business Critical instances.

The EAP release is an experimental product, designed for experimental use only. It’s the perfect way to explore, test, and learn how to easily build knowledge-graph–backed agents in AuraDB. While it’s not intended for production workloads yet, we’ll be moving to General Availability (GA) later this year, delivering a fully supported, production-ready experience.

Whether you’re simply curious about knowledge-graph agents, a startup exploring new AI possibilities, or an enterprise experimenting with your first graph-powered agentic systems, Aura Agent makes it easy to get started. In fact, we’ll show you how to build your own agent in just minutes.

For now, we invite you to try it out — and see how simple it is to build intelligent agents on top of your knowledge graph in AuraDB.

Introducing Neo4j Aura Agent

Neo4j Aura Agent is a no-/low-code platform to build, test, and deploy intelligent agents directly grounded in your AuraDB knowledge graphs.

For use cases where explainability and accuracy matter, knowledge graph grounding provides a clear advantage, with verifiable agent answers derived from the data in your knowledge graphs. Building such agents is not trivial—but Aura Agent abstracts away the complexity, so you can focus on solving real problems, not wrestling with infrastructure.

Challenges of Building a Graph-Backed Agent

Getting a proof-of-concept running on a developer’s laptop is relatively simple, but scaling to a secure production-grade system is not. Most teams spend weeks wrestling with infrastructure before they ever get to solving the actual business problem.

Some common technical challenges faced by teams building GraphRAG agents: 

• Agentic frameworks and LLMs: Dozens of agentic frameworks and LLMs to evaluate, each with trade-offs
• Query translation: Converting natural language into precise Cypher queries requires integrating a specialized text-to-Cypher service or a separate LLM into the architecture
• Graph data retrieval patterns: Implementing precise GraphRAG data retrieval routines in a simple and efficient way
• Agent serving: Standing up a scalable and secure agent serving environment
• Deployment complexity: Hardening, scaling, and monitoring production agent endpoints

Next, we’ll walk you through the process of creating your first Aura Agent: a commercial contract review agent. You will:

1. Create the agent
2. Add tools
3. Test your agent
4. Deploy your agent to an Aura API endpoint

The finished agent will answer complex questions that can’t be answered by traditional RAG or agentic retrieval processes.  

More generally, the agent will:

• Provide transparent reasoning and explainability with tool explanations
• Ground answers in a knowledge graph for accuracy and full contextual understanding

All the resources to build the agent can be found in this GitHub repository.

Legal Contracts as a Knowledge Graph

Before we jump into agent creation, let’s have a quick look at how the contracts were modeled as a knowledge graph. We’ll use a subset of CUAD, a public dataset of commercial contracts. The contracts were turned into a knowledge graph, using an LLM to extract key information from the original contracts.

The diagram below shows the key node labels and relationships in the resulting knowledge graph. Each Agreement represents a contract. An agreement is linked to the Organizations that are party to it. The contract has a number of clauses, which, in turn, can be found in specific excerpts (citations) in the original contract.

Agreement nodes store key contract properties, such as termination and expiration dates, URL of the original contract, and contract type.

Excerpt nodes capture actual contract text in two forms: full text (for readability) and text embeddings (for machine understanding). Each excerpt also stores its page number in the original document and is associated with a clause type.

Storing embeddings enables the agent to run vector similarity searches, making it easier to identify and reason over similar clauses.

Let’s Get Ready To Create Your Agent

Before you create your contract review agent, you need to enable Generative AI Assistance and create a contract knowledge graph. 

Enable Generative AI Assistance

Aura Agent is available through the Aura console.  To access it:

1. Navigate to the Aura Console: https://console.neo4j.io/
2. Log in with your Aura credentials or create an account if you don’t have one yet
3. Enable Generative AI assistance for your Aura Organization

Create a Contract Knowledge Graph

We have created a contracts knowledge graph, which can be restored to an AuraDB instance.

In order to do this, complete these simple steps:

• Head over to https://console.neo4j.io and click Create Instance.
• Wait until your instance is RUNNING.
• Using the three-dots menu in the Aura console, select Backup & restore.  Restore from contract-data.backup file:

• Wait until your instance goes back to RUNNING status. 

Your instance contains 510 contracts from the CUAD dataset represented as a knowledge graph.

Step 1: Create Your Agent

Navigate to Agents in the console sidebar. Select Create to create a new agent. 

Once there, you can assign a name and description to your agent.

Configure your agent as follows: 

• Name: Contract Review Agent
• Description: A legal contract review agent with access to a Neo4j knowledge graph for analyzing contracts, clauses, and legal risks
• Prompt instructions: The prompt instructions are crucial to set your agent tone, personality, and core responsibilities

You are a Commercial Contract Review Agent, a specialized AI assistant for commercial contract analysis using a Knowledge Graph of multiple contracts. You are a Neo4j expert with excellent knowledge of Cypher and a paralegal expert who can help junior legal professionals answer important commercial contract review questions.
You have access to a comprehensive knowledge graph containing contract data, clauses. You can query this graph using tools and Cypher to help you get answers.
You can support legal professionals by:
- Identifying high-risk contracts with missing or problematic clauses
- Assessing risk factors and compliance issues across contract portfolios
- Finding contracts with similar clauses or terms for comparative analysis
- Identifying all contracts associated with specific organizations
- Providing paralegal-level guidance on contract review best practices
- Helping junior legal professionals understand complex contractual relationships
Your responses should be professional, accurate, and tailored to help legal professionals make informed decisions.

• Target instance: This is the Neo4j instance containing the graph for the agent to use (set up above in this example). 
• Visibility: If you set it as “Internal,” you’ll be able to build and test, but not deploy to an endpoint. “External” will allow you to deploy to an endpoint (with authentication), as we’ll see later.

Step 2: Power Up Your Agent: The Three Types of Agent Tools

Once you’ve provided the initial configuration for your agent, you can begin adding tools. Currently, we offer three types of retrieval tools, and they are key to connecting your agent to the data in your graph:

1. Cypher templates: For more precise, controlled graph data retrieval according to predefined logic. Cypher templates can also input parameters/arguments.
2. Similarity search: For semantic search based on vector embeddings.
3. Text2Cypher: To enable the agent to dynamically write and execute its own graph queries based on user input.

Tool 1: Cypher Templates

Cypher templates let you define precise graph data retrieval queries. They allow your agent to handle:

• Queries requiring specialized logic you already know ahead of time
• Frequently asked questions 
• Cases where you want to control agent responses with information from your knowledge graph

While using Cypher templates requires some Cypher knowledge, they’re highly recommended for most scenarios. If you’re not familiar with Cypher, you can:

• Learn Cypher basics on GraphAcademy.
• Jump-start query creation with Query Copilot and simply copy/paste your query into the agent Cypher template tool.
• Use your code generation tool of choice (Cursor, Claude Code) or LLM-powered assistants such as ChatGPT or Anthropic’s Claude.

To illustrate Cypher templates, let’s add a couple of useful tools.

Example: Creating a Contract Details Tool

This tool retrieves basic contract details. Its purpose is clear, and it can be easily anticipated that a legal contract agent will get questions about specific contracts.

On the agent configuration screen:

1. Click the Add Tool drop-down and select Cypher Template.
2. Enter a name and description for the tool:
   – Make sure the description is clear because the LLM will use it to determine when it’s appropriate to use this tool. 
   – Optionally, you can include examples of questions or situations where this tool should be used.

The Get Contract tool will look like this:

Use the information below to set up the tool:

**Name**
```
Get Contract
```

**Description:**
```
Given a contract id, retrieves information about the agreement,  including type, name, effective date, expiration date, parties to the contract, and country of incorporation of each party
```

Cypher templates can (optionally) be configured with query parameters that the agent passes to the tool at query time.   Here, we will create a single parameter contract_id 

**Parameters:**
- Name = `contract_id`. Type = `integer`. Description = `The id of the contract`


**Cypher Query:**
```cypher
MATCH (country:Country)<-[i:INCORPORATED_IN]-(p:Organization)-[r:IS_PARTY_TO]->(a:Agreement {contract_id: $contract_id})

WITH a, 
p, 
collect(country.name) AS party_incorporated_countries, 
collect(r.role) AS party_roles 
RETURN a.contract_id AS contract_id, 
a.agreement_type as agreement_type, 
a.name as contract_name, 
a.effective_date as effective_date, 
a.renewal_term as renewal_term, 
a.expiration_date as expiration_date,
collect({
name:p.name, 
    	incorporated_countries: party_incorporated_countries, 
    	roles: party_roles
}) as parties
```

Note that this Cypher template query matches a contract on the contract_id field using the parameter we defined above. It then traverses the graph to retrieve connected organizations and countries. The results are returned as a list of contracts with details about them.

Let’s add a second Cypher template tool.

Example: Creating a Get Contract for a Given Excerpt

1. Click the Add Tool drop-down and select Cypher Template.
2. Enter a suitable name and description for the tool.

The Get Contract Info for Excerpt ID tool should look like this:

Use the information below to set up the tool:

**Name**
```
Get Contract Info for Excerpt ID
```

**Description:**
```
Given a Excerpt ID, it provides details of the contract where that excerpt appears.
```

**Parameters:**
Name
```
excerpt_id
```
Type
```
integer
```
Description
```
The excerpt id to find its related contract.
```

**Cypher Query:**
```cypher
MATCH (:Excerpt {id: $excerpt_id})<-[:HAS_EXCERPT]-(cc:ContractClause)<-[:HAS_CLAUSE]-(a:Agreement)<-[r:IS_PARTY_TO]-(p:Organization)-[i:INCORPORATED_IN]->(country:Country)




RETURN a.contract_id AS contract_id,
a.agreement_type AS agreement_type,
a.name AS contract_name,
a.effective_date AS effective_date,
a.renewal_term AS renewal_term,
a.expiration_date AS expiration_date,
collect(p.name) AS contract_parties
```

There are a couple other examples of Cypher template tools for pulling contract and organization details you can find in the full tutorial on GitHub. 

Tool 2: Vector Similarity for Semantic Search

As mentioned, our Excerpt nodes store both the full text and a text embedding. For this tool, the text embedding property has been indexed to enable vector search. For more information on how to create vector indexes in Neo4j, check our documentation on vector indexes.

Aura Agent currently supports embeddings generated with the following text embedding providers and models:

• OpenAI: text-embedding-3-small,  text-embedding-3-large and text-embedding-ada-002
• Vertex AI: gemini-embedding-001, text-embedding-005 and text-multi-lingual-embedding-00

Vector similarity is especially powerful when combined with other Cypher tools. It not only identifies semantically similar excerpts but, when paired with a Cypher template tool, also enables traversal of the knowledge graph to uncover connected structured information.

The result: a richer, more relevant context for the agent to generate accurate answers to user questions.

In this example, we’ll create a tool that enables search for similar clause excerpt text. 

Click the Add Tool drop-down and select Similarity Search. 

Use the information below to set up the tool:

**Name**
```
Identify Contracts with Similar Text in Clauses
```

**Description:**
```
Given a piece of text, identify the most semantically similar Excerpts in the system
```
**Embedding provider:**
```
Vertex AI
```
**Embedding Model:**
```
gemini-embedding-001
```

Then enter the vector index and top k. 
**Index Name:**
```
excerpt_embedding
```
**Top K:**
```
5
```

Note that Aura Agent connects to these embedding providers automatically. You don’t need to provide credentials or use your own provider account. 

Tool 3: Text2Cypher for Dynamic Ad-Hoc Queries

We’ll use the Text2Cypher tool as a fallback when precise Cypher templates or vector similarity aren’t enough.

In general, a Text2Cypher tool is most valuable when:

• User questions can’t be anticipated in advance
• The query requires aggregation operations
• No other tool is appropriate (making Text2Cypher a good fallback option)

Under the hood, Aura Agent relies on a specialized, fine-tuned model to generate Cypher queries, which delivers significantly higher accuracy. Read more about our fine-tuned Text2Cypher models.

However, since Text2Cypher still relies on an LLM, queries may occasionally contain inconsistencies or logical errors. While newer models and fine-tuning reduce these issues, use caution when deploying Text2Cypher in production.

To improve reliability, constrain the tool’s use with a clear name and description. In this example, we’ll define it specifically for aggregation tasks. As a best practice, make sure the description explicitly instructs the agent to use this tool only when no other option applies. This extra guidance makes the agent more selective and reduces unnecessary or risky query generation.

From the agent configuration screen, click Add Tool and select Text2Cypher.

Use the information below to configure the tool:

**Name**
```
Tool for system-wide aggregation questions
```

**Description:**
```
Use this tool to answer free-form questions that involve aggregation of organizations, contract clauses, clause types, contracts, countries, parties to contracts, etc.
```

Click Save to add the tool.

Step 3: Save and Test Your Agent

Now that your agent and tools are configured, click Save to store your agent.

You can then test your agent in the Aura Console, which provides a built-in chat interface. At this stage, your agent should be able to answer questions such as:

“List the top 5 organizations with the most contracts”

This aggregation-style question is an ideal use case for the Text2Cypher tool.

By expanding the Reasoning tab, you can confirm that this tool was invoked to generate the answer. Take note of the inputs and outputs:

• Input: A natural language question
• Output: A Cypher query automatically generated and executed to retrieve the organizations with the most contracts (results)

“Find contracts that mention units of product in their clauses”

Here, the agent used the vector similarity tool to identify semantically similar excerpts (shown as “Relevant Excerpts” in the agent’s answer), but then our Cypher template tool (Get Contract Info for Excerpt ID) was automatically used by the agent to navigate from the Excerpt back to the Agreement and compile the information shown in the full answer.

Go ahead and expand the “Reasoning” to verify the sequence of tools used to answer the question.

You can continue to add/remove tools to check how your agent responds.

Step 4: Deploy Your Agent Public

Once you’re satisfied that your agent can handle user questions, you can include the agent in your GenAI application. By making your agent external, you’ll be able to access it (and ask natural language questions) via an Aura API endpoint.

First, let’s make our agent External and save it.

At this point, you should have a new Aura API endpoint for your agent.

Select Copy endpoint to get your Agent endpoint URL.

Next, you need authenticated access to your endpoint. To do this, you must create an API Key and Secret. Please keep your API Key and Secret secure and do not share! 

Finally, now armed with your Agent Aura API endpoint, API Key and Secret, you have all the ingredients to access your Agent from your external application.

You can verify the authentication from a terminal. Execute the following commands:

export CLIENT_ID=<enter your Client ID here>
export CLIENT_SECRET=<enter your Client Secret here>
export ENDPOINT_URL=<enter your agent endpoint URL>

With these environment variables set, you can get a bearer token with:

export BEARER_TOKEN=$(curl -s --request POST 'https://api.neo4j.io/oauth/token' \
    --user "$CLIENT_ID:$CLIENT_SECRET" \
    --header 'Content-Type: application/x-www-form-urlencoded' \
    --data-urlencode 'grant_type=client_credentials' | jq -r .access_token)

With the token, you can finally pose a question to your agent with:

url --request POST "$ENDPOINT_URL" \
 -H 'Content-Type: application/json' \
 -H 'Accept: application/json' \
 -H "Authorization: Bearer $BEARER_TOKEN" \
 -d '{"input": "find Motorola contracts"}' --max-time 60 \
 | jq .

The answer should look like the image below. Notice you get the answer and information of all tools and intermediate output used to generate the final answer.

{
  "content": [
    {
      "thinking": "The user is asking to find contracts related to a specific organization, \"Motorola\". The `identify_contracts_for_organization` tool is designed for this purpose, taking the organization name as input.",
      "type": "thinking"
    },
    {
      "id": "fdfa4d22-334d-44d1-861d-749f436097de",
      "input": {
        "organization_name": "Motorola"
      },
      "name": "identify_contracts_for_organization",
      "type": "cypher_template_tool_use"
    },
    {
      "output": {
        "keys": [
          "contract_id",
          "agreement_type",
          "contract_name",
          "effective_date",
          "renewal_term",
          "expiration_date",
          "party_names",
          "party_roles",
          "party_incorporated_countries"
        ],
        "records": [
          {
            "agreement_type": "Intellectual Property Agreement",
            "contract_id": 18,
            "contract_name": "Intellectual Property Agreement",
            "effective_date": "2014-04-14",
            "expiration_date": "unable to determine",
            "party_incorporated_countries": [
              "United States",
              "United States"
            ],
            "party_names": [
              "Motorola Solutions, Inc.",
              "Zebra Technologies Corporation"
            ],
            "party_roles": [
              "Seller",
              "Purchaser"
            ],
            "renewal_term": "unable to determine"
          }
        ],
        "summary": {}
      },
      "tool_use_id": "fdfa4d22-334d-44d1-861d-749f436097de",
      "type": "cypher_template_tool_result"
    },
    {
      "thinking": "I have already identified the contracts associated with Motorola using the `identify_contracts_for_organization` tool. The output provides a list of contracts with relevant details, directly answering the original query.",
      "type": "thinking"
    },
    {
      "text": "Here are the contracts associated with Motorola:\n\n| contract_id | contract_name | agreement_type | effective_date | expiration_date | party_names | party_roles | party_incorporated_countries |\n|---|---|---|---|---|---|---|---|\n| 18 | Intellectual Property Agreement | Intellectual Property Agreement | 2014-04-14 | unable to determine | Motorola Solutions, Inc., Zebra Technologies Corporation | Seller, Purchaser | United States, United States |",
      "type": "text"
    }
  ],
  "end_reason": "FINAL_ANSWER_PROVIDED",
  "role": "assistant",
  "status": "SUCCESS",
  "type": "message",
  "usage": {
    "candidates_token_count": 226,
    "prompt_token_count": 7148,
    "thoughts_token_count": 301,
    "total_token_count": 7675
  }

Step 5 (Optional): Access Your Agent Via MCP Server 

Today, you can already wrap your agent’s API endpoint as a local MCP server, instantly making it available in Claude Desktop through the Model Context Protocol (MCP). The full tutorial repository includes a ready-to-use contract_review_server.py that demonstrates just how quickly you can set this up for your contract review agent.

But this is just the beginning. Soon, Aura Agent will let you expose agents directly as a remote MCP server, eliminating the need for any local setup and making your agents seamlessly accessible wherever you need them.

Until then, follow the tutorial repo to create a Local MCP server and test it in Claude—while keeping an eye out for what’s coming next.

Your AI-Powered Future

? Congratulations—you’ve just created an Aura Agent with GraphRAG capabilities and securely deployed it. All of the infrastructure and operations come ready out of the box, so instead of piecing together agentic frameworks, LLM providers, and integrating Text-to-Cypher models and orchestration, you can stay focused on building tools for your agent. 

From here, you can continue testing your agent through the Aura Agent UI, add or refine tools, redeploy in seconds, or spin up entirely new agents without writing custom code.

Aura Agent works equally well as a stand-alone API for building agentic systems or as a component within larger multi-agent architectures. By grounding AI in your knowledge graph, it becomes possible to deliver agents that are not only more accurate and explainable but also better suited to specialized domains such as pharma, legal, and healthcare. 

Beyond vertical applications, Aura Agent is also a natural fit for enterprise search, SaaS knowledge assistants, semantic retrieval layers, and long-term memory. What once required weeks of engineering effort can now be accomplished in hours or days.

To dive deeper, we invite you to join us for our upcoming sessions with Aura Agent experts. We’ll cover everything from first steps to advanced techniques:

• LinkedIn Live Event (Oct. 21, 2025)
• Workshop on the Road to NODES 2025: Publish and Power Up Agents in Aura (Oct. 23, 2025)

And if you’re ready to start building knowledge graphs today so you can put Aura Agent to work, check out:

• Aura Agent Tutorials: A repository with step-by-step instructions to build Aura Agents in legal and know-your-customer scenarios
• Aura Agent Early Access Program FAQ 
• Creating Knowledge Graphs From Unstructured Data