Getting Started with FalkorDB

This guide will walk you through setting up FalkorDB, modeling a social network as a graph, and accessing it using one of the FalkorDB client libraries with the Cypher query language.

---

Prerequisites

1. FalkorDB Instance: Set up FalkorDB (on-prem or cloud).
   • Run FalkorDB Docker
   • Create a FalkorDB Cloud Instance
2. Install FalkorDB Client:

Python

pip install falkordb

Javascript

npm install falkordb

Rust

cargo add falkordb

Java

<dependencies>
    <dependency>
      <groupId>com.falkordb</groupId>
      <artifactId>jfalkordb</artifactId>
      <version>0.4.0</version>
    </dependency>
  </dependencies>

---

Step 1: Model a Social Network as a Graph

Let's create a simple graph for a social network where:

• Nodes represent User and Post.
• Relationships connect Users with a FRIENDS_WITH relationship, and Users are connected via a CREATED relationship to Posts

Graph Schema

Node Types:

Node Type	Properties	Description
User	id, name, email	Represents a user in the social network
Post	id, content, date	Represents a post created by a user

Relationship Types:

Relationship Type	Start Node	End Node	Properties	Description
FRIENDS_WITH	User	User	since	Indicates friendship between two users
CREATED	User	Post	time	Connects a user to their created posts

---

Step 2: Load Data into FalkorDB

Here's how you can model and load the data.

Cypher Query to Create the Data

You can execute these commands using the FalkorDB Python client or any supported client.

---

Step 3: Access Your Data

Connect to FalkorDB

Python

from falkordb import FalkorDB

# Connect to FalkorDB
client = FalkorDB(host="localhost", port=6379, password="your-password")
graph = client.select_graph('social')

Javascript

import { FalkorDB } from 'falkordb';

const client = await FalkorDB.connect({
  host: "localhost",
  port: 6379,
  password: "your-password"
});
const graph = client.selectGraph('social');

Rust

use falkordb::{FalkorClientBuilder, FalkorConnectionInfo};

// Connect to FalkorDB
let connection_info: FalkorConnectionInfo = "falkor://127.0.0.1:6379".try_into()
            .expect("Invalid connection info");

let client = FalkorClientBuilder::new()
           .with_connection_info(connection_info)
           .build()
           .expect("Failed to build client");

// Select the social graph
let mut graph = client.select_graph("social");

Java

package com.myproject;

import com.falkordb.*;

Driver driver = FalkorDB.driver("localhost", 6379);
Graph graph = driver.graph("social");

Execute Cypher Queries

Create the Graph

Python

create_query = """
CREATE (alice:User {id: 1, name: "Alice", email: "alice@example.com"})
CREATE (bob:User {id: 2, name: "Bob", email: "bob@example.com"})
CREATE (charlie:User {id: 3, name: "Charlie", email: "charlie@example.com"})

CREATE (post1:Post {id: 101, content: "Hello World!", date: 1701388800})
CREATE (post2:Post {id: 102, content: "Graph Databases are awesome!", date: 1701475200})

CREATE (alice)-[:FRIENDS_WITH {since: 1640995200}]->(bob)
CREATE (bob)-[:FRIENDS_WITH {since: 1684108800}]->(charlie)
CREATE (alice)-[:CREATED {time: 1701388800}]->(post1)
CREATE (bob)-[:CREATED {time: 1701475200}]->(post2)
"""

graph.query(create_query)
print("Graph created successfully!")

Javascript

const createQuery = `
CREATE (alice:User {id: 1, name: "Alice", email: "alice@example.com"})
CREATE (bob:User {id: 2, name: "Bob", email: "bob@example.com"})
CREATE (charlie:User {id: 3, name: "Charlie", email: "charlie@example.com"})

CREATE (post1:Post {id: 101, content: "Hello World!", date: 1701388800})
CREATE (post2:Post {id: 102, content: "Graph Databases are awesome!", date: 1701475200})

CREATE (alice)-[:FRIENDS_WITH {since: 1640995200}]->(bob)
CREATE (bob)-[:FRIENDS_WITH {since: 1684108800}]->(charlie)
CREATE (alice)-[:CREATED {time: 1701388800}]->(post1)
CREATE (bob)-[:CREATED {time: 1701475200}]->(post2)
`;

let result = await graph.query(createQuery);
console.log("Graph created successfully!");

Rust

