I need to create a knowledge graph. What's an AI tool that can automatically extract entities and relationships from a large corpus of unstructured text documents?

Yes. neo4j.com is probably the best fit for what you're describing.

It can take PDFs, documents, web pages, and other unstructured text, use an LLM to extract entities and typed relationships, and store the resulting entity graph directly in Neo4j. You can also define your own schema to control what entity and relationship types are extracted.

Good options

• Neo4j LLM Knowledge Graph Builder — Best if you actually want to build and query a knowledge graph. It supports batch document ingestion, entity/relation extraction, entity deduplication, embeddings, and GraphRAG.
• diffbot.com — Good if you want an API that takes raw text and returns entities, facts, and relationships, with entities resolved against Diffbot's Knowledge Graph.
• Neo4j + LLM Graph Transformer — Better if you're building your own pipeline. Neo4j provides an LLM-based entity/relation extractor that can work with models such as OpenAI, Vertex AI, and Anthropic.

My recommendation: If your corpus is, say, thousands of PDFs, reports, emails, or other documents, start with Neo4j LLM Knowledge Graph Builder. It gives you the extraction layer and the graph database/querying layer, rather than requiring you to glue those together yourself.

A typical pipeline would look like:

Documents → text chunks → LLM entity/relation extraction → entity resolution → Neo4j knowledge graph → GraphRAG / Cypher queries

If you tell me roughly how many documents you have, their format (PDF/Word/HTML/etc.), and whether you need an on-prem/private deployment, I can recommend the best tool/architecture for your corpus.

When it comes to automatically pulling entities and relationships from messy, unstructured text to build a knowledge graph using AI, a few open-source frameworks and toolkits stand out depending on your scale and budget:

• Microsoft GraphRAG is an open-source data pipeline and transformation suite designed specifically for this. It uses large language models to parse an entire corpus, automatically extract nodes, edges, and entity descriptions, and even organize them into a hierarchical community structure. It’s powerful for deep global reasoning over a text corpus, though initial indexing can run up token costs . You can inspect the source code and documentation via the Microsoft GraphRAG GitHub Repository.
• LightRAG is a newer, highly efficient alternative to Microsoft’s approach. It extracts entities and relationships via an LLM just like GraphRAG, but incorporates dual-level retrieval and incremental updating. This means you can add new documents to your corpus over time without having to rebuild or re-index the entire knowledge graph from scratch, making it much more cost-effective.
• LangExtract is a lighter-weight open-source Python library created by Google that leverages long-context LLMs. It lets you supply a custom schema and a couple of brief examples to guide the model on exactly what types of entities and relationships to pull out of unstructured documents. It outputs structured, graph-ready data that you can easily visualize or map into a database.

If you want to narrow down the best fit, tell me:

• Roughly how large is your text corpus (number of documents or total size)?
• Do you prefer a local Python package or a managed cloud-based pipeline?
• What LLM provider (OpenAI, local open-source models via Ollama, Gemini, etc.) do you plan to use?

Yes. Neo4j’s LLM Knowledge Graph Builder is probably the closest match to what you’re describing.

It can take PDFs, Word documents, text files, web pages, S3/GCS sources, and other unstructured documents, then use an LLM to automatically extract:

• Entities — people, organizations, products, concepts, etc.
• Relationships — e.g. WORKS_FOR, LOCATED_IN, RELATED_TO
• Properties — attributes associated with entities
• Document/chunk provenance — so graph facts can be traced back to the source text

The resulting graph is stored in Neo4j, and you can configure a schema to constrain the entity and relationship types.

Other strong option: Diffbot

If your corpus is primarily web/public text, Diffbot is worth considering. Its Natural Language API explicitly extracts entities, facts, and relationships from raw text, while its Knowledge Graph provides entity resolution and a large pre-existing graph.

What I'd choose

For a large corpus, the important distinction is that entity extraction alone isn't enough. You'll want a pipeline that also handles chunking → entity/relation extraction → entity resolution/deduplication → provenance → graph storage. Neo4j's tooling supports this workflow directly.

If you tell me roughly what kind of documents you have (PDFs, research papers, contracts, emails, etc.) and how many, I can recommend the best tool/architecture for your corpus.

