Are Graphs Useful for LLMs? A Comprehensive Survey of Graph-Enhanced Large Language Models

1. Introduction

Large language models (LLMs) [1,2,3] are foundation models with billions of parameters, typically built on the Transformer architecture [4] and pretrained on massive corpora. Under this paradigm, LLMs show impressive capabilities in natural language understanding, generation, and reasoning, enabling them to generalize across diverse tasks with minimal task-specific adaptation.

In practice, LLMs operate within a pipeline that organizes information flow from input to output. (1) In the input phase, task specifications and external knowledge are introduced. This is done using techniques like few-shot prompting [1], retrieval-augmented generation (RAG) [5], or by feeding the model curated training data. These methods help shape how the raw information is presented to LLMs. (2) Next, the model focuses on processing these inputs. Transformer-based architectures use attention mechanisms and feedforward layers to process information sequentially. They can also be extended with multi-agent systems [6,7] to coordinate multiple models through interaction. (3) Finally, in the output phase, LLMs generate task-specific responses. These responses can include question answering, executable code, or decision support, serving as the interface between model predictions and downstream applications.

Despite their impressive performance, LLMs have inherent limitations, primarily due to their reliance on linear token sequences. Such sequential models struggle to capture complex relational structures, long-range dependencies, and multi-hop interactions, which are crucial for many knowledge-intensive tasks [8]. Moreover, reasoning and planning processes are often encoded implicitly in latent representations. This makes intermediate states difficult to interpret, control, or verify systematically [9]. LLMs are also vulnerable to factual inconsistencies and hallucinations, especially when tasks require precise relational reasoning or reliable knowledge grounding. These challenges highlight the limitations of sequence-centric models in tasks that require explicit structure, transparency, and robustness [10].

To address these limitations of LLMs, graphs provide complementary solutions. Graphs are non-Euclidean structures composed of nodes and edges that capture complex relationships. By explicitly encoding these relationships, they support multi-hop reasoning and represent non-linear structures effectively. Additionally, graphs offer transparent, structured intermediate states that improve interpretability and verification. By integrating external knowledge graphs (KGs) [11], they also enhance factual grounding, reducing hallucinations and improving reliability. According to the 2025 Gartner Data & Analytics Summit1, graph technologies are projected to drive 80% of data and analytics innovations by 2026, acting as a foundational enabler to provide structured contextual knowledge for LLMs and systematically enable data to become AI-ready.

Building on the potential of graphs to address LLM limitations, graph-enhanced LLMs, which we refer to as Graph4LLM, leverage relational structures to handle complex, interconnected data more effectively. As a result, a growing body of work has emerged exploring diverse Graph4LLM paradigms and architectures. Despite this rapid development, research on Graph4LLM remains fragmented across communities and applications, making it necessary to provide a comprehensive categorization.

To better understand this gap, it is useful to distinguish two main research directions at the intersection of graphs and LLMs. In the LLM4Graph paradigm, LLMs are applied to enhance graph learning tasks, bringing strong semantic understanding and generative capabilities to traditional graph mining. Correspondingly, the bulk of existing surveys [12,13,14,15,16,17,18,19] focus on this forward direction, systematically reviewing frameworks, methods, and applications of LLMs for graph tasks. In contrast, investigations into the reverse paradigm of graphs enhancing LLMs have received far less attention in existing surveys. Even the few surveys that cover Graph4LLM tend to focus on specific subareas rather than providing a unified view: some delve exclusively into KG-augmented LLMs [20,21,22,23,24], some concentrate on graph-based retrieval-augmented generation frameworks [5,25,26,27], and others deploy graphs as structural scaffolds for multi-agent coordination and long-term memory. This fragmented coverage leaves a gap in understanding how graph structures can broadly address the inherent limitations of LLMs.

In contrast, this paper significantly expands our previous study [28] to provide the first comprehensive, pipeline-oriented survey of Graph4LLM, introducing a more refined taxonomy and coverage of the latest papers. Specifically, we categorize existing works according to the three phases of the LLM pipeline (Figure 1): (1) In the input phase, graphs are used to transform complex and scattered information into structured prompts, enabling LLMs to clearly capture key entities and relations. (2) In the model phase, graphs shape the internal processing of a single model or organize interactions across multiple models, enabling controlled information flow and task coordination. (3) In the output phase, graphs reorganize LLM responses into structured representations, making intermediate steps and dependencies easy to inspect and verify. Based on this taxonomy, we further organize methods within each phase and analyze their key design choices and trade-offs.

The remainder of this paper is organized as follows. Section 2 presents the preliminaries related to Graph4LLM, including the relevant technologies of graphs and LLMs, as well as an overview of Graph4LLM. Section 3 reviews multi-granularity prompt construction and knowledge incorporation techniques in the input phase. Section 4 examines single- and multi-model graph-enhanced systems in the model phase. Section 5 focuses on graph-structured reasoning, planning, and evaluation techniques in the output phase. Section 6 surveys representative Graph4LLM applications, and Section 7 discusses open challenges and future research directions. Overall, this organization follows the LLM pipeline and enables a comprehensive review of Graph4LLM methods.

2. Preliminary

2.1. Graphs

Graphs effectively model complex interactions in real-world systems, including social networks [107], transportation networks [108], and biomedical networks [109]. Formally, a graph $G=(V,E)$ consists of nodes V and edges $E\subseteq V\times V$ encoding pairwise relations, which may be directed or undirected with associated attributes. Unlike sequential or grid data, graphs naturally capture non-Euclidean relational structures. Figure 2 illustrates the common graph structures used in Graph4LLM, including tree structures where reasoning thoughts are organized as nodes, directed acyclic graphs (DAG) that model multi-agent collaboration, and KGs that serve as external knowledge bases.

Graph formalization. Practically, graphs are represented via adjacency matrices, adjacency lists, or edge lists. For $N=\left|V\right|$ nodes, the adjacency matrix $\mathbf{A}\in {\mathbb{R}}^{N\times N}$ encodes connectivity (${\mathbf{A}}_{ij}$ indicates the edge from i to j), while node features are stored in $\mathbf{X}\in {\mathbb{R}}^{N\times d}$. These representations underpin most graph learning algorithms.

Knowledge graphs. Knowledge graphs (KGs) [11] represent factual knowledge as structured triples $(h,r,t)$, where $h,t$ are entities and r denotes the relation between them. By capturing semantic relationships, KGs are pivotal for reasoning and question answering. Common learning techniques include embedding methods that map entities and relations into continuous vector spaces while preserving relational constraints.

Graph neural networks. Graph neural networks (GNNs) [110] are a family of neural models designed to learn representations from graph-structured data. The core idea of GNNs is message passing, where each node iteratively aggregates information from its neighbors to update its representation [111]. A generic message-passing layer can be written as:

$${\mathbf{h}}_v^{\left(k\right)}={\varphi }^{\left(k\right)}\left({\mathbf{h}}_v^{(k-1)},\underset{u\in \mathcal{N}\left(v\right)}{⨁}{\psi }^{\left(k\right)}\left({\mathbf{h}}_u^{(k-1)},{\mathbf{e}}_{uv}\right)\right).$$

(1)

Here, ${\mathbf{h}}_v^{\left(k\right)}$ is the representation of node v at layer k, and $\mathcal{N}\left(v\right)$ denotes its neighbors. ${\mathbf{e}}_{uv}$ represents edge attributes. ${\psi }^{\left(k\right)}$ computes messages from neighbors, ${\varphi }^{\left(k\right)}$ updates the node by aggregating messages and its previous state, and ⨁ is a permutation-invariant aggregation (e.g., sum, mean, or max). Representative GNN architectures include GCNs [112], GATs [113], and GraphSAGE [114].

2.2. Large Language Models

Large language models (LLMs) [1,2,3] are a class of neural language models trained on massive text corpora to learn general-purpose linguistic and reasoning capabilities. Typically based on the Transformer [4] architecture, LLMs model token sequences via conditional probability and are trained with autoregressive objectives. Through large-scale pretraining, LLMs exhibit strong abilities in natural language understanding and generation. These capabilities are realized through various technologies at each phase of the LLM pipeline, as illustrated in Figure 3.

Input phase. The input phase acts as a bridge between raw task requirements, external knowledge, and the LLM’s sequential processing paradigm. Key techniques include prompt engineering [1], which designs prompts to guide in-context learning and align its behavior with specific task goals. Retrieval-augmented generation (RAG) [115] is another key technique. It retrieves task-relevant knowledge from external databases and incorporates it into the input prompt, reducing reliance on parametric memory and mitigating factual hallucinations. Additionally, instruction tuning [116] and supervised fine-tuning (SFT) [117] with curated datasets help LLMs capture the semantic and structural features of input information across downstream tasks.

