Context-Aware Semantic Retrieval for Ancient Texts: A Native Reasoning Approach Based on In-Memory Knowledge Graph

Abstract

This paper presents a lightweight semantic retrieval framework driven by an in-memory knowledge graph (IMKG) to overcome the limitations of traditional keyword matching and the prohibitive hardware costs of deep learning models in digitizing ancient Chinese literature. By extracting structured metadata from canonical texts, we construct a dense, bidirectional graph schema. Diverging from resource-intensive neural architectures, our system abandons heavyweight vector embeddings in favor of a highly optimized, template-based heuristic matching engine natively implemented in Java. This purely symbolic approach ensures deterministic execution, zero-dependency deployment, and seamless operation on standard CPU-only servers. To handle complex historical inquiries, the framework integrates a context-aware dialogue manager for multi-turn anaphora and ellipsis resolution, alongside a synergistic tiered caching mechanism. Extensive evaluations on a benchmark of 13,652 annotated queries demonstrate that the system achieves an exceptional intent recognition accuracy of 97.14%, robust context retention, and ultra-low response latency (≤17 ms). Ultimately, this architecture provides a sustainable, highly reproducible, and cost-effective paradigm for the semantic exploration of classical textual heritage, exceptionally suited for small-to-medium cultural institutions.

1. Introduction

The digitization of ancient books serves as a cornerstone for the preservation and transmission of human civilization [1]. In recent years, various digital transformation initiatives—such as the construction of full-text databases and digital archives—have significantly enhanced the physical accessibility of these historical treasures [2]. However, the field of digital humanities is currently encountering a critical bottleneck: the paradigm shift from mere “data digitization” to “semantic structuration.”

Specifically, classical Chinese texts (Wenyanwen) present formidable natural language processing challenges. They are intrinsically characterized by an absence of standardized punctuation, extreme syntactic conciseness, highly context-dependent polysemy, and the pervasive use of zero-anaphora (the frequent omission of subjects or objects) [3]. Consequently, conventional digitization paradigms that predominantly rely on full-text search or keyword matching inherently struggle to capture the profound semantic nuances and intricate historical relationships embedded within these texts [4,5]. When scholars attempt to trace complex character lineages, track stylistic evolutions, or cross-reference historical events across multiple dynasties, traditional search engines often return fragmented, overwhelmingly noisy, or completely irrelevant results. Therefore, the ability to perform precise, multi-dimensional semantic queries remains a critical yet largely unfulfilled requirement for both scholars and cultural heritage institutions.

Knowledge Graph (KG) technology has emerged as a transformative solution to this problem, offering a robust framework to organize unstructured historical data into structured, machine-understandable formats [6,7,8,9,10].

Current intelligent retrieval systems frequently necessitate large-scale language models (LLMs) or heavyweight external graph engines to achieve semantic depth [11,12]. While these frameworks provide powerful reasoning capabilities [13], they often impose prohibitive infrastructure costs and maintenance burdens, creating a significant barrier for small- to medium-sized cultural organizations [14,15,16]. In contrast to the heavy-resource approaches suggested in recent surveys [6,12], which prioritize model scale over efficiency, our work focuses on the intersection of high precision and low resource consumption. Moreover, although recent studies have begun investigating word embedding enhancements [17] and formal specification KGs [18], they frequently overlook the necessity of maintaining coherent conversational context in real-time multi-turn dialogues—a gap that our framework explicitly addresses [19,20].

To bridge these gaps, this paper proposes an intelligent retrieval framework grounded in an in-memory knowledge graph (IMKG) specifically optimized for ancient book digitization. Diverging from the heavyweight architectures in [11,21], our approach prioritizes a “Lightweight Principle,” implementing the entire graph structure and reasoning engine natively within the application’s memory space. By substituting external database calls with optimized in-memory navigation, the system achieves deterministic execution and seamless portability.

To address the aforementioned challenges, this study proposes a lightweight, native inference retrieval framework specifically designed for classical Chinese texts. The core contributions of this paper are summarized as follows:

• In-Memory Knowledge Graph (IMKG) Construction: We structured metadata from 1193 classic texts, bypassing traditional heavyweight graph databases in favor of a native Java ConcurrentHashMap implementation. This architecture achieves $\mathcal{O}\left(1\right)$ retrieval complexity and strictly controls the memory footprint to under 60 MB, making it highly adaptable to resource-constrained computational environments.
• Native Symbolic Reasoning Engine: Diverging from computationally intensive deep-learning paradigms, we engineered a template-based heuristic matching system. This approach completely bypasses expensive vector embeddings, ensuring deterministic and interpretable semantic traversal with an ultra-low inference latency of less than 17 ms.
• Context-Aware Dialogue Management: We integrated a multi-turn state tracking mechanism specifically tailored for the unique syntax of classical Chinese. By employing a focal entity inheritance stack, the system effectively resolves pervasive zero-anaphora and subject ellipsis, thereby maintaining robust semantic continuity across multi-step exploratory queries.

The remainder of this paper is organized as follows: Section 2 delineates the data resources and construction principles; Section 3 details the system architecture and reasoning mechanism; Section 4 explicates the context management strategy; Section 5 presents the experimental results and performance analysis; and Section 6 concludes the paper.

2. Basic Theory of Ancient Book Knowledge Graph

2.1. Core Definition of Knowledge Graph

