MetaboT: An LLM-based Multi-Agent Frameworkfor Interactive Analysis of Mass SpectrometryMetabolomics Knowledge Graphs

Benjamin Navet (ICN); Emma Tysinger (ICN); Fabien Gandon (WIMMICS; Florence Mehl (SIB); Franck Michel (WIMMICS); ICN); Jean-Luc Wolfender (UNIGE); Laboratoire I3S - SPARKS); Louis-F\'elix Nothias (CNRS; Lucas Pradi (ICN)

REVIEW 3 major objections 4 minor 22 references

MetaboT: An LLM-based Multi-Agent Frameworkfor Interactive Analysis of Mass SpectrometryMetabolomics Knowledge Graphs

T0 review · 3 major / 4 minor · reviewed 2026-08-04 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read This paper claims that a multi-agent LLM pipeline, resolving entities against authoritative sources before writing SPARQL, answers 83.67% of metabolomics knowledge-graph questions correctly, versus 8.16% for a single LLM.

desk verdict Useful open-source multi-agent tool, but the headline accuracy is built on a self-contaminated benchmark and a post-hoc exclusion; the real value is the architecture and the released code, not the 83.67% number. read the letter →

arxiv 2510.01724 v2 pith:XVALX23W submitted 2025-10-02 cs.AI

Madina Bekbergenova (ICN) , Lucas Pradi (ICN) , Benjamin Navet (ICN) , Emma Tysinger (ICN) , Franck Michel (WIMMICS) , Matthieu Feraud (ICN) , Yousouf Taghzouti (ICN , WIMMICS)

show 14 more authors

Yan Zhou Chen Olivier Kirchhoffer (UNIGE) Florence Mehl (SIB) Martin Legrand (ICN) Tao Jiang (ICN) Marco Pagni (SIB) Soha Hassoun Jean-Luc Wolfender (UNIGE) Wout Bittremieux Fabien Gandon (WIMMICS Laboratoire I3S - SPARKS) Louis-Félix Nothias (CNRS UniCA ICN)

This is my paper

classification cs.AI

keywords massspectrometrymetabolomicsknowledgegraphstext-to-SPARQLmulti-agentLLMsystemsentityresolutionnaturallanguagequeryingENPKGSPARQLgeneration

verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

This paper claims that the main obstacle to querying metabolomics knowledge graphs by natural language—LLM hallucination of entity identifiers and schema-incompatible SPARQL—can be largely overcome by decomposing the task into specialized agents. A six-agent pipeline validates the question, resolves every named entity against authoritative external sources before query construction, generates schema-aware SPARQL, and iteratively refines failed queries. On a 50-question expert-crafted benchmark over the ENPKG plant metabolomics graph, the full system answered 83.67% of scored questions correctly, against 8.16% for the same strong LLM asked to write SPARQL directly. The claim matters because it would give metabolomics researchers a conversational route into semantic data mining without learning RDF or SPARQL.

What carries the argument

The load-bearing mechanism is the multi-agent decomposition with external entity resolvers: instead of asking an LLM to map names to identifiers from memory, dedicated tools resolve taxa, chemical classes, SMILES strings, and biological targets against authoritative endpoints, and those canonical IRIs are injected into the SPARQL-generation prompt together with the graph schema in Turtle. The refinement loop is secondary but important: when a query returns nothing, the system regenerates once, distinguishing query-construction errors from genuinely absent data.

What would settle it

Have domain experts who never saw MetaboT's output write a fresh set of reference SPARQL queries for the same ENPKG data, pre-register the scoring rule, and run MetaboT on it. If the accuracy is materially below 83.67%, or the single-LLM baseline rises, the architecture's reported gain was inflated by benchmark construction.

Watch

Extended reading notes

Core claim

