Tutorials

Learn Geode through hands-on, step-by-step tutorials covering everything from basic queries to advanced graph algorithms. Each tutorial builds practical skills with real-world examples.

Overview

These tutorials are designed for learning by doing. Whether you’re new to graph databases or an experienced developer, these guides provide structured, progressive learning paths from basics to advanced topics.

Each tutorial includes complete working examples, expected outputs, and exercises to reinforce learning. Follow tutorials sequentially for a comprehensive learning path, or jump to specific topics as needed.

Learning Paths

Beginner Path

  1. REPL Basics - Get comfortable with the interactive shell
  2. MATCH Basics - Learn fundamental graph queries
  3. Tutorial Overview - Understand the tutorial structure

Intermediate Path

  1. Transaction Patterns - Master ACID transactions
  2. Indexing Tutorial - Optimize query performance
  3. Index Optimization - Advanced index strategies

Advanced Path

  1. Vector Search - Implement similarity search
  2. Graph Algorithms - Apply graph algorithms

Topics in This Section

  • Tutorial Overview - Introduction to the tutorial series with learning objectives and prerequisites
  • REPL Basics - Interactive shell fundamentals including commands, query execution, and meta commands
  • MATCH Basics - Core pattern matching concepts with node patterns, relationship patterns, and filtering
  • Transaction Patterns - ACID transactions with BEGIN/COMMIT/ROLLBACK, savepoints, and error handling
  • Indexing Tutorial - Index creation and usage covering all six index types
  • Index Optimization - Advanced index optimization including EXPLAIN analysis and performance tuning
  • Vector Search Tutorial - Similarity search with HNSW indexes, embeddings, and K-NN queries
  • Graph Algorithms Tutorial - Practical guide to PageRank, community detection, shortest paths, and centrality

Tutorial Format

Each tutorial follows a consistent structure:

1. Learning Objectives

What you’ll learn and prerequisites:

Objectives:
- Understand pattern matching syntax
- Write basic MATCH queries
- Filter results with WHERE

Prerequisites:
- Geode installed and running
- Basic SQL knowledge helpful but not required

2. Concepts

Core concepts explained with examples:

-- Node pattern
(variable:Label {property: value})

-- Explanation: Matches nodes with Label and property

3. Hands-On Exercises

Practice with working examples:

-- Exercise 1: Find all people
MATCH (p:Person)
RETURN p.name;

-- Expected output:
┌─────────┐
│ p.name  │
├─────────┤
│ Alice   │
│ Bob     │
│ Charlie │
└─────────┘

4. Common Pitfalls

Learn from common mistakes:

-- Wrong: Missing variable
MATCH (:Person)
RETURN name;  -- Error: name not bound

-- Right: Use variable
MATCH (p:Person)
RETURN p.name;

5. Next Steps

Suggested follow-up learning:

Next: Learn about relationship patterns in [MATCH Basics](/docs/tutorials/match-basics/)

Quick Start Tutorial

Set Up Sample Data 

-- Create a social network
CREATE GRAPH SocialNetwork;
USE SocialNetwork;

-- Create people
CREATE (:Person {name: "Alice", age: 30, city: "Seattle"});
CREATE (:Person {name: "Bob", age: 25, city: "Portland"});
CREATE (:Person {name: "Charlie", age: 35, city: "Seattle"});

-- Create relationships
MATCH (a:Person {name: "Alice"}), (b:Person {name: "Bob"})
CREATE (a)-[:KNOWS {since: 2020}]->(b);

MATCH (b:Person {name: "Bob"}), (c:Person {name: "Charlie"})
CREATE (b)-[:KNOWS {since: 2021}]->(c);

MATCH (a:Person {name: "Alice"}), (c:Person {name: "Charlie"})
CREATE (a)-[:KNOWS {since: 2019}]->(c);

Basic Queries 

-- Query 1: Find all people
MATCH (p:Person)
RETURN p.name, p.age
ORDER BY p.age;

-- Query 2: Find Alice's friends
MATCH (alice:Person {name: "Alice"})-[:KNOWS]->(friend)
RETURN friend.name;

-- Query 3: Find people in Seattle
MATCH (p:Person)
WHERE p.city = "Seattle"
RETURN p.name;

-- Query 4: Count relationships
MATCH ()-[k:KNOWS]->()
RETURN count(k) AS friendship_count;