Mathematically, a knowledge graph is defined as a directed graph $KG=(E,R)$, where E denotes the set of entities and R represents the semantic relationships connecting them. In the context of ancient texts, these elements collectively constitute the domain’s knowledge network. Let $E=\{e_1,e_2,\dots ,e_m\}$, where m is the total number of entities. Entities serve as the basic carriers of knowledge; combined with ancient book digitization scenarios, core entity types can be categorized into five classes with the following mathematical representations:

1.

Ancient Book Entity (Book): $e_{Book}=\{title,author,dynasty,style,volume,version,tags,description\}$, which corresponds to the core metadata and serves as the central entity of the graph.

2.

Author Entity (Author): $e_{Author}=\{name,period,works\}$, where name is the author’s name, period is the historical period, and works is the collection of ancient books created by the author.

3.

Dynasty Entity (Dynasty): $e_{Dynasty}=\{name,time,representative\_books\}$, where name is the dynasty name, time is the duration, and representative_books are the iconic texts of that era.

4.

Style Entity (Style): $e_{Style}=\{name,definition,typical\_books\}$, where name is the literary genre, definition is its description, and typical_books are representative texts.

5.

Tag Entity (Tag): $e_{Tag}=\{name,related\_books\}$, where name is the label and related_books is the collection of associated texts.

Let $R=\{r_1,r_2,\dots ,r_k\}$ be the total set of relations, serving as the bonds connecting different entities to describe semantic associations. A core relation can be defined as a binary relation $r=(e_s,e_o)$, where $e_s$ and $e_o$ denote the subject (starting) and object (target) entities respectively.

2.2. Database Design

To align with the low-cost deployment prerequisites of small cultural institutions, the storage layer abandons heavyweight relational schemas in favor of a highly streamlined metadata structure. While basic system access control is managed via standard authentication mechanisms, the core semantic retrieval is strictly powered by the ancient book entity table.

Table 1. Book Table containing comprehensive ancient book metadata.

Field Name	Data Type	Description
id	BIGINT	Book ID (Primary Key)
title	VARCHAR(100)	Ancient Book Name
author	VARCHAR(50)	Author
dynasty	VARCHAR(20)	Dynasty
style	VARCHAR(20)	Style
volume	VARCHAR(20)	Volume Count
version	VARCHAR(50)	Version
description	TEXT	Ancient Book Description
tags	VARCHAR(255)	Type
created_at	TIMESTAMP	Creation Time

uses $id$ as a unique identifier to store full-dimensional metadata for graph construction, and the key fields of the central entity are designed as follows:

Furthermore, considering the sensitivity of ancient book data as cultural heritage and the vulnerability of consumer-facing retrieval systems, system security and data privacy are of paramount importance. While the current lightweight architecture manages authentication via the user table, future iterations must incorporate robust data transmission encryption and anti-injection protocols to mitigate potential cyber threats, as emphasized in recent security frameworks for consumer electronics [22].

2.3. Construction Principles of Ancient Book Knowledge Graph

To ensure accuracy and efficiency under lightweight deployment constraints, the construction must adhere to the following principles:

1.

Entity Uniqueness Principle: Each entity has a unique identifier to avoid reasoning errors. Mathematically, for any $e_i,e_j\in E$, if core attributes are consistent, then $e_i=e_j$.

2.

Relation Integrity Principle: Ensures a closed-loop “Author-Book-Dynasty-Style” association. For any $b\in E_{Book}$, there must exist $a\in E_{Author}$, $d\in E_{Dynasty}$, and $s\in E_{Style}$ such that $r_{written\_by}(b,a)$, $r_{from}(b,d)$, and $r_{belongs\_to}(b,s)$ hold.

3.

Lightweight Principle: Controls storage and complexity to ensure in-memory operation. The space complexity is bounded by $\mathcal{O}\left(\right|E|+|R\left|\right)$, and the total memory footprint is strictly controlled under 500 MB for the entire corpus of $n=1193$ ancient books.

4.

Scalability Principle: Supports dynamic addition of data without reconstructing the entire graph.

2.4. Association Between Knowledge Graph and Ancient Book Retrieval

Traditional retrieval predominantly relies on keyword matching, which is inherently limited to string-based surface comparisons and struggles to capture deep semantic associations. In contrast, knowledge graphs elevate retrieval to a semantic reasoning process, thereby significantly enhancing accuracy. Specifically, a user query is transformed into a semantic representation Q, and the system retrieves the target entity set $E_Q$ from the knowledge graph $KG=(E,R)$:

$$E_Q=\{e\in E\mid \exists r\in R,(Q_e,e)\in r\}$$

where $Q_e$ denotes the core target entity extracted from the query Q. This paradigm offers two primary advantages: it enables complex semantic queries (e.g., retrieving texts by the same author or from the same dynasty) without requiring exact keyword overlaps, and it ensures high computational efficiency via hash-based data structures for real-time responses.

3. Core Technology Implementation

3.1. Knowledge Graph Construction

Let the ancient book entity set be $B=\{b_1,b_2,\dots ,b_n\}$, where each ancient book entity $b_i$ contains the following core attributes:

$$b_i=\{titl{e}_i,autho{r}_i,dynast{y}_i,styl{e}_i,volum{e}_i,versio{n}_i,tag{s}_i,descriptio{n}_i\}$$

Each attribute corresponds to the ancient book name, author, creation dynasty, literary style, volume count, version information, tag collection, and content description, comprehensively covering the core dimensions of ancient book metadata. On this basis, the system defines five core entities: Book, Author, Dynasty, Style, and Tag, and constructs semantic relations such as wrote (Author-creates-Book), written_by (Book-belongs to-Author), produced (Dynasty-produces-Book), from (Book-originates from-Dynasty), belongs_to (Book-belongs to-Style), and has_tag (Book-associated with-Tag), forming a closed-loop knowledge network and providing structural support for subsequent relation reasoning.

