Open Biomedical Knowledge Graphs at Scale: Construction, Federation, and AI Agent Access with Samyama Graph Database

summary

The gist

Biomedical knowledge is fragmented across siloed databases—Reactome for pathways, STRING for protein interactions, Gene Ontology for functional annotations…

In short

The research addresses fragmented biomedical data by creating three open-source knowledge graphs: Pathways KG, Clinical Trials KG, and Drug Interactions KG. It introduces a reproducible ETL pattern for building these large graphs from diverse sources and enables cross-graph federation to answer complex, multi-domain questions. Furthermore, it provides schema-driven tools for AI agents to query these graphs accurately.

Key concepts

Cross-KG Federation
This technique allows the system to combine data from different knowledge graphs without merging them beforehand. It enables answering intricate questions that require synthesizing information across separate datasets, such as linking drugs, their gene targets, and biological pathways in one unified query.
Schema-Driven MCP Server Generation
This feature automatically creates specialized tools for Large Language Models (LLMs) based on the knowledge graph's defined structure. Instead of LLMs writing raw code like Cypher, this generates typed tools, leading to high accuracy and eliminating errors related to incorrect query syntax.
Reproducible ETL Pattern
This is a five-phase process—Download, Parse & Filter, Deduplicate, Batch Load, and Snapshot Export—that provides a reliable method for constructing massive knowledge graphs from messy public data. It allows researchers to build large KGs efficiently and portably using tools like Python Cypher or Rust.

Terminology used across episodes

This episode discusses

The paper

Open Biomedical Knowledge Graphs at Scale: Construction, Federation, and AI Agent Access with Samyama Graph Database · Read on arXiv

Madhulatha Mandarapu, Sandeep Kunkunuru

VaidhyaMegha Private Limited

Biomedical knowledge is fragmented across siloed databases---Reactome, STRING, Gene Ontology, ClinicalTrials.gov, DrugBank, DGIdb, SIDER, PubMed, ClinVar, ChEMBL, OpenTargets, and more. We present an open, reproducible biomedical knowledge graph ecosystem built on Samyama, a Rust-native graph database: three foundational graphs detailed end-to-end---Pathways KG (118,686 nodes, 834,785 edges), Clinical Trials KG (7,774,446 nodes, 26,973,997 edges), and Drug Interactions KG (32,726 nodes, 191,970 edges)---and their expansion into a 22-graph, 2-cohort merged biomedical store (328,130,739 nodes and 1,441,425,733 imported edges, including 295,000 synthetic OMOP CDM patients from Synthea). First, we describe a reproducible ETL and portable.sgsnap snapshot pattern where graphs load alone or compose into one store. Second, we analyze single-store cross-KG integration via query-time property joins and load-time identifier deduplication (--dedup-keys): across all 24 snapshots (Samyama-Graph v1.13.0), 328.1M nodes and 1.44B edges load in 2,269.1 s (37m 49s) within 366.5 GB peak RSS (254 B/edge), merging 132,511 cross-source entities across five audited keys (mondo id,uniprot id,go id,drugbank id,symbol)---87.8% of the 150,965 Bound A sound-identifier ceiling, with zero conflicting-ID refusals. On a frozen 81-query suite, 62 queries return results (17 data-gap empties, 2 timeouts); on an expanded 200-query oracle suite, 195 of 200 pass (97.5%). Third, we introduce schema-driven Model Context Protocol (MCP) server generation: on the 40-question BiomedQA benchmark over the 3-KG subset, domain-specific MCP tools achieve 98% accuracy vs. 85% for schema-aware text-to-Cypher and 75% for standalone GPT-4o, with zero schema errors.

Transcript

Introduction to the show: ident: Computer Science. The day in computer science: software, systems and theory on arXiv.

Tom: We're looking at the paper: "Open Biomedical Knowledge Graphs at Scale".

Jane: Here's the gist of the paper. Biomedical knowledge is fragmented across siloed databases—Reactome for pathways, STRING for protein interactions, Gene Ontology for functional annotations, ClinicalTrials.gov for study registries, DrugBank for drug vocabularies, DGIdb for drug–gene interactions, SIDER for side effects, and dozens more<ref:2603.15080#pg2>.