MetaboT's central claim is that routing natural-language questions through specialized agents—an entry agent, a scope validator, a supervisor, a knowledge-graph entity-resolution agent, a SPARQL runner, and an interpreter—yields correct SPARQL where a single LLM fails. The decisive mechanism is entity resolution: before any query is written, chemical names, SMILES strings, biological targets, and taxonomic names are resolved to canonical identifiers using external tools, so the LLM never invents URIs. In evaluation over the ENPKG knowledge graph, the GPT-4o-based system achieved 83.67% accuracy (41 of 49 scored questions after one question was removed), versus 8.16% for standalone GPT-4o and

Load-bearing premise

The accuracy figures stand only if the 49-question benchmark is an unbiased measure: the reference queries were produced by feeding the 50 questions to MetaboT and manually correcting the drafts, and one question was removed from scoring after MetaboT recovered the reference, so the benchmark may overstate real performance on independently written expert queries.

Editorial extensions

If this is right

If the 83.67% accuracy generalizes, metabolomics researchers can explore ENPKG through ordinary questions, with each query costing about $0.06 and taking about 80 seconds.
The modular agent design is claimed to transfer to other mass-spectrometry knowledge graphs with minimal reconfiguration, not just ENPKG.
The drop to 12.24% when the same pipeline runs on a smaller model implies that agent orchestration cannot compensate for weak base-model reasoning, so model selection drives the outcome.
The documented error classes give concrete targets—validator false rejections, supervisor routing, tool selection, and SPARQL syntax—that subsequent work can fix independently.
The one-shot refinement loop that distinguishes empty results caused by query errors from genuinely missing data is a reusable mechanism for any LLM query system over structured data.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

Editorial: The reported 83.67% is likely an upper bound on the architecture's true accuracy: the reference SPARQL queries were drafted from MetaboT's own outputs and then manually corrected, and one question was excluded after MetaboT reproduced the reference. An independently authored benchmark could score lower.
Editorial: Because the anti-hallucination gain comes from external resolvers, applying MetaboT to a new knowledge graph will work only if equivalent authoritative identifier sources exist for that graph's entity types.
Editorial: A hybrid routing policy—cheap model for low-complexity questions, strong model for high-complexity ones—could cut cost while preserving accuracy; the paper gestures at this but does not test it.
Editorial: The framework could be stress-tested by withholding parts of the schema during query generation, checking whether the refinement loop still recovers correct SPARQL, which would isolate the value of schema provision from entity resolution.

Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Desk Editor's Note

read the letter

The paper is worth reading for the MetaboT system itself — open-source, modular, with sensible agent separation — but the headline 83.67% accuracy should not be taken at face value. The benchmark reference queries were partly generated by the same system being evaluated, and one question was removed from the denominator after the fact.

What is genuinely new and good: MetaboT is a concrete, working implementation of a multi-agent LLM pipeline for querying the ENPKG knowledge graph. The six-agent design (entry, validator, supervisor, KG, query runner, interpreter) and the specialized resolvers against Wikidata, ChEMBL, and GNPS are a real engineering contribution. The code, evaluation data, and Docker config are all public, which makes it a useful starting point for anyone building natural-language interfaces over biomedical knowledge graphs. The comparison to single-shot GPT-4o is striking (8.16% vs 83.67%), and even if the true number is lower, the architecture likely does meaningfully reduce entity hallucination because IRIs are pulled from authoritative APIs rather than the LLM's memory.

Now the soft spots. The evaluation procedure is circular as described on pages 18–19: the authors submitted the 50 questions to MetaboT, manually corrected the outputs into the 'reference' SPARQL queries, then scored MetaboT against those corrected outputs. That aligns the yardstick with the system's own query style and typical failure modes, so the accuracy estimate is almost certainly inflated. The post-hoc removal of one question — because the refinement chain reproduced the reference query 'identical' — is a second red flag. No pre-registered rule for exclusion is given. Also, no repeated runs or confidence intervals are reported despite the paper explicitly acknowledging LLM non-determinism. The evaluation also stops at SPARQL generation, while the abstract claims "answer" quality; the interpreter is not evaluated. These are not fatal flaws, but they mean the headline number should be treated as an upper bound, not a reliable point estimate.