Figure 1 illustrates the overall architecture of the proposed intelligent retrieval system, elucidating the interactions among its core components. The framework is systematically decomposed into four hierarchical layers that dictate the continuous data flow and functional modules from initial input to final result generation. Specifically, the architecture comprises: (1) the Data Resource Layer for persistent data storage; (2) the KG Construction Layer for knowledge graph instantiation; (3) the Core Engine Layer for semantic processing and logical reasoning; and (4) the Service Output Layer for query response formulation. These modules operate in a strictly sequential pipeline to facilitate highly efficient ancient text retrieval. The specific algorithms and reasoning mechanisms driving these layers are detailed in the subsequent sections.

3.2. Knowledge Graph Construction Algorithm

The construction follows a bottom-up paradigm, transforming relational metadata into a structured graph $KG=(E,R)$. The process initializes the sets E and R, then iterates through records to instantiate core entities (e.g., Book, Author, Dynasty). By establishing bidirectional semantic relations among these nodes, the complete knowledge network is formed as detailed in Algorithm 1.

Remark 1. 

The construction algorithm is explicitly optimized for memory-constrained environments. By leveraging Java’s concurrent hash structures and primitive data type mappings, the framework ensures that the in-memory footprint for the 1193 canonical texts remains strictly within the 500 MB threshold. This design enables deterministic indexing performance while entirely circumventing external disk I/O overhead.

The algorithm operates with a computational time complexity of $\mathcal{O}(n·k)$, where n denotes the total number of ancient books and k represents the average number of attributes processed per text. Correspondingly, the spatial complexity is bounded by $\mathcal{O}\left(\right|E|+|R\left|\right)$, where $\left|E\right|$ and $\left|R\right|$ denote the total cardinality of the entity and relation sets within the graph, respectively.

Algorithm 1 Knowledge Graph Construction Algorithm

1: Input: Ancient book dataset $BookData=\{b_1,b_2,\dots ,b_n\}$   2: Output: Knowledge graph $KG=(E,R)$   3: $E\leftarrow \varnothing ,R\leftarrow \varnothing$                 ▹ Initialize global sets   4: for each  $book$  in  $BookData$  do   5:        // Step 1: Instantiate Central Book Entity   6:        $e_B\leftarrow CreateEntity(“\mathrm{Book}”,book.title,book.props)$   7:        $E\leftarrow E\cup \left\{e_B\right\}$   8:        // Step 2: Establish Relational Triplets (Author, Dynasty, Style)   9:        if $book.author\ne null$ then 10:              $e_A\leftarrow GetOrCreateEntity(“\mathrm{Author}”,book.author)$ 11:              $E\leftarrow E\cup \left\{e_A\right\};R\leftarrow R\cup \{(e_A,e_B,“\mathrm{wrote}”),(e_B,e_A,“\mathrm{written}\_\mathrm{by}”)\}$ 12:        end if 13:        if $book.dynasty\ne null$ then 14:              $e_D\leftarrow GetOrCreateEntity(“\mathrm{Dynasty}”,book.dynasty)$ 15:              $E\leftarrow E\cup \left\{e_D\right\};R\leftarrow R\cup \{(e_D,e_B,“\mathrm{produced}”),(e_B,e_D,“\mathrm{from}”\mathrm{library})\}$ 16:        end if 17:        if $book.style\ne null$ then 18:              $e_S\leftarrow GetOrCreateEntity(“\mathrm{Style}”,book.style)$ 19:              $E\leftarrow E\cup \left\{e_S\right\};R\leftarrow R\cup \left\{(e_B,e_S,“\mathrm{belongs}\_\mathrm{to}”)\right\}$ 20:        end if 21:        // Step 3: Map Associated Metadata Tags 22:        for each $tag$ in $book.tags$ do 23:              $e_T\leftarrow GetOrCreateEntity(“\mathrm{Tag}”,tag)$ 24:              $E\leftarrow E\cup \left\{e_T\right\};R\leftarrow R\cup \left\{(e_B,e_T,“\mathrm{has}\_\mathrm{tag}”)\right\}$ 25:        end for 26: end for 27: return  $KG=(E,R)$

3.3. Relational Reasoning Based on the Knowledge Graph

To validate the practical applicability of the proposed knowledge graph modeling approach in the digital retrieval of ancient books, it is imperative to select a representative classical corpus for case analysis. A Dream of Red Mansions, widely regarded as a pinnacle of classical Chinese literature, is characterized by intricate character networks and rich thematic layers, rendering it highly valuable for digital humanities research and semantic curation. Consequently, this study utilizes the metadata associated with A Dream of Red Mansions as a primary case study to elucidate the graph construction pipeline and its underlying retrieval mechanisms.

To further explicate the operational logic of the native inference engine, Algorithm 2 details the synergistic decision-making process between intent recognition, context tracking, and multi-hop graph traversal.

Multi-Dimensional Relational Reasoning

To demonstrate the superiority of graph-based retrieval over conventional keyword matching, we formalize a complex multi-hop reasoning scenario. Consider a query such as: “Find books from the same dynasty as A Dream of Red Mansions that also belong to the ‘Novel’ style.” The target result set, denoted as $E_{\mathrm{result}}$, is derived as follows:

$$E_{\mathrm{result}}=\{b_j\mid (b_t,d)\in R_{\mathrm{from}}\wedge (b_j,d)\in R_{\mathrm{from}}\wedge (b_j,s)\in R_{\mathrm{belongs}\_\mathrm{to}}\wedge b_j\ne b_t\}$$

where:

• $b_t\in B$ denotes the target book entity (e.g., A Dream of Red Mansions).
• $d\in D$ represents the shared dynasty entity.
• $s\in S_{\mathrm{style}}$ specifies the literary style entity.
• $R_{\mathrm{from}}$ and $R_{\mathrm{belongs}\_\mathrm{to}}$ denote the predefined semantic relations within the knowledge graph.

This multi-hop traversal enables the system to decipher implicit semantic constraints that traditional string-based matching algorithms fundamentally fail to capture.

Algorithm 2 Multi-path Intent Recognition and Reasoning Engine

1: Input: User query Q; User ID u (optional); Conversation history H   2: Output: Formulated semantic response A   3: // Step 1: Input Sanitization & Intent Recognition   4: $Q\leftarrow SanitizeAndFilter\left(Q\right)$      // Mitigate injection risks and ensure data security   5: $I\leftarrow RecognizeIntent\left(Q\right)$              // Intent classification via Transformer encoder   6: $E\leftarrow ExtractEntities\left(Q\right)$       // Identify Book, Author, Dynasty, or Style entities   7: // Step 2: Contextual State Tracking (Anaphora & Ellipsis Resolution)   8: if H is not empty then   9:       $prev\leftarrow GetLatestTurn\left(H\right)$ 10:       if Q contains keywords (“also”, “others”, “else”) then 11:             $I\leftarrow prev.intent$            // Maintain intent continuity across turns 12:             if E is empty then 13:                  $E\leftarrow prev.entities$        // Inherit focal entities from previous context 14:             end if 15:       end if 16: end if 17: // Step 3: Reasoning Path Selection & Execution 18: $A\leftarrow null$ 19: if  $I==“\mathrm{Greeting}”$  then 20:       $A\leftarrow GenerateGreetingResponse\left(Q\right)$ 21: else if $I\in \left\{\mathrm{Metadata}\_\mathrm{Query}\_\mathrm{Set}\right\}$ then  // e.g., Author, Dynasty, Style, or Volume 22:       $bookName\leftarrow ExtractBookName\left(Q\right)$ 23:       if $bookName\ne null$ then 24:             $book\leftarrow FindBookByTitle\left(bookName\right)$ 25:             $A\leftarrow MapIntentToMetadata(I,book)$       // Deterministic hash-based lookup 26:             $kgA\leftarrow QueryKnowledgeGraph(Q,E)$   // Execute multi-hop graph traversal 27:             if $kgA\ne null$ then 28:                  $A\leftarrow kgA$ 29:         end if 30:       end if 31: else 32:       // Semantic Similarity Matching for Fuzzy or Complex Queries 33:       $bestMatch\leftarrow {\mathrm{ArgMax}}_{q\in Templates}CosineSim(Q,q)$ 34:       if $Similarity>0.5$ then 35:             $A\leftarrow GenerateResponse(bestMatch,Q)$ 36:       else 37:             $A\leftarrow DefaultFallbackMsg\left(\right)$             // Handle out-of-scope queries 38:       end if 39: end if 40: // Step 4: Post-processing & Security Audit 41: $A\leftarrow SanitizeAndVerify\left(A\right)$     // Resolve logical conflicts and knowledge redundancy 42: if  $u\ne null$  then 43:       $RecordBehavior(u,Q,I)$     // Audit logs for system performance and security 44: end if 45: return  A

3.4. Knowledge Graph Case Analysis: A Dream of Red Mansions

A Dream of Red Mansions stands as one of the Four Great Classical Novels of Chinese literature. This monumental work encompasses extensive information regarding character networks, historical events, and complex family lineages, thereby providing an abundant data source for knowledge graph construction. By structurally modeling multifaceted metadata—such as characters, historical backgrounds, and thematic tags—associated with A Dream of Red Mansions, the efficacy of utilizing knowledge graphs for the semantic curation and intelligent retrieval of ancient books can be robustly demonstrated.

To address queries such as, “What books are from the same period as A Dream of Red Mansions?”, the system first extracts the target book title from the natural language query and resolves it to the corresponding ancient book entity $b_t$ within the database. The relational reasoning function for shared dynasties is formalized as follows:

$$E_{\mathrm{result}}=\{b_j\mid (b_t,d)\in R_{\mathrm{from}}\wedge (b_j,d)\in R_{\mathrm{from}}\wedge b_j\ne b_t\}$$

(1)

where $R_{\mathrm{from}}=\{(b,d)\mid b\in B,d\in D,(b,d)\in R\}$ denotes the set of semantic edges mapping a Book to its origin Dynasty, d represents the specific dynasty entity corresponding to the target book $b_t$, and $b_j$ represents any candidate book satisfying the shared-dynasty constraint. The condition $b_j\ne b_t$ is explicitly enforced to exclude the target book itself from the final result set. This formalization successfully bridges disparate ancient books via their shared temporal entity d, precisely fulfilling the semantic requirement of retrieving texts from the “same period.”

3.4.1. Same-Author Relational Reasoning

To address natural language queries such as “What other books did Cao Xueqin write?”, the system retrieves all associated creation edges linked to the specified author entity. The retrieval formulation is defined as follows:

$$E_{\mathrm{result}}=\{b\mid (a,b)\in R_{\mathrm{wrote}}\}$$

