Tutorial Lengkap Neo4j: Graph Database untuk Knowledge Graphs dan AI

# Tutorial Lengkap Neo4j: Graph Database untuk Knowledge Graphs dan AI Graph database telah menjadi komponen penting dalam arsitektur aplikasi AI modern, terutama untuk membangun knowledge graphs dan...

By Ruby Abdullah · · tutorial
Neo4jGraph DatabaseKnowledge GraphGraph RAGPython

Tutorial Lengkap Neo4j: Graph Database untuk Knowledge Graphs dan AI

Graph database telah menjadi komponen penting dalam arsitektur aplikasi AI modern, terutama untuk membangun knowledge graphs dan sistem Graph RAG (Retrieval-Augmented Generation). Neo4j adalah graph database paling populer yang memungkinkan kita memodelkan, menyimpan, dan melakukan query terhadap data yang memiliki relasi kompleks dengan performa tinggi.

Dalam tutorial ini, kita akan mempelajari Neo4j dari dasar hingga penggunaan lanjutan, termasuk bagaimana mengintegrasikannya dengan pipeline AI untuk membangun sistem knowledge graph yang powerful.

Mengapa Graph Database?

Database relasional tradisional menyimpan data dalam tabel dengan baris dan kolom. Ketika data memiliki banyak relasi antar entitas, query JOIN yang bertumpuk menjadi lambat dan sulit di-maintain. Graph database menyimpan data sebagai nodes (entitas) dan relationships (relasi), sehingga traversal relasi menjadi operasi native yang sangat cepat.

Contoh use case yang cocok untuk graph database:

  • Knowledge graphs untuk AI dan LLM
  • Social network analysis
  • Fraud detection dan anti-money laundering
  • Recommendation engines
  • Supply chain management
  • Network dan IT infrastructure mapping

Instalasi dan Setup

Cara tercepat untuk menjalankan Neo4j adalah menggunakan Docker:

docker run -d \

--name neo4j \

-p 7474:7474 \

-p 7687:7687 \

-e NEO4JAUTH=neo4j/yourpasswordhere \

-e NEO4JPLUGINS='["apoc", "graph-data-science"]' \

-v neo4jdata:/data \

neo4j:5.latest

Port 7474 untuk Neo4j Browser (web UI) dan port 7687 untuk Bolt protocol (koneksi dari aplikasi).

Menggunakan Neo4j Desktop

Download Neo4j Desktop dari situs resmi Neo4j untuk mendapatkan GUI management tool yang lengkap. Neo4j Desktop menyediakan fitur untuk membuat multiple database instances, mengelola plugins, dan menjalankan Cypher queries secara interaktif.

Menggunakan Neo4j AuraDB (Cloud)

Untuk penggunaan production atau eksperimen cepat tanpa setup lokal, Neo4j AuraDB menyediakan managed cloud service dengan free tier yang cukup untuk development.

Install Python Driver

pip install neo4j

Untuk integrasi dengan LangChain (opsional):

pip install langchain-neo4j langchain-openai

Konsep Dasar Neo4j

Property Graph Model

Neo4j menggunakan property graph model yang terdiri dari:

  • Nodes: Entitas dalam graph, memiliki labels dan properties
  • Relationships: Koneksi antar nodes, memiliki type dan properties
  • Labels: Kategori untuk nodes (seperti Person, Company, Product)
  • Properties: Key-value pairs pada nodes dan relationships

Cypher Query Language

Cypher adalah bahasa query deklaratif untuk Neo4j. Berikut pattern dasarnya:

// Membuat node

CREATE (p:Person {name: 'Ruby Abdullah', role: 'Data Consultant'})

// Membuat node dengan multiple labels

CREATE (c:Company:Organization {name: 'PT Rubythalib Data Konsulta', industry: 'AI Consulting'})

// Membuat relationship

MATCH (p:Person {name: 'Ruby Abdullah'})

MATCH (c:Company {name: 'PT Rubythalib Data Konsulta'})

CREATE (p)-[:WORKSAT {since: 2024}]->(c)

// Query dengan pattern matching

MATCH (p:Person)-[:WORKSAT]->(c:Company)

RETURN p.name, c.name

Pattern Cypher menggunakan ASCII art yang intuitif: () untuk nodes, --> untuk relationships, dan [] untuk relationship details.

Basic Usage dengan Python

Koneksi ke Database

