Meta Query Module (MQM) in Modern Systems

• Meta Query Module (MQM) is a design concept that mediates diverse signals across systems like semantic querying, open-set active learning, and recommender pre-ranking.
• It orchestrates mechanisms such as parsing natural-language queries, balancing purity and informativeness, and restoring early user-item interactions.
• While each MQM variant targets specific optimization and modularity challenges, they collectively enhance system performance despite latency and signal quality concerns.

Searching arXiv for the specified MQM papers and closely related context papers. Meta Query Module (MQM) is a non-standard term used in recent arXiv literature for several technically distinct mechanisms rather than a single canonical architecture. In the papers considered here, MQM denotes: a top-level orchestration pattern for semantic querying over multi-modal or unstructured data in Meta Engine; a meta-model for balancing purity and informativeness in open-set active learning in Meta-Query-Net; and a learnable early-interaction component inside a two-tower pre-ranking recommender in FIT (Li et al., 2 Feb 2026, Park et al., 2022, Xiong et al., 16 Sep 2025). The commonality is not a shared algorithm but a shared role: each MQM mediates among heterogeneous signals, decomposes or reweights decisions, and exposes a compact interface to a larger system.

1. Terminological scope and principal variants

The term “Meta Query Module” has at least three meanings in the cited literature. In Meta Engine, it is an architectural pattern for “semantic querying over multi-modal or unstructured data” that sits on top of specialized LLM-based query systems. In Meta-Query-Net, it is a small meta-model that scores unlabeled examples from purity and informativeness signals in open-set active learning. In FIT, it is a learnable item-meta matrix that restores early user-item interaction inside a two-tower pre-ranking model (Li et al., 2 Feb 2026, Park et al., 2022, Xiong et al., 16 Sep 2025).

Context	MQM meaning	Primary objective
Meta Engine	Unified semantic query engine module stack	Decompose, route, execute, aggregate
Meta-Query-Net	Non-negative MLP meta-model	Balance purity and informativeness
FIT	Item-meta matrix with soft/hard queries	Enable early interaction with efficient inference

This terminological plurality matters because the acronym can suggest continuity where the actual objects differ in inputs, outputs, optimization criteria, and deployment assumptions. One MQM begins with a natural-language question, another with an unlabeled pool element, and another with an item embedding; correspondingly, their outputs are a final answer string, a query score, and a query-conditioned user representation.

2. MQM as a unified semantic query layer in Meta Engine

In Meta Engine, MQM is an architectural pattern for unified semantic querying over heterogeneous LLM-based systems. Its stated goals are to expose a single natural-language interface for complex queries requiring text, table, and image reasoning; to leverage best-of-breed systems such as DocETL for long text, StructGPT for tables, and VLMs for images; and to decompose, route, execute, and aggregate sub-queries so that each reasoning step uses the system most suited to its modality and task (Li et al., 2 Feb 2026).

The architecture comprises five components. The Natural Language Query Parser determines whether a raw question $Q$ is “simple” or “complex” and, if complex, decomposes it into at most three self-contained sub-queries in “basic-to-advanced” order. The decomposition output is structured as $[Q]$26 and the parser returns either $[Q]$ or $[q_1,\dots,q_n]$ with $n \le 3$.

The Operator Generator then assigns, for each sub-query $q_i$, a ranked list of semantic operators with confidences:

$[(op_1, conf_1), (op_2, conf_2), (op_3, conf_3)],$

where each operator belongs to $$\{\text{TextAnalytics}, \text{TableAnalytics}, \text{ImageAnalytics}\}$$ and each confidence lies in $[0,1]$. The ranking uses lightweight metadata such as titles and captions, and execution follows a fallback policy: the top-ranked operator is tried first, and if it fails to return a valid answer, the next operator is used.

Routing is handled by one of two variants. The Statistic Router (“StatRouter”) always selects the historically best adapter for a given operator type, based on held-out statistics. The Learned Router (“MLRouter”) trains a lightweight classifier $p_\theta(k \mid q, op)$ over adapter IDs $k$, using a frozen LLM encoder for the features and a weighted cross-entropy objective:

$[Q]$0

Here, $[Q]$1 and $[Q]$2 are the top two adapter quality scores on sub-query $[Q]$3, and $[Q]$4 is the best adapter.