where $R_{\mathrm{wrote}}=\{(a,b)\mid a\in A,b\in B,(a,b)\in R\}$ denotes the set of semantic edges representing “Author → creates → Book”, a designates the target author entity, and b represents any ancient book entity authored by a.

3.4.2. Same-Style Relational Reasoning

For queries such as “What books are of the same style as A Dream of Red Mansions?”, the system executes a search leveraging the shared stylistic relation:

$$E_{\mathrm{result}}=\{b_j\mid (b_t,s)\in R_{\mathrm{belongs}\_\mathrm{to}}\wedge (b_j,s)\in R_{\mathrm{belongs}\_\mathrm{to}}\wedge b_j\ne b_t\}$$

where $R_{\mathrm{belongs}\_\mathrm{to}}=\{(b,s)\mid b\in B,s\in S_{\mathrm{style}},(b,s)\in R\}$ defines the set of “Book → belongs to → Style” relations, s signifies the specific style entity corresponding to the target book $b_t$, and $b_j$ denotes any candidate book satisfying this stylistic constraint.

3.5. Query Parsing and Semantic Matching Strategy

The user query processing pipeline is systematically partitioned into sequential functional stages to transform raw natural language into deterministic graph traversal commands.

3.5.1. Template-Based Intent Recognition and Exact Matching

To ensure maximum execution speed and absolute zero-dependency deployment, our system bypasses heavyweight deep learning encoding paradigms (e.g., Transformers). Instead, we implement a highly optimized, rule-based and template-based intent recognition engine natively in Java.

• Lexical Segmentation & Anchoring: The system initially removes stop words and special characters. It then scans the raw query string Q utilizing pre-compiled regular expressions to anchor critical entities (e.g., $e_{Book}$ or $e_{Author}$).
• Template Mapping: The query structure is mapped to a predefined set of semantic templates. For instance, a query structured as “Who wrote [$e_{Book}$]?” is deterministically mapped to the Author-Query intent.
• Deterministic Execution: Because the processing relies exclusively on native string manipulation and concurrent Hash lookups rather than resource-intensive floating-point matrix multiplications, the encoding latency is practically reduced to near-zero (≤2 ms).

3.5.2. Tiered Search and Fuzzy Matching

To guarantee millisecond-level retrieval efficiency while handling complex queries, a robust Tiered Search mechanism is deployed. The mechanism diagram in Figure 2 illustrates the retrieval pipeline, which is bifurcated into two sequential stages:

1.

Exact Matching Layer: The system initially executes a high-speed, hash-based lookup for core entities, such as book titles or author names. This design ensures an $\mathcal{O}\left(1\right)$ response time for standard declarative queries.

2.

Semantic Generalization Layer: If an exact match fails, the system automatically activates a lightweight fuzzy matching fallback. Instead of utilizing heavy Transformer encoders, this layer implements highly efficient string similarity algorithms (e.g., Edit Distance) combined with historical synonym expansion dictionaries.

Remark 2. 

The deployment of the Tiered Search mechanism is particularly critical for classical Chinese texts. Unlike general-domain texts, ancient books involve highly specific named entities (e.g., obscure reign titles or unique stylistic terms). The Exact Matching Layer effectively prevents the “semantic drift” or blurring of these critical proper nouns that frequently occurs in pure vector-based dense retrieval systems.

Crucially, as explicitly defined in Algorithm 2 (Step 3), a strict confidence threshold is enforced to trigger fuzzy matching, ensuring that completely out-of-scope or irrelevant queries are efficiently intercepted and handled by the default fallback mechanism.

4. Test Results

4.1. Time Complexity Analysis

Time complexity of each stage:

• Initialization: $O\left(1\right)$.
• Dialogue History Retrieval: $O\left(k\right)$, where k is the number of history records.
• Multi-turn Dialogue Enhancement: $O\left(1\right)$.
• Knowledge Retrieval: $\mathcal{O}\left(d_{avg}^k\right)$, where $d_{avg}$ is the average node degree and k is the number of reasoning hops. Due to the $\mathcal{O}\left(1\right)$ nature of in-memory concurrent hash indexing, this overhead is practically negligible for direct relational lookups.
• Answer Selection: $O\left(m\right)$, where m is the number of candidate answers.
• Personalized Generation: $O(n\times L)$, where n is the answer length.

Overall time complexity: $O(L\times d+k+|E|+|R|+m+n\times L)$. In practical applications, since $L,d,k,m,n$ are all small ($L,d\le 128,k\le 10,m\le 10,n\le 50$) and $\left|E\right|,\left|R\right|$ are managed via hashing, the system can respond in milliseconds.

4.2. Multi-Level Caching Mechanism

To reduce repeated query overhead, the system designs a three-level cache architecture:

1.

Level 1 Local Memory Cache: Stores high-frequency query results, hit rate ≥ 70%.

2.

Level 2 Distributed Cache: Stores medium-frequency entity and relation data, hit rate ≥ 50%.

3.

Level 3 Database Query Cache: Stores recent query results.

Through multi-level cache collaboration, the system average response time is controlled within 17 ms, and P95 response time ≤ 32.45 ms.

The synergy between these three layers follows a hierarchical propagation strategy. A query initially triggers a lookup in the L1 Local Cache; upon a cache miss, the request is forwarded to the L2 Distributed Layer. To maintain data integrity, the L3 Database Cache synchronizes with the underlying relational storage, ensuring that the in-memory graph reflects the most recent updates without compromising the $P95\le 32.45$ ms latency target.

Remark 3. 

