Graph Databases: Neo4j, RDF, Knowledge Graphs & GraphRAG

Explore graph theory by defining nodes and edges and understanding how relationships form networks. Differentiate directed from undirected graphs, weighted from unweighted, cyclic from acyclic and connected versus disconnected structures.

Explore key graph concepts: degree of nodes, tree and dag structures, bipartite and multigraphs, and weighted graphs with multiple weights, with examples like file systems, family trees, and ETL pipelines.

Explore how graph databases store data as nodes and edges from road networks, and compare property graphs like Neo4j with RDF triple stores, using Cypher and Dijkstra for shortest paths.

Install Neo4j Desktop on Windows, explore the interface, connect to local and remote instances, and run Cypher queries to create nodes and relationships.

Learn to set up Neo4j by creating a local instance named graph test and connecting to it via the query tool. Begin writing Cypher queries to explore nodes and relationships.

Create nodes and edges in a Neo4j graph database using Cypher, defining movie and person nodes with title, year, and name, then establish a directed relationship.

Create undirected graphs in Neo4j by connecting two city nodes with two directed edges, one from Chennai to Delhi and one from Delhi to Chennai.

Learn how to read records from a graph using the match keyword in Neo4j, returning nodes, edges, and properties while applying filters and limits.

Explore updating graph properties in Cypher: view node properties with properties(), add and override properties with set, remove properties, and use merge with on create and on match.

Explore deleting nodes and edges in Neo4j using detach delete to remove a node and its relationships, and delete to remove an edge, with examples of directed and undirected graphs.

Neo4j indexing speeds lookups by creating an index on a property (like email). The query planner uses the index to locate the node by its ID quickly.

Explore composite, unique, and full text indexes in Neo4j, learn how to create them with Cypher, and understand when to use each for fast, relevant queries.

Model your data around relationships, storing important data on relationships and designing nodes with properties to answer queries efficiently, as shown in product purchases and road networks.

Discover the fundamentals of Python, including procedural, object oriented, and functional programming, dynamic typing, and automatic memory management. Explore how code becomes bytecode and runs on the Python virtual machine.

Install python and visual studio code on windows, with mac steps similar. Download python 3.13.7, download vs code, install, and create a desktop icon before you start coding in python.

Learn python fundamentals by building a guess-the-number game that demonstrates variables, user input, data types, type conversion, and memory address using id.

Learn to implement loops and conditions in Python by building a five-round number-guessing game. Use a while loop, input validation, and round counters to control flow.

Explore Python data structures: lists, tuples, sets, and dictionaries—and learn to store game state and a three-user scoreboard. Use while and for loops to run the rounds.

Import the Python random module and generate a random number between 1 and 9 for a guessing game; update per-user scores in a dictionary and print the final scoreboard.

Refactor and streamline Python code by using the def keyword to create methods like generate_random_number and verify_number, improving readability, maintainability, and reuse.

Learn how to handle runtime errors in Python using try and except, with finally for cleanup, demonstrated through a zero division example and graceful error recovery.

Learn object oriented programming in Python by creating classes as blueprints, building objects, and applying encapsulation, inheritance, polymorphism, and abstraction with practical examples.

Explore list and dictionary comprehension in Python, including filtering even numbers, flattening a 2d matrix to 1d, and building dicts from items.

Learn Python file handling to load data, read and write text files, append content, and copy binary files using with, read/write modes, and basic error handling.

Learn how Python decorators inject behavior into functions with a random-number example, and how generators yield values for memory-efficient data processing.

Demonstrate Python multiprocessing to accelerate cpu-intensive tasks by using pool.map across four processes, fetching and parsing web content with requests and BeautifulSoup.

Master Python asyncio and async IO to avoid blocking on external calls. Learn await, event loop, and tasks for concurrency and parallelism.

Learn how to use lambda functions in Python, including anonymous functions defined with the lambda keyword, and practice with arguments, expression, conditional checks, and nested calls.

Master Python's filter, map, and reduce to extract even numbers, double them with map, and reduce the results to a single sum using the func tool module.

