Retrieval-Augmented Generation with Covariate Time Series

This paper proposes RAG4CTS, a training-free, regime-aware retrieval-augmented generation framework that utilizes a hierarchical native knowledge base and a two-stage bi-weighted retrieval mechanism to significantly improve predictive maintenance accuracy for covariate time series in data-scarce industrial scenarios, as validated by its successful deployment in China Southern Airlines.

The Gist

🛠️ The Big Problem: The "Amnesia" of AI in the Sky

Imagine you are a mechanic trying to predict when a specific valve on an airplane (called a PRSOV) is about to break. This valve controls air pressure, and if it fails, the plane could be grounded, costing the airline thousands of dollars.

The problem? This valve only does its critical job for 10 seconds during takeoff. It happens once per flight.

• Data Scarcity: You don't have years of data for this specific valve; you only have a few seconds of data per flight.
• Short Memory: The "story" of the valve's behavior is incredibly short (only 18 data points).
• Complex Physics: The valve doesn't act alone. It is pushed and pulled by other forces (engine speed and air pressure). If you ignore those forces, the valve's behavior looks random.

The AI's Struggle:
Standard AI models (like the ones that power chatbots) are like students who memorized a textbook but have never seen a real airplane. When they look at this tiny, 10-second slice of data, they get confused. They try to guess the future based on patterns they learned from generic data, but they fail because the specific conditions (the "regime") are too unique and the data is too scarce.

🧠 The Solution: RAG4CTS (The "Super-Consultant" System)

The authors created a new system called RAG4CTS. Instead of forcing the AI to memorize everything, they gave it a library of past experiences and a smart librarian to find the right one instantly.

Think of it like this:

Instead of asking a student to guess the answer from memory, you hand them a stack of old exam papers that look exactly like the current test, and say, "Look at how we solved these before."

Here is how the system works, broken down into three simple steps:

1. The Library: A "Raw" Time Machine 📚

Most AI systems try to compress data into abstract "vectors" (like turning a photo into a blurry sketch). This loses detail.

• RAG4CTS Approach: They built a Hierarchical Knowledge Base. Imagine a library where books aren't just stacked randomly. They are organized by: Airline -> Plane Type -> Specific Plane -> Specific Flight.
• The Magic: They store the raw, unedited data. No blurring, no summarizing. If a valve moved 0.01 inches, the library remembers it exactly. This preserves the "fingerprint" of the machine.

2. The Librarian: The "Physics-Aware" Search 🔍

When a new flight happens, the system needs to find similar past flights to help predict the future.

• The Old Way: "Find a flight where the pressure looked similar." (This is dangerous! Two flights might look similar by accident, but have different causes.)
• The RAG4CTS Way: The system acts like a Physics Detective. It asks:
  1. Did the engine speed (N2) and air pressure (IP) behave the same way? (Covariate Weighting)
  2. Did the most recent moments match? (Critical Point Weighting)
• The Analogy: Imagine you are trying to predict how a car will brake.
  • Bad Search: "Find a car that stopped quickly." (Maybe it was on ice, maybe it was on dry road.)
  • Good Search: "Find a car that was going 60mph, had dry tires, and the driver pressed the pedal exactly like this."
  • RAG4CTS finds the exact physical context, not just a visual look-alike.

3. The Editor: The "Smart Agent" 🤖

Once the system finds 5 or 10 similar past flights, it has to decide: How many of these should I show the AI?

• The Problem: Showing too many past flights confuses the AI (too much noise). Showing too few isn't enough help.
• The Solution: They use an Agent (a tiny, self-checking AI).
  • The Agent takes the best past flight and says, "Let me try adding the 2nd best flight. Did that help? Yes? Okay, let's try the 3rd."
  • It keeps adding past examples one by one until the prediction gets perfect, then it stops. It's like a chef tasting the soup and adding salt only until it's perfect, rather than guessing a fixed amount.

🚀 The Real-World Result: Saving the Day

This isn't just a theory; it's running on China Southern Airlines right now.

• The Goal: Move from "Reactive Maintenance" (fixing the plane after it breaks or delays) to "Predictive Maintenance" (fixing it before it breaks).
• The Success:
  • The system is deployed in their database (Apache IoTDB).
  • In just two months, it successfully identified one real fault in a valve.
  • Zero False Alarms: It didn't cry wolf. It only flagged the one plane that actually needed help.
  • The Impact: By catching the fault early, the airline could fix it during a scheduled layover, avoiding a last-minute cancellation that would have cost them ~$50,000 and damaged their reputation.

🌟 Summary in One Sentence

RAG4CTS is like giving a mechanic a perfect, organized archive of every past flight's "vital signs," allowing them to instantly find the exact historical match to predict if a valve is about to fail, without needing to retrain the AI on scarce data.

Technical Summary

1. Problem Statement

The paper addresses the critical limitations of applying Time-Series Foundation Models (TSFMs) and existing Retrieval-Augmented Generation (RAG) frameworks to high-stakes industrial scenarios, specifically the Predictive Maintenance of Pressure Regulating and Shut-Off Valves (PRSOV) in commercial aircraft.

The core challenges in this domain are:

• Data Scarcity: Critical operational regimes (e.g., specific valve regulation phases) occur rarely (e.g., once per flight cycle), providing insufficient data for training deep models or fine-tuning adapters.
• Short Transient Sequences: The relevant data windows are extremely brief (e.g., 18 data points over 10 seconds). Standard RAG methods often pad these to fixed lengths, destroying fine-grained transient signals with artificial noise.
• Covariate-Coupled Dynamics: The target variable (Manifold Pressure, MP) is not autonomous but passively driven by external covariates (Engine Speed $N2$ and Intermediate Pressure $IP$). Existing methods often retrieve based solely on target similarity, ignoring the physical driving forces, leading to "hallucinated" or physically inconsistent predictions.
• Failure of Current RAG: Existing time-series RAG approaches rely on learnable adapters (which fail in low-data regimes) and static vector embeddings (which distort short transients and ignore covariate logic).

2. Methodology: RAG4CTS

The authors propose RAG4CTS, a regime-aware, training-free RAG framework designed specifically for covariate time series. It operates in three main stages:

A. Hierarchical Time-Series Native Knowledge Base (KB)

Instead of converting time series into static vector embeddings (which causes information loss), the authors construct a tree-structured, native knowledge base.

• Structure: Organized by physical hierarchy: Group (Aircraft Type) -> Device (Tail Number) -> Regime (PRSOV L/R) -> Series (Raw Data).
• Benefit: This preserves the lossless storage of raw operational cycles, maintaining full numerical precision and the integrity of short transient sequences without padding or slicing.

B. Two-Stage Bi-Weighted Retrieval Mechanism

To retrieve relevant historical regimes that share the same physical logic as the query, the framework employs a two-stage filtering process using a bi-weighted strategy operating directly in the raw data space:

1. Critical Point Weighting ($W_{point}$): Assigns higher weights to recent system states and known future covariates (e.g., planned $N2$ and $IP$ profiles), while strictly masking unknown future target values. This ensures retrieval aligns with the intended control trajectory.
2. Covariate Weighting ($W_{cov}$): Uses Mutual Information (MI) to quantify the causal influence of each covariate on the target. Variables with stronger physical coupling (e.g., $IP$ vs. $N2$) receive higher weights.
3. Two-Stage Filtering:
   • Stage 1 (Shape Alignment): Uses Weighted Cosine Similarity to filter candidates that share the same evolutionary trend and transient edges.
   • Stage 2 (State Precision): Uses a Weighted Matrix Profile distance to pinpoint exact matches in absolute numerical values, ensuring physical state fidelity.

C. Agent-Driven Context Augmentation

Instead of using a fixed number of retrieved contexts or a learnable adapter, the framework uses a self-supervised, agent-driven strategy:

• Mechanism: The Top-1 retrieved sample acts as an "Agent." The system uses the Agent's known future ground truth to perform a greedy search, dynamically determining the optimal number of context fragments ($k^*$) to prepend to the query.
• Goal: This balances the benefit of additional historical patterns against the noise introduced by excessive context, optimizing the In-Context Learning (ICL) capability of the backbone TSFM (Chronos-2) without gradient updates.

3. Key Contributions

1. First TSFM-oriented RAG for Covariate Time Series: Introduces a framework specifically designed for scenarios where target variables are driven by external physical covariates.
2. Native Storage & Lossless Retrieval: Proposes a hierarchical, tree-structured KB that stores raw sequences, avoiding the information loss inherent in vector embedding approaches.
3. Physics-Informed Bi-Weighted Retrieval: Develops a novel retrieval mechanism that aligns historical trends based on both point-wise temporal importance and multivariate causal coupling (using Mutual Information).
4. Dynamic Context Optimization: Replaces static context augmentation with an agent-driven, self-calibrating strategy that dynamically selects the optimal context length for each query.
5. Industrial Deployment: Successfully deployed within Apache IoTDB at China Southern Airlines, moving from academic research to real-world predictive maintenance.

4. Experimental Results

The framework was evaluated on the CSA-PRSOV dataset (Boeing 777 and Airbus A320 fleets) and compared against SOTA deep learning models, zero-shot TSFMs, and existing RAG methods.

• Prediction Accuracy: RAG4CTS significantly outperformed all baselines.
  • On the B777L dataset, it achieved an MSE of 0.058, compared to 0.254 for the next best deep learning model (DLinear) and 1.542 for the zero-shot TSFM (Chronos-2).
  • It reduced errors by an order of magnitude compared to zero-shot foundation models.
• Covariate Impact: Experiments confirmed that utilizing full physical covariates ($N2$ and $IP$) with the proposed weighting scheme is critical for accuracy.
• Ablation Studies:
  • Retrieval: The hybrid "Cosine + Matrix Profile" strategy with bi-weighting was proven superior to single metrics or unweighted approaches.
  • Context: The dynamic agent-based selection of context length ($k^*$) consistently outperformed fixed-length retrieval.
• Real-World Deployment:
  • Deployed in China Southern Airlines' maintenance workflow since late 2025.
  • Outcome: Successfully identified a confirmed PRSOV fault on aircraft B-27** within two months of online operation with zero false alarms.
  • The system transitioned maintenance from reactive (waiting for failure) to proactive (identifying fault precursors days in advance).

5. Significance

This work bridges the gap between general-purpose Time-Series Foundation Models and the rigorous requirements of industrial physics. By shifting from parametric learning (which fails with scarce data) to non-parametric, physics-informed retrieval, RAG4CTS demonstrates that:

• Industrial time-series forecasting can be achieved without massive training datasets or fine-tuning.
• Preserving the physical structure of data (covariates and raw transients) is more important than abstract vector representations for critical systems.
• The integration of such AI frameworks into existing industrial databases (Apache IoTDB) is feasible and delivers immediate, high-value operational safety improvements.