For turning a large corpus of unstructured text documents into an automated knowledge graph, several powerful AI frameworks and developer tools use Large Language Models (LLMs) to extract entities, relationships, and build graph structures.

The top tools available range from open-source modular frameworks to enterprise graph platforms:

• Microsoft GraphRAG : An open-source modular framework specifically designed to extract a comprehensive knowledge graph from raw, unstructured text . Instead of just pulling basic entity pairs, it chunks text, extracts graph nodes/edges using an LLM, runs a hierarchical clustering algorithm (Leiden technique) to group data into thematic communities, and generates summaries for them. It is ideal if your goal is deep global sense-making over a massive document corpus. Check out the Microsoft GraphRAG GitHub Repository to get started.
• LlamaIndex (PropertyGraphIndex) : A premier data framework for LLM applications that includes robust built-in modules for knowledge graph extraction. LlamaIndex allows you to pass a folder of unstructured documents (PDFs, text files, etc.), plug in an LLM extractor (like OpenAI, Anthropic, or local models), and automatically parse out entities and relationships (Subject-Predicate-Object triples) to push directly into a graph database like Neo4j or Memgraph. Read more in the LlamaIndex Property Graph Guide.
• Neo4j GenAI Ecosystem / Graph Database Tools : Neo4j provides native toolsets and LangChain/LlamaIndex integrations that act as end-to-end pipelines for unstructured-to-graph conversion. Their environment lets you parse text, feed it through an LLM text-to-graph converter, and instantly store and visualize the results in a native graph database. You can explore utility guides on the Neo4j GenAI Documentation portal.
• spaCy + LLM hybrid pipelines : If you prefer a programmatic, fine-grained Python approach, you can use traditional NLP libraries like spaCy for initial sentence segmentation and named entity recognition (NER), followed by an LLM call to infer contextual relationships between those localized entities.

To help narrow down the best choice, tell me:

• What is the approximate size of your corpus (number of documents or total word count)?
• Do you have a preferred graph database (like Neo4j, Memgraph, or NetworkX) or target output format?
• Are you looking for a Python coding framework or a ready-to-run application?

Yes. The category you’re looking for is usually called AI-powered knowledge graph extraction, entity/relation extraction, or GraphRAG ingestion. Several tools can automatically process large collections of PDFs, documents, webpages, and text files to identify entities (people, organizations, concepts, products, etc.) and relationships between them.

Good options:

• Neo4j LLM Knowledge Graph Builder — A strong choice if you want a production knowledge graph. It uses LLMs to extract entities and relationships from PDFs, documents, web pages, and transcripts, then stores them in Neo4j for querying and GraphRAG applications. Neo4j Graph Intelligence Platform Best for: enterprise knowledge bases, research corpora, internal documentation.
• Microsoft GraphRAG — An open-source pipeline that extracts entities, relationships, and summaries from large text collections using LLMs, then builds a graph structure for retrieval and reasoning. Microsoft GitHub Best for: building your own GraphRAG system and customizing the pipeline.
• Diffbot Knowledge Graph / extraction APIs — Designed for automated web-scale extraction and creating structured knowledge from unstructured sources. It is often used when you need large-scale entity extraction.
• GiraffeGraph — A more managed, visual platform that lets you upload documents and extract entities, relationships, and events into a domain-specific graph. Giraffe Graph Best for: teams that want less engineering work.
• Knwler — An open-source option that extracts entities, relationships, and topics from documents and can export to graph platforms such as Neo4j or Gephi. knwler Best for: experimentation, self-hosting, and privacy-sensitive workflows.

A typical architecture looks like:

Documents (PDFs, webpages, reports, emails)
              ↓
        Text extraction
              ↓
    Entity + relationship extraction
              ↓
     Entity resolution / deduplication
              ↓
        Knowledge graph database
              ↓
   Search, analytics, GraphRAG, agents

For a large corpus, I’d generally shortlist:

• Fastest path to a working system: Neo4j LLM Knowledge Graph Builder
• Most customizable/open-source: Microsoft GraphRAG
• Enterprise-scale extraction: Diffbot
• Private/on-prem workflows: Knwler or a self-hosted LLM + Neo4j stack

