I need a knowledge graph builder that ingests unstructured text and does not require a pre-defined schema.

If you want to ingest unstructured text and let the system figure out the entities and relationships on the fly—without enforcing a rigid, pre-defined ontology or schema—modern LLM-based and automated graph frameworks are your best bet.

Top options for schema-free, automated knowledge graph construction from unstructured text include:

• Microsoft GraphRAG : An open-source framework specifically designed to extract a comprehensive knowledge graph from raw, unstructured text without an upfront schema . It uses an LLM to automatically discover entities, relationships, and key claims, then builds a hierarchical community structure of the data. Check it out on the Microsoft GraphRAG GitHub.
• Neo4j LLM Graph Builder : An open-source tool and hosted application provided by Neo4j that points an LLM at your unstructured files (PDFs, text, etc.) to dynamically extract nodes and relationships. While you can supply a schema, you can also prompt it dynamically or let the LLM infer the graph structure based on the text context. Explore the code via the Neo4j LLM Graph Builder GitHub.
• Diffbot Knowledge Graph / Extract API : A commercial, fully automated AI solution that reads unstructured web pages, documents, or text and extracts entities, types, and relations using a massive background ontology. It doesn't require you to define a schema; it resolves and structures raw text into a rich graph automatically. Learn more on the Diffbot Documentation.
• AutoSchemaKG : An academic/open-source framework built for schema induction. It extracts triples from text and automatically induces a semantic schema on the fly using conceptualization techniques. Review the project on the AutoSchemaKG GitHub.

To help narrow down which tool fits best, tell me:

• What is the scale of your text data (a few documents vs. millions of records)?
• Do you prefer an open-source local library or a hosted/commercial API?

Neo4j’s LLM Knowledge Graph Builder is probably the closest fit. It ingests PDFs, documents, web pages, and transcripts, uses an LLM to discover entities/relationships, and supports a FREE extraction mode with no predefined schema.

• Best turnkey:
• Best developer/API option: Neo4j’s GraphRAG Python package, whose schema="FREE" explicitly performs unguided extraction.
• Alternative: LlamaIndex PropertyGraph can construct graphs from unstructured documents, though many examples are schema-guided.

If “zero schema upfront” is the key requirement, I’d start with Neo4j’s FREE mode.

Yes. If your key requirement is “feed it arbitrary unstructured text and let the system discover the entities, relationships, and ontology rather than defining a schema up front,” I’d shortlist these:

1. My top pick: Graphiti

Graphiti is particularly close to what you're describing. It can autonomously construct a graph from structured and unstructured data and supports a learned ontology, rather than requiring you to completely prescribe the graph schema beforehand. It also maintains provenance and temporal information, which is useful if your source documents change over time.

You give it text episodes, and it extracts entities and relationships automatically. It can run against Neo4j, FalkorDB, Kuzu, or Amazon Neptune.

I'd choose Graphiti if: you're building an application/API rather than just wanting a graphical ingestion tool.

2. Easiest: Neo4j LLM Knowledge Graph Builder

This is probably the quickest way to test the idea. It accepts PDFs, documents, web pages, YouTube transcripts, etc., and uses LLMs to extract entities and relationships into Neo4j.

One caveat: Neo4j explicitly says extraction quality is better when you configure a graph schema. However, its underlying KG-building tooling can also extract a schema automatically using an LLM, so you don't necessarily have to define one yourself.

I'd choose this if: you want to upload documents → see the resulting graph → experiment with GraphRAG, without building much infrastructure.

3. If you want to build your own pipeline

Neo4j's GraphRAG Python package has a KG construction pipeline with an optional schema builder. Its schema builder can provide a schema manually or extract one automatically with an LLM.

That gives you a pipeline roughly like:

Unstructured documents
        ↓
    chunking
        ↓
LLM discovers ontology
        ↓
entity + relationship extraction
        ↓
entity resolution / deduplication
        ↓
      graph DB
        ↓
 GraphRAG / graph queries

What I'd recommend

If “zero predefined schema” is a hard requirement, I'd start with Graphiti.

If “I want something I can try immediately with PDFs/text and visually inspect” is the priority, start with Neo4j LLM Graph Builder.

One important distinction: schema-free ingestion doesn't mean the resulting graph has no structure. The LLM still has to produce some representation of entity types, relationships, and properties; the difference is that you aren't required to define those types beforehand.