Model phase. The underlying technologies in the model phase are mainly based on the Transformer architecture and its extended optimizations, as well as the collaborative mechanisms of multiple models. For an individual LLM, the focus lies on enhancing its parametric memory and structural adaptability. Techniques such as parameter-efficient fine-tuning (PEFT) techniques [118,119] can be viewed as lightweight modules that adapt internal representations without changing the weights of core models. For multiple LLM collaboration, LLM-based multi-agent systems (MAS) [6,7] have emerged as a key extension. They coordinate interactions between multiple LLMs through structured communication and enable task decomposition by defining agent roles and interaction rules.

Output phase. The output phase of LLMs focuses on generating coherent and task-relevant text from latent representations. Beyond simple next-token prediction, various techniques guide the generation process to improve reasoning quality. Reasoning methods [120], such as Chain-of-Thought (CoT) [121], encourage the model to generate explicit intermediate steps, improving performance on tasks requiring multi-step inference or logical deduction. These capabilities enable LLMs to handle complex tasks including multi-hop question answering, mathematical/logical reasoning, and causal inference. Building on this, planning techniques further extend generation from reasoning traces to structured action sequences. LLM planning methods [122] decompose goals into sequences of interdependent sub-tasks, allowing models to generate coherent plans rather than isolated responses. By decomposing complex tasks into manageable steps, planning supports tool use, workflow design, and strategic decision-making, leading to more accurate and executable results.

2.3. Graph4LLM

Graph4LLM refers to a class of methods that explicitly integrate graph structures into LLM–centric systems in order to enhance reasoning, knowledge utilization, and reliability. In this survey, we use Graph4LLM as an umbrella term to denote methods where graphs are not merely auxiliary data formats, but play a functional role in the overall system design and inference process.

At a high level, a Graph4LLM system consists of three core components: graph construction, graph–LLM interaction, and task execution. First, graph construction defines how structured representations are built. These graphs may encode entities and relations, intermediate reasoning states, agent interactions, or task dependencies. Second, graph–LLM interaction specifies how the graph is incorporated into the LLM workflow, including how graph information is queried, updated, or used to guide generation. Third, task execution describes how the combined system generates final outputs, potentially involving iterative reasoning, verification, or multi-step decision making.

3. Input Phase

The input phase of LLMs involves processing raw text, which is typically fed in a sequential manner. Graph4LLM input-phase methods extract knowledge from graphs or use them to index and organize text content. In this section, we categorize these methods based on the source of the graph structure (as shown in Figure 4): Prompt from Knowledge Graph, which utilizes pre-existing KGs; Prompt from Corpus-Level Graph, which constructs a global graph index from the text corpus; and Prompt from Instance-Level Graph, which induces ad-hoc structures based on specific input instances to guide generation.

3.1. Prompt from Knowledge Graph

Prompt from Knowledge Graph methods integrate existing KGs into LLM prompting pipelines to provide structured and reliable knowledge support. These methods rely on task-agnostic KGs and typically fall into two categories: Graph-Enhanced Instruction Tuning, which collects training data from KG facts and relations, and Graph-Retrieval Augmented Generation (Graph-RAG), which treats KGs as external knowledge databases for structured retrieval.

3.1.1. Graph-Enhanced Instruction Tuning

Graph-Enhanced Instruction Tuning modifies LLM parameters to better align internal representations with KG structures. This is achieved by constructing structure-aware instruction tuning data. Such data introduces explicit relational and logical information into training, enabling the model to generalize to more complex scenarios. Existing methods differ mainly in how training data are derived and formatted from KGs.

A line of work derives supervision signals from formal query languages (e.g., SPARQL), where KG reasoning processes are explicitly expressed as executable queries. To address low-resource knowledge graph question answering (KGQA), GAIL [103] employs Generative Adversarial Imitation Learning to fine-tune LLMs on synthetic data. This data is generated by translating sampled SPARQL queries into natural language to approximate real query distributions. ChatKBQA [102] reduces the syntactic complexity of graph query languages by fine-tuning LLMs to translate natural language questions into intermediate logical forms, rather than directly generating SPARQL queries. This semantic parsing paradigm effectively reduces syntax errors and improves query execution.

Another line of work avoids explicit query languages and instead constructs training data by directly traversing KG structures, such as subgraphs, neighborhoods, or paths, to capture relational patterns. GLaM [104] initiates this by transforming domain-specific KGs into text-based Q&A pairs. Graph neighborhoods are linearized into natural language to construct instruction tuning data. KG-SFT [105] uses subgraph extraction to identify relevant reasoning structures and generate explanations for each Q&A pair. It incorporates a knowledge conflict detector to filter unreliable paths, thus improving the model’s ability to handle complex relational knowledge during reasoning. Expanding from local subgraphs to global topology, CoFine [106] leverages KG community structures for fine-tuning. It partitions the graph into semantically homogeneous clusters using algorithms like Louvain [123]. Then, it utilizes random walks to capture relational chains within each community, converting these paths into chat-based interactions as training data that expose deep thematic patterns to the LLMs.

3.1.2. Graph-Retrieval Augmented Generation

Building on the same goal of leveraging KG structure, Graph-Retrieval Augmented Generation differs by keeping LLM parameters unchanged. It retrieves task-relevant subgraphs and leverages graph topology to support evidence-based reasoning in real time. Existing methods mainly differ in their retrieval and reasoning strategies to construct effective prompts.

One line of work treats the KG purely as a structured evidence source, focusing on retrieving relevant facts and feeding them to the LLMs while leaving all reasoning to the model itself. KAPING [95], for instance, retrieves relevant facts from KGs for the input question, prepends these facts to the question as a prompt, and feeds them to off-the-shelf LLMs for zero-shot KGQA. For unified reasoning over diverse structured data, StructGPT [96] designs specialized interfaces for KGs, tables and databases to extract evidence. It iterates an invoke-linearization-generation procedure, letting LLMs focus on reasoning to reach the answer. MindMap [97] retrieves multi-hop and neighborhood evidence from KGs, converts these subgraphs into natural language “mind maps”, and feeds them as prompts to guide inference. To address the trade-off between retrieval efficiency and effectiveness, SubgraphRAG [98] employs a lightweight multi-layer perceptron (MLP) with parallel triple-scoring to flexibly retrieve structure-aware subgraphs for zero-shot LLM reasoning.

In contrast, another line of work treats KGs not only as evidence but also as active guides that steer or constrain the reasoning process of LLMs. ToG [99] tightly couples LLMs with KGs by allowing the model to dynamically explore reasoning paths. It uses beam search over KG triples, enabling the LLMs to evaluate and prune paths in real time for optimal reasoning. RoG [100] frames reasoning as KG-grounded relation path planning: it first prompts the LLMs to generate relation-only templates, then retrieves matching entity paths from the KGs to ensure interpretable inference. To further enhance reliability, KGR [10] introduces iterative KG-based verification, treating KGs as an external fact checker that corrects LLM outputs across multiple rounds to reduce hallucinations. GNN-RAG [101] utilizes GNNs to process KG subgraphs, assigning relevance weights to nodes and extracting shortest paths to potential answer candidates. These paths are then verbalized as context for LLM RAG reasoning, with the system offering optional retrieval augmentation and routing.

3.1.3. Discussion

Prompt from Knowledge Graph methods provide LLMs with explicit factual and relational knowledge from curated sources. This helps the model ground its reasoning on reliable facts, improves performance on knowledge-intensive tasks, and makes the reasoning process more interpretable by exposing entity–relation structures.

However, these methods face challenges that are closely tied to the nature of KGs. KGs are often incomplete, inconsistent, or outdated, which can directly mislead the model. Aligning KG structures with natural language inputs is also non-trivial, as symbolic relations do not always match how information is expressed in text. In addition, retrieving useful subgraphs requires understanding both the query intent and the graph structure, which is difficult when relations are complex or sparsely connected.

Future work should focus on improving the alignment between structured knowledge and natural language understanding. Developing methods that can automatically detect and resolve inconsistencies in KGs will be important for reliability. More intelligent retrieval mechanisms that consider both semantic meaning and graph structure could help select truly relevant knowledge. Another direction is to enable continuous updating of KGs so that models can stay consistent with evolving real-world information.

3.2. Prompt from Corpus-Level Graph

In contrast to Prompt from Knowledge Graph, Prompt from Corpus-Level Graph constructs corpus-specific graph indices over unstructured text collections rather than relying on existing KGs. In this setting, nodes correspond to documents, entities, or concepts extracted from the corpus, and edges encode semantic or structural relations. Such graph indices enable LLMs to efficiently locate the associated textual content.

