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
Menggunakan Docker (Recommended)
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 create
relationship(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!")
setup
knowledgegraph(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 langchain
openai 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:
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.