Using the REPL 

# Start interactive shell
geode shell

# Enable timing
\timing on

# Run query
MATCH (p:Person) RETURN p.name;

# Check execution time
-- Query executed in 0.523ms

# Exit
\quit

Tutorial Highlights

REPL Basics Tutorial

Master the interactive shell:

  • Meta Commands: \help, \connect, \timing, \format
  • Query Execution: Single-line and multi-line queries
  • Output Formats: Text tables and JSON
  • Transaction Control: \begin, \commit, \rollback
  • History: Command history and search

See: REPL Basics

MATCH Basics Tutorial

Learn pattern matching:

  • Node Patterns: (n:Label {property: value})
  • Relationship Patterns: -[:TYPE]->, <-[:TYPE]-, -[:TYPE]-
  • Path Patterns: (a)-[:KNOWS*1..3]->(b)
  • Filtering: WHERE clauses with complex conditions
  • Aggregation: COUNT, SUM, AVG, MIN, MAX

See: MATCH Basics

Transaction Patterns Tutorial

Master ACID transactions:

  • Basic Transactions: BEGIN, COMMIT, ROLLBACK
  • Isolation Levels: Read Committed to Serializable
  • Savepoints: Partial rollback within transaction
  • Error Handling: Retry logic for serialization errors
  • Patterns: Optimistic concurrency, pessimistic locking

See: Transaction Patterns

Indexing Tutorial

Optimize query performance:

  • Index Types: B-tree, Hash, HNSW, R-tree, Full-text, Patricia Trie
  • Index Creation: CREATE INDEX syntax for each type
  • Index Usage: EXPLAIN to verify index selection
  • Performance: Before/after index benchmarks
  • Maintenance: Index statistics and rebuilding

See: Indexing Tutorial

Index Optimization Tutorial

Advanced index strategies:

  • EXPLAIN Analysis: Understand query plans
  • PROFILE Analysis: Measure actual performance
  • Composite Indexes: Multi-column indexes
  • Partial Indexes: Filtered indexes for subsets
  • Index Selection: When to use each index type

See: Index Optimization

Vector Search Tutorial

Implement similarity search:

  • HNSW Indexes: High-performance approximate search
  • Embeddings: Generate and store vector embeddings
  • K-NN Queries: Find similar items
  • Distance Metrics: L2, cosine, dot product
  • Hybrid Search: Combine vector and keyword search

See: Vector Search Tutorial

Graph Algorithms Tutorial

Apply graph algorithms:

  • PageRank: Identify important nodes
  • Community Detection: Find clusters
  • Shortest Paths: Dijkstra and A* algorithms
  • Centrality: Betweenness, closeness, degree
  • Practical Examples: Social networks, recommendations

See: Graph Algorithms Tutorial

Sample Datasets

Social Network 

-- Create sample social network (10 people)
CREATE (:Person {name: "Alice", age: 30, interests: ["hiking", "reading"]});
CREATE (:Person {name: "Bob", age: 25, interests: ["gaming", "cooking"]});
CREATE (:Person {name: "Charlie", age: 35, interests: ["hiking", "photography"]});
-- ... 7 more people

-- Create friendships
MATCH (a:Person {name: "Alice"}), (b:Person {name: "Bob"})
CREATE (a)-[:KNOWS {since: 2020}]->(b);
-- ... more relationships

E-Commerce 

-- Products and categories
CREATE (:Product {sku: "WIDGET-001", name: "Widget", price: 29.99});
CREATE (:Category {name: "Widgets"});

-- Customers and orders
CREATE (:Customer {id: 1, name: "Alice", email: "[email protected]"});
CREATE (:Order {order_id: "ORD-001", total: 59.98, status: "shipped"});

-- Relationships
MATCH (p:Product {sku: "WIDGET-001"}), (c:Category {name: "Widgets"})
CREATE (p)-[:IN_CATEGORY]->(c);

Knowledge Graph 

-- Entities
CREATE (:Person {name: "Alan Turing", born: 1912, died: 1954});
CREATE (:Concept {name: "Computer Science"});
CREATE (:Institution {name: "University of Cambridge"});

-- Relationships
MATCH (p:Person {name: "Alan Turing"}), (c:Concept {name: "Computer Science"})
CREATE (p)-[:CONTRIBUTED_TO]->(c);

Exercise Solutions