Traditional RAG methods often struggle with queries that require global understanding of the corpus. To address this limitation, recent work explores hierarchical structures for global information aggregation. GraphRAG [86] targets query-specific summarization over massive private corpora by constructing an entity KG from source documents. Crucially, the graph is partitioned into groups of closely related entities (communities) via community detection. Hierarchical summaries are then generated through a two-stage process: the system first prompts the LLMs to generate partial responses for each community, and subsequently synthesizes these into a cohesive global answer. RAPTOR [87], on the other hand, constructs a bottom-up hierarchical tree by recursively embedding, clustering, and summarizing text chunks. During inference, it retrieves directly from multiple abstraction levels within this tree, enabling the seamless integration of global themes and local details for complex reasoning. Despite these advances, hierarchical aggregation may still introduce retrieval redundancy, increase token usage (longer reasoning chains), and reduce control over intermediate summarization errors.

Recent work has shifted the focus from merely organizing information to optimizing the specific pathways and efficiency of the retrieval process. These methods seek to progressively exploit and reuse graph structures to improve generation efficiency while substantially reducing retrieval noise. LightRAG [88] employs graph-enhanced indexing and a dual-level retrieval paradigm to capture complex entity dependencies, enabling simultaneous low-level local and high-level global queries. Its incremental update algorithm ensures seamless data integration without costly full-graph reconstruction. Similarly, G-Retriever [89] formulates retrieval as a Prize-Collecting Steiner Tree optimization. It extracts compact subgraphs to reduce context length and mitigate hallucinations. Drawing inspiration from mammalian memory, HippoRAG [90] and its successor HippoRAG 2 [91] employ a neuro-symbolic approach that combines LLM extraction with Personalized PageRank, propagating relevance to diffuse relevance signals across KGs. To overcome domain-specific constraints, GFM-RAG [92] trains a general graph foundation model (GFM) [124] through a two-stage process on massive datasets comprising 60 KGs and 700k documents to learn transferable topological representations. PathRAG [93] directly targets retrieval redundancy by using flow-based pruning to extract critical relational paths, converting them into structured prompts that enhance logical coherence.

3.2.1. Discussion

Prompt from Corpus-Level Graph methods organize large text collections into structured graphs, allowing LLMs to navigate information beyond linear context windows. By capturing both local connections and global structure, these methods help the model retrieve more coherent and relevant information for complex queries.

A key challenge in this setting lies in the construction and abstraction of graphs from raw text. Hierarchical structures often introduce redundant information across different levels, which increases token usage and slows down inference. Errors from intermediate steps such as clustering and summarization can also propagate and affect final outputs. At the same time, methods that aggressively optimize retrieval may simplify the graph too much, for example, through excessive pruning or compression, causing important context to be missed. Achieving a good balance between global coverage and local precision is difficult in practice.

Future work can focus on improving how corpus information is structured rather than simply making construction more efficient. Better methods are needed to preserve important details during abstraction while still enabling scalable retrieval. Designing adaptive graph structures that can reorganize based on query intent may also improve performance. Another promising direction is to jointly optimize graph construction and retrieval, so that the structure directly supports downstream usage instead of being built independently.

3.3. Prompt from Instance-Level Graph

Unlike the previous two paradigms, Prompt from Instance-Level Graph does not rely on pre-built KGs or corpus-level indices. Instead, it constructs graphs on the fly for each input instance, transforming a logically complex query into a structured representation. This graph is then linearized into semi-structured text, preserving structure while staying compatible with standard LLM inputs.

Basically, graph structures are used to improve how models select and organize in-context examples. For example, GRL-Prompt [84] constructs a task-specific KG to encode correlations between the query and candidate demonstrations. A policy network, trained via reinforcement learning with reward shaping, selects and orders in-context examples to construct optimal prompts. By leveraging this instance-driven, structured approach, the framework can identify informative examples and arrange them effectively.

Beyond example selection, graphs are further used to expose and guide the reasoning process. Instead of treating reasoning as implicit token generation, these methods explicitly organize intermediate logic. To address chronological confusion in narrative understanding, TG-LLM [82] converts textual narratives into temporal graphs to enhance the learning of temporal dependencies. This structured representation allows the model to reason over diverse temporal concepts through strategies such as CoT bootstrapping and graph data augmentation. Similarly, RwG [83] constructs explicit graphs directly from the context to bridge information gaps in logical reasoning tasks. By structuring implicit knowledge into pairwise entity relationships, the framework enhances the ability of LLMs to understand multi-hop dependencies and implicit connections.

At a larger scale, graph structures become a way to organize the entire reasoning workflow. Rather than optimizing individual prompts or reasoning steps, these approaches treat graphs as a global control mechanism. SGP [85] provides a task-agnostic three-stage prompting framework that directs models to convert unstructured text into graph representations, plan navigation strategies, and execute reasoning by traversing the graph step by step. This decomposition enables more controllable multi-step reasoning across diverse natural language scenarios. For extreme long-context challenges, GraphReader [81] structures extensive documents into navigable graphs to facilitate processing. Instead of feeding the entire document into the model, the framework deploys an autonomous agent that iteratively explores the graph in a query-guided manner. This mechanism allows the model to handle massive contexts up to 256k tokens while operating within a limited 4k context window, demonstrating superior performance on various long-text benchmarks.

3.3.1. Discussion

Prompt from Instance-Level Graph methods dynamically construct structured representations for each input, organizing complex relationships such as temporal, logical, or dependency connections. This helps the model better understand how different pieces of information are related, especially in long or interdependent inputs, leading to more informed decisions.

The main challenge here lies not only in efficiency but also in reasoning stability. Since the graph is built on the fly, small mistakes in early steps, such as missing nodes or incorrect relations, can quickly affect later decisions. This makes the overall process sensitive to noise and difficult to debug. In addition, different tasks may require very different graph structures, and there is no clear standard for how these graphs should be constructed, which limits generalization across tasks.

Future work should focus on making instance-level graph reasoning more stable and adaptive. Methods that can verify or refine intermediate graph structures during reasoning could help reduce error accumulation. It is also important to develop more unified frameworks that can flexibly adjust graph structures without heavy task-specific design. Finally, integrating lightweight feedback mechanisms into the reasoning loop may help the model actively correct itself and improve robustness.

4. Model Phase

The model phase of LLMs concerns both the internal architecture of the model and the way multiple agents collaborate. Graph4LLM model-phase methods introduce graph structures as explicit relational priors that complement the sequence-centric inductive bias of LLMs. Existing methods can be broadly categorized into two paradigms (as shown in Figure 5): Single Model, where graph modules are integrated into one LLM backbone with varying depth of fusion, and Multiple Models, where graphs specify or learn the communication topology and task dependencies among multiple models/agents.

4.1. Single Model

In the field of graph-enhanced single model, the core goal is to integrate structured graph signals within the LLM framework. This aims to improve the model’s ability to process relational and structural information within a unified architecture. Broadly, existing strategies can be grouped into two paradigms: External Graph Adapter, which adds graph encoders before LLMs to fuse graph features, and Internal Model Fusion, which embeds structural interactions deeply into the model’s layers for bidirectional influence.

4.1.1. External Graph Adapter

External Graph Adapter aims to inject structural signals through auxiliary graph encoding modules, while keeping the LLM backbone parameters (e.g., multi-head attention and feed-forward layers) largely frozen or only lightly fine-tuned. These methods typically employ dedicated graph encoders (e.g., GCNs, GATs) to encode graph topologies, and subsequently map the structured features into the natural language representation space of the LLM through lightweight projection or adaptation mechanisms. Existing works exhibit high diversity in specific feature alignment and projection mechanisms.

A dominant line of work encodes graphs into dense embeddings and injects them into LLMs through lightweight projection or adaptation modules, without explicitly preserving graph topology. KoPA [76] introduces a Knowledge Prefix Adapter that projects KG-derived embeddings into virtual tokens prepended to the prompt, enabling structure-aware reasoning through prefix conditioning. GraphAdapter [78] extends this strategy to text-vision settings by constructing a dual KG over textual and visual structures, and injecting cross-modal structural knowledge via a textual adapter to improve downstream classification. In domain-specific scenarios, MolCA [79] aligns molecular graphs with text via a cross-modal projector (e.g., Q-Former) and employs lightweight low-rank adaptation (LoRA) for model optimization.

In contrast, recent approaches aim to preserve graph topology more explicitly when interfacing with LLMs. To mitigate LLM hallucinations, FtG [77] adopts a filter-then-generate framework, formulating KG construction as a multiple-choice task. It further uses ego-graph serialization and a structure-text adapter to better align topology with text. Graph Tokenization [80] advances the interface to the vocabulary level by introducing reversible graph serialization and graph byte pair encoding (BPE), enabling the learning of structure-aware tokens without breaking subgraph connectivity. This allows standard Transformers to process graph structures similarly to text, without modifying the backbone model.

4.1.2. Internal Model Fusion

