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

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.

When building a knowledge graph from unstructured text without a pre-defined schema, you are essentially asking an AI to read text, figure out what entities exist, determine how they relate on the fly, and structure them dynamically.

A few top-tier tools and open-source frameworks specialize in schema-free (or dynamic-schema) knowledge graph extraction:

• Microsoft GraphRAG — An open-source package designed specifically to parse unstructured text (PDFs, books, datasets) using LLMs to extract a comprehensive, schema-free graph of entities, relationships, and semantic summaries. It handles community detection and hierarchical summarization without you ever needing to define node or edge types ahead of time. Available on the Microsoft GraphRAG GitHub.
• Neo4j LLM Graph Builder — While it can use schemas to guide extraction, you can run it in a flexible/dynamic mode where the LLM determines entities and relationships organically based entirely on the text provided. It lets you ingest PDFs, URLs, or YouTube transcripts and dumps the dynamic graph straight into a Neo4j database. Explore it via the Neo4j LLM Graph Builder Repository.
• Diffbot Extract API — A fully managed, commercial AI-driven web and text extractor that automatically structures unstructured text or web pages into a rich knowledge graph. It doesn't use a schema or rules; it automatically identifies entities, types, and connections, and importantly performs built-in entity resolution so the same person or concept mentioned across different texts maps to the same node. Check documentation at Diffbot Docs.
• Corcel / LangChain / LlamaIndex workflows — If you prefer rolling your own code in Python, you can use modular orchestration frameworks like LlamaIndex or LangChain with a property graph index. They feature out-of-the-box extractors (like LLMPropertyGraphExtract ) that take raw text and prompt an LLM to extract arbitrary triples(𝑠𝑢𝑏𝑗𝑒𝑐𝑡,𝑝𝑟𝑒𝑑𝑖𝑐𝑎𝑡𝑒,𝑜𝑏𝑗𝑒𝑐𝑡) without a restricted schema.

To help narrow down the best fit, let me know:

• Are you looking for a local open-source library/Python package or a fully managed cloud API?
• What is your target destination for the graph (e.g., Neo4j, a vector database, or JSON files)?

Yes. If “no predefined schema” is a hard requirement, there are a few good options, but one stands out.

Best fit: Neo4j Knowledge Graph Builder

It takes unstructured sources such as PDFs, documents, web pages, and YouTube transcripts and uses an LLM to extract entities and relationships into a Neo4j graph.

Importantly, Neo4j's newer KG pipeline explicitly supports:

• FREE schema mode — no schema is extracted or predefined; entity and relationship extraction is completely unguided.
• Automatically extracted schemas — the system can infer a guiding schema from your corpus if you want more consistency without manually designing one.
• Visualization and GraphRAG afterward.
• Local deployment as well as Neo4j Aura.
• Multiple LLM providers.

So if your requirement is literally:

“Give it arbitrary text and let the system discover the entities, attributes, and relationships itself.” Neo4j's KG Builder / SimpleKGPipeline with schema="FREE" is probably the closest direct match.

Also worth considering: Graphiti

Graphiti is particularly interesting if this isn't just a static document corpus. It autonomously builds a temporal knowledge graph from unstructured and structured data, incrementally incorporating new facts and tracking when relationships change.

It doesn't require you to define an ontology up front; it extracts entities and relationships automatically. You can optionally introduce custom entity/edge types later.

I'd choose Graphiti over Neo4j's builder if you're building something like:

• an agent memory system
• a continuously growing knowledge base
• a graph from emails/conversations/documents
• a system where facts change over time
• temporal queries such as “What did we believe about X as of March?”

Quick comparison

| Neo4j KG Builder | Graphiti --- | --- | --- Unstructured text | Excellent | Excellent No predefined schema | Yes — FREE mode | Yes Automatic entity/relation discovery | Yes | Yes Visual graph exploration | Excellent | More developer-oriented Static document corpus | Best fit | Good Continuously changing data | Good | Excellent Temporal reasoning | Limited | Excellent GraphRAG | Excellent | Excellent Self-hostable | Yes | Yes Underlying graph DB | Neo4j | Neo4j / FalkorDB / Neptune Ease of experimentation | Very good | Good

