Edge
An edge is a connection between two vertices or nodes in a graph or related structure, representing a relationship and optionally carrying direction, labels, or weights.
Authorization in Action
A relationship edge is a graph connection that records an association between entities or between an entity and a resource.
- How it is used
- Uses relationship edges to support dynamic authorization for shared resources and collaborative systems.
- How deep it goes
- Explains named relationship links, stored tuples, graph traversal, and membership modeling, including a contrast with embedded lists.
- Examples
- Illustrates viewer and ownership links for shared documents, plus employee-to-team membership in a collaboration platform.
- What you can do after
- Apply it via OpenFGA by defining relations and checking permissions against stored relationship tuples.
D3.js in Action, Third Edition
A network edge, also called a link, is a connection between two nodes in a network or graph.
- How it is used
- Represents connections between nodes so network visualizations can display relationship patterns.
- How deep it goes
- Defines endpoints, direction, and weight, then shows how to prepare edge data and render links as paths.
- Examples
- Uses shared scenes between characters as weighted edges and parent-child links in a language tree chart.
- What you can do after
- Build it from scratch by preparing an edge list and drawing its connections with D3.
Grokking Data Structures
A tree link is a connection from one tree node to another tree node, typically representing a parent-child relationship.
- How it is used
- Connects nodes to express parent–child relationships and paths through a tree.
- How deep it goes
- Defines links through parents, children, leaves, and unique paths, but does not implement tree links.
- Examples
- Illustrates a root linked to children valued 2 and 8, then contrasts friendship edges in a graph.
- What you can do after
- Evaluate/understand it by identifying parents, children, leaves, and paths from a tree’s links.
Advanced Algorithms and Data Structures
An edge is a connection between two vertices in a graph, represented here by an ordered pair of endpoints.
- How it is used
- Models relationships, permitted movement, routes, recommendations, databases, circuit boards, and visual process flows.
- How deep it goes
- Defines endpoints, direction, loops, multiplicity, and weights, then applies edges to route and visualization models.
- Examples
- Uses product associations, ordered-pair listings, delivery maps, flow charts, circuit boards, and graph drawings.
- What you can do after
- Build graph models by selecting endpoints, direction, loops, multiplicity, and weights for concrete applications.
Read how Advanced Algorithms and Data Structures explains edge →
Graph Neural Networks in Action
An edge is a graph element representing a relationship or connection between nodes and optionally carrying attributes or properties.
- How it is used
- Represents relationships chosen when converting raw or tabular data into a graph for analysis and GNN training.
- How deep it goes
- Defines links, illustrates binary and weighted adjacency entries, and discusses graph-construction choices without specifying edge-level model internals.
- Examples
- Uses passenger family and cabin ties, investor co-investment, and job-candidate referrals to illustrate possible edges.
- What you can do after
- Build it from scratch by choosing relationships, direction, weights, and attributes before preparing a graph for a GNN.
Knowledge Graphs and LLMs in Action
A relationship, or edge, is a graph connection representing a meaningful association between nodes.
- How it is used
- Connects entities in knowledge graphs, individuals in fraud networks, or agent functions in executable workflows.
- How deep it goes
- Explains semantic direction, undirected modeling, properties, and dynamic routing, but does not develop edge algorithms independently.
- Examples
- Uses healthcare entity associations, Jane Austen–WORKS_FOR–Google, a NetworkX fraud network, and LangGraph agent routing.
- What you can do after
- Build graph connections in NetworkX, model extracted relations consistently, or configure execution paths in LangGraph.
Read how Knowledge Graphs and LLMs in Action explains edge →
Natural Language Processing in Action, Second Edition
An edge is a graph relationship connecting two nodes or vertices.
- How it is used
- Represents relationships in social networks, semantic graphs, knowledge graphs, and chatbot conversation designs.
- How deep it goes
- Explains directed and undirected forms, weighted similarity connections, and graph construction, but defers general graph algorithms.
- Examples
- Uses friendship, social-network following, sentence similarity, knowledge triples, and chatbot state transitions as concrete edge examples.
- What you can do after
- Build it from scratch by connecting nodes with NetworkX edges, assigning weights, and plotting the resulting graph.
Read how Natural Language Processing in Action, Second Edition explains edge →
Learn Haskell by Example
An edge is a graph relationship that connects one node to another, optionally with a specified direction.
- How it is used
- Uses edges to build a word-ladder graph whose paths can be searched for a shortest transformation chain.
- How deep it goes
- Defines directed and undirected edges, then implements directed-edge insertion, duplicate handling, bulk insertion, and child lookup.
- Examples
- Uses English word ladders and a directed integer graph with edges such as `(3,2)` and `(3,1)`.
- What you can do after
- Build from scratch a directed graph API that adds edges and retrieves a node's connected children.
Financial AI in Practice
A connection between vertices in a graph, representing a relationship or interaction.
- How it is used
- Models relationships between financial entities to reveal connections missed by transaction-level fraud analysis.
- How deep it goes
- Defines edges and their properties, then constructs weighted co-occurrence edges from transaction data.
- Examples
- Illustrates transaction, ownership, shared-identifier, and account-transfer edges, plus a chargeback graph linking users and merchants.
- What you can do after
- Apply edges via NetworkX to construct a weighted graph for investigating transaction co-occurrences.
Optimization Algorithms: AI techniques for design, planning, and control problems
An edge is a graph connection between two vertices, optionally representing a directed or weighted relationship.
- How it is used
- Models relationships and transitions between vertices for graph construction, traversal, routing, and search.
- How deep it goes
- Defines edge direction, multiplicity, and weights, then connects them to NetworkX construction and shortest-path search.
- Examples
- Uses NetworkX graphs, parallel roads, device connections, social relationships, and University of Toronto road segments.
- What you can do after
- Build graph connections with NetworkX and select direction, multiplicity, or weights for routing and search problems.
The Coder Cafe
An edge is a directed connection between two vertices that carries flow and has a capacity limit.
- How it is used
- Uses edges to express graph connections, task dependencies, and capacity-limited routes through flow networks.
- How deep it goes
- Defines edge types and compares their storage costs, then applies capacity-limited edges to augmenting paths without specifying a general edge implementation.
- Examples
- Illustrates edges with social connections, travel times, job dependencies, water pipes, and bandwidth-limited data networks.
- What you can do after
- Evaluate/understand whether a connection has direction, weight, or available capacity and choose a graph representation by lookup and space costs.
AI-Powered Search
An edge is a graph element representing a relationship between two nodes.
- How it is used
- Models relationships in knowledge graphs and enables traversal-based inference in search applications.
- How deep it goes
- Defines edges, explains traversal and document-set construction, and demonstrates typed relationships without detailing graph-storage internals.
- Examples
- Uses an author-paper-conference graph and a Jean Grey traversal through an "in love with" relationship.
- What you can do after
- Apply it via SKG traversal to model or discover relationships from document-set intersections and relationship queries.
Build Python Web Apps with Streamlit
A graph edge is a connection between two graph nodes that represents a relationship or execution transition.
- How it is used
- Models relationships between objects and execution flow between state-transforming actions.
- How deep it goes
- Explains graph connections, direction, execution order, and state transfer without detailing implementation APIs.
- Examples
- Uses social-network friendships, LangGraph workflows, and a sum-of-squares computation as concrete graph examples.
- What you can do after
- Apply it via LangGraph to represent which application actions execute next and exchange updated state.
Read how Build Python Web Apps with Streamlit explains edge →
Digital Twins in Action
A geometric edge is a line segment connecting two vertices in a polygonal model.
- How it is used
- Uses edges as surface boundaries in polygon meshes for digital-twin visualization.
- How deep it goes
- Defines edges and related mesh primitives, then illustrates their use in a cube without detailing edge-specific storage or algorithms.
- Examples
- Provides a text-based OBJ cube with vertex coordinates, face normals, and quadrilateral face definitions.
- What you can do after
- Build it from scratch by defining vertices, faces, and normals in a text-based 3D model.
AI Agents and Applications
An edge is a LangGraph graph connection that determines how execution moves between nodes, optionally according to a condition.
- How it is used
- Connects LangGraph processing nodes and routes execution through fixed or state-dependent workflow paths.
- How deep it goes
- Defines fixed, conditional, entry, and terminating transitions with implementation examples, but does not detail edge internals.
- Examples
- Uses research refinement, result summarization, and LLM-tool loops to demonstrate fixed and runtime-selected transitions.
- What you can do after
- Apply it via LangGraph to construct directed workflows, route on runtime state, terminate execution, and debug data flow.
Spring in Action, Sixth Edition
An entity relationship is an association between persisted domain entities represented in an application's data model.
- How it is used
- Models associations between persisted domain entities when implementing reactive persistence.
- How deep it goes
- Explains relationship-storage alternatives and their trade-offs, but stops short of implementing relationship loading.
- Examples
- Uses Taco ingredient IDs and TacoOrder taco IDs stored in sets and database array columns.
- What you can do after
- Apply it via Spring Data R2DBC by choosing an explicit storage strategy for related entity identifiers.
Sutskever's List
An edge is a graph element representing a relationship between two nodes and optionally carrying attributes.
- How it is used
- Represents molecular bonds in graph-based learning for predicting molecular properties.
- How deep it goes
- Defines molecular edges and explains virtual connections for message propagation without detailing their implementation.
- Examples
- Uses molecular bonds as physical edges and added virtual edges between unconnected atoms.
- What you can do after
- Understand how physical and virtual edges support message passing in molecular graphs.
Grokking Algorithms, Second Edition
An edge is a connection between two vertices in a graph, optionally representing a direction from one vertex to another.
- How it is used
- Models relationships between nodes for network searches, dependencies, and hierarchical structures.
- How deep it goes
- Explains direction, neighbor terminology, Python representation, runtime impact, dependencies, and trees through concrete examples.
- Examples
- Uses poker debts, social connections, Python adjacency lists, morning-task dependencies, and family trees.
- What you can do after
- Build it from scratch by representing directed graph edges with Python hash tables and lists.
Read how Grokking Algorithms, Second Edition explains edge →
Event Processing in Action
An edge is a connection between vertices in a graph, and in a directed graph it has an assigned direction.
- How it is used
- Represents event-instance flow between processing elements in an event processing network.
- How deep it goes
- Defines terminal connections and explains branching and merging, while leaving event ordering implementation-dependent.
- Examples
- Shows one agent sending event copies to two consumers and a consumer receiving events through multiple links.
- What you can do after
- Understand how links represent event flow, distribute copies, and bring interleaved events to an input.
Fabulous Adventures in Data Structures and Algorithms
An edge is a graph or tree connection from one node to another that may carry a label.
- How it is used
- Represents character-labeled transitions while traversing and constructing a trie.
- How deep it goes
- Defines labels, targets, traversal, lookup, and creation, but does not develop general graph algorithms.
- Examples
- Uses a C# trie node whose Dictionary<char, Node> stores outgoing character-labeled edges.
- What you can do after
- Apply edge accessors to traverse, inspect, and extend a mutable trie node.
Read how Fabulous Adventures in Data Structures and Algorithms explains edge →
Also covered in
- Graph Algorithms for Data Science
- Interview Speak
- Building User-Friendly DSLs
- Learn SQL in a Month of Lunches
- Grokking Relational Database Design
- Data-Oriented Programming: Reduce software complexity
- Acing the CCNA Exam: Volume 2 Advanced Networking and Security
- Crack Any Codebase with AIIn early access (MEAP)
- Software Security for Developers
- Geometry for Programmers
- Data Analysis with LLMs
- Classic Computer Science Problems in Swift: Essential techniques for practicing programmers
What to know first
- graphA graph is a mathematical structure consisting of vertices and edges that connect pairs of vertices to represent relationships or connections.
- language modelA language model is a computational model that represents patterns in linguistic sequences to assign probabilities, predict, generate, or evaluate language.
- 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.
- entityAn entity is a distinct, identifiable object, concept, participant, or record represented in a system's model or data.
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.
- weighted edgeincludes · A weighted edge is a graph edge associated with a value representing a cost, distance, capacity, or other connection attribute.
- cycleincludes · A cycle is a path in a graph that starts and ends at the same vertex.
- crossing edgeincludes · A crossing edge is an edge in a graph drawing that intersects another edge at a point other than a shared endpoint.
- multiple edgeincludes · A multiple edge is one of two or more distinct edges connecting the same pair of vertices in a multigraph.
- shortcut edgeincludes · An added graph edge representing a path through contracted nodes while preserving the path's total cost.
Questions about edge
What is edge?
An edge is a connection between two vertices or nodes in a graph or related structure, representing a relationship and optionally carrying direction, labels, or weights.
Which Manning books explain edge?
Authorization in Action, D3.js in Action, Third Edition, Grokking Data Structures, Advanced Algorithms and Data Structures, Graph Neural Networks in Action, Knowledge Graphs and LLMs in Action, Natural Language Processing in Action, Second Edition, Learn Haskell by Example and 12 more.
What should I know before learning edge?
Manning books that teach edge usually introduce graph, language model, graph database and entity first.
What kinds of edge are there?
Kinds of edge include weighted edge, cycle, crossing edge, multiple edge and shortcut edge.
What is edge part of?
Edge 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.
What is edge also called?
Edge is also called relationship, links, association, relations or arc.
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.



