Credit where due: the paper is transparent about its procedure and limitations, lists non-determinism and hallucinations as acknowledged weaknesses, and the released artifacts are genuinely useful. This is an honest engineering paper, not a hidden-ball trick. The issues are fixable with an independent expert-written benchmark, repeated runs, error bars, and an end-to-end evaluation of the interpreter.

Who gets value: researchers building LLM-based interfaces over biomedical knowledge graphs, and metabolomics data scientists who want a working tool to try. It deserves serious peer review, with the evaluation section flagged for major revision. My recommendation: send it to referees, but expect the benchmark to be redone.

Referee Report

3 major / 4 minor

Summary. The paper introduces MetaboT, an open-source multi-agent LLM framework that converts natural-language questions into executable SPARQL queries over the ENPKG metabolomics knowledge graph. The architecture consists of six specialized agents—Entry, Validator, Supervisor, KG, SPARQL Query Runner, and Interpreter—supported by nine tools for entity resolution (TaxonResolver, ChemicalResolver, SMILESResolver, TargetResolver), query generation (GraphSparqlQAChain), and result interpretation. The authors evaluate three configurations on a 50-question benchmark: standalone GPT-4o achieves 8.16% accuracy, MetaboT with GPT-4o mini 12.24%, and MetaboT with GPT-4o 83.67% (reported as 41/49 after one question is removed). The paper also reports average query times, token costs, an error analysis with four error types, and a discussion of limitations including hallucinations, non-determinism, and computational cost.

Significance. If the reported accuracy is taken at face value, the paper makes a useful contribution: it demonstrates a multi-agent architecture with external entity resolvers substantially improving text-to-SPARQL generation over single-LLM prompting for a domain-specific knowledge graph, and it ships open-source code, a public demo instance, and a released evaluation dataset. These artifacts make the work reproducible and give the community a concrete baseline. However, the central claim rests on an evaluation whose ground truth was partly produced by the system itself and whose scoring rule includes a post-hoc exclusion, so the precise magnitude of the claimed improvement (roughly 10x over standalone GPT-4o) is not yet established. The architecture and qualitative findings are valuable even if the headline number requires re-estimation with an external benchmark.

major comments (3)

[Evaluation Procedure, pp. 18–19] The reference SPARQL queries are not independent of the system under test. The text states: 'These questions were then submitted to MetaboT, which generated initial SPARQL queries. We manually reviewed and corrected these queries based on the knowledge graph schema to ensure semantic correctness...' This means the ground-truth yardstick is a corrected version of MetaboT's own output. Such contamination can align the reference queries with MetaboT's query style, typical property choices, and error patterns, biasing the 83.67% accuracy upward relative to an independently authored expert benchmark. The abstract's phrase 'expert-authored benchmark' overstates what the Methods describe. To make the headline claim load-bearing, the authors need either (a) an independent set of reference queries written by experts without exposing them to MetaboT's outputs, or (b) a clear demonstration that the
[Evaluation Procedure, p. 19] The post-hoc removal of one question from the denominator is not justified by a pre-specified rule. The text reads: 'For 3 out of the 50 questions, the SPARQL refinement chain regenerated queries by using formulations identical to the correct reference queries for those questions; however, this approach proved beneficial for only 1 question, and consequently, that question was removed from the overall accuracy count.' Since the reference queries were themselves derived from MetaboT outputs, the fact that the refinement chain can regenerate the reference query is precisely an indication of circularity rather than a reason to delete the failure from scoring. The authors should report results both as 41/50 (82%) and 41/49 (83.67%), and specify, before scoring, which exclusions are permissible and why. Without this, the reported six-percentage-point gap between 41/49 and 41/50 hides part of
[Limitations and Future Directions, p. 20; Evaluation Procedure, pp. 18–19] The paper acknowledges non-determinism ('The inherent variability in LLM outputs means that identical queries may yield slightly different SPARQL commands') but reports a single run of the evaluation with no repeats, no confidence intervals, and no error bars. For a point estimate of 83.67% on 49 questions, stochastic variation alone could plausibly shift the accuracy by several points. At minimum, the authors should run the full evaluation multiple times (e.g., 3–5 runs) and report the range and standard deviation, or a bootstrap confidence interval. They should also report per-question stability across runs, since some errors may be transient while others are systematic.