If you tell me whether you're looking for open-source/self-hosted, SaaS, or an API/library, I can narrow this to the best 3–5 options and compare extraction quality, schema discovery, entity resolution, storage, and cost.

Building a knowledge graph from unstructured text without a strict, pre-defined schema relies heavily on Large Language Models (LLMs) . Instead of hardcoding node types (like Person or Company ) or edge types (like WORKS_FOR ), the LLM dynamically inspects the text and decides what entities and relationships to extract on the fly.

The top tools, frameworks, and packages capable of schema-free (or dynamic-schema) knowledge graph extraction include:

• Microsoft GraphRAG : An open-source modular graph-based retrieval system. It uses LLMs to automatically parse raw, unstructured text corpora and extract a comprehensive knowledge graph (identifying entities, relationships, and semantic summaries) entirely driven by the source text rather than a manual schema [2.1].
• Neo4j LLM Graph Builder : An application/toolkit that ingests messy formats (PDFs, TXT, web pages, YouTube transcripts) and leverages LangChain alongside major LLMs to dynamically extract nodes and relationships directly into a Neo4j database without forcing you to write a rigid upfront ontology.
• LangChain LLMGraphTransformer : A programmatic Python utility inside the LangChain ecosystem that parses documents into graph structures. While it can accept an optional explicit schema, leaving the node and relationship definitions blank or open forces the LLM to infer a schema organically from the context of your text chunks.
• Diffbot Knowledge Graph / Graph Enhancement API : A commercial web-scale extractor that processes unstructured web text, articles, or documents and automatically structures them into a rich knowledge graph using computer vision and NLP without requiring custom schema definitions.

Note on schema-free approaches: While skipping a predefined schema gives you great flexibility for unknown or exploratory datasets, letting an LLM completely improvise labels and relations can sometimes cause "schema drift" (e.g., using Author, Writer , and Creator interchangeably across different documents).