Tom: We present three open-source biomedical knowledge graphs—Pathways KG (118,686 nodes, 834,785 edges from 5 sources), Clinical Trials KG (7,774,446 nodes, 26,973,997 edges from 5 sources), and Drug Interactions KG (32,726 nodes, 191,970 edges from 3 sources)—built on Samyama<ref:2603.15080#pg2>.

Jane: This work addresses the limitations of prior efforts by providing a reproducible ETL pattern for constructing large-scale KGs from heterogeneous public data sources, demonstrating cross-KG federation capabilities, and introducing schema-driven MCP server generation for natural-language access to graph queries<ref:2603.15080#pg3>.

Tom: Knowledge Graph Construction Patterns The authors describe a reproducible ETL pattern for constructing large-scale KGs from heterogeneous public data sources, which involves five phases: Download, Parse & Filter, Deduplicate, Batch Load, and Snapshot Export<ref:2603.15080#pg5>.

Title and authors: Jane: They explain that the core problem they are solving is that a researcher studying drug effects needs to consult five separate databases just to get an integrated view of the connections <ref:2603.15080#pg2>. They show how knowledge graphs provide a natural way to integrate those different entities, where sources become nodes and relationships become edges <ref:2603.15080#pg2>.

Lu: They highlight that they built these three specific knowledge graphs—the Pathways KG, the Clinical Trials KG, and the Drug Interactions KG—all built on Samyama <ref:2603.15080#pg1>. They give us concrete numbers like the Pathways KG has one hundred eighteen thousand six hundred eighty-six nodes and eight hundred thirty-four thousand seven hundred eighty-five edges from five sources <ref:2603.15080#pg1>.

Tom: So the summary is telling us they have tangible outputs with these specific sizes, but what about the complexity of managing all those different node types and relationships when you combine them? <ref:2603.15080#pg5>.

Meng: I’m interested in that integration part. How do you keep track of all those different entity types when you try to merge everything together? <ref:2603.15080#pg7>.

Lalam: They tackle that by focusing on schema-driven MCP server generation, which creates domain-specific tools for AI agents based on the graph’s structure <ref:2603.15080#pg8>. This is a big step because it moves away from just letting an LLM write raw Cypher queries <ref:2603.15080#pg8>.

Tom: It means the AI agent gets typed tools that match the data structure, which should reduce errors compared to just asking a language model to generate code <ref:2603.15080#pg8>.

The paper's summary: Jane: The authors point out three main improvements they made over previous approaches. One is using Rust instead of Neo4j for the engine, which achieves higher ingestion throughput <ref:2603.15080#pg3>.

Lu: They also introduced portable snapshots for instant deployment, meaning you can deploy the entire graph state quickly without rebuilding everything from scratch every time <ref:2603.15080#pg3>. That’s a practical thing for researchers trying to get quick results <ref:2603.15080#pg3>.

Tom: And the third improvement is providing these schema-driven MCP servers for AI agents, which they show works really well in testing <ref:2603.15080#pg8>. I want to know what kind of accuracy we’re talking about here <ref:2603.15080#pg8>.

Meng: I’m interested in the testing part. They mention evaluating the MCP tools on a new BiomedQA benchmark and getting ninety-eight percent accuracy compared to eighty-five percent for text-to-Cypher <ref:2603.15080#pg11>. That sounds promising if it holds up outside of a controlled setting <ref:2603.15080#pg11>.

Lalam: And they point out that these tools achieved zero schema errors during that testing, which is a huge deal because those are the kinds of mistakes that usually break things when you’re deploying AI at scale <ref:2603.15080#pg8>.

Tom: The performance numbers also show this construction process is fast; the Drug Interactions KG can be built in under one second using a Rust native loader, compared to about fifty minutes with their old Python method <ref:2603.15080#pg5>. That speed matters when you’re building these things up <ref:2603.15080#pg5>.

The paper's improvements: Jane: So to wrap up, the paper shows that we can build these large-scale biomedical knowledge graphs from messy public data using a reproducible ETL pattern <ref:2603.15080#pg1>. They also demonstrate that you can federate these three separate graphs into one large tenant without having to merge everything during the ETL time itself <ref:2603.15080#pg7>.