minor comments (4)

[Abstract and Evaluation Procedure] The abstract calls the benchmark 'expert-authored,' but the Methods describe a 'synthetic dataset' whose questions were 'crafted with the help of domain experts' and whose reference SPARQL queries were generated by MetaboT and then manually corrected. Please align the terminology with the actual provenance to avoid overstating objectivity.
[Results, Supplementary Table 1] Per-complexity accuracies such as 78.95% for high-complexity queries are based on small denominators (roughly 20 questions, and fewer after the post-hoc exclusion). Reporting raw counts (e.g., 15/19) alongside percentages would allow readers to judge the stability of the per-category claims.
[System Architecture / Figure 1] The caption of Figure 1 notes that 'SPARQL Agent' in the figure refers to the 'SPARQL Query Runner Agent' in the text. The inconsistency is confusing; please align the naming in the figure with the rest of the paper.
[Evaluation Procedure, p. 19] The sentence describing the three 'out of 50 questions' is ambiguous: it is not clear whether the refinement chain produced queries 'identical to the correct reference queries' in all three cases or only in one, and whether the other two were counted as successes or failures. Clarify the scoring logic and report the outcomes for all three cases.

Circularity Check

2 steps flagged · score 4.0 of 10

Central accuracy estimate is partly circular: the reference SPARQL benchmarks were seeded by MetaboT's own outputs and one matching success was excluded post hoc.

fitted input called prediction [Evaluation Procedure, p. 18-19]
"These questions were then submitted to MetaboT, which generated initial SPARQL queries. We manually reviewed and corrected these queries based on the knowledge graph schema to ensure semantic correctness and full alignment with the intent of each question."

The reference SPARQL queries are not an independent expert yardstick: they were drafted by the system under test and then manually corrected. Measuring MetaboT's accuracy against references derived from MetaboT's own outputs aligns the target with the system's query style, entity choices, and error patterns. This makes the headline 83.67% accuracy partly a comparison of the system to a corrected version of itself rather than to an external standard. Manual review mitigates but does not remove the circularity, because the draft queries retain the system's structural choices.
other [Evaluation Procedure, p. 19]
"For 3 out of the 50 questions, the SPARQL refinement chain regenerated queries by using formulations identical to the correct reference queries for those questions; however, this approach proved beneficial for only 1 question, and consequently, that question was removed from the overall accuracy count."

A system-generated query that exactly matches the reference is, by the paper's own definition, a correct answer. Removing that question after observing the result changes the scoring set post hoc. Since the reference queries were themselves initialized from MetaboT outputs, the fact that the refinement chain 'regenerated' the reference is not independent confirmation; it is the system reproducing a query that the benchmark construction had already absorbed from it. This post hoc exclusion influences the reported 83.67% (41/49) figure and reduces the objectivity of the estimate.

full rationale

The architecture itself is not circular: the multi-agent decomposition, entity resolvers, refinement loop, and within-framework comparisons (GPT-4o vs GPT-4o mini) are implemented and evaluated against a real SPARQL endpoint, and the natural-language questions were expert-crafted. No load-bearing self-citation chain or imported uniqueness theorem is present. However, the principal quantitative claim is partially circular because the reference SPARQL queries used as ground truth were initiated by MetaboT and then manually corrected, so the benchmark is not fully external to the system. The additional post-hoc removal of a question in which the system matched the reference further weakens the independence of the reported accuracy. These issues attack the yardstick rather than the internal logic of the framework, so the appropriate score is 4: partial circularity in the evaluation benchmark, while the central system design retains independent content.

Assumptions & free parameters 3 free parameters · 4 assumptions · 0 invented entities

This is an empirical systems paper, so there are no mathematical free parameters in the derivation sense. The closest equivalents are hand-chosen system hyperparameters and external resources the evaluation relies on, listed above. MetaboT introduces no new physical or conceptual entities; 'agents' and 'tools' are software components, not postulated mechanisms.

