LLM knowledge graph databases

Yes. If your goal is “a knowledge graph that an LLM/agent can query reliably”, I’d build it as a GraphRAG architecture, rather than simply putting documents into a graph database.

My shortlist

Option	Best for	LLM querying	Semantic reasoning	Recommendation
Neo4j	General-purpose KG + LLM apps	Excellent	Good	Best default
Amazon Neptune	AWS-scale production systems	Excellent	Excellent with RDF	Best AWS choice
Ontotext GraphDB	Ontologies, RDF, semantic reasoning	Very good	Excellent	Best semantic KG
Microsoft GraphRAG	Turning documents into graph-based RAG	Excellent	Depends on underlying graph	Good methodology/tooling

1. My default recommendation: Neo4j + GraphRAG

Neo4j's GraphRAG tooling is particularly suited to what you're describing. Its current Python package provides first-party GraphRAG functionality, including knowledge-graph construction and retrieval.neo4j.com+1

The architecture would look roughly like:

                 ┌──────────────────┐
Documents ──────►│ Entity / Relation│
PDFs              │ Extraction      │
Web                └────────┬─────────┘
                            │
                            ▼
                    ┌───────────────┐
                    │ Knowledge     │
                    │ Graph         │
                    │               │
                    │ Person        │
                    │   │           │
                    │ Company ──────┤
                    │   │           │
                    │ Product       │
                    └───────┬───────┘
                            │
                ┌───────────┴───────────┐
                │                       │
          Graph traversal          Vector search
                │                       │
                └───────────┬───────────┘
                            ▼
                       Retrieved
                        context
                            │
                            ▼
                           LLM
                            │
                            ▼
                         Answer

This is important because the LLM shouldn't have to “know” the entire graph. Your application translates the user's question into graph/vector retrieval, supplies the relevant subgraph and source evidence to the LLM, and asks it to answer from that context.

Neo4j's documentation explicitly describes GraphRAG as combining knowledge graphs with vector search, and its KG Builder can extract entities and relationships from unstructured documents.neo4j.com+1

2. If you need a true semantic knowledge graph: GraphDB

If by “knowledge graph” you mean something closer to:

entities + relationships + ontology + inference + provenance

then I'd seriously consider Ontotext GraphDB.

It is an RDF/SPARQL database and supports semantic inference, allowing the system to derive facts from existing facts.graphdb.ontotext.com

For example:

Alice ──worksFor──► Acme
Acme  ──subClassOf─► TechnologyCompany
TechnologyCompany ──subClassOf─► Company

A reasoning engine can infer:

Alice worksFor a Company

without that exact fact having been explicitly stored.

That's considerably different from a typical property graph.

3. Neptune if you're already in AWS

Amazon Neptune is compelling if this needs to live inside an AWS production environment.

It supports both property graphs and RDF, with Gremlin, openCypher and SPARQL query options.docs.aws.amazon.com

That makes it unusually flexible:

LLM
 │
 ▼
Query planner / agent
 │
 ├──► SPARQL ───► RDF knowledge graph
 │
 └──► openCypher ─► Property graph

4. Don't confuse GraphRAG with the database

This distinction is important.

Graph database:

Where the knowledge lives.

GraphRAG:

How an LLM retrieves and uses that knowledge.

Microsoft's GraphRAG project, for example, is a pipeline for extracting structured information from unstructured text and using graph-based structures to create context for question answering. Microsoft currently describes the project as being largely in maintenance mode, so I would treat it more as a useful methodology/reference implementation than automatically as the foundation of a new production system.github.com

What I would build

For a new system today, my default stack would be:

Neo4j + vector index + LLM + structured query generation + source provenance

with something like:

                    User
                      │
                      ▼
                 ┌─────────┐
                 │   LLM   │
                 └────┬────┘
                      │
              determine intent
                      │
          ┌───────────┴───────────┐
          ▼                       ▼
   graph query              vector search
     (Cypher)                   │
          │                     │
          └───────────┬─────────┘
                      ▼
                 subgraph +
                source chunks
                      │
                      ▼
                 ┌─────────┐
                 │   LLM   │
                 └────┬────┘
                      ▼
              grounded answer
               + citations

The Cypher query should ideally be generated against a constrained schema, rather than allowing the LLM to invent arbitrary graph structure. You can also expose a small set of safe graph operations as tools to an agent.

One particularly important design decision

I would store provenance on graph facts:

(Acme)-[EMPLOYS]->(Alice)

source:
    document = "annual_report_2025.pdf"
    page     = 42
    chunk_id = "abc123"
    confidence = 0.96

Then the LLM can answer:

Alice works for Acme.

while your application can also provide:

Source: Annual Report 2025, p. 42.

That makes the KG much more useful for an LLM than a graph consisting solely of anonymous triples.

If you tell me what kind of knowledge you're modeling (e.g. company data, scientific literature, legal documents, product catalog, enterprise documents, Wikipedia-like facts), I can recommend the exact database + ontology/schema + LLM querying architecture, including a concrete schema and example queries.

Yes. The strongest match I found is Neo4j LLM Knowledge Graph Builder.

Best matches

Tool	Schema required?	Unstructured text	Best for
Neo4j LLM Graph Builder	No — schema is optional; it can infer entities/relationships	PDFs, DOCX, TXT, web pages, YouTube, etc.	Easiest ready-to-use solution
Graphiti	No upfront ontology required	Documents, conversations, events, agent memory	Developers building a continuously evolving/temporal KG
Knowledge Graph Foundry	No — explicitly discovers the ontology	PDF, DOCX, TXT, MD, JSON, CSV, XLSX	Simple CLI/self-hosted pipeline

1. Neo4j LLM Knowledge Graph Builder — my first choice

This is almost exactly your requirement. You feed it unstructured sources and the LLM extracts entities, relationships, and properties; defining a schema is explicitly optional. Neo4j also has an experimental automatic-schema capability that can infer the schema using an LLM.github.com

It supports PDFs, documents, web pages, YouTube transcripts, and other sources, and stores the resulting graph in Neo4j.neo4j.com

One caveat: completely schema-free extraction can produce a very large number of entity/relationship types. Neo4j itself recommends schema guidance for highly constrained production graphs, although its automatic consolidation can reduce the proliferation of types afterward.neo4j.com

Good choice if: you want to upload documents and visually inspect the automatically generated graph without building the extraction pipeline yourself.

2.Graphiti on GitHub

Graphiti is more of a developer framework than a turnkey UI. Its strength is building dynamic/temporal knowledge graphs from continuously arriving information—particularly useful for agent memory, conversations, and changing facts. It supports Neo4j and other graph backends.github.com

Good choice if: you're embedding the KG into an application rather than just uploading a document corpus.

3. Knowledge Graph Foundry

This is an interesting newer CLI option. Its documentation explicitly says “No predefined schema required” and that it discovers the ontology from your data, while still allowing you to seed a schema later. It accepts common document formats and produces a Neo4j graph with provenance.pypi.org

Good choice if: you want a lightweight, code/CLI-oriented alternative to Neo4j's UI.

My recommendation

If your requirement is literally:

“Give it arbitrary documents → automatically discover what entities and relationships exist → produce a knowledge graph without me designing an ontology first.”

I'd start with Neo4j LLM Knowledge Graph Builder. It is the most mature and turnkey fit I found.github.com

If you tell me whether you want (a) a hosted SaaS, (b) open-source/self-hosted, or (c) a Python/API library, I can narrow this down to the best 3–5 options and compare schema discovery, entity resolution, provenance, temporal support, LLM requirements, and cost.