In contrast to External Graph Adapter that remains at shallow alignment, Internal Model Fusion advocates breaking the architectural boundary between LLMs and GNNs, embedding graph structure interaction mechanisms into the internal computational layers of the LLM. A common design interleaves Transformer layers with GNN-style message passing or introduces cross-stream modules for bidirectional exchange between token and graph layers.

A highly representative fusion strategy involves constructing explicit layer-wise interleaving and bidirectional interaction modules. GreaseLM [71] interleaves pretrained language model (PLM) and GNN layers to enable iterative exchange between token and graph representations, achieving bidirectional grounding between language context and structured knowledge. Similarly, GraphFormers [72] binds Transformer and GNN modules layer by layer, injecting neighborhood aggregation after each layer to progressively enhance structure awareness.

Beyond such layer-wise coupling, another line of work internalizes graph signals by modifying the self-attention mechanism. GIT [8] introduces a graph-induced attention mechanism that encodes graph connectivity and shortest-path distances as attention patterns. This injects structural inductive biases into the Transformer, encouraging the model to prioritize topologically closer entities during attention computation.

Furthermore, some works explore internal graph routing and fusion mechanisms within the model. GNNavi [73] adopts a lightweight yet effective strategy by inserting a small number of GNN navigation layers into a frozen LLM decoder, where prompt-induced temporary graphs act as routing signals to guide message passing and regulate information flow in few-shot scenarios. KG-Adapter [74] extends internal fusion to decoder-only LLMs by introducing a dedicated adapter that encodes both node-centric and relation-centric knowledge, performing structural integration before each attention computation. At the pre-training level, Patton [75] learns structure-aware representations by jointly modeling text and large-scale network links, implicitly encoding topology into the foundation model.

4.1.3. Discussion

Single-model methods directly integrate graph structure into the internal computation process of a model. This allows the model to learn structured representations together with language understanding in one unified system. As a result, the model can better capture relational information and improve reasoning on tasks that depend on structured inputs, without relying heavily on external retrieval or extra prompting.

At the same time, these methods face several practical challenges. External adapters often rely on projecting graph features into the text space, which can weaken structural signals when graph structures become complex. Internal fusion methods introduce additional components such as GNN layers or modified attention mechanisms, increasing model complexity and training cost. This makes them harder to scale and deploy. Compatibility is another concern, since different graph types and tasks may require different designs, limiting generalization. When graph and language representations are tightly coupled, it also becomes more difficult to identify and analyze errors.

Future work can focus on designing more efficient ways to integrate graph structure without adding significant computational overhead. Improving how structural information is preserved during alignment will help maintain important graph signals. More flexible model designs are needed so that a single framework can handle different graph types and tasks. It is also promising to explore hybrid strategies that combine lightweight adaptation with selective deeper integration. Finally, better pre-training approaches with diverse graph and text data may help models learn more general and robust structural patterns.

4.2. Multiple Models

Unlike single-model methods, graph-enhanced multiple models leverage graphs to coordinate interactions, communication flows, and task dependencies across multiple models or agents. These methods are categorized into Static and Dynamic Topology. Static Topology relies on predefined graph structures to ensure controllable orchestration and reduce redundant communication. Dynamic Topology, by contrast, adapts the graph at runtime through learning, pruning, or generation mechanisms, providing greater flexibility and responsiveness in multi-agent collaboration.

4.2.1. Static Topology

Static Topology uses a fixed collaboration graph to define communication links and artifact flows in multi-agent systems. The graph is predefined based on human priors or task logic (e.g., directed acyclic pipelines, hierarchical structures, or fixed role graphs), focusing on optimizing message passing and role execution. Within this paradigm, existing methods mainly differ in the source of the predefined collaboration graph.

Task-dependency graphs (TDGs) are a core application of static topology. In multi-step reasoning or code generation, tasks often follow a strict sequential order. FLORA [66] abstracts agent workflows into a DAG, using graph message passing to efficiently evaluate and predict multi-agent collaboration. To improve scalability, MACNET [67] organizes hundreds or thousands of LLM agents into a topologically sorted DAG, allowing unidirectional message passing to support asynchronous parallel collaboration and avoid the communication explosion of fully connected architectures. S-DAG [68] extends this to cross-disciplinary problem solving by pre-constructing a subject-based DAG across multiple knowledge bases and statically assigning expert models along with their derivation sequences.

Beyond task-flow-based partitions, static topologies also frequently manifest as predefined social role networks. CAMEL [69] adopts a hard-coded binary role interaction pattern, achieving highly enclosed autonomous exploration mechanisms through a pre-set “AI User” and “AI Assistant” role graph. TAPE [70] utilizes hierarchically structured preset collaboration trees, establishing strict top-down communication links between high-level planners and low-level executors.

4.2.2. Dynamic Topology

Addressing the rigidity of Static Topology in open-domain tasks, Dynamic Topology uses a variable collaboration graph that can be learned or generated at runtime. These methods allow agents to dynamically adjust connections based on current inputs, states, or feedback, offering greater flexibility in multi-agent coordination. Existing methods mainly differ in how and when the collaboration structure is adjusted or constructed.

One representative line of work focuses on graph topology sparsification and communication cost optimization. AgentPrune [59] learns to remove redundant edges from dense interaction graphs, showing that sparse topologies can reduce API costs while even improving decision accuracy by filtering noise. GPTSwarm [60] further treats agents and their connections as a differentiable system, jointly optimizing node prompts and edge-level data flow to discover task-specific graph structures during execution.

Another important line of work emphasizes instant graph generation and selection based on input sample features. AMAS [61] is based on the observation that there is no one-size-fits-all optimal communication topology for different input samples within the same dataset. Therefore, it constructs a dynamic graph selector that adaptively picks the most suitable collaboration graph structure from a pre-maintained pool of candidate topologies upon receiving a new input. DyLAN [62] focuses on evolution during the execution process, dynamically evaluating the current contribution scores of each agent across multiple rounds of reasoning, selectively culling marginal nodes and rewiring core nodes in real-time. In the domain of inference-time structure generation, Graph-of-Agents (GoA) [63] breaks the limitations of traditional single-thread dialogues by dynamically instantiating agents and establishing graph connections, achieving massive nonlinear context extension. Recent frameworks like CARD [64] and AgentNet [65] have also systematically explored how to leverage the LLMs’ own meta-reasoning capabilities to allocate role nodes and automatically construct interaction networks on the fly during runtime.

4.2.3. Discussion

Multi-model methods use graph structures to coordinate multiple agents, where the graph defines how agents communicate, share information, and split tasks. This turns the system into a collaborative network rather than a single-model reasoning system. Such designs are effective for complex problems because they allow parallel processing, flexible role assignment, and better handling of long or multi-step workflows. They are especially useful when different subtasks require different expertise.

However, this setting also introduces new challenges. Designing an effective collaboration structure is not straightforward, as static graphs may be too rigid for open-ended tasks, while dynamic graphs can be unstable and harder to control. Communication overhead becomes a key issue when many agents are involved, especially if messages are not well filtered. Coordination errors may arise when agents have inconsistent views or produce conflicting outputs. In addition, dynamically adjusting the graph requires extra computation and reliable signals for decision-making, which is still difficult in practice. Evaluating these systems is also challenging, since performance depends not only on individual agents but also on their interactions.

Future work can focus on improving the balance between structure and flexibility, so that systems remain stable while adapting to different tasks. More efficient communication strategies are needed to reduce unnecessary message passing. Better mechanisms for conflict resolution and coordination will help maintain consistency across agents. It is also promising to explore learning-based approaches that can automatically design and refine collaboration graphs over time. Finally, developing clearer evaluation frameworks may provide better insights into how multi-agent interactions contribute to overall performance.

5. Output Phase

The output phase of LLMs generates text sequences based on the internal representation and the received context. Graph4LLM output-phase methods represent LLM responses as graphs to clarify the thinking process, enabling more structured and verifiable outputs. We categorize existing methods into three directions based on the function of the graphs (as shown in Figure 6): Reasoning, which represents and traverses intermediate inference states; Planning, which organizes multi-step decision making and action sequences; and Evaluation, where graphs serve as structured references for verifying and scoring generated content.

5.1. Reasoning

Graph-based reasoning uses graph structures to organize reasoning thoughts as relationships and dependencies between entities, improving the clarity and interpretability of model outputs. Methods in this category fall into two primary categories: Reasoning Based on Node Summarization, which consolidates information around key nodes to guide reasoning, and Reasoning Based on Path Exploration, which performs reasoning by selecting and traversing paths in a structured space.

5.1.1. Reasoning Based on Node Summarization

Reasoning Based on Node Summarization organizes the reasoning process around central nodes that aggregate information from multiple steps. Each node acts as an information hub, condensing partial conclusions. The reasoning process converges to a final node where relevant information is summarized and synthesized into the output. Existing methods differ mainly in how reasoning nodes are structured and updated.