from neo4j import GraphDatabase

URI = "bolt://localhost:7687"

AUTH = ("neo4j", "yourpasswordhere")

driver = GraphDatabase.driver(URI, auth=AUTH)

Verifikasi koneksi

driver.verifyconnectivity()

print("Koneksi berhasil!")

CRUD Operations

def createperson(driver, name, role, skills):

query = """

CREATE (p:Person {name: $name, role: $role, skills: $skills})

RETURN p

"""

with driver.session() as session:

result = session.run(query, name=name, role=role, skills=skills)

record = result.single()

return record["p"]

def createrelationship(driver, personname, companyname, role):

query = """

MATCH (p:Person {name: $personname})

MATCH (c:Company {name: $companyname})

CREATE (p)-[r:WORKSAT {role: $role}]->(c)

RETURN p, r, c

"""

with driver.session() as session:

result = session.run(

query,

personname=personname,

companyname=companyname,

role=role

)

return result.single()

def findcolleagues(driver, personname):

query = """

MATCH (p:Person {name: $name})-[:WORKSAT]->(c:Company)<-[:WORKSAT]-(colleague:Person)

RETURN colleague.name AS name, colleague.role AS role

"""

with driver.session() as session:

result = session.run(query, name=personname)

return [{"name": r["name"], "role": r["role"]} for r in result]

Contoh penggunaan

createperson(driver, "Alice", "ML Engineer", ["Python", "PyTorch"])

createperson(driver, "Bob", "Data Engineer", ["Spark", "Airflow"])

colleagues = findcolleagues(driver, "Alice")

for c in colleagues:

print(f"{c['name']} - {c['role']}")

Batch Operations dengan Transactions

Untuk performa optimal saat memasukkan data dalam jumlah besar, gunakan explicit transactions:

def batchcreatenodes(driver, peopledata):

query = """

UNWIND $people AS person

CREATE (p:Person {

name: person.name,

role: person.role,

department: person.department

})

"""

with driver.session() as session:

session.run(query, people=peopledata)

people = [

{"name": "Alice", "role": "ML Engineer", "department": "AI"},

{"name": "Bob", "role": "Data Engineer", "department": "Data"},

{"name": "Charlie", "role": "Backend Developer", "department": "Engineering"},

{"name": "Diana", "role": "Product Manager", "department": "Product"},

]

batchcreatenodes(driver, people)

Membangun Knowledge Graph

Knowledge graph adalah salah satu aplikasi utama Neo4j dalam ekosistem AI. Mari kita bangun knowledge graph sederhana untuk domain teknologi AI.

Desain Schema

def setupknowledgegraph(driver):

constraints = [

"CREATE CONSTRAINT IF NOT EXISTS FOR (t:Technology) REQUIRE t.name IS UNIQUE",

"CREATE CONSTRAINT IF NOT EXISTS FOR (c:Category) REQUIRE c.name IS UNIQUE",

"CREATE CONSTRAINT IF NOT EXISTS FOR (u:UseCase) REQUIRE u.name IS UNIQUE",

]

with driver.session() as session:

for constraint in constraints:

session.run(constraint)

print("Schema constraints created!")

setupknowledgegraph(driver)

Populate Knowledge Graph

def populateaiknowledgegraph(driver):

