Node
A node is a discrete element in a structured system, such as a graph, tree, network, or distributed system, representing an entity, state, component, or computational unit and potentially connected 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.
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 individual processing tasks in stateful LangGraph workflows, including research pipelines and tool-based agents.
- How deep it goes
- Works through node inputs, returned state updates, registration, and edge routing; advises single-task nodes without detailing execution internals.
- Examples
- Uses research query generation, an LLM-and-tools agent loop, and a no-op guardrail refusal node.
- What you can do after
- Build it from scratch by defining state-reading functions, returning updates, registering nodes, and connecting them with fixed or conditional edges.
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 as states in graph search, positions in tree paths, and inputs or outputs in neural networks.
- How deep it goes
- Defines node relationships and walks through their use in depth-first search, without developing graph theory proofs.
- Examples
- Illustrates nodes with road-trip stops, a maze-search Python listing, and pixel inputs for handwritten-digit recognition.
- What you can do after
- Build it from scratch: represent connected states and use a stack, visited list, and parent links to search a maze.
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
- Represents financial entities so investigators can trace relationships hidden by transaction-level analysis.
- How deep it goes
- Defines nodes against edges and properties, then shows typed-node construction and graph-count checks without detailing node-specific algorithms.
- Examples
- Uses a shared merchant in a chargeback investigation and a typed NetworkX graph built from transaction entity columns.
- What you can do after
- Apply it via NetworkX to create typed entity nodes, check graph size, and prepare relationships for community detection.
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 →
Related concepts
- graphpart of · A graph is a mathematical structure consisting of vertices connected by edges that represent relationships or connections.
- pointkind of · A point is a zero-dimensional location in a geometric or coordinate space represented by an ordered set of coordinate values.
- trianglepart of · A triangle is a polygon bounded by three line segments joining three noncollinear vertices.
- database clusterpart of · A database cluster is a group of coordinated networked database servers that jointly provide database storage and processing.
- knowledge graphpart of · A knowledge graph is a graph-structured representation of entities and their semantically meaningful relationships, often including associated attributes or facts.
- root nodeincludes · A root node is the designated starting node of a rooted tree or hierarchy, with no parent within that structure.
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.