At the structured reasoning level, several methods adopt hierarchical or tree-based organizations to iteratively refine node summaries. THOUGHTSCULPT [54] adopts a search-driven formulation within a Monte Carlo tree search (MCTS) framework. It integrates a thought generator, an evaluator, and a decision simulator, while iteratively revising node-level summaries. RATT [55] similarly leverages tree-structured reasoning, but emphasizes path evaluation and branch selection, using node representations to identify promising reasoning trajectories.

Beyond explicit tree structures, node summarization can be extended to more flexible graph-based or compositional reasoning paradigms. CR [58] organizes intermediate propositions into a dynamically constructed DAG, where nodes represent verified reasoning units. Through a proposer, a verifier, and reporter roles, it incrementally validates and aggregates node-level conclusions, enabling reliable accumulation of evidence toward the final output. GoL [57] further enhances this paradigm by incorporating symbolic logic, with nodes encoding logical statements and edges capturing formal inference relations. By enforcing precise logical rules during updates, it improves faithfulness and supports systematic hallucination detection while remaining scalable. GoT [56] generalizes this paradigm by modeling dependencies among thoughts, organizing reasoning as a graph where nodes represent units of information and edges encode inter-thought relations. This enables flexible thought transformations, including aggregation of multiple reasoning paths, refinement via feedback loops, and distillation of key insights from interconnected thought networks.

5.1.2. Reasoning Based on Path Exploration

By comparison, Reasoning Based on Path Exploration frames reasoning as a traversal over multiple candidate paths. Information is not centralized at a single node but distributed along a path. Each node on the path corresponds to an independent action or intermediate decision. The final output is constructed by accumulating information along the selected path. Existing methods mainly differ in how paths are generated and selected during exploration.

A line of existing methods instantiates path exploration over tree-structured spaces, where reasoning proceeds by branching and selecting among alternative trajectories. ToT [9] models reasoning as a tree, exploring branches and selecting promising trajectories. SoT [48] improves efficiency with a skeleton-first strategy, generating concise outlines that are later expanded in parallel. LATS [49] incorporates MCTS to support long-horizon decision making, enabling systematic exploration of combinatorial reasoning–action spaces and unifying reasoning, acting, and planning. XoT [50] augments MCTS with pretraining signals and external knowledge, allowing more informed traversal of reasoning paths. PGTS [51] integrates reinforcement learning with tree search, learning to balance exploration and exploitation via reward optimization instead of relying on hand-crafted heuristics or costly self-evaluation.

In contrast, recent methods move beyond the tree-structure constraint and generalize path exploration to graph-structured spaces, enabling richer dependencies beyond single trajectories. SaGoT [52] constructs a thought graph during decoding via a graph-structured self-attention mechanism, allowing reasoning steps to form flexible interconnections rather than being restricted to a single path, thus implicitly guiding exploration through inter-step dependencies. DAG-Math [53] instead imposes a directed acyclic graph structure over reasoning trajectories, where nodes represent intermediate states and edges encode rule-based transitions, constraining valid paths to follow structured derivations and enabling more faithful and controllable reasoning.

5.1.3. Discussion

Graph-based reasoning introduces structure into the reasoning process, making intermediate steps more organized and easier to track. This structured organization helps models handle multi-step problems more reliably, as information can be accumulated, compared, or refined in a controlled way. It also makes the reasoning process more transparent, which is useful for understanding model behavior and diagnosing errors.

At the same time, several challenges limit its effectiveness. Node-based methods rely heavily on accurate summarization, and early mistakes can affect all later steps. Path-based methods face a large search space, which can lead to high computational cost or inefficient exploration. Controlling the trade-off between exploration and correctness is still difficult, especially when many possible reasoning paths exist. In more flexible graph settings, dependencies between steps can become complex, making it harder to maintain consistency. Another issue is that structured reasoning often requires additional design choices, such as how to define nodes, edges, or update rules, which may not generalize well across tasks.

Future work can explore more efficient ways to manage the reasoning process, such as reducing unnecessary paths or improving the quality of intermediate summaries. Better strategies for guiding exploration may help models focus on more promising reasoning directions. It is also important to design more general frameworks that can adapt to different tasks without heavy manual design. Combining node-based and path-based reasoning in a unified approach may further improve flexibility and performance. Finally, improving how reasoning structures are aligned with model outputs could make results both more accurate and easier to interpret.

5.2. Planning

Building on reasoning capabilities, graph-based planning focuses on task organization rather than performing step-by-step inference. It leverages graphs to organize and manage interdependent goals, tasks and actions, enabling LLMs to handle complex multi-step tasks through plan executions. Existing methods mainly differ in how they use graphs for task decomposition and execution.

A common perspective models planning as a hierarchical structure, starting with methods that emphasize structural decomposition. In these approaches, high-level goals are decomposed into sub-tasks represented as graph nodes, where edges explicitly capture logical and temporal dependencies. Typically, RAP [43] treats graphs as task decomposition tools, with nodes as sub-tasks and edges encoding dependencies. GNNs support sub-task retrieval and execution, while the same LLM serves dual roles: generating potential actions and predicting resulting states to evaluate progress through reward functions. GNN4TaskPlan [44] formulates task planning as a graph-based decision-making problem, using learned representations to guide sub-task selection and execution. Following this line of work, ControlLLM [45] introduces the Thoughts-on-Graph paradigm, which searches for optimal paths on tool graphs modeling parameter and dependency relations, while supporting the decomposition of complex tasks for multimodal execution.

While the aforementioned methods focus on establishing a blueprint, a more adaptive paradigm has emerged that treats graphs as active feedback structures. Rather than relying on static representations, these approaches emphasize the model’s ability to revise, backtrack, or expand plans based on real-time environmental feedback. PoG [46] uses graphs as feedback structures during planning. Unlike conventional approaches that rely on fixed exploration breadth or unidirectional reasoning, PoG adopts a self-correcting planning mechanism. It incrementally constructs and updates multi-level sub-goal graphs to detect deviations and enable correction through three components: Guidance, Memory, and Reflection. In robotic task planning, recent work by Sakib and Sun [47] utilizes graphs as execution-oriented interfaces. Multiple GPT-4–generated task trees are consolidated into a unified plan, which is then converted into executable low-level actions through cost-aware selection and symbolic planning.

5.2.1. Discussion

Graph-based planning organizes goals, sub-tasks, and their dependencies into structured plans, helping models manage complex workflows in a more systematic way. This structure supports clear task decomposition, explicit dependency management, and coordinated execution across multiple steps. It is particularly useful for long-horizon tasks, where maintaining a consistent execution order and adapting plans based on feedback are critical.

Several challenges remain in practice. Designing a good task structure is difficult, as an incorrect decomposition can lead to inefficient or even failed execution. Plans that rely on fixed structures may lack flexibility when the environment changes, while adaptive methods introduce additional complexity and may become unstable. Keeping track of dependencies across many sub-tasks can also be challenging, especially when tasks interact in non-trivial ways. In addition, planning often depends on accurate predictions of future outcomes, and errors in these predictions can lead to poor decisions during execution.

Future work can focus on making planning more robust and adaptive without adding too much computational overhead. Better methods for automatic task decomposition could reduce the need for manual design. Improving how models update plans based on feedback will help them recover from mistakes more effectively. It is also promising to explore tighter connections between planning and execution, so that plans remain aligned with real outcomes. Finally, combining planning with stronger reasoning and memory mechanisms may further improve performance on complex, long-term tasks.

5.3. Evaluation

Unlike reasoning and planning, graph-based evaluation focuses on assessing LLM outputs. It uses graph structures to capture richer associations among entities, facts, and sentences. Specifically, evaluation methods can be categorized into two main types: Factuality Evaluation, which assesses the accuracy and reliability of generated content through explicit entity and relation modeling; Logicality Evaluation, which measures logical coherence and reasoning consistency using graph-based relational representations.

5.3.1. Factuality Evaluation

Factuality Evaluation assesses whether LLM outputs are correct by modeling content as structured graphs to verify dependencies, propagate uncertainty, and detect inconsistencies. Existing methods mainly differ in the form of evidence they construct and how it is aligned with model outputs.

Some works focus on leveraging graph structures to model and reason about uncertainty for factuality evaluation. BTProp [34] formulates hallucination detection as probabilistic inference over a belief tree, jointly estimating latent claim truth via a hidden Markov tree conditioned on logical relations and confidence signals. Chen et al. [35] model uncertainty propagation using entity- and sentence-level graphs, calibrating uncertainty through semantic dependencies and contradiction probabilities. From a global perspective, Jiang et al. [36] estimate claim uncertainty via graph centrality over bipartite generation–claim graphs, showing that higher-order metrics better capture global support than simple self-consistency. Similarly, Li et al. [37] construct consistency graphs over sampled outputs and apply GNNs to map uncertainty to correctness probabilities for robust factuality estimation.