query = """

// Buat categories

MERGE (ml:Category {name: 'Machine Learning'})

MERGE (dl:Category {name: 'Deep Learning'})

MERGE (nlp:Category {name: 'Natural Language Processing'})

MERGE (cv:Category {name: 'Computer Vision'})

MERGE (mlops:Category {name: 'MLOps'})

// Buat technologies

MERGE (pytorch:Technology {name: 'PyTorch', type: 'framework', language: 'Python'})

MERGE (tf:Technology {name: 'TensorFlow', type: 'framework', language: 'Python'})

MERGE (transformers:Technology {name: 'HuggingFace Transformers', type: 'library', language: 'Python'})

MERGE (langchain:Technology {name: 'LangChain', type: 'framework', language: 'Python'})

MERGE (neo4jtech:Technology {name: 'Neo4j', type: 'database', language: 'Java'})

MERGE (mlflow:Technology {name: 'MLflow', type: 'platform', language: 'Python'})

MERGE (fastapi:Technology {name: 'FastAPI', type: 'framework', language: 'Python'})

// Buat use cases

MERGE (rag:UseCase {name: 'RAG Pipeline'})

MERGE (kg:UseCase {name: 'Knowledge Graph'})

MERGE (chatbot:UseCase {name: 'AI Chatbot'})

MERGE (imgclass:UseCase {name: 'Image Classification'})

MERGE (objdet:UseCase {name: 'Object Detection'})

// Buat relationships: Technology -> Category

MERGE (pytorch)-[:BELONGSTO]->(dl)

MERGE (tf)-[:BELONGSTO]->(dl)

MERGE (transformers)-[:BELONGSTO]->(nlp)

MERGE (langchain)-[:BELONGSTO]->(nlp)

MERGE (neo4jtech)-[:BELONGSTO]->(mlops)

MERGE (mlflow)-[:BELONGSTO]->(mlops)

// Buat relationships: Technology -> UseCase

MERGE (langchain)-[:USEDIN]->(rag)

MERGE (neo4jtech)-[:USEDIN]->(kg)

MERGE (neo4jtech)-[:USEDIN]->(rag)

MERGE (transformers)-[:USEDIN]->(chatbot)

MERGE (pytorch)-[:USEDIN]->(imgclass)

MERGE (pytorch)-[:USEDIN]->(objdet)

// Buat relationships: Technology -> Technology (dependencies)

MERGE (transformers)-[:DEPENDSON]->(pytorch)

MERGE (langchain)-[:INTEGRATESWITH]->(neo4jtech)

MERGE (langchain)-[:INTEGRATESWITH]->(transformers)

RETURN count() AS totaloperations

"""

with driver.session() as session:

result = session.run(query)

print(f"Knowledge graph populated!")

populateaiknowledgegraph(driver)

Query Knowledge Graph

def findtechnologiesforusecase(driver, usecasename):

query = """

MATCH (t:Technology)-[:USEDIN]->(u:UseCase {name: $usecase})

OPTIONAL MATCH (t)-[:BELONGSTO]->(c:Category)

RETURN t.name AS technology, t.type AS type, c.name AS category

"""

with driver.session() as session:

result = session.run(query, usecase=usecasename)

return [dict(r) for r in result]

def findtechnologyecosystem(driver, techname):

query = """

MATCH (t:Technology {name: $techname})

OPTIONAL MATCH (t)-[:DEPENDSON]->(dep:Technology)

OPTIONAL MATCH (t)-[:INTEGRATESWITH]->(int:Technology)

OPTIONAL MATCH (t)-[:USEDIN]->(u:UseCase)

OPTIONAL MATCH (t)-[:BELONGSTO]->(c:Category)

RETURN t.name AS technology,

collect(DISTINCT dep.name) AS dependencies,

collect(DISTINCT int.name) AS integrations,

collect(DISTINCT u.name) AS usecases,

collect(DISTINCT c.name) AS categories

"""

with driver.session() as session:

result = session.run(query, techname=techname)

return result.single()

Cari teknologi untuk RAG Pipeline

techs = findtechnologiesforusecase(driver, "RAG Pipeline")

for t in techs:

print(f" {t['technology']} ({t['type']}) - {t['category']}")

Lihat ekosistem LangChain

eco = findtechnologyecosystem(driver, "LangChain")

print(f"\nLangChain ecosystem:")

print(f" Dependencies: {eco['dependencies']}")

print(f" Integrations: {eco['integrations']}")

print(f" Use cases: {eco['usecases']}")

Advanced Usage: Graph RAG dengan LangChain

Graph RAG menggabungkan kekuatan knowledge graph dengan LLM untuk menghasilkan jawaban yang lebih akurat dan contextual. Berbeda dengan vector RAG tradisional yang hanya mencocokkan similarity, Graph RAG memahami relasi eksplisit antar entitas.

Setup Neo4j Graph Store dengan LangChain

from langchainneo4j import Neo4jGraph, GraphCypherQAChain

from langchainopenai import ChatOpenAI

graph = Neo4jGraph(

url="bolt://localhost:7687",

username="neo4j",

password="yourpasswordhere"

)

print(graph.schema)

Membuat GraphCypherQAChain

GraphCypherQAChain memungkinkan LLM mengkonversi pertanyaan natural language menjadi Cypher query, mengeksekusinya di Neo4j, dan menghasilkan jawaban berbasis hasil query:

llm = ChatOpenAI(model="gpt-4o", temperature=0)