My recommendation: start with Neo4j KG Builder if you want a ready-to-use text → automatically discovered graph experience. Start with Graphiti if you're building an application/API and expect the graph to continuously evolve.

One important caveat: schema-free extraction is less consistent than schema-guided extraction. If your corpus is large or heterogeneous, a useful middle ground is to let the system infer the schema automatically from the corpus, rather than manually defining it. Neo4j explicitly supports that mode as well.

It doesn't require you to define an ontology up front; it extracts entities and relationships automatically. You can optionally introduce custom entity/edge types later.

Building a schema-free knowledge graph from unstructured text is most effectively done using LLM-driven entity and relation extraction , where the model dynamically decides what entities and verbs/relationships to create on the fly.

Several tools, frameworks, and packages fit your requirement of ingesting raw text without requiring a pre-defined ontology:

• Neo4j LLM Knowledge Graph Builder : An open-source and hosted application/tool that ingests PDFs, text files, web pages, or YouTube transcripts and leverages an LLM (OpenAI, Claude, Gemini, Llama) to extract free-form nodes and relationships directly into a Neo4j database without forcing a strict schema.
• LangChain LLMGraphTransformer : A programmatic Python component that takes unstructured document chunks and converts them into graph documents using a language model. If you omit the allowed_nodes and allowed_relationships parameters, it operates completely schema-free, letting the model dynamically invent labels and edges.
• sift-kg : An open-source command-line tool designed for local document collections that extracts entities/relations via LLMs and builds a browsable graph with optional human-in-the-loop entity resolution, exporting to standard graph formats like GraphML or JSON.
• kg-gen : A lightweight open-source library that parses plain text or conversational logs into a knowledge graph using AI without requiring complex ontological setup beforehand.
• Graphify : A local tool/CLI that maps unstructured folders, documentation, and codebases into an interactive graph, utilizing deterministic parsing mixed with semantic LLM passes for free-form relationship discovery.

To help narrow down the best choice, let me know:

• Are you looking for a no-code visual application/UI or a Python library to code into your own pipeline?
• Do you want the data stored in a graph database (like Neo4j) or exported as a flat file (JSON/GraphML)?

Yes. What you want is generally called a schema-free, open-schema, or schema-inducing knowledge graph builder.

Best fit: Neo4j LLM Knowledge Graph Builder

neo4j.com is probably the closest match.

• Ingests PDFs, DOC/DOCX, TXT, web pages, YouTube transcripts, and other unstructured sources.
• Uses LLMs to extract entities, relationships, and properties.
• Doesn't require a predefined schema; schema configuration is optional.
• Stores the resulting graph in Neo4j and supports GraphRAG, vector retrieval, and Text2Cypher.
• It's open source and can be deployed locally.

There's an especially relevant distinction in Neo4j's current KG builder API: schema="FREE" performs extraction without either a predefined or automatically derived schema, whereas schema="EXTRACTED" has the LLM infer a schema first and then use it consistently.

Other options worth considering

TrustGraph explicitly describes its GraphRAG extraction as working without an ontology or schema. TrustGraph Graphora offers a "Schema Copilot" and zero-config mode, but is more oriented toward eventually imposing structure and validating it.

One important caveat

If you literally want zero schema at all, rather than "I don't want to define one beforehand", I'd favor Neo4j's FREE mode or TrustGraph. Pure schema-free extraction can produce inconsistent labels such as Company, Organization, and Business for essentially the same concept. Recent research also points out that completely schema-free graphs can become fragmented, which is why automatic schema induction is often a better compromise.

My recommendation: start with Neo4j LLM Graph Builder if you want something usable immediately; use its automatic schema extraction if consistency matters, or FREE mode if your requirement is genuinely schema-less extraction.

If you tell me whether you're looking for a hosted product, open-source/self-hosted tool, or Python library, I can narrow this to 2–3 options.

Building a knowledge graph without a pre-defined schema means relying on Open Information Extraction (OpenIE) powered by Large Language Models . Instead of forcing text into rigid boxes (like Person-Works_For-Company ), the LLM dynamically infers entities, events, and relationship types on the fly based strictly on what it reads in the text.