Another line of work converts generated text into structured knowledge for fine-grained verification: GraphEval [38] represents responses as KG triples and evaluates them via graph traversal and natural language inference (NLI)-based reasoning, enabling interpretable localization of hallucinated facts. FactAlign [39] formulates hallucination detection as a KG alignment problem, supporting fact-level detection and intrinsic–extrinsic error classification without additional training. Domain-specific extensions such as FAITH [40] show that KG-based evaluation is particularly effective in high-stakes domains like healthcare, where interpretability and expert alignment are essential.

Graph structures are also leveraged for sample-based evaluation. GCA [41] constructs contextual KGs over multiple sampled outputs, modeling fact dependencies via relational graph convolution to improve alignment and consistency in long-form generation. FactSelfCheck [42] similarly represents responses as fact-level graphs and detects hallucinations through cross-sample inconsistency analysis, enabling more fine-grained and effective correction than sentence-level self-consistency.

5.3.2. Logicality Evaluation

At a higher level, Logicality Evaluation assesses the quality of reasoning in LLM outputs. It goes beyond factual correctness to examine semantic coherence, inferential structure, and the organization of logical transitions using explicit relational representations. Existing methods mainly differ in the stage and granularity of the structures they target.

Semantic-Eval [29] is a training-free framework for assessing reasoning quality via semantic comprehension rather than surface matching. It constructs semantic graphs from pairwise similarity and uses a graph-based weighting scheme (SemanticRank) to capture sentence-level contributions. A pretrained NLI model refines relations, producing scores better aligned with semantic coherence and human judgments. In a different modality, DiagramEval [30] abstracts LLM-generated diagrams into directed graphs, with elements as nodes and connections as edges. It evaluates logical soundness via node and path alignment, measuring whether relational structures preserve intended reasoning flow and dependencies.

Another line of work targets the explicit verification of reasoning processes. GraphReason [31] aggregates multiple reasoning paths produced by an LLM into a unified reasoning graph, merging shared intermediate steps across solutions. By applying a graph neural verifier over this merged structure, the method evaluates logical consistency across reasoning trajectories and selects solutions that exhibit stronger structural support, leading to improved reasoning accuracy without additional model training.

Beyond direct verification, graph-based representations are also employed to analyze and characterize reasoning behavior. Xiong et al. [32] cluster chain-of-thought outputs into semantic steps and construct directed graphs to analyze structural properties, showing that features like branching and convergence correlate with reasoning performance and prompting strategies. At a finer granularity, Minegishi et al. [33] propose Circuit-based Reasoning Verification. This method extracts attribution-based computational graphs from hidden states, revealing distinct structural patterns for correct versus incorrect reasoning and linking graph topology to reasoning outcomes.

Figure 7. A taxonomy of Graph4LLM Application.

Figure 7. A taxonomy of Graph4LLM Application.

5.3.3. Discussion

Graph-based evaluation provides a structured way to assess LLM outputs by explicitly modeling facts, relationships, and reasoning processes. This makes evaluation more fine-grained, as it can check not only whether an answer is correct, but also where errors occur and how they propagate. Such structured analysis improves interpretability, supports more reliable hallucination detection, and allows evaluation to move beyond surface-level matching toward deeper semantic and logical assessment.

However, this line of work still faces several challenges. Constructing accurate graphs from generated text is not trivial, and errors in extraction can affect the reliability of evaluation results. Different methods rely on different forms of structure, such as triples, graphs over samples, or reasoning paths, which makes it hard to compare results across approaches. Modeling uncertainty and consistency across multiple outputs can also be computationally expensive. For logicality evaluation, capturing complex reasoning patterns in a clean and consistent structure is difficult, especially when reasoning steps are implicit or loosely expressed. In addition, many methods depend on external components such as NLI models or GNNs, which introduces extra complexity and potential sources of error.

Future work can focus on improving the robustness of graph construction from text, so that evaluation is less sensitive to extraction errors. More unified evaluation frameworks may help compare different methods and provide clearer benchmarks. Reducing computational cost while maintaining fine-grained analysis is another important direction. It is also promising to design evaluation methods that better align with human judgment, especially for complex reasoning tasks. Finally, combining factuality and logicality evaluation into a single framework may provide a more complete view of model performance.

6. Applications

Graph4LLM methods has been widely applied across diverse domains, substantially improving performance on both general and domain-specific tasks.

6.1. General Applications

6.1.1. Classic Natural Language Processing

Classic natural language processing (NLP) tasks provide a natural testbed for studying how graph structures can enhance LLMs. These tasks cover multiple linguistic levels, ranging from word-level semantics to sentence-level representations and sequence-level predictions [199]. In these scenarios, Graph4LLM methods leverage graph structures to encode domain knowledge and provide explicit guidance for model reasoning.

Word-level tasks. Word-level tasks focus on modeling token semantics and relationships, such as word sense disambiguation and lexical analysis. In these tasks, graphs encode lexical relations, co-occurrence structures, or KG connections, grounding token representations in explicit relational structures to enhance contextual understanding. Pons et al. [185] improve zero-shot entity disambiguation by leveraging KG hierarchies and entity descriptions to prune candidates and enrich prompts, reducing ambiguity while maintaining cross-domain adaptability. Similarly, Salman et al. [186] integrate LLMs with Wikidata, retrieving candidates via SPARQL and selecting the most appropriate entity through generative matching, combining symbolic retrieval with contextual reasoning for strong disambiguation without task-specific training.

Sentence-level tasks. Sentence-level tasks aim to capture holistic semantics, including classification, similarity, and entailment. By constructing graphs over syntactic or inter-sentence relations, these methods provide a structured context that enriches sentence-level embeddings. For example, Zou and Markov [187] combine BERT [200] embeddings with GNNs and augment node features using GPT-generated emotion descriptions, leveraging both contextual encoding and structural modeling for improved emotion recognition. SKG-LLM [188] injects sentiment KG priors by constructing graphs over product features and emotion categories, integrating graph-derived signals into prompt optimization with adaptive weighting, enabling more fine-grained sentiment classification.

Sequence tagging. Sequence tagging tasks require assigning labels to each token in a sequence, such as named entity recognition and part-of-speech tagging. Graphs model dependencies beyond linear order, such as syntactic or long-range relations, to enable more globally consistent predictions. GNN-SL [189] addresses long-tail labeling by constructing a heterogeneous graph that links input sequences with similar annotated examples, using GNNs to propagate label information for token-level prediction. For cross-domain settings, Zheng et al. [190] model label relationships as graphs in both source and target domains and integrate them into BERT representations, improving named entity recognition (NER) under label mismatch and data scarcity.

Information extraction. Information extraction aims to identify structured elements such as entities, relations, and events. Graphs represent elements and their interactions, enabling structured reasoning over complex text. GLiM [191] constructs dynamic entity-pair graphs to constrain the search space of potential entities and uses LLMs to recover missing relations under incomplete labeling. RePooL [192] models tokens, spans, and relations in a dual-view graph, supporting relation-aware composition and hierarchical validation. Extending to event-level extraction, GDLLM [193] introduces distance-aware event graphs to capture long-range temporal dependencies. Beyond text, Iranmanesh et al. [194] apply graph-based retrieval to structured industry foundation classes (IFC) data, enabling graph-guided extraction of object properties and relations.

Text generation. Text generation tasks include summarization, data-to-text generation, and question answering. Graphs act as planning or control structures to organize content, guide decoding, and enforce structural constraints. GRAFT [195] models discourse units as a DAG to maintain cross-sentence consistency in document-level translation. POMP [196] builds a dynamic meta-graph over auxiliary languages to guide prompting in low-resource translation. For long-context summarization, GoR [197] links retrieved chunks with historical responses to jointly refine retrieval and generation. HeterMDS [198] further constructs a heterogeneous graph over sentences, paragraphs, and documents to capture hierarchical structure for coherent multi-document summarization.

6.1.2. Code

Code-related applications focus on understanding, generating, and reasoning over program structures, where syntax, control flow, and semantic dependencies play a central role. Unlike natural language, source code exhibits structures such as abstract syntax trees, control-flow graphs, and call graphs. Graph4LLM methods leverage these structures to complement token-level representations, enabling more precise and context-aware code understanding and generation.

Function-level tasks. These tasks operate at the level of individual functions or snippets, including code summarization, completion, and defect detection. Graphs typically model intra-function structures such as syntax trees, data-flow, and control-flow dependencies, exposing execution logic and variable interactions. SCoT [176] introduces structure-aware reasoning by aligning chains of thought with program constructs (e.g., branches and loops), improving generation accuracy. GRACE [177] enhances vulnerability detection by injecting code graph structures into in-context learning, while GALLa [178] aligns LLM representations with graph-based semantics during training, incorporating structural information without inference-time overhead.

