Loading…

BYOKG: Bring Your Own Knowledge Graph for GraphRAG — An AWS Case Study in Pharmaceutical Research | Graphs | graphwiz.ai

BYOKG: Bring Your Own Knowledge Graph for GraphRAG

On 8 July 2026, AWS published a detailed case study of a GraphRAG implementation in pharmaceutical research that reduced research cycles from six months to three weeks — an 87 per cent efficiency gain. The solution, built on Amazon Neptune Analytics and Amazon Bedrock, uses a Bring Your Own Knowledge Graph (BYOKG) approach that integrates diverse scientific entities — plants, compounds, genes, proteins, and health effects — into a unified knowledge network.

The Research Bottleneck

Pharmaceutical researchers face a data landscape where relevant information is scattered across disconnected silos: PubMed articles, Gene Ontology entries, clinical trial registries, proprietary assay data, and structural databases. A typical research question — "Which compounds similar to X have shown activity against targets related to disease Y, with published safety data in humans?" — requires correlating information across five or more data sources, each with its own schema, access method, and update frequency.

Traditional approaches rely on manual literature review, cross-referencing spreadsheets, and domain expertise to connect the dots. Even with experienced researchers, a single multi-fact research question can take weeks to answer comprehensively.

Solution Architecture

The BYOKG framework connects Amazon Neptune Analytics for high-performance graph processing with Amazon Bedrock for LLM-based generation. The architecture separates cleanly into four layers:

Knowledge graph construction accepts data from structured sources (compound databases, assay results, gene ontologies) and unstructured sources (PubMed abstracts, clinical trial reports). Structured sources map programmatically; unstructured sources use entity and relationship extraction via the graphrag-toolkit Python package, which connects extracted entities back to source documents for provenance.

Query understanding and entity linking identifies the key entities and intended relationships in each natural language question. The system uses a fuzzy string index combined with an EntityLinker from the graphrag-toolkit to map imprecise natural language references — "that kinase inhibitor we tested last quarter" — to specific graph nodes.

Graph-based context assembly retrieves the connected context required to answer the question: entities, relationships, properties, rules, and source text. Unlike vector-only retrieval, which returns the most similar chunks regardless of connection, graph traversal returns the evidence path — the chain of relationships that justifies the answer.

LLM generation with structured context passes the assembled graph context to Amazon Bedrock's Anthropic Claude 4.5 Sonnet model, which generates a response grounded in the connected evidence path. The response includes source citations and visual pathway traces.

Results

The reported KPIs from the implementation demonstrate the measurable impact of GraphRAG on research productivity:

Metric	Before	After	Improvement
Research cycle time	6 months	3 weeks	87% reduction
Discovery hit rate	Baseline	5× increase	400% improvement
Review time	Baseline	—	70% reduction
Data access time	Baseline	—	85% reduction
Knowledge utilisation	Baseline	—	90% improvement

The BYOKG Principle

The "bring your own knowledge graph" approach is significant because it acknowledges that most enterprises already have structured or semi-structured data that can be expressed as a graph. The solution does not require building a knowledge graph from scratch — it provides tooling to map existing data models onto graph structures, connecting domain-specific ontologies with public knowledge bases.

The graphrag-toolkit Python package and the accompanying notebook, published by AWS as open source, provide the reference implementation:

from graphrag_toolkit import KGLinker

linker = KGLinker(
    graph_store=neptune_analytics_client,
    llm_generator=bedrock_claude_client
)

result = linker.query(
    "Which compounds similar to PF-07321332 have shown activity "
    "against 3CL protease targets with published human safety data?"
)

The Pipeline in Code

The BYOKG architecture is a pipeline of three composable stages, each exposed as a distinct graphrag-toolkit component:

1. Construction ingests structured and unstructured sources into a unified graph. Structured records map programmatically; unstructured abstracts go through entity and relationship extraction with provenance back to the source document:

from graphrag_toolkit import KGIndexer

indexer = KGIndexer(
    graph_store=neptune_analytics_client,
    llm_generator=bedrock_claude_client,
)

indexer.ingest_structured(
    sources=[assays_df, compounds_df, gene_ontology_dump],
    type_mappings={"compound_id": "Compound", "gene_id": "Gene"},
)
indexer.ingest_unstructured(
    sources=pubmed_abstracts,
    chunk_size=512,
    entity_types=["Compound", "Protein", "Gene", "Disease", "Effect"],
)

The type_mappings parameter is what makes this "bring your own" — it tells the indexer how existing schema fields map onto graph node labels, so no greenfield graph design is required.

2. Entity linking resolves imprecise natural-language references against the graph using a fuzzy index:

from graphrag_toolkit import EntityLinker

linker = EntityLinker(
    graph_store=neptune_analytics_client,
    fuzzy_threshold=0.82,
)

# Resolves "that kinase inhibitor we tested last quarter"
# to the canonical Compound node before traversal begins
entities = linker.resolve("kinase inhibitor tested last quarter")

3. Context assembly retrieves the connected evidence path. The KGLinker.query call in the example above performs this internally: it traverses from the linked entities along typed relationships, collects the surrounding subgraph, and passes it to the LLM with provenance metadata so every generated claim maps back to a source node.

Enterprise Implications

The case study validates GraphRAG as a production pattern with measurable ROI. An 87 per cent reduction in research cycle time is not incremental improvement — it changes the strategic calculus for enterprise knowledge management. For regulated industries where the evidence path behind every answer must be traceable, GraphRAG provides an audit trail that vector retrieval cannot: the exact traversal path through entities and relationships that produced the answer.

The full implementation guide and notebook are available at github.com/awslabs/graphrag-toolkit.