Top tools, frameworks, and architectural patterns available for schema-free, text-to-graph extraction include:

• Neo4j GraphRAG Python Package / LLM Graph Builder
  Neo4j provides native support for dynamic extraction via its ecosystem. When using their graph-building pipelines (via LangChain's llm-graph-transformer or the Neo4j LLM Graph Builder ), setting the schema configuration parameter to FREE or letting it default bypasses schema constraints entirely. The LLM freely reads text chunks and assigns whatever node labels and relationship types it deems appropriate.
• Graphiti (by Zep)
  Available via the Graphiti GitHub Repository , this framework builds temporal context graphs designed for AI agents. It supports learned ontologies that continuously ingest unstructured data and track evolving facts over time without requiring you to script a static domain schema beforehand.
• LightRAG / GraphRAG Implementations
  Modern GraphRAG implementations use an open-extraction first pass. They parse raw documents into chunks and prompt an LLM to extract all co-occurring entity-relation-entity triplets without an a priori ontology, letting the structural taxonomy emerge organically from the corpus.

The Core Catch with Schema-Free Extraction

While skipping a schema gets you up and running instantly, free-text extraction creates messy graphs . Without constraints, an LLM will frequently generate semantic duplicates (e.g., creating a Company node in one chunk and an Organization node in another, or using both DEVELOPED_BY and DEVELOPER as edge types).

If you want to keep it entirely schema-free while keeping data clean, look for a pipeline that includes an Entity Resolution / Canonicalization step (using embedding similarity post-extraction) to automatically merge overlapping concepts before writing them to your graph store.

To help narrow down the best path, tell me:

• What database or storage target are you planning to use (e.g., Neo4j, FalkorDB, NetworkX, RDF)?
• Are you looking for a no-code/low-code web app or a Python code library to embed in a pipeline?

If you need a knowledge graph builder that ingests unstructured text and does not require a predefined schema, look for a schema-inducing or schema-optional KG system. The best fits are:

1. Neo4j LLM Knowledge Graph Builder — best practical choice

Neo4j’s LLM Graph Builder is probably the closest match to your requirements.

It can:

• ingest PDFs, DOCX, TXT, webpages, and other text sources
• extract entities, relationships, and properties using LLMs
• create a graph without you designing an ontology first
• optionally infer a schema or accept one later
• preserve links back to source documents for traceability

Neo4j’s graph pipeline supports automatic schema extraction, and also has a “free” extraction mode where schema guidance is not imposed.

Good choice if you want:

• a visual graph explorer
• Cypher queries
• GraphRAG applications
• a production database behind the KG

---

2. Microsoft GraphRAG — best for LLM search over large corpora

Microsoft GraphRAG builds graphs from unstructured text as part of its indexing process.

Good for:

• asking questions over large document collections
• discovering communities and themes
• improving retrieval beyond embeddings alone

Less of a “KG management UI” and more of a graph-powered retrieval architecture.

---

3. Knowledge Graph Foundry — closest to “drop in documents, get a KG”

Knowledge Graph Foundry is designed around:

• ingesting PDFs, DOCX, TXT, Markdown, JSON, and spreadsheets
• extracting entities and relationships with LLMs
• discovering an ontology from the source material
• loading the resulting graph into Neo4j

It explicitly targets “no predefined schema required” workflows.

---

4. Research-grade schema induction systems

If you mean truly no schema and the system invents the ontology dynamically, look at newer research approaches such as AutoSchemaKG, which jointly extracts knowledge and induces schemas from text.

These are interesting for:

• massive corpora
• evolving domains
• automated ontology discovery

…but they are generally less turnkey than Neo4j/GraphRAG.

---

Recommendation by use case

• Enterprise knowledge base / document intelligence: Neo4j LLM Graph Builder
• Chat with thousands of documents: Microsoft GraphRAG
• Developer pipeline where schema discovery matters: Knowledge Graph Foundry
• Research into autonomous KG creation: AutoSchemaKG

A practical architecture is usually:

Documents → chunking → LLM entity/relation extraction → entity resolution → emergent schema → graph database → GraphRAG/query layer

The main caveat: “schema-free” systems still tend to develop an implicit schema (entity types and relationship patterns) if you want a clean, queryable graph at scale. Fully schema-less extraction usually produces noisier graphs.

Building a knowledge graph without a pre-defined schema means relying on Open Information Extraction (OpenIE) or dynamic/emergent schema generation via Large Language Models . Instead of forcing text into rigid categories like (Person)-[:WORKS_FOR]->(Company) , the system lets the text dictate the entity types and relationship verbs dynamically.

The most practical tools, libraries, and architectural frameworks for schema-agnostic extraction include:

• Microsoft GraphRAG : Uses an LLM indexing pipeline to parse unstructured text, extract free-form node entities and relationship edges without a strict initial schema, and then cluster them into hierarchical communities.
• Neo4j LLM Knowledge Graph Builder : An open-source application and toolkit that ingests PDFs, web pages, or text. While it can use schemas, you can prompt or configure it in a schema-agnostic mode where the LLM dynamically infers nodes and relationships on the fly.
• LangChain LLM Graph Transformer : A modular component you can use in a custom Python pipeline. Passing it unstructured text with a generalized system prompt allows it to output arbitrary [Subject, Predicate, Object] triplets without a constrained Pydantic schema.
• AutoSchemaKG / Research Frameworks : Academic and experimental frameworks implementing automated schema induction, which extract raw open triplets first and then use a secondary LLM pass to lightly cluster or abstract them into conceptual categories without manual upfront design.

If you want to build this yourself or use an existing tool, let me know:

• Are you looking for a ready-to-deploy application or a Python library to code a custom pipeline?
• What target database or output format do you plan to use (e.g., Neo4j, NetworkX, RDF/Triples, JSON)?

If you need a knowledge graph builder that ingests unstructured text without requiring a predefined schema, look for a schema-free / schema-inducing KG pipeline. The best fits are:

My shortlist

1. Neo4j LLM Knowledge Graph Builder — strongest general choice

Good if you want:

• PDFs, DOCX, TXT, web pages, transcripts → knowledge graph
• automatic entity and relationship extraction
• optional schema inference rather than schema design
• graph visualization and GraphRAG querying

It extracts entities, relationships, and properties from text and stores them in a Neo4j graph. It can work with a configured schema, but schema configuration is not mandatory for initial extraction.

2. TrustGraph — closest to “no ontology at all”

Good if your requirement is specifically:

“Give it documents and discover the structure.”

Its GraphRAG workflow supports ontology-free knowledge extraction, where entities and relationships are discovered from documents rather than constrained by a predefined ontology.

3. Microsoft GraphRAG — best for LLM applications

Good when the end goal is:

• question answering over a document corpus
• summarization
• multi-hop reasoning

It builds a graph representation from text as part of its indexing process rather than requiring you to manually model a domain ontology first.

4. Knowledge Graph Foundry — good open-source pipeline

Useful if you want a CLI/library approach:

• ingest files
• chunk documents
• extract entities and relations
• resolve duplicates
• write into Neo4j

It explicitly supports discovering an ontology from data instead of requiring a predefined schema.

Architecture I would use

For a serious production system:

Unstructured documents
        |
        v
Document parser + chunker
        |
        v
LLM entity/relation extraction
        |
        v
Entity resolution + deduplication
        |
        v
Emergent ontology / schema induction
        |
        v
Graph database
        |
        v
GraphRAG + semantic search

Key capabilities to evaluate:

• entity resolution (same entity across documents)
• provenance tracking (every edge points back to source text)
• schema evolution (new concepts can appear later)
• confidence scoring
• human review loop

One caveat: “schema-free” systems usually still create an implicit schema (node types, relationship types, properties). The difference is that the schema is discovered from the corpus instead of designed beforehand. Research systems such as AutoSchemaKG and TRACE-KG focus specifically on this dynamic schema induction problem.

For most teams, I would start with Neo4j LLM Knowledge Graph Builder for a practical implementation, or TrustGraph if the priority is truly ontology-free extraction.