Each tutorial includes exercises with solutions:

Example Exercise

Exercise: Find people who have at least 2 friends.

Solution:

MATCH (p:Person)-[:KNOWS]->(friend)
WITH p, count(friend) AS friend_count
WHERE friend_count >= 2
RETURN p.name, friend_count
ORDER BY friend_count DESC;

Explanation:

  • MATCH finds all friendships
  • WITH aggregates friends per person
  • WHERE filters for 2+ friends
  • RETURN shows results

Best Practices Learned

Throughout tutorials, you’ll learn:

Query Writing

  • Start with selective filters
  • Use LIMIT to prevent runaway queries
  • Return only needed properties
  • Use parameters instead of literals

Performance

  • Create indexes for frequent queries
  • Use EXPLAIN before optimizing
  • Profile production queries
  • Monitor query patterns

Data Modeling

  • Model relationships explicitly
  • Use labels for categorization
  • Choose appropriate property types
  • Denormalize for performance

Transactions

  • Keep transactions short
  • Handle errors gracefully
  • Use appropriate isolation level
  • Implement retry logic

Common Patterns

Find Friends of Friends 

MATCH (me:Person {name: "Alice"})-[:KNOWS*2]->(fof)
WHERE fof <> me
RETURN DISTINCT fof.name;

Recommendation Engine 

MATCH (me:Person {name: "Alice"})-[:LIKES]->(item)<-[:LIKES]-(other)
MATCH (other)-[:LIKES]->(recommendation)
WHERE NOT (me)-[:LIKES]->(recommendation)
RETURN recommendation.name, count(*) AS score
ORDER BY score DESC
LIMIT 10;

Shortest Path 

MATCH path = shortestPath(
  (a:Person {name: "Alice"})-[*]-(b:Person {name: "Bob"})
)
RETURN path, length(path) AS hops;

Troubleshooting Tips

Query Not Returning Results

  1. Verify data exists: MATCH (n) RETURN count(n);
  2. Check labels: MATCH (n) RETURN DISTINCT labels(n);
  3. Simplify pattern: Remove constraints one by one
  4. Use EXPLAIN: Verify query plan

Slow Queries

  1. Check for indexes: SHOW INDEXES;
  2. Use PROFILE: Identify bottlenecks
  3. Create missing indexes
  4. Limit result size

Transaction Errors

  1. Check isolation level
  2. Implement retry logic
  3. Reduce transaction scope
  4. Check for deadlocks

Learn More

After completing tutorials:

Next Steps

Start your learning journey:

  1. Begin with REPL Basics - Get comfortable with the shell
  2. Learn MATCH Patterns - Master graph queries
  3. Practice Transactions - Ensure data consistency
  4. Optimize with Indexes - Improve performance
  5. Explore Advanced Topics - Apply algorithms

Contributing Tutorials

Have a tutorial idea? Contributions welcome!

See Contributing Guide for how to submit new tutorials or improvements.

Pages

Tutorials and Examples

Step-by-step tutorials for Geode: MATCH basics, indexing and EXPLAIN/PROFILE, graph algorithms, embeddings, and backup/restore workflows

4 min read

MATCH Basics Tutorial

Step-by-step tutorial for learning GQL pattern matching fundamentals: creating nodes, relationships, and querying graph data with MATCH clauses

11 min read

Indexing and Query Optimization Tutorial

Comprehensive tutorial for creating indexes, using EXPLAIN and PROFILE, and optimizing GQL queries for maximum performance in Geode

13 min read

Graph Algorithms Tutorial

Step-by-step tutorial for using graph algorithms in Geode: PageRank, shortest paths, community detection, centrality measures, and practical applications

13 min read

Index Optimization Tutorial

Practical guide to index optimization in Geode including EXPLAIN analysis, B-tree, HNSW, and full-text indexes with performance tuning strategies

13 min read

Vector Similarity Search Tutorial

Learn vector similarity search with Geode: generate embeddings, create HNSW indexes, and find semantically similar items with cosine and L2 distance

12 min read

Transaction Patterns Tutorial

Master ACID transactions in Geode: isolation levels, savepoints, deadlock handling, and practical transaction patterns for data consistency

16 min read

REPL Interactive Shell Basics

Getting started with Geode's REPL interactive shell including meta commands, query execution, history navigation, and productivity features.

7 min read