Repository-level tasks. These tasks consider entire codebases and model cross-file and cross-module relationships through graphs such as call graphs, dependency graphs, and module interaction graphs. CodePlan [179] treats large-scale code editing as a planning problem, constructing dependency-aware edit sequences across files. RepoGraph [180] builds a unified code graph to support repository-level reasoning, while RepoHyper [181] performs graph-based search and expansion to retrieve relevant code beyond local scopes. CodexGraph [182] enables explicit structure-aware querying via a graph database interface, and LocAgent [183] applies multi-hop reasoning over heterogeneous graphs to align queries with code entities. Finally, CGM [184] injects graph structures into the attention mechanism, enabling holistic reasoning without relying on agent-based interaction.

6.1.3. Table

Table-related applications focus on understanding and reasoning over structured data, including table interpretation, table question answering, and synthetic data generation. Unlike unstructured text, tabular inputs encode meaning through rows, columns, cells, and schema relations, and prior table-specific models such as TaBERT [201] have shown the importance of modeling such structures. Graph4LLM methods extend this line of research by converting tables and their associated schemas or evidence into graphs, enabling LLMs to better capture structural dependencies that are easily lost in naive row-wise serialization.

Table understanding and representation. These approaches aim to enable LLMs to capture the semantic and structural properties of tables through explicit graph-based encoding. In this setting, graphs represent relationships among cells, headers, and rows. HeGTa [168] uses a heterogeneous graph with multi-grained self-supervised objectives to align tabular structure with LLM parametric knowledge for few-shot table understanding. TabGLM [169] combines graph-encoded structural embeddings with text-based semantic features to learn transferable table representations across datasets. For metadata-oriented tasks, RACOON [170] injects triples from external KGs into the LLM context to improve column type annotation.

Table-based question answering and reasoning. These tasks require navigating complex schemas or multimodal contexts, where answers are often distributed across tables and external evidence. Graphs typically serve as reasoning scaffolds or unified indices for cross-table dependencies. GraphOTTER [171] structures LLM reasoning over tabular graphs via a “Thought-Action-Update” loop. For joint table-text reasoning, Hybrid-QA [172] constructs a unified graph linking cells and passages for subgraph-based answer discovery. In large-scale databases, SGAM [173] encodes schema-level relations such as foreign keys and derivation paths, while TUNES [174] integrates entity-oriented search to enable graph-based reasoning over complex tables.

Synthetic tabular data generation. These tasks explore how graph-guided constraints can improve the fidelity and downstream utility of generated records. KGSynX [175] models attribute dependencies with a KG and feeds graph-derived structure into the LLM during synthesis. It further uses explainable feedback to iteratively refine generated samples, helping preserve relational consistency and task-relevant utility in low-data settings.

6.2. Domain-Specific Applications

6.2.1. E-Commerce

E-commerce applications primarily rely on recommendation systems to match users with relevant products, making recommendation a central task in this domain. These systems model user preferences from historical interactions between users and items, where collaborative signals, high-order connectivity, and semantic contexts play a key role. Unlike free-form text, e-commerce data is naturally organized as bipartite or heterogeneous graphs that encode user behaviors, product attributes, and relational signals such as co-purchase or co-view patterns [202]. Graph4LLM methods leverage these structures to integrate graph-based interaction modeling with the semantic understanding of LLMs, yielding more accurate, explainable, and context-aware product recommendations.

Collaboration and behavior. These applications operate on user-item interaction graphs to capture community patterns and high-order collaborative filtering signals in e-commerce platforms. In this setting, methods align structural graph representations with LLM representations to address challenges such as data sparsity and weak ID semantics. ELMRec [161] uses graph-aware whole-word embeddings and propagated structural positions to improve high-order interaction modeling. GAL-Rec [162] strengthens collaborative semantics through graph-aware learning, while LLMRec [163] and LLM-AGR [164] use LLMs to supervise graph augmentation or restructuring before recommendation. Beyond representation learning, graph topology can also reshape the computational space. CORONA [165] constructs a structured retrieval space from user–item graphs with coarse-to-fine filtering, narrowing the search space and aligning generation with high-order collaborative signals.

Knowledge and reasoning. These applications incorporate structured knowledge and reasoning to support more interpretable and domain-aware recommendations in e-commerce. Graphs in this category encode explicit relations such as product attributes, category hierarchies, and user preferences, allowing LLMs to reason beyond interaction history. In conversational recommendation, COMPASS [166] uses knowledge-graph-augmented LLMs to perform explainable reasoning over user preferences by extracting and aligning preference subgraphs. For domain-specific scenarios, GLRec [167] combines heterogeneous graphs with LLM prompting to improve zero-shot understanding of structured signals.

6.2.2. Medicine

Medical applications require knowledge-intensive tasks like clinical question answering, drug discovery, and diagnosis support, where factual accuracy and multi-step reasoning are critical. Biomedical data is structured, including molecular networks, clinical records, and medical ontologies [156,158]. Graph4LLM methods leverage biomedical KGs for question answering and grounding [155,157], and multiscale molecular graphs for drug development. By incorporating structured knowledge into retrieval, reasoning, and generation, they mitigate factual drift, enhance interpretability, and improve the reliability of medical decision support.

Medical question answering and reasoning. Methods in this category focus on retrieving and reasoning over biomedical literature and knowledge bases to support reliable answer generation. Medical Graph RAG [155] uses graph-based retrieval to anchor LLM outputs in verified medical evidence and reduce hallucinations. KG-RAG [156] further incorporates graph structure into prompt construction to better align model responses with clinical knowledge. LLM-KGMQA [157] tackles this by augmenting LLMs with a medical KG for multi-hop question answering.

Drug discovery and molecular design. These applications focus on generating or reasoning over candidate molecules under biochemical and synthesis constraints. Llamole [158] incorporates retrosynthetic planning into multimodal LLMs for inverse molecular design, where chemical synthesis pathways serve as graph-structured constraints during generation.

Clinical diagnosis and healthcare analytics. These applications use patient data and clinical graphs to support diagnosis and healthcare analytics. Magic [159] activates graph reasoning in a multi-agent diagnostic workflow, allowing LLM agents to navigate structured disease evidence for liver disease diagnosis. Diet-ODIN [160] models dietary patterns and patient behaviors as interpretable graphs, showing how graph-enhanced LLM pipelines can support public health monitoring tasks such as opioid misuse detection.

6.2.3. Education

Education-related applications focus on tasks such as resource discovery, intelligent tutoring, and personalized learning path planning. Unlike general information retrieval, educational settings are structured by prerequisite relations, curriculum constraints, and heterogeneous learning resources [149,153]. Recent Graph4LLM methods use course KGs, learner knowledge component graphs, and graph-induced learning paths to support tutoring and recommendation [148,150]. When operating without explicit structure, standalone LLMs may produce responses that are pedagogically inconsistent or weakly aligned with curriculum requirements. By grounding tutoring and recommendation in educational graphs, Graph4LLM methods improve coherence, interpretability, and personalization.

Educational knowledge discovery and question answering. These tasks aim to provide students with curriculum-aligned answers by retrieving relevant structural context. In MOOCs, Abdelmagied et al. [148] navigate course-specific KGs in GraphRAG-based tutoring to keep LLM explanations consistent with the syllabus. In institutional settings, cross-data KG construction [149] unifies heterogeneous educational resources for question answering, while KG-CQ [150] uses educational KGs to support self-directed tutoring. AcademicRAG [151] further treats academic resources as a graph-enhanced retrieval problem, enabling multi-hop access to learning materials.

Personalized learning and cognitive modeling. These applications tailor educational content by modeling the structure of knowledge components and learner states. FOKE [152] integrates foundation models with KGs to provide explainable feedback aligned with a student’s cognitive profile. MAS-KCL [153] uses an agentic workflow to learn latent knowledge component graphs, and Wasnik and Shrivastava [154] integrate LLMs and KGs to build adaptive educational frameworks that adjust difficulty and content distribution based on the learner’s graph-encoded proficiency profile.

6.2.4. Finance

Financial applications focus on tasks such as market trend analysis, financial question answering, fraud or risk detection, and personalized financial services. Unlike standalone document analysis, financial settings rely on transaction graphs, inter-corporate relation graphs, event propagation structures, and dynamic market knowledge [141,142]. Recent Graph4LLM methods use these structures for market trend detection, financial retrieval, and graph-based risk analysis [144,145]. When processing financial data without explicit relational structure, standalone LLMs often miss systemic dependencies and weakly capture temporal propagation patterns. By combining graph-based market structure with LLM semantic reasoning, Graph4LLM methods provide more structured support for financial analysis and services.

Market trend analysis and event ripple effects. These tasks focus on modeling how market signals propagate across related entities and events. FinRipple [141] aligns LLMs with financial market structure to improve awareness of event ripple effects across equities. FinDKG [142] combines dynamic KGs with LLMs for global trend detection, while FinCARE [143] uses graph-enhanced reasoning to analyze causal relations behind market movements.

