Knowledge Graph Construction from Unstructured Data: A Practical Pipeline

Unstructured text accounts for an estimated 80% of enterprise data — emails, PDFs, internal wikis, support tickets, regulatory filings, and web pages. These documents contain a dense web of entities, relationships, and facts, yet most organisations can only search them by keyword or, at best, by semantic similarity via vector embeddings. Neither approach surfaces the structural connections that make knowledge graphs so powerful: who is connected to what, and how.

This article walks through a production-grade pipeline for transforming unstructured text into a Neo4j knowledge graph, drawing on the latest tools — the Neo4j GraphRAG Python package, LangChain's LLMGraphTransformer, and LLM-based entity resolution — and covering the design decisions that separate a useful graph from a noisy one.

Why Bother? The Limits of Vector-Only RAG

Retrieval-augmented generation (RAG) over vector embeddings retrieves chunks of text that are semantically similar to a user's query. This works well for single-fact questions — "What is the capital of France?" — but fails on multi-hop queries that require reasoning across documents:

"Which products from companies that received FDA clearance in 2025 are relevant to autoimmune diagnostics?"

A vector search returns chunks similar to each fragment of the query, but cannot join across them. A knowledge graph, by contrast, stores entities as nodes and relationships as edges, making multi-hop traversal a single Cypher query:

MATCH (c:Company)-[:HAS_SIGNAL]->(s:Signal {type: "FDA_CLEARANCE"})
WHERE s.date STARTS WITH "2025"
MATCH (c)-[:DEVELOPS]->(a:Application {name: "Autoimmune Diagnostics"})
MATCH (c)-[:SUPPLIES]->(p:Product)
RETURN c.name, p.name, s.date
ORDER BY s.date DESC

This query crosses three relationship types and two entity hops in a single, index-accelerated traversal — something no vector store can express. The graph becomes a structured context layer that an LLM can query with precision.

The Pipeline at a Glance

Building a knowledge graph from unstructured text is a multi-stage pipeline. Each stage introduces a design choice that affects the quality and utility of the final graph:

Raw Documents
    ↓
[1] Data Loading & Chunking
    ↓
[2] Embedding & Lexical Graph Construction
    ↓
[3] Schema-Guided Entity & Relation Extraction
    ↓
[4] Knowledge Graph Writing
    ↓
[5] Entity Resolution & Deduplication
    ↓
[6] Post-Processing & Enrichment
    ↓
Queryable Knowledge Graph

Stage 1: Data Loading and Chunking

The pipeline begins with ingesting documents from whatever source they live in — PDFs, web pages, S3 buckets, YouTube transcripts, or plain text files.

The neo4j-graphrag Python package provides a SimpleKGPipeline that abstracts most of this away:

from neo4j import GraphDatabase
from neo4j_graphrag.llm import OpenAILLM
from neo4j_graphrag.embeddings import OpenAIEmbeddings
from neo4j_graphrag.pipeline import SimpleKGPipeline

driver = GraphDatabase.driver("neo4j+s://your-instance.databases.neo4j.io",
                              auth=("neo4j", "password"))
llm = OpenAILLM(model_name="gpt-4o", model_params={"temperature": 0})
embedder = OpenAIEmbeddings(model="text-embedding-3-small")

kg_builder = SimpleKGPipeline(
    llm=llm,
    driver=driver,
    embedder=embedder,
    from_pdf=True,
)

kg_builder.run("path/to/document.pdf")