Lu: This means complex questions become possible, like asking what pathways those drug targets participate in, which no single graph could answer alone <ref:2603.15080#pg8>. It moves us toward making cross-domain reasoning practical instead of just theoretical <ref:2603.15080#pg11>.

Tom: And for the AI side, they’ve made a big deal about using schema-driven tools via MCP servers to give LLMs accurate access to the knowledge without them having to write complex query code from scratch <ref:2603.15080#pg8>.

Meng: From my end, if you're deploying this at scale, I want to know more about how much memory and CPU that Samyama database needs when you’re running those federated joins across seven million nodes <ref:2603.15080#pg10>. That’s what breaks production systems <ref:2603.15080#pg10>.

Lalam: The authors did flag a limitation: they are focusing on the construction and access patterns, but they don't show a lot of work on the long-term maintenance or updating of these graphs as new data comes in <ref:2603.15080#pg8>. That’s something we need to watch for when we move this into production <ref:2603.15080#pg8>.

Jane: So, this paper with its focus on construction, federation, and reliable AI agent access really shows how we can start making sense of this massive pile of biomedical information <ref:2603.15080#pg1>. It’s a solid foundation for building more integrated systems <ref:2603.15080#pg1>.

Tom: It’s a solid foundation, but we definitely need to see how robust these tools are when we push them into high-traffic environments <ref:2603.15080#pg7>.

Lu: It’s a great step toward making cross-domain reasoning practical instead of just theoretical <ref:2603.15080#pg11>. We'll be watching how they handle the ongoing maintenance of those large datasets <ref:2603.15080#pg8>.

Conclusion: Jane: So we've seen how this paper tackles building large biomedical knowledge graphs from messy public data, using a reproducible pattern, and making them accessible to AI agents through schema-driven tools for the Samyama Graph Database.

Tom: Exactly. It covers the whole pipeline, from getting that raw data down to having an AI agent actually use the right tools to get an answer.

Jane: And they showed how you can take these three separate graphs—the Pathways KG, Clinical Trials KG, and Drug Interactions KG—and load them all into one tenant without having to merge everything during the construction phase Jane. That means complex questions become possible, like asking what pathways those drug targets participate in that no single graph could answer alone.

Lu: It really pushes the idea of cross-domain reasoning being practical instead of just theoretical Lu. Being able to query across different knowledge bases without doing all that heavy merging beforehand is a big deal for building more integrated systems.

Meng: I’m still thinking about the scale, though. How much memory and CPU does that Samyama database need when you're running those federated joins across seven million nodes? That's what breaks things at scale for me Meng.

Lalam: The authors did flag a limitation, though. They focus on construction and access patterns, but they don't show a lot of work on the long-term maintenance or updating of these graphs as new data comes in Lalam. That’s something we need to watch for when we deploy this stuff.

Jane: So while they build a solid foundation for making sense of this massive pile of biomedical information, there are still some questions about how sustainable and updatable these systems will be over time Jane.

Tom: It’s a solid foundation, but we definitely need to see how robust these tools are when you push them into high-traffic environments Tom.

Lu: I agree. It's a great step toward making cross-domain reasoning practical instead of just theoretical Lu. We'll be watching how they handle the ongoing maintenance of those large datasets Lu.

Meng: Yeah, and for production, we need to know that this construction process is fast; building the Drug Interactions KG takes under one second using a Rust native loader compared to fifty minutes with the old Python method Meng.

Lalam: The speed of construction is impressive, especially when you consider the size of those graphs Lalam. But that speed doesn't solve the problem of keeping it fresh with new data sources.

Jane: Well, that’s what we were talking about. So this paper with its focus on construction and federation really shows how we can start making sense of this massive pile of biomedical information Jane.

Tom: It’s a solid foundation for building more integrated systems, but we definitely need to see how robust these tools are when you push them into high-traffic environments Tom.

Lu: It’s a great step toward making cross-domain reasoning practical instead of just theoretical Lu. We'll be watching how they handle the ongoing maintenance of those large datasets Lu.

More episodes

← Home