Financial question answering and document intelligence. These tasks require LLMs to navigate financial documents and dynamic market knowledge under factual constraints. Barry et al. [144] use graph-based indices in GraphRAG for finance to improve retrieval efficiency and factual grounding over financial data. FinQA [145] treats financial question answering as navigation over dynamic KGs and uses LLM-based revision to refine responses without task-specific fine-tuning.

Risk management and financial services. These applications use transaction graphs, behavioral relations, and user profiles to support risk detection and personalized services. For financial risk governance, Li et al. [146] present an end-to-end risk assessment model. By integrating text mining and financial risk KGs into an LLM with RAG and multi-feature fusion, the model enables precise credit risk prediction and rational default probability estimation for effective risk quantification. On the consumer-facing side, Zhao et al. [147] combine LLMs with GNNs for personalized financial product recommendation by integrating user-item interaction structure with semantic profiles.

6.2.5. Law

Applications in the legal domain focus on tasks such as legal consulting, statutory question answering, judgment prediction, and legal article recommendation. Unlike general text, legal data is governed by statutory hierarchies, precedent relations, temporal validity, and normative constraints [135]. Recent Graph4LLM systems construct legal KGs, citation graphs, and graph-based legal indices to support retrieval and analysis [136]. When processing such data, standalone LLMs are prone to hallucinations, weak temporal grounding, and unreliable alignment with formal legal constraints. By integrating legal graphs with LLM reasoning, Graph4LLM methods provide more structured support for legal retrieval, analysis, and decision assistance.

Legal consulting and question answering. These tasks aim to provide legally grounded answers under current rules and precedents. Legal-LM [135] integrates legal KGs with language models for legal consulting. Law GraphRAG [136] and Dang et al. [137] construct structured graph indices for multi-hop legal retrieval.

Judgment prediction and judicial recommendation. These applications use case graphs and statutory relations to predict outcomes or recommend legal provisions. LLG-Judger [138] combines LLMs with graph contrastive learning over similar-case structures for legal judgment prediction. For law article recommendation, JKEM [139] builds a case-enhanced legal KG that links case facts with criminal law statutes for graph-guided retrieval and recommendation. LegisSearch [140] further combines legislative KGs with LLMs and text embeddings for graph-aware legislative retrieval.

6.2.6. EDA

Electronic design automation (EDA) applications leverage circuit topology to enhance hardware design and analysis with LLMs. Unlike natural language, hardware description languages (HDL) and circuit netlists exhibit strict interconnectivity [203], fan-in/fan-out constraints [204], and hierarchical dependencies [205], forming rich multi-source structural data [206,207]. Early works [208,209] primarily used GNNs to model circuit topology, but overlooked textual semantics in design documents and comments. Standalone LLMs struggle with long-range dependencies and may generate hallucinations that violate syntax or logic. By introducing structure-aware graphs, Graph4LLM integrates circuit topology with LLM reasoning, improving code generation, power-performance-area (PPA) prediction, and automated optimization.

Multimodal circuit modelling and performance analysis. By aligning structural features from graph encoders with the semantic understanding of LLMs, these applications enable early prediction of circuit performance metrics such as timing and power. NetTAG [125] represents netlists as text-attributed graphs, using LLMs to encode gate-level logic semantics and graph Transformers to capture global structure, resulting in a universal netlist foundation model. CircuitFusion [126] further fuses hardware code, structure graphs, and functional summaries via multimodal alignment, improving the generalization of PPA prediction. For timing analysis, GT-LLM [127] uses an LLM as a parser to convert register-transfer level (RTL) into graph structures, paired with a graph learning engine for early timing prediction. MOSS [128] targets sequential circuits, integrating GNNs and LLMs to resolve long-range information dependencies and strengthen modeling of complex logical behaviors.

Structure-enhanced hardware code generation. These applications use the syntactic and logical graph structures of circuits to guide LLMs in generating high-quality hardware description code. Given the stringent requirements for logical correctness in hardware design, SAGE-HLS [129] introduces a syntax-aware, abstract syntax tree (AST)-guided framework that improves the quality of high-level synthesis (HLS) code generation via structured prompting. For RTL modeling, RTL++ [130] converts code into control flow graphs (CFGs) and data flow graphs (DFGs) with textual encoding, capturing internal hierarchies and dependencies to substantially boost the RTL generation quality of open-source models. SynC-LLM [131] further breaks through the limitations of LLMs in circuit generation scale, and proposes a hierarchical synthetic circuit code generation framework: first, the global structure is generated through the graph diffusion model, and then the LLMs are guided to fill the code layer by layer with hierarchical controllable prompts.

Graph-guided design optimization. These applications harness LLM reasoning to guide sophisticated graph transformations or provide generic graph enhancement across tasks. For datapath optimization, ASPEN [132] uses LLMs to direct E-Graph rewriting in equality saturation, automatically searching for optimal area-performance trade-offs along the Pareto frontier. In logic synthesis, CircuitEvo [133] innovatively employs LLMs to iteratively evolve graph-structured programs, automating circuit compactness optimization while preserving functional correctness. To address the difficulty of integrating graph modalities in EDA tasks, BRIDGES [134] constructs a large-scale multimodal dataset and generic framework. It connects DFGs and netlist graphs to LLMs via lightweight cross-modal projectors, providing a standardized graph-enhanced foundation for diverse EDA workflows.

7. Challenges and Future Directions

Graph construction quality and robustness. The effectiveness of Graph4LLM methods critically depends on the quality and robustness of the constructed graphs. In practice, graphs are often derived from noisy corpora or imperfect knowledge bases, making them prone to incompleteness, spurious relations, and structural bias. These imperfections can propagate through downstream components, leading to misleading retrieval results and distorted reasoning trajectories. Future work should therefore prioritize reliable and adaptive graph construction, capable of handling varying data quality and uncertainty. This can be achieved, for instance, by incorporating uncertainty quantification methods applied to graph nodes and edges, enabling LLMs to reason over probabilistic or graded relations. Additionally, iterative refinement mechanisms that leverage feedback from LLM outputs to revise or prune unreliable structures represent a promising direction.

Complexity challenges from explicit structural expansion. Larger graphs can capture more entities and relations, but increasing size, density, and diversity also brings higher computational cost and reasoning difficulty. In practice, large or highly connected graphs can lead to a combinatorial explosion of paths, making search inefficient and sometimes unstable. Future work should therefore focus on complexity-aware graph design, such as pruning and hierarchical structures, to better match graph granularity with task requirements. This allows the model to focus on the most relevant parts of the graph at each stage. A key challenge is to determine how much structure to expose to the model and when to use it, which is critical for scalable and reliable reasoning. Ultimately, the goal is to make graph structure not just richer, but more useful.

Scaling laws for structural information. While scaling laws for model size and training data are well understood, it remains unclear how performance scales with different graph structures in Graph4LLM systems. In this context, scaling involves graph size, the number of agents, and the expansion of intermediate reasoning steps during inference. Increasing these factors can improve reasoning depth, but may also introduce noise and degrade overall efficiency. A key challenge is to understand how structural properties such as graph density and reasoning depth affect performance. In particular, it remains unclear whether increasing structure leads to consistent gains or quickly reaches saturation due to redundancy and error propagation. Future work should aim to characterize these scaling trends and identify efficient regimes, enabling better control over graph expansion and more reliable reasoning.

Towards self-improving Graph4LLM: distillation, feedback, and co-evolution. Despite their effectiveness, most existing Graph4LLM methods use a unidirectional process, where graphs assist LLMs at specific stages but remain external to the model. The information in these graphs is consumed only during generation and not retained afterward. As a result, valuable structural signals must be repeatedly reconstructed, which limits efficiency and long-term knowledge transfer. To address these limitations, future work should focus on self-improving Graph4LLM systems. One promising method is graph-to-model distillation, where useful relational patterns from the Graph4LLM process are integrated into the model’s representations through fine-tuning or knowledge distillation. This would allow the model to internalize structural priors and reduce reliance on explicit graphs during inference. Model-to-graph feedback can also refine graph construction, enabling representations to evolve based on utility and support more robust, reusable structures.

8. Conclusions

This paper presents a comprehensive survey of Graph4LLM, categorizing existing graph-enhanced LLM methods in the input, model, and output phases. It covers representative methods across different paradigms and their diverse application scenarios. Specifically, it also introduces both general and domain-specific applications of Graph4LLM, illustrating its wide applicability in universal scenarios. Additionally, the paper summarizes key challenges facing current Graph4LLM research and outlines future directions. By providing a coherent structural perspective on the integration of graphs and LLMs, this survey offers a concise overview of the field, facilitating a clear understanding of how graphs enhance the capabilities of LLMs.