Node
A node is a discrete element of a graph, tree, linked structure, network, or computing system that can represent an entity, state, or component and may connect to other elements.
Grokking Data Structures
A vertex is a node in a graph that represents an entity or endpoint of relationships.
- How it is used
- Models distinct entities as vertices so edges can express relationships and support questions about connectivity and paths.
- How deep it goes
- Defines vertices as a set and edges as endpoint pairs, then explains edge direction without prescribing a vertex class.
- Examples
- Uses an animal friendship network and contrasts one-way social-media follows with two-way friendships.
- What you can do after
- Evaluate/understand it by identifying graph vertices and choosing edge direction to represent a relationship.
ScyllaDB in Action
A node is an individual computing instance participating in a distributed database or system.
- How it is used
- Establishes how ScyllaDB distributes storage and request serving for scalability and fault tolerance.
- How deep it goes
- Explains node roles, replication, quorum behavior, joining, sizing, and lifecycle operations without a universal sizing formula.
- Examples
- Demonstrates three Docker nodes named scylla-1, scylla-2, and scylla-3, including taking one offline.
- What you can do after
- Operate/configure nodes by launching a local cluster, adding capacity, and planning maintenance or membership changes.
The Coder Cafe
A vertex is an individual element in a graph that may be connected to other vertices by edges.
- How it is used
- Identifies the elements connected by edges in graphs, including dependency graphs and flow networks.
- How deep it goes
- Defines vertices and explains their representation and processing, without developing a standalone vertex implementation.
- Examples
- Uses social-network connections, network reachability, dependency ordering, and source-to-sink flow paths.
- What you can do after
- Evaluate/understand it by comparing vertex representations and tracing how topological sort processes vertices.
AI Agents and Applications
A node is a LangGraph workflow component that performs processing by reading the current state and returning state updates.
- How it is used
- Organizes stateful AI workflows into discrete processing steps with explicit transitions.
- How deep it goes
- Explains node inputs, processing, updates, registration, and routing through progressively richer implementations.
- Examples
- Uses research query generation, an LLM-and-tools loop, and a no-op guardrail refusal node.
- What you can do after
- Apply it via LangGraph to register state-processing functions and connect them into conditional workflows.
Grokking Machine Learning
A structural element of a tree that can contain a question or prediction and connect to branches.
- How it is used
- Uses nodes to represent questions and outcomes in a decision tree traversed to make predictions.
- How deep it goes
- Defines root, decision, and leaf nodes by their positions and branches, without detailing how questions are learned.
- Examples
- Illustrates nodes with a jacket decision based on whether it is raining and, if not, the temperature.
- What you can do after
- Understand how questions and branches form a decision tree used to make a prediction.
D3.js in Action, Third Edition
A node is an entity or vertex in a network or graph that can participate in connections to other nodes.
- How it is used
- Uses nodes to model entities in hierarchical visualizations and connected things in network visualizations.
- How deep it goes
- Defines nodes, separates them from edges, and shows node data preparation, but defers detailed force-simulation implementation.
- Examples
- Uses language hierarchies and Romeo and Juliet characters to demonstrate root, leaf, attributed, connected, and weighted nodes.
- What you can do after
- Build network visualizations by separating node data from edge data and attaching attributes to each node.
Graph Neural Networks in Action
A node is a discrete element in a graph structure that can represent an entity such as an atom.
- How it is used
- Represents entities whose features and relationships are structured as graph data for analysis or GNN training.
- How deep it goes
- Defines nodes and features, then walks through entity selection and graph preparation without specifying a node data structure in code.
- Examples
- Uses passengers and cabins, co-investing investors, and job candidates linked by referrals to illustrate node choices.
- What you can do after
- Build it from scratch by choosing entities as nodes, assigning features, and defining edges before GNN preprocessing.
Grokking AI Algorithms, Second Edition
A node, also called a vertex, is an individual state or object represented within a graph.
- How it is used
- Uses nodes to represent states in graphs and search trees, and inputs and outputs in neural networks.
- How deep it goes
- Defines node relationships and graph representations, then traces visited nodes and parent references through depth-first search.
- Examples
- Illustrates nodes with road-trip stops, maze positions, and handwritten-digit image inputs and outputs.
- What you can do after
- Apply nodes to model graph states and trace a depth-first search path using parent references.
Read how Grokking AI Algorithms, Second Edition explains node →
Graph Algorithms for Data Science
A node is an element of a graph that represents an entity such as a person, organization, location, or biomedical concept.
- How it is used
- Uses nodes as graph elements for modeling entities and analyzing their explicit, inferred, or indirect connections.
- How deep it goes
- Defines node meaning, domains, visual form, and Cypher notation, but stops short of detailed graph-theory internals.
- Examples
- Uses people, companies, cities, services, social graphs, service dependencies, biomedical concepts, and transportation networks.
- What you can do after
- Evaluate and understand graph representations, then identify entities and analyze their connected patterns.
Build Python Web Apps with Streamlit
A graph node is a vertex in a graph that represents an entity, state, or executable step in a workflow.
- How it is used
- Structures LangGraph workflows as executable steps that transform shared application state.
- How deep it goes
- Explains graph meaning, state updates, directed execution, and a static-method implementation, but defers broader node internals.
- Examples
- Demonstrates social-network vertices, a sum-of-squares graph, and a base-context node for a support agent.
- What you can do after
- Build it from scratch by defining state-transforming functions and connecting them with directed LangGraph edges.
Read how Build Python Web Apps with Streamlit explains node →
Financial AI in Practice
A vertex in a graph representing an entity or object.
- How it is used
- Uses nodes to represent financial entities and expose relationships that transaction-level fraud analysis can miss.
- How deep it goes
- Defines nodes, edges, and properties, then demonstrates typed node creation and co-occurrence edge construction from transaction data.
- Examples
- Illustrates nodes with chargeback users and a shared merchant, plus a multi-entity transaction graph of users, devices, IPs, phones, and cards.
- What you can do after
- Apply it via NetworkX to build typed entity nodes and connect entities that co-occur in transactions.
Learn Haskell by Example
A node is an entity represented as a vertex in a graph and connected to zero or more other nodes.
- How it is used
- Models words as graph nodes so a word-ladder program can search for a shortest transformation path.
- How deep it goes
- Defines nodes through graph representations and implements directed-node lookup and edge insertion, while deferring shortest-path algorithm details.
- Examples
- Uses English words in a ladder graph and integer nodes queried after adding directed edges.
- What you can do after
- Build it from scratch as a directed adjacency map with functions to add edges and retrieve connected nodes.
Optimization Algorithms: AI techniques for design, planning, and control problems
A vertex is a node in a graph that can be connected to other vertices by edges.
- How it is used
- Models entities and locations so graph representations and search algorithms can operate on their relationships.
- How deep it goes
- Defines nodes, distinguishes graph types, demonstrates NetworkX construction, and applies nodes to weighted routing networks.
- Examples
- Uses NetworkX node lists, social-media entities, and University of Toronto road intersections and points of interest.
- What you can do after
- Build it from scratch with NetworkX by creating nodes, connecting edges, and visualizing a graph.
Natural Language Processing in Action, Second Edition
A node is an entity or vertex in a graph that can be connected to other nodes by edges.
- How it is used
- Represents entities, conversation states, or ideas so their relationships can be analyzed, routed, or visualized.
- How deep it goes
- Defines nodes through graph intuition and demonstrates construction, visualization, and chatbot-state semantics without detailing graph algorithms.
- Examples
- Uses social networks, sentence-similarity plots, and a counting chatbot with welcome, question, and answer states.
- What you can do after
- Build nodes in NetworkX graphs and interpret them as clustered ideas or context-dependent chatbot states.
Read how Natural Language Processing in Action, Second Edition explains node →
AI-Powered Search
A graph element representing a query-defined set of documents or another graph object.
- How it is used
- Models entities, query-defined document sets, and relationship contexts for knowledge-graph traversal.
- How deep it goes
- Defines graph nodes and explains their document-set implementation, stopping short of database-specific storage details.
- Examples
- Uses authors, research papers, conferences, locations, Jean Grey, and the relationship “in love with.”
- What you can do after
- Apply it via a semantic graph traversal API to define query-backed nodes and discover related terms.
Build and Orchestrator in Go (From Scratch)
A node is a machine-representing object in a cluster that exposes identity, network location, capacity, and allocation information for scheduling.
- How it is used
- Represents cluster machines so managers can address workers, inspect capacity, track allocations, and schedule tasks.
- How deep it goes
- Defines Go fields and implements stats retrieval with retries, response checks, and JSON decoding.
- Examples
- Uses node-1, machine capacity fields, the /stats endpoint, HTTP retries, and repeated polling for CPU usage.
- What you can do after
- Build it from scratch as a Go struct and operate it through resilient statistics retrieval for scheduler decisions.
Read how Build and Orchestrator in Go (From Scratch) explains node →
Data Analysis with LLMs
A node is an entity in a graph that can be connected to other nodes and associated with properties.
- How it is used
- Represents entities in graph data, where edges connect them and properties describe them.
- How deep it goes
- Defines nodes, illustrates labels and properties, and applies them in simple MATCH queries; defers a full Cypher introduction.
- Examples
- Illustrates subway stations, people, movies, and a Tom Cruise acting query.
- What you can do after
- Understand how node labels and properties participate in simple Cypher MATCH patterns and query results.
Advanced Algorithms and Data Structures
A vertex is a node in a graph that may be connected to other vertices by edges.
- How it is used
- Represents distinct entities that algorithms connect and traverse within graphs.
- How deep it goes
- Defines nodes through graph sets and applies them to road intersections, while deferring route-solving details.
- Examples
- Uses abstract vertices and road intersections connected by one-way or two-way street edges.
- What you can do after
- Evaluate/understand how real entities and road intersections become vertices in a graph model.
Read how Advanced Algorithms and Data Structures explains node →
Go in Action, Second Edition
A node is a data-structure element that stores a value and links to neighboring elements in a linked list.
- How it is used
- Supports generic linked lists and demonstrates type parameters across a data structure.
- How deep it goes
- Defines the node fields and explains linked-list memory behavior, but stops short of a complete list implementation.
- Examples
- Uses node[T any] with value T and next *node[T] as the concrete implementation.
- What you can do after
- Build it from scratch: Define a generic node that links values into a type-safe linked-list structure.
Fabulous Adventures in Data Structures and Algorithms
A node is an element in a graph or tree data structure that stores state and connects to related nodes through edges.
- How it is used
- Represents trie positions while supporting left-to-right word traversal and incremental construction.
- How deep it goes
- Defines node state, edge representation, mutability, and accessor operations, stopping short of complete trie or DAWG algorithms.
- Examples
- Uses a C# Node class with IsEnd, EdgeLabels, FollowEdge, HasEdge, and node-creation operations.
- What you can do after
- Build it from scratch by implementing a mutable trie node with encapsulated character-labeled edge operations.
Read how Fabulous Adventures in Data Structures and Algorithms explains node →
Also covered in
- Functional Programming in JavaScript
- Knowledge Graphs and LLMs in Action
- Object-Oriented Software Design in C++
- Crack Any Codebase with AIIn early access (MEAP)
- Sutskever's List
- Fight Fraud with Machine LearningIn early access (MEAP)
- Geometry for Programmers
- AI-Powered Developer: Build software with ChatGPT and Copilot
- Causal Inference for Data Science
- Acing the CCNA Exam: Volume 1 Fundamentals and Protocols
- Digital Twins in Action
- Classic Computer Science Problems in Swift: Essential techniques for practicing programmers
What to know first
- language modelA language model is a computational model that represents patterns in linguistic sequences to assign probabilities, predict, generate, or evaluate language.
- graphA graph is a mathematical structure consisting of vertices and edges that connect pairs of vertices to represent relationships or connections.
- data structureA data structure is an organized representation of data and its relationships that supports defined operations for storing, accessing, or modifying it.
- graph databaseA graph database is a database system that represents data as entities and their relationships, typically using nodes and edges, and supports queries over that structure.
Related concepts
- graphpart of · A graph is a mathematical structure consisting of vertices and edges that connect pairs of vertices to represent relationships or connections.
- database clusterpart of · A database cluster is a group of coordinated networked database servers that jointly provide database storage and processing.
- pointkind of · A point is a zero-dimensional location in a geometric or coordinate space, commonly represented by an ordered set of coordinate values.
- trianglepart of · A triangle is a polygon with three sides and three vertices.
Questions about node
What is node?
A node is a discrete element of a graph, tree, linked structure, network, or computing system that can represent an entity, state, or component and may connect to other elements.
Which Manning books explain node?
Grokking Data Structures, ScyllaDB in Action, The Coder Cafe, AI Agents and Applications, Grokking Machine Learning, D3.js in Action, Third Edition, Graph Neural Networks in Action, Grokking AI Algorithms, Second Edition and 12 more.
What should I know before learning node?
Manning books that teach node usually introduce language model, graph, data structure and graph database first.
What kinds of node are there?
Kinds of node include action node and branch node.
What is node a kind of?
Node is a kind of point. A point is a zero-dimensional location in a geometric or coordinate space, commonly represented by an ordered set of coordinate values.
What is node part of?
Node is part of graph. A graph is a mathematical structure consisting of vertices and edges that connect pairs of vertices to represent relationships or connections.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.



