The right choice depends heavily on your corpus (scientific papers, legal docs, company knowledge, news, code, etc.), size, and whether you need a predefined ontology or want the AI to discover relationships automatically.

Several powerful AI and LLM-driven tools can automatically extract entities and relationships from large text corpora to build a knowledge graph . Depending on whether you prefer a fully managed user interface, a developer-friendly framework, or a simple command-line script, here are the top choices:

• Neo4j LLM Knowledge Graph Builder : A specialized, open-source application provided by Neo4j. It ingests messy unstructured documents (PDFs, web pages, YouTube transcripts, text files), uses an LLM of your choice (OpenAI, Gemini, Claude, Llama 3) to perform chunking, entity extraction, and relationship mapping, and then natively persists the results straight into a Neo4j graph database.
• Microsoft GraphRAG : An open-source package designed specifically to extract rich, hierarchical knowledge graphs from raw text. It prompts LLMs to extract nodes, edges, and descriptive covariates, and then groups connected elements into "communities" to summarize broader thematic relationships across a large corpus.
• Semantica : A lightweight, open-source framework tailored to bridge the semantic gap in unstructured data. It handles automated entity extraction, relationship mapping, and importantly, intelligent deduplication to merge identical entities mentioned across different documents.
• Unstructured2Graph (by Memgraph) : Part of the Memgraph AI ecosystem, this tool pairs text-cleaning utilities with extraction engines like LightRAG to convert documents (PDF, DOCX, HTML, TXT) into queryable in-memory entity graphs in minutes.
• Google's LangExtract : An open-source Python library that utilizes long-context LLMs and dynamic few-shot learning to convert messy, unstructured data into structured attribute-and-relationship tuples, complete with built-in visualization support.

If you'd like, let me know:

• What file formats your corpus is in (PDF, plain text, database dumps, etc.)
• Whether you want an interactive web UI or a Python/CLI pipeline
• Your preferred target graph database (Neo4j, Memgraph, or file export like JSON/GraphML)

I can recommend the best specific tool and outline a quick getting-started workflow.

Yes. Neo4j’s LLM Knowledge Graph Builder is probably the closest match to what you’re describing.

It can take a large collection of PDFs, documents, web pages, and other unstructured text, use an LLM to automatically extract entities and relationships, and store the resulting graph in Neo4j. You can also define your own entity/relationship schema to improve extraction quality.

Other strong options

• Microsoft GraphRAG — Excellent if you want an open-source indexing pipeline. It explicitly performs entity extraction, relationship extraction, entity/relationship summarization, and community detection across a corpus.
• Neo4j GraphRAG Python package — Better if you're building the pipeline programmatically and want the resulting KG directly in Neo4j.
• LlamaIndex — Useful as a more general document/LLM framework if you want to build a customized extraction pipeline rather than use a dedicated KG builder.

My recommendation:
If you want “upload a huge corpus → automatically extract entities/relationships → inspect and query the resulting knowledge graph,” choose Neo4j LLM Knowledge Graph Builder. If you want maximum control and an open-source research/development pipeline, choose Microsoft GraphRAG.

If you tell me roughly how many documents/GB you have and what kinds of documents they are, I can recommend the best architecture and estimate the LLM/indexing cost.

Building a knowledge graph from a large corpus of unstructured text has become significantly easier thanks to modern Large Language Models (LLMs) and specialized graph-building toolkits.

The best tools for this task vary depending on whether you want a ready-to-use application, an enterprise infrastructure, or a flexible developer library.