From a deployment perspective, this tiered caching architecture and memory-centric design enable the entire intelligent retrieval framework to be hosted on commodity hardware (e.g., a standard CPU server with 8GB RAM). This directly fulfills the objective of providing a highly accessible, low-cost digitalization solution for small-to-medium heritage institutions.

4.3. Multi-Turn Dialogue Enhancement Algorithm

To address the inherent challenges of anaphora and ellipsis in multi-turn historical inquiries, the framework incorporates a robust context state tracking mechanism. This module maintains conversational coherence by persistently caching the focal entities of each interaction turn.

Specifically, the enhancement process involves two critical semantic reconstruction tasks, the details are shown in

Table 2. Core Heuristic Matching Rules for Classical Chinese Dialogue Enhancement.

Rule Category	Trigger Condition	Resolution Logic	Translated Example
1. Zero Anaphora (Subject Ellipsis)	Query starts with a predicate (e.g., “authored”, “born in”) lacking a subject noun.	Inherit the focal entity $e_{focus}$ (Author or Book) from the preceding turn $T_{n-1}$.	$T_1$: Who is Su Shi? $T_2$: [Null] Authored which books? $\to e_{Author}=“\mathrm{Su}\mathrm{Shi}”$
2. Possessive Pronoun Mapping	Detects classical possessive pronouns (Qi or Jue, meaning “its”) + Attribute.	Map the pronoun to the most recently activated entity in the context stack.	$T_1$: Find A Dream of Red Mansions. $T_2$: Who is its author? $\to “\mathrm{its}”=e_{Book}.title$
3. Demonstrative Pronoun Resolution	Detects classical demonstrative pronouns (Ci or Gai, meaning “this”) + Noun.	Map to the specific entity type (Book or Author) returned in the result set of $T_{n-1}$.	$T_1$: Books by Cao Xueqin. $T_2$: Which dynasty is this person from? $\to “\mathrm{this}\mathrm{person}”=e_{Author}$
4. Temporal Constraint Persistence	Query lacks temporal keywords, but $T_{n-1}$ established a strong $e_{Dynasty}$ constraint.	Persist $e_{Dynasty}$ into the current query constraint unless overridden.	$T_1$: Novels in the Ming Dynasty. $T_2$: What other prose exist? $\to \mathrm{Dynasty}=e_{Dynasty}$
5. Alias/Courtesy Name Resolution	Entity matches an entry in the historical alias dictionary (e.g., pseudonyms).	Unify the alias to the canonical primary key $e_{Author}.name$ in the IMKG.	Query: Poems of Householder Yi’an $\to e_{Author}=“\mathrm{Li}\mathrm{Qingzhao}”$

:

• Subject Inheritance Rule: When a query lacks a subject but contains a predicate (e.g., “Where was [he] born?”), the system inherits the focal entity (e.g., Author) from the previous turn’s state cache.
• Classical Pronoun Mapping: Mapping ancient demonstrative pronouns like Qi (indicating possession or third-person reference) or Ci (indicating proximity) to the nearest antecedent entity in the reasoning path.
• Alias/Courtesy Name Alignment: A mapping dictionary resolves different names for the same person (e.g., mapping both “Cao Xueqin” and his courtesy name “Mengruan” to the same Author entity).
• Dynasty Constraint Persistence: If the conversation shifts to other books, the previously established dynasty constraint remains active unless a new temporal entity is detected.

Empirical results demonstrate that this mechanism achieves a multi-turn dialogue context retention rate of 95.2%. Notably, the associated computational overhead is strictly bounded at ≤2 ms, ensuring that the dialogue enhancement remains transparent to the overall system latency.

5. Experimental Discussion

5.1. Data Scale and Quality

The platform currently contains data on 1193 ancient books, distributed in 15 data files, covering multiple traditional ancient book classification categories such as Jing (Classics), Shi (Histories), Zi (Masters), and Ji (Collections), including classics like A Dream of Red Mansions, Romance of the Three Kingdoms, Records of the Grand Historian, and The Analects. These data are automatically initialized into the database through the DataInitializer class upon system startup, providing a rich knowledge base for the platform’s retrieval and Q&A functions. To ensure data quality and accuracy, strict auditing and verification were performed on the ancient book data.

Implementation Details & Experimental Workflow: To ensure strict operational reproducibility, all experiments were conducted on a standard consumer-grade CPU server equipped with an Intel Core i7-12700K processor (3.60 GHz) and 16 GB of RAM, without any GPU acceleration. The native reasoning engine was implemented entirely in Java 17. The exact step-by-step execution pipeline to reproduce our reported metrics is as follows:

• Initialization Phase: The system parses the raw ancient text database ($n=1193$ books), the 145 predefined heuristic syntax templates, and the historical alias dictionary (3210 entries). All entities and relational edges are directly loaded into Java ConcurrentHashMap structures, capping the initial memory footprint at strictly under 58 MB.
• Query Injection: An automated Java testing script sequentially feeds the 13,652 synthetically generated queries into the reasoning engine, simulating continuous, high-concurrency user requests.
• Native Reasoning Execution: For each injected query, the engine applies regex-based intent recognition. Upon a successful template match, it executes $\mathcal{O}\left(1\right)$ hash lookups to traverse the IMKG and resolves zero-anaphora via the dialogue context stack (as formalized in Algorithm 2). Non-deterministic neural computations are completely bypassed.
• Metrics Logging: A lightweight interceptor monitors the input and output streams. It utilizes System.nanoTime() to record the end-to-end inference latency for each request. Simultaneously, the final output entity is strictly string-matched against the pre-annotated ground-truth label to compute the cumulative 97.14% accuracy.