free parameters (3)

SPARQL query regeneration attempts = 1
GraphSparqlQAChain regenerates an unsuccessful query only once; raising this number would change accuracy, so the reported 83.67% is contingent on this hand-set value. Location: 'This refinement is performed only once'.
LLM context result token cap = 6000 tokens
Results exceeding 6000 tokens are truncated before reaching the LLM, which can alter answers; this limit is chosen by hand. Location: 'exceed a specified limit (6000 tokens)'.
ChemicalResolver embedding model = OpenAI embeddings (unspecified)
Chemical-class retrieval uses FAISS with OpenAI embeddings on a local NPCClass CSV; the embedding model affects entity-resolution accuracy and is an implementation choice. Location: Tools Integration, item 2.

assumptions (4)

domain assumption ENPKG schema and data coverage are sufficient to answer the 50 benchmark questions, so every failure to return data is attributable to query-construction errors rather than missing data.
MetaboT's refinement loop treats a second failure as possible data absence, but the accuracy metric assumes reference queries yield data. The ground truth depends on ENPKG containing the answers. Location: SPARQL Query Generation and Execution / Evaluation Procedure.
ad hoc to paper The 50 synthetic benchmark questions are representative of real metabolomics researcher queries.
The dataset is self-created ('we created a synthetic dataset comprising 50 questions across different ontology classes') and no real user query logs or external benchmark are used to validate representativeness. Location: Evaluation Procedure.
domain assumption LLM-as-a-judge, after manual review, provides correct labels of SPARQL query correctness.
Automated evaluation used LangSmith with LLM evaluators comparing outputs to reference queries by correctness and similarity. If the judge rewards textual similarity over semantic equivalence, accuracy can be inflated. The paper acknowledges judges can hallucinate and says manual evaluation was used, but does not quantify judge accuracy. Location: Evaluation Procedure.
domain assumption Entity resolvers (Wikidata, ChEMBL, GNPS, FAISS) return correct IRIs for all entities appearing in the benchmark questions.
The system inserts resolved IRIs directly into generated SPARQL; a wrong IRI would make a correct query fail and be scored as an error. No evaluation of resolver accuracy is reported. Location: Tools Integration / KG Agent.

how reviews work

0 comments

Cite this review

Pith. "Pith review of MetaboT: An LLM-based Multi-Agent Frameworkfor Interactive Analysis of Mass SpectrometryMetabolomics Knowledge Graphs." pith.science (2026). https://pith.science/paper/XVALX23W

@misc{pith2026251001724,
  author       = {Pith},
  title        = {Pith review of: MetaboT: An LLM-based Multi-Agent Frameworkfor Interactive Analysis of Mass SpectrometryMetabolomics Knowledge Graphs},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/XVALX23W}},
  note         = {Machine review of arXiv:2510.01724}
}

read the original abstract

Mass spectrometry-based metabolomics generates complex, high-dimensional data that holds vast potential for biological discovery but remains difficult to integrate and interpret. Knowledge graphs (KGs) unify this heterogeneous information by representing spectra, annotations, taxa, chemical classes, and biological activities as a single interoperable network; however, their practical use is limited by the steep learning curve of corresponding specialized representation and query languages. Here we introduce MetaboT, an open-source multi-agent Large Language Model (LLM) framework that translates natural-language questions into executable SPARQL queries over metabolomics knowledge graphs. MetaboT mitigates the hallucination and schema-compliance limitations of single-model approaches through a modular architecture in which specialised agents handle scope validation, entity resolution against authoritative resources, schema-aware query generation, iterative refinement, and result interpretation. We validated MetaboT on the Experimental Natural Products Knowledge Graph (ENPKG), using an expert-authored benchmark of natural-language questions paired with reference SPARQL queries, and demonstrate its ability to answer complex questions about plant--metabolite relationships and biological activities. MetaboT lowers the technical barrier for metabolomics researchers and enables semantic data mining without specialised programming expertise.

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