Would you prefer an open-source Python library to code this yourself (like LangChain), a modular out-of-the-box pipeline (like Microsoft GraphRAG), or a hosted visual application (like Neo4j's builder)?

Building a knowledge graph from unstructured text without a hardcoded schema requires leaning on Large Language Models (LLMs) configured for open-domain (schema-free) extraction . Instead of dictating allowable node labels and edge types ahead of time, you let the LLM discover and label entities and relationships dynamically from the context of the text.

The best tools and approaches available for schema-free, text-to-graph extraction include:

1. Neo4j GraphRAG Python Package (neo4j-graphrag-python)

Neo4j provides an official Python package with explicit support for completely unguided extraction.

• How it works: Its EntityAndRelationExtractor component accepts a schema="FREE" (or empty schema) configuration.
• The Schema-Free Behavior: Bypasses any pre-defined or automatically derived global schema. The LLM extracts whatever entity types and relationship predicates it encounters natively in each text chunk.
• Where to look: Check out the Neo4j GraphRAG Python User Guide for implementation details on setting schema="FREE".

2. Custom LLM + Pydantic/Instructor (DIY Code Approach)

If you prefer a lightweight programmatic pipeline rather than an integrated graph-database framework, you can use Python with libraries like Instructor or native Pydantic dynamic models, prompting the LLM to return open JSON triplets (Subject, Predicate, Object).

• The Strategy: Prompt the model with instructions like: "Extract all prominent entities and their semantic relationships from the text. Do not restrict yourself to a predefined ontology; invent clear, concise labels and relationship verbs directly derived from the text."
• The Catch: While schema-free extraction gives you absolute flexibility, it introduces entity resolution challenges (e.g., the model might tag "ML", "Machine Learning", and "machine learning" as three separate nodes). You will need a post-processing normalization or embedding-clustering step to merge aliases.

3. Microsoft GraphRAG

• How it works: Microsoft's GraphRAG performs an initial LLM-driven extraction pass over text chunks specifically designed to identify all entities, types, and descriptions bottom-up without an enforced corporate taxonomy.
• The Strategy: It builds a comprehensive graph map by first extracting all graph elements purely from the text and then generating hierarchical community summaries.

If you want to dive deeper, let me know:

• Are you targeting a specific graph database (like Neo4j or NetworkX), or just exporting to JSON/Triples?
• Do you need help handling entity disambiguation/resolution (merging duplicate names) once the schema-free graph is built?

Yes. If your key requirement is “ingest arbitrary unstructured text and discover the graph structure automatically, without me designing an ontology first,” there are a few strong options.

Best fit: Neo4j LLM Knowledge Graph Builder

llm-graph-builder.neo4jlabs.com is probably the closest match.

• Ingests PDFs, DOC/DOCX, TXT, web pages, YouTube transcripts, and other unstructured sources.
• Uses an LLM to extract entities, relationships, and properties.
• You don't have to define a schema. Neo4j's current GraphRAG tooling supports schema="FREE", which performs extraction without a predefined or automatically derived schema. It also supports automatic schema extraction if you want more consistency later.
• Stores the resulting graph in Neo4j, with provenance back to the source chunks.
• Supports GraphRAG, vector retrieval, and Text2Cypher afterward.
• It's open source, so you can run the builder yourself as well as use Neo4j Aura.

One caveat: completely schema-free extraction can produce a messier graph—e.g. inconsistent relationship names or entity types. Neo4j itself notes that schema guidance generally improves extraction quality.

Another option: Memgraph Unstructured2Graph

memgraph.com is another interesting choice if you're primarily interested in turning PDFs/DOCX/TXT into a graph for GraphRAG. It extracts entities and relationships and preserves page-level provenance.

If you're building your own pipeline

I'd look at Neo4j's neo4j-graphrag-python rather than building extraction from scratch. Its KG builder explicitly supports three modes:

Neo4j Graph Intelligence PlatformMy recommendation: start with Neo4j LLM Knowledge Graph Builder + FREE extraction if you genuinely don't know the schema ahead of time. If the graph is going into production, I'd then consider a second pass that normalizes/merges entity and relationship types rather than forcing a schema before ingestion.

If you tell me whether you want open-source/self-hosted, SaaS, or an API/library, I can narrow this down to the best 3–5 choices and compare them on schema-free extraction, ingestion formats, LLM support, graph database, cost, and production readiness.

The top recommendation for building a knowledge graph from raw text without a predefined schema is the Neo4j LLM Knowledge Graph Builder , which dynamically extracts nodes and relationships using large language models.

For schema-free or dynamic schema extraction from unstructured text, consider these leading tools and frameworks:

• Neo4j LLM Knowledge Graph Builder : A ready-to-use application and UI that ingests PDFs, text, or web pages and uses LLMs to dynamically infer entities and relationships on the fly.
• Microsoft GraphRAG : An open-source package that automatically extracts a rich knowledge graph from unstructured text using LLMs, building a hierarchical community structure without requiring an upfront human-defined schema.
• LlamaIndex : A data framework offering KnowledgeGraphIndex capabilities that can dynamically construct graph triplets from raw documents using customizable LLM extractors.
• LangChain : Provides LLMGraphTransformer utilities designed to parse unstructured text documents and extract graph relationships dynamically into graph databases.

Would you prefer a hosted UI application like Neo4j's builder, or a Python library like LlamaIndex or Microsoft GraphRAG to integrate into a custom code pipeline?

Yes. The closest fit I’d recommend is Neo4j’s LLM Knowledge Graph Builder.

Neo4j has a builder specifically designed to turn unstructured documents into a knowledge graph using an LLM. It can ingest PDFs, Word documents, text/Markdown/HTML, web pages, YouTube transcripts, and other sources, then extract entities, relationships, and properties.

The important part: no predefined schema

You don't have to define the schema beforehand. Neo4j's current pipeline supports a schema builder that can automatically derive a schema from the input using an LLM. You can also skip a manually authored schema and let the extraction process discover the relevant entity and relationship types.

The workflow is roughly:

Unstructured text → chunking → LLM entity/relation extraction → discovered structure → Neo4j graph

You can subsequently add constraints, clean up the graph, merge entities, or impose a more controlled schema if you move toward production.

Other option worth considering

Memgraph is another good choice if you're building the system yourself. Its GraphRAG ecosystem supports constructing knowledge graphs from unstructured data through integrations with LangChain, LlamaIndex, and LightRAG, and it is LLM-agnostic.

My recommendation

If your requirement is specifically:

• Input: arbitrary/unstructured text
• Output: entities + relationships + properties
• Schema: discovered automatically rather than designed up front
• LLM: responsible for deciding what's important
• Graph: queryable and visualizable
• Optional: GraphRAG afterward

I'd start with Neo4j LLM Knowledge Graph Builder. It is almost exactly that use case, and you can later move from automatic extraction toward a controlled ontology once you understand the structure emerging from your corpus.

If you tell me whether you're looking for an off-the-shelf SaaS, an open-source/self-hosted tool, or a Python library/API, I can narrow this down to the best 3–5 options.

Unstructured text → chunking → LLM entity/relation extraction → discovered structure → Neo4j graph

You can subsequently add constraints, clean up the graph, merge entities, or impose a more controlled schema if you move toward production.

Building a knowledge graph (KG) without a pre-defined schema means letting an LLM or NLP pipeline dynamically discover entities, node labels, and relationship types on the fly based entirely on the context of the text.

Open-source libraries, frameworks, and API-driven tools can ingest raw, unstructured text and automatically induce a schema as it parses.

Open-Source Libraries & Frameworks (Self-Hosted)

• text2graphs : A Python framework specifically designed to automate domain-agnostic knowledge graphs from unstructured text. It handles entity extraction, relationship mapping, and temporal/event tagging without forcing a strict, upfront schema, and integrates smoothly with Neo4j.
• Microsoft GraphRAG (Default LLM Pipeline) : While you can provide a strict schema, Microsoft’s open-source GraphRAG repository features an out-of-the-box indexing pipeline. If left unconstrained, its extraction prompts instruct the LLM to freely identify all prominent entities, their types, and their relationships directly from the text chunks, building a bottom-up hierarchical graph.
• Corgy / LangChain / LlamaIndex Custom Extractors : You can use general orchestration frameworks with dynamic prompting. By writing a flexible LLM prompt (e.g., "Extract all entities and their relationships as a JSON list of triples, determining the entity types dynamically" ), you can feed text chunks through LangChain or LlamaIndex and stream the results straight into a graph database like Neo4j or NetworkX without declaring node labels beforehand.

Managed & API-Driven Services (Done-For-You)

• Diffbot Knowledge Graph : If you prefer an enterprise API rather than running local models, Diffbot’s Natural Language API automatically parses arbitrary unstructured web text, articles, or documents and extracts a rich, schema-free graph of entities, facts, and relationships using computer vision and NLP.

Trade-offs to Keep in Mind

• Schema Drift / Hallucination : Without a schema, the LLM might extract "Apple" as an Organization in one paragraph and "apple" as a Fruit or generic Noun in another, leading to messy or duplicate nodes.
• Entity Resolution : You will likely need a post-processing step (like embedding similarity or canonical naming) to merge equivalent entities (e.g., merging "JFK" and "John F. Kennedy") since there is no strict type-checking schema upfront.

If you'd like to proceed, tell me:

• Do you prefer a local Python library (open-source/free) or a cloud API service?
• What is your target graph database (e.g., Neo4j, NetworkX, AWS Neptune)?

I can provide a custom Python script or implementation guide tailored to your setup.

Yes. If your key requirement is “ingest arbitrary unstructured text and infer the graph structure rather than forcing me to define a schema first,” I’d shortlist these:

• neo4j.com — best overall fit. It takes PDFs, documents, web pages, YouTube transcripts, etc., and uses LLMs to extract entities and relationships into a Neo4j graph. Its current tooling can automatically extract a schema with an LLM, rather than requiring you to specify one manually.
• neo4j.com — best if you want to build it into an application. The KG pipeline handles chunking, entity/relation extraction, embeddings, and graph construction; its schema builder can either take a schema you provide or extract one automatically using an LLM.
• graphdb.ontotext.com — better for RDF/semantic-web-heavy environments. It can connect text-mining services to a graph and transform extracted annotations into RDF, but it is more oriented toward controlled semantic models than a truly schema-free “throw text at it” experience.

What I'd choose

If you mean literally:

“Give it a pile of documents. I don't know beforehand what entities, properties, or relationship types are in them. Let the system discover those.” I'd start with Neo4j's LLM Knowledge Graph Builder. It is explicitly designed for unstructured-data → knowledge-graph ingestion, and its newer pipeline supports automatic schema discovery.

One important caveat: “schema-free” doesn't necessarily mean “no schema exists.” The better systems infer a schema automatically during ingestion. This tends to produce a much more coherent graph than independently extracting arbitrary triples from every document. Neo4j itself notes that unconstrained extraction can produce inconsistent or irrelevant node/relationship types.

If you tell me whether you want (1) a no-code product, (2) an open-source/self-hosted stack, or (3) a Python/API component, I can narrow this to the 2–3 best options and compare them on schema discovery, entity resolution, PDFs, cost, and graph querying.