chain = GraphCypherQAChain.fromllm(

llm=llm,

graph=graph,

verbose=True,

allowdangerousrequests=True

)

response = chain.invoke({

"query": "Teknologi apa saja yang digunakan untuk RAG Pipeline?"

})

print(response["result"])

response = chain.invoke({

"query": "Apa saja dependencies dari HuggingFace Transformers?"

})

print(response["result"])

Membangun Hybrid RAG (Vector + Graph)

Untuk hasil terbaik, kombinasikan vector search dengan graph traversal:

from langchainneo4j import Neo4jVector

from langchainopenai import OpenAIEmbeddings

embeddings = OpenAIEmbeddings()

vectorstore = Neo4jVector.fromexistinggraph(

embedding=embeddings,

url="bolt://localhost:7687",

username="neo4j",

password="yourpasswordhere",

nodelabel="Technology",

textnodeproperties=["name", "type", "language"],

embeddingnodeproperty="embedding"

)

def hybridsearch(driver, querytext, vectorstore, k=5):

# Step 1: Vector search untuk menemukan entitas relevan

vectorresults = vectorstore.similaritysearch(querytext, k=k)

entitynames = []

for doc in vectorresults:

if hasattr(doc, 'metadata') and 'name' in doc.metadata:

entitynames.append(doc.metadata['name'])

# Step 2: Graph traversal untuk memperkaya context

enrichmentquery = """

UNWIND $names AS name

MATCH (t:Technology {name: name})

OPTIONAL MATCH (t)-[r]->(related)

RETURN t.name AS source,

type(r) AS relationship,

labels(related)[0] AS relatedtype,

related.name AS relatedname

"""

with driver.session() as session:

result = session.run(enrichmentquery, names=entitynames)

graphcontext = [dict(r) for r in result]

return {

"vectorresults": vectorresults,

"graphcontext": graphcontext

}

Graph Data Science (GDS)

Neo4j Graph Data Science Library menyediakan algoritma graph untuk analytics dan machine learning:

Community Detection

// Louvain Community Detection

CALL gds.graph.project(

'tech-graph',

'Technology',

{

INTEGRATESWITH: {orientation: 'UNDIRECTED'},

DEPENDSON: {orientation: 'UNDIRECTED'}

}

)

CALL gds.louvain.stream('tech-graph')

YIELD nodeId, communityId

RETURN gds.util.asNode(nodeId).name AS technology, communityId

ORDER BY communityId

Node Similarity

// Hitung similarity antar teknologi berdasarkan shared use cases

CALL gds.nodeSimilarity.stream('tech-graph')

YIELD node1, node2, similarity

RETURN gds.util.asNode(node1).name AS tech1,

gds.util.asNode(node2).name AS tech2,

similarity

ORDER BY similarity DESC

LIMIT 10

PageRank untuk Menemukan Teknologi Paling Berpengaruh

CALL gds.pageRank.stream('tech-graph')

YIELD nodeId, score

RETURN gds.util.asNode(nodeId).name AS technology, score

ORDER BY score DESC

LIMIT 10

Import Data dari Berbagai Sumber

Import dari CSV

// Import nodes dari CSV file

LOAD CSV WITH HEADERS FROM 'file:///technologies.csv' AS row

CREATE (t:Technology {

name: row.name,

type: row.type,

language: row.language,

githubstars: toInteger(row.stars)

})

Import dari JSON via Python

import json

def importfromjson(driver, jsonfile):

with open(jsonfile) as f:

data = json.load(f)

query = """

UNWIND $items AS item

MERGE (t:Technology {name: item.name})

SET t.type = item.type,

t.description = item.description,

t.language = item.language

WITH t, item

UNWIND item.categories AS cat

MERGE (c:Category {name: cat})

MERGE (t)-[:BELONGSTO]->(c)

"""

with driver.session() as session:

session.run(query, items=data["technologies"])

importfromjson(driver, "aitechnologies.json")

Best Practices

1. Schema Design

  • Gunakan labels yang spesifik dan konsisten (PascalCase untuk labels, UPPERSNAKECASE untuk relationship types)
  • Buat unique constraints untuk property yang digunakan sebagai identifier
  • Hindari menyimpan terlalu banyak data sebagai properties; pertimbangkan untuk memecah menjadi nodes terpisah jika data memiliki relasi sendiri