22 extracted references · 2 canonical work pages

[1]

& Huan, T

Guo, J., Yu, H., Xing, S. & Huan, T. Addressing big data challenges in mass spectrometry-based metabolomics. Chem. Commun. 58, 9979–9990 (2022). Page 26/29

2022
[2]

Schmid, R. et al. Integrative analysis of multimodal mass spectrometry data in MZmine 3. Nat. Biotechnol. 41, 447–449 (2023)

2023
[3]

Wang, M. et al. Sharing and community curation of mass spectrometry data with Global Natural Products Social Molecular Networking. Nat. Biotechnol. 34, 828–837 (2016)

2016
[4]

Röst, H. L. et al. OpenMS: a exible open-source software platform for mass spectrometry data analysis. Nat. Methods 13, 741–748 (2016)

2016
[5]

Dührkop, K. et al. Systematic classication of unknown metabolites using high-resolution fragmentation mass spectra. Nat. Biotechnol. 39, 462–471 (2021). . Alseekh, S. et al. Mass spectrometry-based metabolomics: a guide for annotation, quantication and best reporting practices. Nat. Methods 18, 747–756 (2021)

2021
[7]

Ebbels, T. M. D. et al. Recent Advances in Mass Spectrometry-Based Computational Metabolomics. Curr. Opin. Chem. Biol. 74, 102288 (2023). . Meijer, D. et al. Empowering natural product science with AI: leveraging multimodal data and knowledge graphs. Nat. Prod. Rep. 42, 654–662 (2025)

2023
[9]

Gaudry, A. et al. A Sample-Centric and Knowledge-Driven Computational Framework for Natural Products Drug Discovery. ACS Cent. Sci. 10, 494–510 (2024)

2024
[10]

Rony, M. R. A. H., Kumar, U., Teucher, R., Kovriguina, L. & Lehmann, J. SGPT: A Generative Approach for SPARQL Query Generation From Natural Language Questions. IEEE Access 10, 70712–70723 (2022)

2022

Show all 22 references

[11]

& Both, A

Perevalov, A., Gashkov, A., Eltsova, M. & Both, A. Understanding SPARQL Queries: Are We Already There? Multilingual Natural Language Generation Based on SPARQL Queries and Large Language Models. in The Semantic Web – ISWC 2024 173–191 (Springer, Cham, 2025). doi:10.1007/978-3-...

2024 doi
[12]

& Arndt, N

Meyer, L.-P., Frey, J., Brei, F. & Arndt, N. Assessing SPARQL capabilities of Large Language Models. Preprint at http://arxiv.org/abs/2409.05925 (2024)

2024 arXiv
[13]

Emonet, V., Bolleman, J., Duvaud, S., Farias, T. M. de & Sima, A. C. LLM-based SPARQL Query Generation from Natural Language over Federated Knowledge Graphs. Preprint at https://doi.org/10.48550/arXiv.2410.06062 (2024)

2024 doi arXiv
[14]

& de Farias, T

Sima, A.-C. & de Farias, T. M. On the Potential of Articial Intelligence Chatbots for Data Exploration of Federated Bioinformatics Knowledge Graphs. arXiv.org https://arxiv.org/abs/2304.10427v1 (2023)

2023 arXiv
[15]

Lobentanzer, S. et al. Democratizing knowledge representation with BioCypher. Nat. Biotechnol. 41, 1056–1059 (2023). 1. Lobentanzer, S. et al. A platform for the biomedical application of large language models. Nat. Biotechnol. 43, 166–169 (2025)

2023
[17]

M., Ali, M., Sherif, M

Zahera, H. M., Ali, M., Sherif, M. A., Moussallem, D. & Ngomo, A.-C. N. Generating SPARQL from Natural Language Using Chain-of-Thoughts Prompting. in (2024). Page 27/29 1. Zong, C. et al. Triad: A Framework Leveraging a Multi-Role LLM-based Agent to Solve Knowledge Base Questi...

2024 doi arXiv
[19]