Adapters normalize heterogeneous back ends under a common interface: $[Q]$27 The evidence is modality-specific: a list of passages for TextAnalytics, a DataFrame or serialized CSV for TableAnalytics, and image URLs or binary blobs for ImageAnalytics. Each adapter handles API translation, authentication, prompt templates, and deterministic decoding. The Result Aggregator receives the original question and the chain $[Q]$5, filters noisy or irrelevant results, resolves contradictions by preferring specificity and consistency, and returns a final answer capped at at most 10 words.

The integration strategy emphasizes modularity. Adapters decouple core logic from system-specific details; adding a new underlying system only requires a new adapter plus either router retraining or statistics updates. Inter-component communication uses simple Python data structures and JSON rather than bespoke network protocols.

Evaluation spans MultiModalQA (23 817 queries; text + table + image; multi-hop QA), ManyModalQA (1 440 queries; single-hop QA over 3 modalities), Text2Vis (1 788 queries; analytical tasks over table + text + generated chart), M2QA (∼1 000 Wikipedia QA; mixed modalities; multi-hop), and FinMMR (1 291 queries; financial numerical reasoning with tables/charts). Metrics are token-level F1, Hit, and Semantic Hit. The token-level F1 is defined from tokenized prediction $[Q]$6 and ground truth $[Q]$7 through precision and recall; Hit is 1 if there is any token overlap; Semantic Hit is 1 if an independent LLM judge deems $[Q]$8 semantically equivalent to some ground truth. Reported gains are substantial: across five datasets, Meta Engine yields $[Q]$9–$[q_1,\dots,q_n]$0 higher F1 on most tasks and peaks at approximately $[q_1,\dots,q_n]$1 on specialized benchmarks. Concrete examples include Text2Vis, where F1 improves from approximately $[q_1,\dots,q_n]$2 for LOTUS to approximately $[q_1,\dots,q_n]$3 for Meta Engine, and ManyModalQA, where F1 rises from approximately $[q_1,\dots,q_n]$4 to approximately $[q_1,\dots,q_n]$5 and Semantic Hit from approximately $[q_1,\dots,q_n]$6 to approximately $[q_1,\dots,q_n]$7 (Li et al., 2 Feb 2026).

The paper’s own interpretation is that modality-aware decomposition plus adaptive routing produces synergistic gains beyond any single system, confidence-based operator ranking with fallback improves robustness, and learned routing generally outperforms static heuristics. Its listed limitations are latency overhead from multiple LLM calls, potentially reaching $[q_1,\dots,q_n]$8–$[q_1,\dots,q_n]$9 that of a single pass; possible under- or over-decomposition because the parser is restricted to at most three sub-queries; and production cost from GPT-4-style models.

3. MQM as a meta-scoring model in open-set active learning

In Meta-Query-Net, MQM denotes a small meta-model $n \le 3$0 that learns how to balance purity and informativeness when selecting examples from an unlabeled pool containing both in-distribution and out-of-distribution data. Open-set active learning differs from standard active learning because the unlabeled pool $n \le 3$1 includes in-distribution examples drawn from $n \le 3$2 and open-set noise drawn from $n \le 3$3. The paper argues that standard uncertainty, diversity, or hybrid strategies either overlook purity and select many OOD examples or overemphasize purity at the cost of informativeness (Park et al., 2022).

MQ-Net addresses this through a two-dimensional input

$n \le 3$4

where $n \le 3$5 estimates purity and $n \le 3$6 estimates informativeness. The model is a 2-layer MLP with hidden size 64 and non-negative weights. In each active learning round it is used first to select the next batch $n \le 3$7 for labeling and then to meta-train on that same queried set, treated as a self-validation set. This “self-validation” exploits the multi-round structure of active learning and avoids the need for an additional clean validation set.

The learning objective is built around masked cross-entropy, a ranking loss, and skyline regularization. For a target model $n \le 3$8 and IN/OOD indicator $n \le 3$9, the masked cross-entropy is

$q_i$0

so OOD examples incur zero loss. On the queried set $q_i$1, the primary ranking loss enforces agreement between the meta-scores and the ordering induced by masked losses:

$q_i$2

with margin $q_i$3. Skyline regularization imposes monotonicity:

$q_i$4