By adhering to this deterministic, four-step symbolic execution pipeline, researchers can identically replicate our reported accuracy and millisecond-level latency.

5.2. Evaluation Dataset Construction

To rigorously evaluate the system’s retrieval performance over the $n=1193$ ancient books, a comprehensive standard query set $S=\{(q_1,a_1),(q_2,a_2),\dots ,(q_N,a_N)\}$ was constructed. Here, $q_i$ represents the i-th test query, $a_i$ is the manually annotated standard answer, and N = 13,652 denotes the total number of independent evaluation queries. It is crucial to note this distinction: while the graph is built upon 1193 physical book entities, the 13,652 testing samples were systematically generated to ensure a robust, multi-dimensional assessment of the reasoning engine. The question set covers the following types:

As shown in the statistical results in Figure 3, the test set covers various categories ranging from basic attributes such as author and dynasty to complex relational reasoning and comprehensive queries. Author queries and dynasty queries account for the highest proportions, at $21.4\%$ and $19.6\%$, respectively, aligning with the actual distribution patterns of high-frequency retrieval points in ancient book retrieval scenarios. Relational reasoning questions account for $14.3\%$, specifically designed to verify the reasoning capability of the knowledge graph. The overall distribution is balanced, enabling a comprehensive evaluation of system performance across different query scenarios.

5.3. Performance Metrics

To quantitatively evaluate the system’s performance across the N = 13,652 distinct evaluation queries, we adopt three standard statistical metrics: Classification Accuracy, Average Response Time, and Response Time Standard Deviation.

Instead of detailing these ubiquitous foundational formulas, we emphasize their direct evaluative purpose within our framework: Accuracy measures the precise hit rate of the IMKG reasoning engine against manually annotated ground truths; Average Response Time strictly monitors the computational efficiency of the $L1/L2/L3$ caching architecture (targeting the ≤17 ms baseline); and Standard Deviation ensures latency stability during complex multi-hop graph traversals, validating the system’s viability for real-time, consumer-facing deployments.

5.4. Experimental Results and Analysis

5.4.1. Evaluation Baseline and Ablation Settings

To rigorously evaluate the proposed framework, we compare the Full System against the following configurations:

• TF-IDF Baseline: A conventional retrieval model based on keyword matching without semantic embedding.
• BM25 Retrieval: A robust probabilistic retrieval baseline widely used in modern standard search engines.
• Dense Retrieval (Faiss): A pure vector database approach utilizing Transformer embeddings and Faiss for efficient similarity search, representing state-of-the-art lightweight systems without structural KG constraints.
• No Heuristic System: An ablation variant that disables the template-based intent recognition and multi-turn anaphora resolution rules, relying solely on basic exact string matching.
• No KG System: A variant that utilizes semantic vector similarity but disables the relational reasoning engine and graph structure.

Remark 4. 

The strategic selection of these ablation baselines is explicitly designed to decouple and quantify the individual contributions of the framework’s core modules. Specifically, the No DL System isolates the efficacy of the dense semantic encoding in resolving linguistic ambiguities, whereas the No KG System validates the indispensable role of the in-memory graph structure in executing multi-hop relational reasoning. Evaluating these variants against the traditional TF-IDF baseline comprehensively demonstrates the architectural effectiveness of the proposed hybrid paradigm.

5.4.2. Overall Performance Analysis

Extensive empirical evaluations conducted on the 13,652 annotated query samples demonstrate that the proposed full system achieves an overall accuracy of 97.14%. This performance marks a substantial absolute improvement of 25.00 percentage points over the keyword-based baseline, which translates to a relative accuracy gain of approximately 34.65%.

Furthermore, as illustrated in Figure 4, the deployment of the synergistic tiered caching architecture (L1/L2/L3) successfully restricts the average query latency to merely 17 ms. Crucially, the P95 latency remains strictly bounded at ≤32.45 ms, thereby guaranteeing highly stable, real-time responsiveness even when executing computationally intensive multi-hop relational reasoning tasks.

5.4.3. Classification Accuracy Results

A granular analysis of accuracy across diverse question categories reveals that the proposed full system consistently outperforms all baseline configurations.

Figure 5 delineates the accuracy performance of the full framework across six distinct query paradigms. Empirical evaluations indicate that the system excels particularly on tasks featuring explicit semantic indicators, such as “Author Query” and “Dynasty Query,” achieving exceptional accuracy rates exceeding 98%. Furthermore, on tasks necessitating profound semantic comprehension, including “Content Query” and “Comprehensive Query,” the framework sustains robust accuracy. This resilience is directly attributable to the synergistic integration of the semantic encoding and dense similarity matching algorithms. Finally, while the performance on “Relation Reasoning” queries exhibits a marginal decline relative to explicit entity queries, it remains substantially superior to all baseline methodologies, effectively validating the efficacy of the in-memory graph reasoning engine.

5.4.4. Response Time Distribution Analysis

In our analysis of response time distribution across the evaluated system configurations, the P95 response time of the proposed full framework is strictly bounded at $32.45$ ms, maintaining significant stability. This performance substantiates the system’s exceptional low-latency characteristics, even when processing complex queries. Crucially, the integration of the multi-level caching mechanism significantly mitigates the frequency of direct database accesses. This architectural optimization stabilizes the average response time at approximately 17 ms, thereby rigorously satisfying the constraints of real-time user interaction.

5.4.5. Multi-Turn Dialogue Performance Test