2. Query Optimization

// Buat index untuk property yang sering di-query

CREATE INDEX IF NOT EXISTS FOR (t:Technology) ON (t.type)

CREATE INDEX IF NOT EXISTS FOR (t:Technology) ON (t.language)

// Gunakan PROFILE untuk melihat query plan

PROFILE MATCH (t:Technology)-[:USEDIN]->(u:UseCase)

WHERE t.language = 'Python'

RETURN t.name, u.name

3. Connection Management di Python

from contextlib import contextmanager

from neo4j import GraphDatabase

class Neo4jConnection:

def init(self, uri, user, password):

self.driver = GraphDatabase.driver(uri, auth=(user, password))

def close(self):

self.driver.close()

def query(self, cypher, parameters=None):

with self.driver.session() as session:

result = session.run(cypher, parameters or {})

return [dict(record) for record in result]

def write(self, cypher, parameters=None):

with self.driver.session() as session:

result = session.executewrite(

lambda tx: tx.run(cypher, parameters or {}).data()

)

return result

Penggunaan

conn = Neo4jConnection("bolt://localhost:7687", "neo4j", "password")

try:

results = conn.query("MATCH (n) RETURN count(n) AS total")

print(f"Total nodes: {results[0]['total']}")

finally:

conn.close()

4. Error Handling dan Retry

from neo4j.exceptions import ServiceUnavailable, TransientError

import time

def executewithretry(driver, query, params=None, maxretries=3):

for attempt in range(maxretries):

try:

with driver.session() as session:

result = session.run(query, params or {})

return [dict(r) for r in result]

except (ServiceUnavailable, TransientError) as e:

if attempt == maxretries - 1:

raise

waittime = 2 attempt

print(f"Retry {attempt + 1}/{maxretries} after {waittime}s: {e}")

time.sleep(wait_time)

5. Monitoring dan Maintenance

// Cek statistik database

CALL db.stats.retrieve("GRAPH COUNTS")

// Lihat semua indexes

SHOW INDEXES

// Lihat semua constraints

SHOW CONSTRAINTS

// Hapus data lama (contoh: nodes tanpa relationships)

MATCH (n)

WHERE NOT (n)--()

DELETE n

Kesimpulan

Neo4j adalah graph database yang sangat powerful untuk membangun knowledge graphs dan sistem AI berbasis graf. Beberapa poin penting yang telah kita pelajari:

  • Property Graph Model memungkinkan representasi data yang natural dengan nodes, relationships, labels, dan properties
  • Cypher adalah bahasa query yang intuitif menggunakan pattern ASCII art
  • Python driver menyediakan API yang mudah digunakan untuk integrasi dengan aplikasi Python
  • Graph RAG menggabungkan knowledge graph dengan LLM untuk menghasilkan jawaban yang lebih akurat dibanding vector-only RAG
  • Graph Data Science library menyediakan algoritma analytics seperti community detection, PageRank, dan node similarity
  • Best practices* mencakup schema design, indexing, connection management, dan error handling
  • Neo4j sangat cocok digunakan bersama framework AI seperti LangChain dan LlamaIndex untuk membangun sistem yang memahami relasi antar data secara mendalam. Dengan semakin populernya Graph RAG dan agentic AI, kemampuan mengelola graph database menjadi skill yang semakin penting bagi AI/ML practitioners.

    Artikel Terkait

    Tutorial Lengkap Flower (flwr): Framework Federated Learning dengan Python

    Tutorial Lengkap Flower (flwr): Framework Federated Learning dengan Python Federated learning adalah paradigma machine l...

    Tutorial Lengkap Aisuite: Unified Multi-LLM Interface dari Andrew Ng

    Tutorial Lengkap Aisuite: Unified Multi-LLM Interface dari Andrew Ng Apa itu Aisuite? Aisuite adalah library Python open...

    Tutorial CatBoost: Gradient Boosting untuk Data Tabular dengan Penanganan Fitur Kategorikal Otomatis

    Tutorial CatBoost: Gradient Boosting untuk Data Tabular dengan Penanganan Fitur Kategorikal Otomatis CatBoost (Categoric...

    Tutorial LiveKit Agents: Membangun AI Voice Agent Real-Time dengan Python

    Tutorial LiveKit Agents: Membangun AI Voice Agent Real-Time dengan Python Pengantar LiveKit Agents adalah framework open...