This is enforced by constraining all MLP weights to be non-negative and using non-decreasing activations such as ReLU and Sigmoid. The full meta-objective is

$q_i$5

The algorithmic procedure alternates between base-level target-model training and meta-level score-model training. The target model $q_i$6 is trained on in-distribution elements of the labeled set $q_i$7. Selection proceeds under a labeling budget $q_i$8. In the first round, before the meta-model has been trained, the heuristic is

$q_i$9

In later rounds, the query rule becomes

$[(op_1, conf_1), (op_2, conf_2), (op_3, conf_3)],$0

After oracle labeling of $[(op_1, conf_1), (op_2, conf_2), (op_3, conf_3)],$1, the queried set is added to $[(op_1, conf_1), (op_2, conf_2), (op_3, conf_3)],$2, pairwise training examples are formed from $[(op_1, conf_1), (op_2, conf_2), (op_3, conf_3)],$3, and the MQ-Net parameters are updated by gradient descent on the meta-loss. The paper specifies equal annotation cost for IN and OOD examples.

Purity and informativeness are modular. Purity can be derived from an OOD detector score $[(op_1, conf_1), (op_2, conf_2), (op_3, conf_3)],$4 such as Energy, ODIN, ReAct, or CSI via

$[(op_1, conf_1), (op_2, conf_2), (op_3, conf_3)],$5

while informativeness can be derived from an active learning query score $[(op_1, conf_1), (op_2, conf_2), (op_3, conf_3)],$6 such as entropy, margin, LL, or BADGE via

$[(op_1, conf_1), (op_2, conf_2), (op_3, conf_3)],$7

The reported empirical behavior is adaptive: MQ-Net tends to prefer high purity in early rounds or at higher OOD ratios, and shifts toward high informativeness in later rounds or at lower OOD ratios.

The experimental setup includes split-dataset and cross-dataset scenarios. Split-dataset settings use CIFAR10 with 4 target classes and 6 OOD classes, CIFAR100 with 40 target and 60 OOD classes, and ImageNet50 versus the other 950 ImageNet classes, with noise ratios $[(op_1, conf_1), (op_2, conf_2), (op_3, conf_3)],$8. Cross-dataset settings mix CIFAR or ImageNet50 with LSUN+Places365 as external OOD. Final test accuracy on a clean IN test set is the principal metric, with AUROC used in some ablations. Baselines include Random, CONF, CORESET, LL, BADGE, CCAL, and SIMILAR. The target model is ResNet-18 trained with SGD, learning-rate schedule $[(op_1, conf_1), (op_2, conf_2), (op_3, conf_3)],$9, weight decay $$\{\text{TextAnalytics}, \text{TableAnalytics}, \text{ImageAnalytics}\}$$0, and 20K iterations on CIFAR. MQ-Net uses a meta learning rate of $$\{\text{TextAnalytics}, \text{TableAnalytics}, \text{ImageAnalytics}\}$$1 and is trained for 10 AL rounds with budget $$\{\text{TextAnalytics}, \text{TableAnalytics}, \text{ImageAnalytics}\}$$2 for CIFAR and $$\{\text{TextAnalytics}, \text{TableAnalytics}, \text{ImageAnalytics}\}$$3 for ImageNet over 5 independent runs.

Quantitatively, MQ-Net is reported to achieve final-round accuracies of 93.10 on CIFAR10 at $$\{\text{TextAnalytics}, \text{TableAnalytics}, \text{ImageAnalytics}\}$$4, 89.51 on CIFAR10 at $$\{\text{TextAnalytics}, \text{TableAnalytics}, \text{ImageAnalytics}\}$$5, 58.96 on CIFAR100 at $$\{\text{TextAnalytics}, \text{TableAnalytics}, \text{ImageAnalytics}\}$$6, and 54.11 on ImageNet50 at $$\{\text{TextAnalytics}, \text{TableAnalytics}, \text{ImageAnalytics}\}$$7. The paper summarizes these results as outperforming the second-best method by up to 4.37% and the worst baseline by up to 20.14% (Park et al., 2022). Its stated limitations are dependence on the quality of $$\{\text{TextAnalytics}, \text{TableAnalytics}, \text{ImageAnalytics}\}$$8 and $$\{\text{TextAnalytics}, \text{TableAnalytics}, \text{ImageAnalytics}\}$$9, the fact that OOD-labeled examples are not used for training $[0,1]$0, and privacy concerns because queried examples are exposed to annotators.