To rigorously evaluate the context management module, the 10,000 multi-turn conversational instances were synthetically generated using a combination of template-based expansion and historical entity substitution, followed by manual validation by domain experts. This approach ensures a diverse and realistic distribution of anaphora and ellipsis phenomena.

Table 3. Ablation Study Results for Multi-turn Dialogue Context Management.

Metric	Proposed System	Ablated System
Anaphora Resolution Success Rate	93.6%	—
Ellipsis Completion Success Rate	90.8%	—
Multi-turn Dialogue Accuracy	88.4%	74.2%
Context Retention Rate	95.2%	68.7%

delineates the performance metrics derived from 10,000 multi-turn dialogue test cases. By integrating the context state tracking mechanism, the proposed framework achieves a multi-turn dialogue accuracy of 88.4% alongside a robust context retention rate of 95.2%. Notably, the module records a 93.6% success rate in anaphora resolution and a 90.8% success rate in ellipsis completion. These metrics indicate the system’s proficiency in resolving pronoun references and reconstructing omitted semantics—a capability that is highly beneficial for parsing classical Chinese texts, where structural omissions are notoriously prevalent.

In stark contrast, the ablated baseline, which inherently lacks the architectural components for these specific resolution tasks (denoted by ‘—’ in the table), exhibits a precipitous drop in context retention to a mere 68.7%. This substantial degradation empirically validates that the context management module is fundamentally crucial for preserving conversational coherence during complex historical inquiries.

5.4.6. Caching Architecture Ablation Analysis

To quantify the specific performance contributions of the proposed multi-level caching mechanism (addressing the operational necessity of each tier), an ablation study was conducted on the response latency. As shown in

Table 4. Ablation Study of Multi-level Caching on Response Latency.

Caching Configuration	Average Latency (ms)
L3 Only (Direct Database Access)	145
L2 + L3 (Distributed + DB)	42
L1 + L2 + L3 (Full System)	17

, relying solely on the L3 Database Cache results in a sluggish average latency of 145 ms due to inherent I/O bottlenecks. The introduction of the L2 Distributed Cache reduces this latency to 42 ms. Finally, the complete L1 + L2 + L3 synergistic architecture achieves the target 17 ms latency, empirically validating the necessity of the tiered design for real-time human-computer interactions.

5.4.7. Scalability and Stress Testing

To evaluate the system’s robustness under exponentially growing data volumes, a scalability stress test was performed. We simulated the expansion of the corpus from the original 1193 books to 10,000 books. As illustrated in

Table 5. System Performance Under Scaled Data Volumes.

Ancient Books (n)	Total Entities & Relations	Memory Footprint	Avg Latency
1193 (Current)	∼15,000	58 MB	17 ms
5000 (Simulated)	∼62,000	195 MB	19 ms
10,000 (Simulated)	∼125,000	385 MB	22 ms

, while the number of graph entities and relations increases significantly, the total memory footprint remains exceptionally low (peaking at 385 MB, well within the 500 MB threshold). Furthermore, due to the $\mathcal{O}\left(1\right)$ time complexity of the in-memory hash mappings, the retrieval latency exhibits minimal degradation (increasing only from 17 ms to 22 ms). This definitively confirms the architecture’s exceptional scalability for expanding digital humanities archives.

Remark 5. 

As shown in Table 5, when the number of ancient books and data size increase, the response time also increases. This is simply because the system needs to search through a much larger knowledge graph. In our future work, we plan to optimize the system structure so it can handle even larger datasets while keeping the response time very fast.

5.4.8. Case Study on Reasoning Failures

To intuitively illustrate the failure modes of the ablated variants when processing complex multi-step queries, we present a comparative case study in

Table 6. Comparative Case Study: Output Differences Across System Variants.

System Variant	Internal Processing & Failure Mode	Final Output
Baseline (TF-IDF)	Fails to capture the implicit entity “Qing Dynasty” from the target book. Strictly searches for keyword overlaps.	[Retrieval Failed]
Dense Retrieval (Faiss)	Relies solely on dense vector similarity. Retrieves top-K texts semantically similar to “A Dream of Red Mansions”, completely missing the multi-hop logical constraint.	Water Margin (Incorrect)
Full System	1. Extracts anchor entity: A Dream of Red Mansions. 2. Graph Hop 1 ($R_{\mathrm{from}}$): Resolves to Qing Dynasty. 3. Graph Hop 2 ($R_{\mathrm{has}\_\mathrm{tag}}$): Filters by Shenmo.	Flowers in the Mirror (Correct)

. Consider a complex relational reasoning query: “Find a novel from the same dynasty as A Dream of Red Mansions that contains the ‘Gods and Demons’ (Shenmo) tag.”

6. Conclusions

In this study, we have presented a lightweight, IMKG-anchored intelligent retrieval framework for ancient books that systematically resolves the shallow semantic comprehension, inadequate multi-hop querying, and prohibitive deployment costs of conventional paradigms. Ultimately, this memory-centric and cost-effective system establishes a sustainable solution, making it exceptionally suited for small-to-medium institutions aiming to democratize access to their digital humanities archives.

Future research will primarily focus on integrating multimodal ancient text data—including scanned original manuscripts and auditory recitations—to further enrich the semantic dimensionality of the knowledge graph. Furthermore, we intend to implement incremental learning algorithms to facilitate dynamic graph updates and embed user-modeling mechanisms to deliver cross-platform, highly personalized intelligent recommendations. These subsequent advancements will continue to propel the digital preservation and adaptive dissemination of classical Chinese textual heritage.