Waagmeester, A. et al. Wikidata as a knowledge graph for the life sciences. eLife 9, e52614 (2020)

2020
[20]

Zdrazil, B. et al. The ChEMBL Database in 2023: a drug discovery platform spanning multiple bioactivity data types and time periods. Nucleic Acids Res. 52, D1180–D1192 (2024)

2023
[21]

https://www.psidev.info/usi (2023)

Universal Spectrum Identier - HUPO Proteomics Standards Initiative. https://www.psidev.info/usi (2023)

2023
[22]

Bittremieux, W. et al. Universal MS/MS Visualization and Retrieval with the Metabolomics Spectrum Resolver Web Service. 2020.05.09.086066 Preprint at https://doi.org/10.1101/2020.05.09.086066 (2020)

2020 doi
[23]

& Liu, T

Chen, S., Liu, Y., Han, W., Zhang, W. & Liu, T. A Survey on LLM-based Multi-Agent System: Recent Advances and New Frontiers in Application. Preprint at https://doi.org/10.48550/arXiv.2412.17481 (2025)

2025 doi arXiv
[24]

Guo, T. et al. Large Language Model based Multi-Agents: A Survey of Progress and Challenges. Preprint at https://doi.org/10.48550/arXiv.2402.01680 (2024)

2024 doi arXiv
[25]

Rutz, A. et al. The LOTUS Initiative for Open Natural Products Research: Knowledge Management through Wikidata. 2021.02.28.433265 Preprint at https://doi.org/10.1101/2021.02.28.433265 (2021). 2. Heling, L. & Acosta, M. A Framework for Federated SPARQL Query Processing over Het...

2021 doi arXiv
[27]

SPARQL Agent

M. Bran, A. et al. Augmenting large language models with chemistry tools. Nat. Mach. Intell. 6, 525– 535 (2024). Figures Page 28/29 Figure 1 MetaboT overview. a) A user’s natural-language question is translated into a SPARQL query and executed against the mass spectrometry kno...

2024

Pith tools

Reviewed August 4, 2026 · model on record in the stance chip above.

[1] [1]

& Huan, T

Guo, J., Yu, H., Xing, S. & Huan, T. Addressing big data challenges in mass spectrometry-based metabolomics. Chem. Commun. 58, 9979–9990 (2022). Page 26/29

2022

[2] [2]

Schmid, R. et al. Integrative analysis of multimodal mass spectrometry data in MZmine 3. Nat. Biotechnol. 41, 447–449 (2023)

2023

[3] [3]

Wang, M. et al. Sharing and community curation of mass spectrometry data with Global Natural Products Social Molecular Networking. Nat. Biotechnol. 34, 828–837 (2016)

2016

[4] [4]

Röst, H. L. et al. OpenMS: a exible open-source software platform for mass spectrometry data analysis. Nat. Methods 13, 741–748 (2016)

2016

[5] [5]

Dührkop, K. et al. Systematic classication of unknown metabolites using high-resolution fragmentation mass spectra. Nat. Biotechnol. 39, 462–471 (2021). . Alseekh, S. et al. Mass spectrometry-based metabolomics: a guide for annotation, quantication and best reporting practices. Nat. Methods 18, 747–756 (2021)

2021

[6] [7]

Ebbels, T. M. D. et al. Recent Advances in Mass Spectrometry-Based Computational Metabolomics. Curr. Opin. Chem. Biol. 74, 102288 (2023). . Meijer, D. et al. Empowering natural product science with AI: leveraging multimodal data and knowledge graphs. Nat. Prod. Rep. 42, 654–662 (2025)

2023

[7] [9]

Gaudry, A. et al. A Sample-Centric and Knowledge-Driven Computational Framework for Natural Products Drug Discovery. ACS Cent. Sci. 10, 494–510 (2024)

2024

[8] [10]

Rony, M. R. A. H., Kumar, U., Teucher, R., Kovriguina, L. & Lehmann, J. SGPT: A Generative Approach for SPARQL Query Generation From Natural Language Questions. IEEE Access 10, 70712–70723 (2022)

2022