4. MQM as an early-interaction mechanism in FIT pre-ranking

In the FIT architecture for recommender-system pre-ranking, MQM is a learnable early-interaction mechanism that counteracts the expressiveness limits of conventional two-tower models. Standard two-tower systems independently encode user and item inputs and combine them only through a late interaction such as a dot product. FIT’s MQM restores early interaction by learning an item-meta matrix $[0,1]$1 whose rows act as a small set of “cluster-centroid” queries. During training, each item embedding softly matches all rows to produce a weighted “soft query” $[0,1]$2, which conditions an attention or sequence-pooling operation in the user tower. During inference, each item is assigned to a single “hard query” so that only one extra user-tower forward pass per cluster is needed, preserving nearly the same efficiency as a vanilla two-tower system (Xiong et al., 16 Sep 2025).

The paper defines the item embedding $[0,1]$3, the learnable item-meta matrix $[0,1]$4 with rows $[0,1]$5, the softmax temperature $[0,1]$6, the user behavior sequence $[0,1]$7, and the injected query-mediated vector $[0,1]$8. A parameter-free self-attention transform first produces

$[0,1]$9

For an item embedding $p_\theta(k \mid q, op)$0, the logits are

$p_\theta(k \mid q, op)$1

and the softmax weights are

$p_\theta(k \mid q, op)$2

The training-time soft query is then

$p_\theta(k \mid q, op)$3

while the hard-query index is

$p_\theta(k \mid q, op)$4

At inference, $p_\theta(k \mid q, op)$5 is replaced by the single hard query $p_\theta(k \mid q, op)$6.

The soft query is injected into the user tower through attention over the behavior sequence. Using DIN-style attention as the example in the paper,

$p_\theta(k \mid q, op)$7

The final user-tower input is

$p_\theta(k \mid q, op)$8

which is fed through $p_\theta(k \mid q, op)$9 layers of FC + ReLU + L2-norm to obtain $k$0. Downstream scoring is then handled by the Lightweight Similarity Scorer (LSS), which lies outside MQM proper.

The module’s dimensions and scheduling are explicitly specified. $k$1 is the concatenated item-feature dimension, and in the experiments $k$2. The meta-vector count $k$3 takes typical values 16, 32, 64, 128, or 256, with $k$4 reported as a good trade-off between performance and efficiency. The matrix $k$5 is initialized with Kaiming uniform, and the temperature $k$6 decays linearly from 1.0 to 0.001 over the first epoch before being clamped at 0.001. This schedule initially spreads gradient across many meta-vectors and then gradually collapses to a single hard cluster per item, improving consistency between training and inference.

Training and inference are designed to retain pre-ranking efficiency. During training, the model computes $k$7, injects it into the user tower, computes user and item representations, and optimizes the cross-entropy loss

$k$8

Gradients flow from $k$9 back to the softmax weights and hence to $[Q]$00 and $[Q]$01. During inference, $[Q]$02 is precomputed offline, and for each item the system stores $[Q]$03, where $[Q]$04 is the hard-query index. Online, the user side computes $[Q]$05 user-tower branches in parallel, and the correct branch $[Q]$06 is used for scoring against $[Q]$07.

The complexity analysis contrasts vanilla two-tower and FIT. Vanilla scoring requires one user-tower pass plus $[Q]$08 dot products, for total complexity approximately $[Q]$09. FIT adds an offline $[Q]$10 computation for $[Q]$11 and replaces one user-tower pass with $[Q]$12 parallel branches, giving approximately $[Q]$13 on the user side; per-item online cost remains essentially unchanged because only an index lookup and a single score are needed. The paper states that when $[Q]$14, the extra user-side cost is amortized.

The empirical ablation isolates the effect of MQM by comparing full FIT to a version “w/o MQM” that removes the meta query and reverts to average pooling over the user sequence with no item-context injection. On Taobao at $[Q]$15, full FIT reaches AUC 0.6736, whereas “w/o MQM” reaches 0.6662, a drop of 0.0074 AUC and a loss of 11% relative improvement. On Amazon Books, full FIT reaches 0.9171, versus 0.9058 without MQM, a drop of 0.0113 AUC. Additional diagnostics report that hard-query-only training converges more slowly and reaches lower AUC than soft-query training, training without temperature scheduling underperforms training with decaying $[Q]$16, and removing the parameter-free self-attention step slows early training and slightly degrades final AUC (Xiong et al., 16 Sep 2025).