Install Python on Windows and set up Visual Studio Code, then connect Python with Neo4j to move from Neo4j's desktop Cypher testing to production interactions.

Create 100 person nodes in neo4j from a csv using python, with cypher create queries for name, age, city, and email, managing sessions with a context.

Create and activate a Python virtual environment in Visual Studio Code to prepare a Neo4j development workspace, then install the required Python packages for graph databases.

Create a requirements.txt file with the necessary python packages for working with neo4j, activate the virtual environment, and install them using pip -r requirements.txt.

Create and activate a virtual environment to isolate a Python project. Install Flask inside the environment and generate a requirements.txt for consistent setups.

Generate dummy data with a Python faker-like package, write it to a friends.csv file, then load the CSV to create person nodes and friendship relationships in Neo4j.

Establish a secure connection to a local neo4j instance by loading credentials from a .env file, initializing a neo4j driver, and verifying connectivity before creating nodes and relationships.

Learn to create relationships between nodes in Neo4j using a Python method that runs the Cypher query, handle parameters, and use indexing to speed up undirected graph creation.

Explore depth first search, a graph traversal that goes as deep as possible before backtracking, with adjacent and parent vertices, cycle detection, and applications in navigation systems and recommendations.

Apply the DFS algorithm to enumerate all paths from A to F and write Cypher queries to create nodes and edges and detect cycles with root star.

Explore how breadth first search traverses a graph by exploring each node's neighbors before moving deeper, revealing shortest paths, nearest locations, and social connections using a queue-based traversal.

Explore how APOC (epoch) in Neo4j loads JSON with apoc.load.json, creates nodes with epoch.create.node, updates properties via epoch.periodic.iterate, and runs BFS with apoc.path.expand.config, while noting the GDS library installation.

Discuss how Dijkstra's algorithm finds the shortest path in a weighted graph and apply it to the A to E example with nodes A, B, C, D, and E.

Generate a fake road network with Python and Faker, creating intersections, places, and edges in csv files. Apply Dijkstra to find the shortest path between two points in the graph.

Create nodes and edges for Dijkstra's algorithm in Neo4j using Python and CSV data, with helper db queries for nodes and relationships.

Learn to implement Dijkstra in Neo4j with APOC and the GDS library, using a dynamic cost from distance, time, and traffic to compute the shortest path.

Explore RDF, the resource description framework, and how it represents information as triples—subject, predicate, and object—enabling data integration across silos and linked open data.

Install GraphDB on Windows, obtain a free license, and access the localhost 7200 interface to upload RDF, run turtle-based RDF snippets, and manage RDF data.

Create a repository in graph db by opening graph db, navigating to setup and repositories, entering a repository id, and then importing RDF data into the graph db repository.

Explore how RDF represents data as a graph using triples with URIs and query with SPARQL. See how ETL pipelines convert JSON to RDF for graph databases and cross-system queries.

Create rdf triples for John and Alice linking government, purchase, and medical records. Demonstrate creating csv, python etl, and importing into graph db for sparql queries.

Master sparql queries on rdf data by selecting and traversing resources such as customers and records, filtering by blood group, purchases, dates, and allergies.

GraphQL is a query language for APIs, not a database; it is backend agnostic and can query data from any database, enabling a social schema with user, post, and comment.

This lecture demonstrates building a GraphQL server in Python by defining a schema with product, user, and order types, and implementing read queries and write mutations.

Establish a Neo4j connection by creating a db.pi file in the graph ql directory, implementing a connection class with a uri, auth, a close method, and a parameterized query executor.

Learn mutation in GraphQL by building resolver logic for Neo4j to create user, product, and order records. Implement Cypher queries, use merge for relationships, and compute the order total.

Build and test GraphQL query resolvers for users and products, use a schema to resolve read operations with Cypher against Neo4j, and expose user orders and order products through relationships.

Combine the GraphQL schema with resolvers using load_schema_from_path and make_executable_schema, then build a CGI/WSGI app to serve GraphQL requests and run a local server for querying Neo4j data.

Learn how to build a GraphQL client with Python requests to create users, products, and orders via mutations. Fetch users with queries and explore schema constraints that limit queried fields.