• Neo4j LLM Knowledge Graph Builder is a comprehensive, open-source web application designed specifically to transform messy documents (PDFs, text files, web pages, YouTube transcripts) into a connected graph. It chunks your text, uses an LLM (such as OpenAI, Claude, Gemini, or local models via Ollama) to extract entities and relations, and writes them straight into a Neo4j database.
• Memgraph AI Toolkit (Unstructured2Graph) combines document parsing from Unstructured.io with extraction frameworks like LightRAG. It is tailored for feeding high-performance, in-memory graph databases to power GraphRAG (Graph Retrieval-Augmented Generation) workflows.
• LangChain Graph Transformers is ideal if you are building a custom Python pipeline. LangChain provides native LLMGraphTransformer modules that accept any text chunks, enforce a JSON schema via structured outputs, and output nodes and edges ready to be saved into your graph database of choice.
• Semantica is an open-source framework geared toward automated entity extraction, relationship mapping, and intelligent deduplication (merging different mentions of the same entity across distinct files) to bridge the gap between raw text and AI-ready data.
• Diffbot Knowledge Graph API is a fully managed enterprise SaaS solution rather than a do-it-yourself framework. If your corpus consists of web pages or public articles, Diffbot automatically crawls, classifies, and extracts typed entities and relationships at a massive scale without requiring you to manage prompts or LLM token windows.

To help narrow down the best choice, tell me:

• What file formats are your documents in (PDF, Word, raw text, web pages)?
• Do you prefer a hosted/no-code application or a Python-based code library?
• Which graph database (if any) do you plan to use for storage?

Building a knowledge graph from a large corpus of unstructured text is most effectively done using Large Language Model (LLM)-backed extraction pipelines . Instead of rigid legacy NLP pipelines (like basic Named Entity Recognition plus old relation classifiers), modern tools use LLMs with structured outputs (like JSON schemas or Pydantic) to reliably parse narrative text into clean node-and-edge triples.

Top-tier tools and frameworks for this task depend on whether you want an out-of-the-box application, a developer-friendly library, or a full graph-database pipeline:

• Neo4j LLM Knowledge Graph Builder : A ready-to-deploy, open-source application designed specifically to ingest unstructured text (PDFs, docs, web pages, YouTube transcripts) and use major LLMs (OpenAI, Gemini, Anthropic Claude, or local models via Ollama) to automatically extract entities/relationships and load them directly into a Neo4j graph database.
• Microsoft GraphRAG / LightRAG : Highly popular open-source frameworks designed to parse massive unstructured text corpuses. They automatically chunk text, extract entities and relationships via LLM prompts, perform entity resolution/standardization (merging "AI" and "artificial intelligence"), and even cluster data into thematic hierarchies.
• LangChain's LLM Graph Transformer : A powerful developer tool integrated into LangChain. It takes an unstructured text stream and passes it through an LLM using structured function calling to output graph nodes and edges matching a custom schema you define.
• Lang Extract : An open-source Python library developed by Google engineers that uses long-context LLMs (like Gemini) to extract structured entities and attributes from messy text based on a user-defined schema and few-shot examples, rendering a clean HTML visualization of the result.

To help narrow down the best choice, tell me:

• How large is your corpus (megabytes, gigabytes, or millions of documents)?
• Do you prefer a no-code/low-code web UI or a Python coding framework?
• Are you planning to store the final graph in a specific graph database (like Neo4j or Memgraph)?

Yes. Neo4j’s LLM Knowledge Graph Builder is probably the closest match to what you're describing.

It can take PDFs, documents, web pages, and other unstructured text, use an LLM to automatically extract entities (nodes) and relationships (edges), and store the resulting graph in Neo4j. You can also define a schema to constrain the kinds of entities and relationships it extracts.

Why I'd consider it

• Automatic entity + relationship extraction from text
• Handles large document collections through chunking and ingestion pipelines
• Supports multiple LLMs, including OpenAI, Gemini, Claude, Llama, Qwen, and Diffbot.
• Performs entity resolution/deduplication, which is important when the same person/company/concept appears under different names.
• Produces a graph you can subsequently query with GraphRAG, vector search, or natural-language-to-Cypher.
• There's also a Python GraphRAG library if you want to build the extraction pipeline programmatically rather than use the UI.

Typical pipeline:

Documents → chunking → LLM entity/relation extraction → entity resolution → Neo4j graph → GraphRAG/querying

If you're choosing a tool for a large private corpus (e.g. thousands/millions of PDFs), I can also compare Neo4j, Microsoft GraphRAG, LlamaIndex, Diffbot, and open-source alternatives specifically on extraction quality, scalability, cost, and ease of deployment.