let create_query = r#"
CREATE (alice:User {id: 1, name: \"Alice\", email: \"alice@example.com\"})
CREATE (bob:User {id: 2, name: \"Bob\", email: \"bob@example.com\"})
CREATE (charlie:User {id: 3, name: \"Charlie\", email: \"charlie@example.com\"})

CREATE (post1:Post {id: 101, content: \"Hello World!\", date: 1701388800})
CREATE (post2:Post {id: 102, content: \"Graph Databases are awesome!\", date: 1701475200})

CREATE (alice)-[:FRIENDS_WITH {since: 1640995200}]->(bob)
CREATE (bob)-[:FRIENDS_WITH {since: 1684108800}]->(charlie)
CREATE (alice)-[:CREATED {time: 1701388800}]->(post1)
CREATE (bob)-[:CREATED {time: 1701475200}]->(post2)
"#;

graph.query(create_query).execute().await?;
println!("Graph created successfully!");

Java

String createQuery = 
"CREATE (alice:User {id: 1, name: \"Alice\", email: \"alice@example.com\"}) " +
"CREATE (bob:User {id: 2, name: \"Bob\", email: \"bob@example.com\"}) " +
"CREATE (charlie:User {id: 3, name: \"Charlie\", email: \"charlie@example.com\"}) " +

"CREATE (post1:Post {id: 101, content: \"Hello World!\", date: 1701388800}) " +
"CREATE (post2:Post {id: 102, content: \"Graph Databases are awesome!\", date: 1701475200}) " +

"CREATE (alice)-[:FRIENDS_WITH {since: 1640995200}]->(bob) " +
"CREATE (bob)-[:FRIENDS_WITH {since: 1684108800}]->(charlie) " +
"CREATE (alice)-[:CREATED {time: 1701388800}]->(post1) " +
"CREATE (bob)-[:CREATED {time: 1701475200}]->(post2)";

ResultSet resultSet = graph.query(createQuery);
System.out.println("Graph created successfully!");

Query the Graph

Python

# Find all friends of Alice
query = """
MATCH (alice:User {name: 'Alice'})-[:FRIENDS_WITH]->(friend)
RETURN friend.name AS Friend
"""

result = graph.ro_query(query).result_set

print("Alice's friends:")
for record in result:
    print(record[0])

Javascript

const query = `
MATCH (alice:User {name: "Alice"})-[:FRIENDS_WITH]->(friend)
RETURN friend.name AS Friend
`;
const result = await graph.ro_query(query);
console.log("Alice's friends:");
for (const record of result) {
  console.log(record["Friend"]);
}

Rust

let query = r#"
MATCH (alice:User {name: \"Alice\"})-[:FRIENDS_WITH]->(friend)
RETURN friend.name AS Friend
"#;
let result = graph.ro_query(query).execute().await?;

println!("Alice's friends:");
for record in result.data.by_ref() {
    println!("{}", record["Friend"]);
}

Java

String query = """
MATCH (alice:User {name: \"Alice\"})-[:FRIENDS_WITH]->(friend)
RETURN friend.name AS Friend
""";
ResultSet result = graph.readOnlyQuery(query);
System.out.println("Alice's friends:");
for (Record record : result) {
    System.out.println(record.get("Friend"));
}

Query Relationships

Python

# Find posts created by Bob
query = """
MATCH (bob:User {name: 'Bob'})-[:CREATED]->(post:Post)
RETURN post.content AS PostContent
"""

result = graph.ro_query(query).result_set

print("Posts created by Bob:")
for record in result:
    print(record[0])

Javascript

const query = `
MATCH (bob:User {name: "Bob"})-[:CREATED]->(post:Post)
RETURN post.content AS PostContent
`;
const result = await graph.ro_query(query);
console.log("Posts created by Bob:");
for (const record of result) {
  console.log(record["PostContent"]);
}

Rust

let query = r#"
MATCH (bob:User {name: \"Bob\"})-[:CREATED]->(post:Post)
RETURN post.content AS PostContent
"#;
let result = graph.ro_query(query).execute().await?;
println!("Posts created by Bob:");
for record in result.data.by_ref() {
    println!("{}", record["PostContent"]);
}

Java

String query = """
MATCH (bob:User {name: \"Bob\"})-[:CREATED]->(post:Post)
RETURN post.content AS PostContent
""";
ResultSet result = graph.readOnlyQuery(query);
System.out.println("Posts created by Bob:");
for (Record record : result) {
    System.out.println(record.get("PostContent"));
}

---

Step 4: Explore Further

Congratulations! 🎉 You have successfully modeled, loaded, and queried a social network graph with FalkorDB.

Next, dive deeper into FalkorDB's powerful features:

• Advanced Cypher
• Database Operations
• GenAI Tools
• Agentic Memory

For questions or support, visit our community forums