5. Comparative analysis across the three MQM lineages

Although the three MQM variants are architecturally unrelated, they share a common systems role: each inserts a learned or configurable mediation layer between a raw upstream signal and a downstream decision. In Meta Engine, the mediation occurs between a natural-language question and a set of heterogeneous LLM-based query systems through parsing, operator selection, routing, and aggregation. In Meta-Query-Net, it occurs between purity/informativeness heuristics and the active-learning selection policy through a non-negative MLP. In FIT, it occurs between item features and the user tower through a learnable matrix of meta-queries and a soft-to-hard selection schedule (Li et al., 2 Feb 2026, Park et al., 2022, Xiong et al., 16 Sep 2025).

Their optimization targets differ sharply. Meta Engine is evaluated by answer quality metrics such as token-level F1, Hit, and Semantic Hit, so its MQM is optimized for semantic query execution quality. MQ-Net is optimized through a ranking loss defined on masked cross-entropy over a self-validation set, so its MQM is explicitly a meta-learner over active-learning rounds. FIT is optimized through standard click-prediction cross-entropy within a pre-ranking pipeline, so its MQM is a differentiable feature-interaction module.

Their modularity mechanisms also differ. Meta Engine’s modularity is external: adapters expose a common execute(...) interface and allow new back ends to be added by supplying a wrapper and retraining or updating the router. MQ-Net’s modularity is score-level: any OOD detector can furnish $[Q]$17 and any active-learning query function can furnish $[Q]$18, while the non-negative MLP learns the combination. FIT’s modularity is representational: the meta matrix $[Q]$19 supplies a compact learned basis of item-conditioned queries that can be inserted into a user behavior encoder without altering the fundamental precompute-and-score pattern of two-tower retrieval.

A frequent source of confusion is the shared acronym itself. In these papers, “Meta Query Module” does not denote a single standardized mathematical object, nor does it imply a common code path, benchmark family, or theoretical framework. The term instead describes a recurring design intuition: a compact intermediate mechanism can improve system-level behavior by reconfiguring how queries, examples, or item representations interact with downstream computation.

6. Limitations, misconceptions, and reported future directions

The limitations reported for MQM depend on the domain in which the term is instantiated. In Meta Engine, the chief issue is systems overhead: the full pipeline can require multiple LLM calls for parsing, operator generation, routing, execution, and aggregation, leading to latency that may be $[Q]$20–$[Q]$21 that of a single-pass system. The restriction to at most three sub-queries can also under-break extremely complex questions or over-break simple ones, and reliance on GPT-4-style models may make production deployment expensive (Li et al., 2 Feb 2026).

In MQ-Net, the bottleneck is signal quality rather than orchestration overhead. If the underlying OOD detector produces poor purity estimates or the active-learning heuristic produces poor informativeness estimates, the meta-learner may struggle. The paper also notes that OOD-labeled examples are not exploited for training the target model and identifies privacy concerns because annotated queries are shown to human annotators (Park et al., 2022).

In FIT, the main tension is between expressiveness and latency. Larger $[Q]$22 gives finer item clustering and potentially better AUC, but it also increases the number of user-tower branches and the risk of overfitting. The reported guidance is therefore to start with $[Q]$23, match $[Q]$24 to the item-tower output dimension, use He initialization, and decay $[Q]$25 from 1.0 to 0.001 over the first epoch (Xiong et al., 16 Sep 2025).

The papers also identify future extensions. Meta Engine proposes parallel sub-query execution, result caching at the operator or adapter level, meta-learning for online router adaptation as new adapters or domain shifts emerge, and user-guided refinement of sub-queries before execution. MQ-Net suggests explicit skyline-margin losses and the incorporation of OOD examples into target-model training as outlier exposure. FIT suggests longer temperature-decay schedules for very large datasets and retains the general possibility of tuning the meta-vector count to balance AUC against serving cost. Taken together, these directions suggest continued interest in MQM-like designs as control layers that sit above raw signals and below final task outputs, even though the exact mathematical form of the module remains domain-specific.