What Is a Knowledge Graph? Entities, Relationships, and GraphRAG for LLM Applications

TL;DR — Knowledge graphs for LLMs: entities, relationships, GraphRAG. Neo4j: "Knowledge graph organizes information as a network of entities and relationships. Vector search cannot show how people, ideas, and organizations connect across documents. GraphRAG uses knowledge graph to surface entities, relationships, and facts — enabling multi-hop reasoning." BigDataBoutique: "Vector store = recall engine (top-k semantic). Graph store = precision engine (entity neighborhoods, multi-hop paths). Dual-index is the production pattern. Neo4j is safe default, FalkorDB for low-latency, Kuzu for embedded." FalkorDB: "Super fast graph database using GraphBLAS sparse matrices. Purpose-built for LLM/GraphRAG. OpenCypher support." ASOasis: "GraphRAG pipeline: semantic seeds → graph expansion (Cypher) → re-rank → citations → answer. Schema: Document→Chunk→Entity with typed relationships." Learn more with RAG pipeline, function calling, no framework, and Ollama tutorial.

Neo4j provides the definition: "A knowledge graph is a way to organize information by showing how things are connected. Instead of storing data in rows and columns, a knowledge graph represents data as a network, where data entities like people, places, or concepts are connected to each other by relationships."

BigDataBoutique explains the LLM use case: "A vector store handles broad semantic recall, a graph store handles precise relational queries and multi-hop traversal. Neither replaces the other. The wins come from running them together, joined on entity IDs."

Knowledge Graph Architecture

Graph Database Comparison

GraphRAG vs Vector RAG

Implementation

from dataclasses import dataclass
from typing import Optional
from enum import Enum

class GraphModel(Enum):
    PROPERTY_GRAPH = "property_graph"
    RDF = "rdf"

@dataclass
class KnowledgeGraphGuide:
    """Knowledge graph implementation guide."""

    def get_graph_schema(self) -> str:
        """Typical GraphRAG schema in Cypher."""
        return (
            "// === GRAPH SCHEMA ===\n"
            "// Nodes (Entities)\n"
            "//   :Document {id, title, url, date}\n"
            "//   :Chunk {id, text, embedding, position}\n"
            "//   :Person {name, canonical_name}\n"
            "//   :Organization {name, type}\n"
            "//   :Topic {name, category}\n"
            "//   :Event {name, date, location}\n"
            "\n"
            "// Relationships\n"
            "//   (Document)-[:CONTAINS]->(Chunk)\n"
            "//   (Chunk)-[:MENTIONS]->(Entity)\n"
            "//   (Person)-[:WORKS_AT]->(Organization)\n"
            "//   (Person)-[:COLLABORATED_WITH]->(Person)\n"
            "//   (Document)-[:CITES]->(Document)\n"
            "//   (Chunk)-[:ABOUT]->(Topic)\n"
            "//   (Organization)-[:PARTNER_OF]->(Organization)\n"
            "\n"
            "// === CREATE NODES ===\n"
            "CREATE (d:Document {\n"
            "  id: 'doc1',\n"
            "  title: 'AI Research Paper',\n"
            "  url: 'https://example.com',\n"
            "  date: '2026-01-15'\n"
            "})\n"
            "\n"
            "CREATE (c:Chunk {\n"
            "  id: 'chunk1',\n"
            "  text: 'Dr. Smith works at AI Lab',\n"
            "  position: 0\n"
            "})\n"
            "\n"
            "CREATE (p:Person {\n"
            "  name: 'Dr. Smith',\n"
            "  canonical_name: 'smith_dr'\n"
            "})\n"
            "\n"
            "CREATE (o:Organization {\n"
            "  name: 'AI Lab',\n"
            "  type: 'research'\n"
            "})\n"
            "\n"
            "// === CREATE RELATIONSHIPS ===\n"
            "MATCH (d:Document {id: 'doc1'}),\n"
            "      (c:Chunk {id: 'chunk1'})\n"
            "CREATE (d)-[:CONTAINS]->(c)\n"
            "\n"
            "MATCH (c:Chunk {id: 'chunk1'}),\n"
            "      (p:Person {name: 'Dr. Smith'})\n"
            "CREATE (c)-[:MENTIONS]->(p)\n"
            "\n"
            "MATCH (p:Person {name: 'Dr. Smith'}),\n"
            "      (o:Organization {name: 'AI Lab'})\n"
            "CREATE (p)-[:WORKS_AT {since: 2020}]->(o)"
        )

    def get_extraction_prompt(self) -> str:
        """LLM prompt for entity/relationship extraction."""
        return (
            "# === LLM EXTRACTION PROMPT ===\n"
            "prompt = '''\n"
            "Extract entities and relationships\n"
            "from the following text.\n"
            "\n"
            "Schema (optional — constrains\n"
            "  extraction types):\n"
            "  Entity types: Person,\n"
            "    Organization, Topic, Event\n"
            "  Relation types: WORKS_AT,\n"
            "    MENTIONS, CITES,\n"
            "    COLLABORATED_WITH,\n"
            "    AFFILIATED_WITH\n"
            "\n"
            "Text: {chunk_text}\n"
            "\n"
            "Return JSON:\n"
            "{{\n"
            "  \"entities\": [\n"
            "    {{\"name\": \"Dr. Smith\",\n"
            "      \"type\": \"Person\",\n"
            "      \"properties\": {{}}}},\n"
            "    {{\"name\": \"AI Lab\",\n"
            "      \"type\": \"Organization\",\n"
            "      \"properties\": {{}}}}\n"
            "  ],\n"
            "  \"relationships\": [\n"
            "    {{\"source\": \"Dr. Smith\",\n"
            "      \"target\": \"AI Lab\",\n"
            "      \"type\": \"WORKS_AT\",\n"
            "      \"properties\": {{}}}}\n"
            "  ]\n"
            "}}\n"
            "'''\n"
            "\n"
            "# === PYTHON EXTRACTION ===\n"
            "from openai import OpenAI\n"
            "import json\n"
            "\n"
            "client = OpenAI(\n"
            "    base_url=\n"
            "      'http://localhost:11434/v1',\n"
            "    api_key='ollama'\n"
            ")\n"
            "\n"
            "def extract_entities(text):\n"
            "    '''Extract entities and\n"
            "    relationships from text.'''\n"
            "    resp = client.chat.completions\n"
            "        .create(\n"
            "        model='llama3.2',\n"
            "        messages=[{\n"
            "            'role': 'user',\n"
            "            'content': prompt.format(\n"
            "                chunk_text=text)\n"
            "        }],\n"
            "        format='json',\n"
            "        stream=False\n"
            "    )\n"
            "    return json.loads(\n"
            "        resp.choices[0].message\n"
            "        .content)\n"
            "\n"
            "# Usage\n"
            "result = extract_entities(\n"
            "    'Dr. Smith works at AI Lab')\n"
            "print(result['entities'])\n"
            "# [{'name': 'Dr. Smith',\n"
            "#   'type': 'Person'}, ...]\n"
            "print(result['relationships'])\n"
            "# [{'source': 'Dr. Smith',\n"
            "#   'target': 'AI Lab',\n"
            "#   'type': 'WORKS_AT'}]"
        )

    def get_hybrid_retrieval(self) -> str:
        """Hybrid vector + graph retrieval."""
        return (
            "# === HYBRID RETRIEVAL ===\n"
            "# Vector recall + graph expansion\n"
            "\n"
            "from neo4j import GraphDatabase\n"
            "import faiss\n"
            "\n"
            "driver = GraphDatabase.driver(\n"
            "    'bolt://localhost:7687',\n"
            "    auth=('neo4j',\n"
            "      'password'))\n"
            "\n"
            "def hybrid_retrieve(\n"
            "    question, top_k=5):\n"
            "    '''1. Vector seeds\n"
            "    2. Graph expansion\n"
            "    3. Re-rank''' \n"
            "    \n"
            "    # Step 1: Vector recall\n"
            "    #   (semantic seeds)\n"
            "    q_embedding = embed(\n"
            "        question)\n"
            "    seeds = faiss.search(\n"
            "        q_embedding, top_k)\n"
            "    seed_chunk_ids = [\n"
            "        s.id for s in seeds]\n"
            "    \n"
            "    # Step 2: Graph expansion\n"
            "    #   (Cypher traversal)\n"
            "    with driver.session() as sess:\n"
            "        result = sess.run(\n"
            "            '''\n"
            "            MATCH (c:Chunk)\n"
            "            WHERE c.id IN $ids\n"
            "            MATCH (c)-[:MENTIONS]->\n"
            "              (e)\n"
            "            MATCH (e)<-[:MENTIONS]-\n"
            "              (c2:Chunk)\n"
            "            RETURN DISTINCT\n"
            "              c2.id, c2.text\n"
            "            LIMIT 20\n"
            "            ''',\n"
            "            ids=seed_chunk_ids\n"
            "        )\n"
            "        expanded = [\n"
            "            (r['c2.id'],\n"
            "             r['c2.text'])\n"
            "            for r in result]\n"
            "    \n"
            "    # Step 3: Re-rank\n"
            "    #   (cross-encoder)\n"
            "    ranked = rerank(\n"
            "        question, expanded)\n"
            "    return ranked[:top_k]\n"
            "\n"
            "# Usage\n"
            "chunks = hybrid_retrieve(\n"
            "    'Who works at AI Lab?')\n"
            "# Returns chunks connected\n"
            "# to AI Lab via graph"
        )

    def get_database_comparison(self) -> dict:
        """Graph database comparison."""
        return {
            "neo4j": {
                "type": "Property graph",
                "query": "Cypher",
                "vector": "Native",
                "ecosystem": "LangChain, LlamaIndex, GDS library",
                "best_for": "Default choice, broadest support",
                "weakness": "License terms for self-hosted Enterprise",
            },
            "falkordb": {
                "type": "Property graph",
                "query": "OpenCypher",
                "vector": "Native",
                "ecosystem": "LangChain, Redis client, Flexible GraphRAG",
                "best_for": "Low-latency, purpose-built for LLM/GraphRAG",
                "weakness": "Smaller community than Neo4j",
            },
            "memgraph": {
                "type": "Property graph",
                "query": "Cypher",
                "vector": "Native",
                "ecosystem": "LangChain, MCP tooling, AI Toolkit",
                "best_for": "In-memory speed, agentic applications",
                "weakness": "Memory sizing, not for cold archives",
            },
            "kuzu": {
                "type": "Property graph",
                "query": "Cypher",
                "vector": "Native",
                "ecosystem": "LlamaIndex KuzuPropertyGraphStore",
                "best_for": "Embedded, single-process, prototyping",
                "weakness": "Single-writer model",
            },
            "neptune": {
                "type": "Both (property + RDF)",
                "query": "openCypher/Gremlin/SPARQL",
                "vector": "Native",
                "ecosystem": "AWS Bedrock, AWS-native",
                "best_for": "AWS-native deployments, Bedrock integration",
                "weakness": "Less ecosystem tooling outside AWS",
            },
        }

    def get_graphrag_vs_rag(self) -> dict:
        """GraphRAG vs vector RAG comparison."""
        return {
            "vector_rag": {
                "retrieval": "Embedding similarity",
                "multi_hop": False,
                "provenance": False,
                "best_for": "Simple Q&A, semantic search",
                "weakness": "Cannot show relationships across documents",
            },
            "graphrag": {
                "retrieval": "Graph traversal (Cypher)",
                "multi_hop": True,
                "provenance": True,
                "best_for": "Complex relationships, multi-hop reasoning",
                "weakness": "Higher complexity, requires graph construction",
            },
            "dual_index": {
                "retrieval": "Vector recall + graph precision",
                "multi_hop": True,
                "provenance": True,
                "best_for": "Production applications",
                "pattern": "Router/fusion layer in front of both stores",
                "weakness": "Highest complexity, two systems to maintain",
            },
        }

Knowledge Graph Checklist

• [ ] Knowledge graph: network of entities (nodes) and relationships (edges) with properties
• [ ] Entities: people, organizations, documents, topics, events — nodes with properties
• [ ] Relationships: WORKS_AT, MENTIONS, CITES, COLLABORATED_WITH — edges with properties
• [ ] Triples: subject → predicate → object (Person → WORKS_AT → Organization)
• [ ] Two graph models: property graph (Neo4j, FalkorDB) and RDF/triples (Jena, GraphDB)
• [ ] Property graph: nodes + edges with properties, Cypher query — better for RAG
• [ ] RDF/triples: subject-predicate-object, SPARQL query, OWL/RDFS ontology — for federation/compliance
• [ ] Property graphs beat RDF/SPARQL on developer ergonomics and tooling for RAG
• [ ] Choose RDF only if: existing RDF infrastructure, regulatory requirements, federated-query needs
• [ ] GraphRAG: structured graph-based retrieval — entities, relationships, facts, multi-hop reasoning
• [ ] Vector RAG: embedding similarity — standalone chunks, no relationships
• [ ] Dual-index pattern (production): vector store (recall) + graph store (precision), joined on entity IDs
• [ ] Dual-index: router/fusion layer sits in front of both stores, routes by query type
• [ ] Vector RAG answers "Find similar text" — GraphRAG answers "Who worked with whom?"
• [ ] Neo4j: default choice, broadest ecosystem, Cypher, GDS library (PageRank, community detection), native vector index
• [ ] Neo4j: LangChain and LlamaIndex first-class integrations, Neo4jPropertyGraphStore
• [ ] FalkorDB: low-latency, GraphBLAS sparse matrices, purpose-built for LLM/GraphRAG, OpenCypher
• [ ] FalkorDB: successor to RedisGraph (EOL early 2025), sparse-matrix algebra
• [ ] Memgraph: in-memory, Cypher-compatible, agentic toolkits, MCP tooling
• [ ] Kuzu: embedded, single-process, no infrastructure, ideal for prototyping, KuzuPropertyGraphStore
• [ ] Amazon Neptune: AWS-native, Bedrock integration, openCypher/Gremlin/SPARQL
• [ ] Flexible GraphRAG: 15 property graph databases, 4 RDF triple stores, 10 vector databases
• [ ] Flexible GraphRAG: OWL/RDFS ontology support, SPARQL 1.1, hybrid search (fulltext, vector, graph, RDF)
• [ ] Build from text: parse documents → chunk text → LLM extracts entities/relations → upsert to graph
• [ ] Optional schema constrains extraction to specific entity/relation types
• [ ] LlamaIndex SchemaLLMPathExtractor: typed triplets with enum entity/relation types
• [ ] LangChain + LlamaIndex both integrate with Neo4jPropertyGraphStore
• [ ] GraphRAG retrieval: semantic seeds (top-k vector) → graph expansion (Cypher) → re-rank → citations
• [ ] Schema: (Document)-[:CONTAINS]->(Chunk), (Chunk)-[:MENTIONS]->(Entity), (Person)-[:WORKS_AT]->(Org)
• [ ] Chunk nodes hold raw text for LLM context; entity nodes enable disambiguation
• [ ] Edges preserve provenance and support topological queries (neighbors, paths, communities)
• [ ] GDS library: PageRank, community detection, shortest paths — graph algorithms for RAG
• [ ] Native vector indexes: colocate node embeddings with graph (Neo4j, FalkorDB)
• [ ] Multi-index retrieval: blend BM25 keyword + vector search + graph paths, learn weights
• [ ] Read RAG pipeline for vector RAG basics
• [ ] Read function calling for tool use
• [ ] Read no framework for agent integration
• [ ] Read Ollama tutorial for local LLM setup
• [ ] Test: entities and relationships extracted correctly from sample text
• [ ] Test: graph query returns expected multi-hop results
• [ ] Test: hybrid retrieval combines vector + graph results effectively
• [ ] Test: provenance tracking shows source documents for answers
• [ ] Test: schema constrains extraction to specified types
• [ ] Test: graph database performance acceptable for your query patterns
• [ ] Document graph model, schema, database choice, extraction pipeline, retrieval strategy

FAQ

What is a knowledge graph and why does it matter for LLMs?

A knowledge graph organizes information as a network of entities and relationships, enabling multi-hop reasoning that vector search cannot do. Neo4j: "A knowledge graph is a way to organize information by showing how things are connected. Instead of rows and columns, it represents data as a network where entities like people, places, or concepts are connected by relationships. Vector search cannot show you how people, ideas, and organizations connect across documents. A knowledge graph provides organization so you can see these relationships." BigDataBoutique: "A vector store handles broad semantic recall, a graph store handles precise relational queries and multi-hop traversal. Neither replaces the other. The wins come from running them together, joined on entity IDs." ASOasis: "When your data has rich structure — people, organizations, documents, events, citations — plain vector search loses context and precision. A knowledge graph restores that structure and lets you ask topology-aware questions." Knowledge graph: (1) Entities (nodes): people, organizations, concepts. (2) Relationships (edges): works_at, cites, mentions. (3) Properties: attributes on nodes and edges. (4) Enables multi-hop reasoning, provenance tracking, community detection.

How does GraphRAG differ from vector RAG?

GraphRAG uses knowledge graph traversal for precise relational retrieval; vector RAG uses embedding similarity for semantic recall. Neo4j: "GraphRAG builds on RAG by introducing structured, graph-based retrieval. Instead of just retrieving similar chunks of text, GraphRAG uses a knowledge graph to surface relevant entities, relationships, and facts, giving the LLM better context and enabling multi-hop reasoning across connected knowledge." BigDataBoutique: "The pattern that holds up in production is dual-index. The vector store is the recall engine: top-k chunks by semantic similarity. The graph is the precision and traversal engine: entity neighborhoods, multi-hop paths, type-filtered subgraphs. A router or fusion layer sits in front of both." ASOasis: "Retrieval: semantic seeds (top-k chunks by embedding) → graph expansion (Cypher neighbors) → re-ranking → assemble citations → generate answer." Differences: (1) Vector RAG: embedding similarity, standalone chunks, no relationships. (2) GraphRAG: entity/relationship traversal, multi-hop reasoning, provenance. (3) Dual-index: vector for recall + graph for precision — production pattern. (4) GraphRAG answers 'Who collaborated with whom?' — vector RAG cannot.

What are the types of knowledge graph models?

Property graph (Neo4j, FalkorDB) and RDF/triples (SPARQL, OWL) are the two main models. BigDataBoutique: "For RAG specifically, property graphs beat RDF/SPARQL on developer ergonomics and tooling. Choose RDF only if you have existing RDF infrastructure, regulatory requirements, or genuine cross-organization federated-query needs." FalkorDB: "FalkorDB is the first queryable Property Graph database to leverage sparse matrices for representing the adjacency matrix. Supports nodes and relationships with attributes, adhering to the Property Graph Model. OpenCypher support." Flexible GraphRAG: "Supports 15 property graph databases, 4 RDF triple stores (Apache Jena Fuseki, Ontotext GraphDB, Oxigraph, Amazon Neptune RDF). Load OWL/RDFS ontologies to guide KG extraction. SPARQL 1.1 queries." Models: (1) Property graph: nodes + relationships with properties, Cypher query language, Neo4j/FalkorDB/Memgraph/Kuzu. (2) RDF/triples: subject-predicate-object, SPARQL query, OWL/RDFS ontology, Jena/GraphDB/Neptune RDF. (3) Property graph is better for RAG — developer ergonomics, tooling, LangChain/LlamaIndex integration.

Which graph database should you choose for GraphRAG?

Neo4j is the safe default; FalkorDB for low-latency; Kuzu for embedded prototyping. BigDataBoutique: "Neo4j is the default because the ecosystem is broadest. Cypher is the de facto property-graph query language, Graph Data Science library covers PageRank, community detection, shortest paths. Both LangChain and LlamaIndex have first-class integrations. Native vector indexes. Memgraph is in-memory and Cypher-compatible. Kuzu is embedded — one process, no infrastructure, ideal for prototyping. FalkorDB is the RedisGraph successor, uses sparse-matrix algebra, targets low-latency subgraph caching." FalkorDB: "Super fast Graph Database uses GraphBLAS under the hood for sparse adjacency matrix. Goal: provide the best Knowledge Graph for LLM (GraphRAG). Prioritizing exceptionally low latency." Databases: (1) Neo4j: default, broadest ecosystem, Cypher, GDS library, native vector index. (2) FalkorDB: low-latency, sparse-matrix, GraphBLAS, purpose-built for LLM/GraphRAG. (3) Memgraph: in-memory, Cypher-compatible, agentic toolkits. (4) Kuzu: embedded, single-process, prototyping. (5) Amazon Neptune: AWS-native, Bedrock integration.

How do you build a knowledge graph from unstructured text with LLMs?

Use LLM to extract entities and relationships from documents, then upsert to graph database. Neo4j: "LLM Knowledge Graph Builder: ready-made pipeline for turning unstructured text into a structured graph. Includes prompt templates, chunking logic, and CSV exports for Neo4j. You can run a version with a schema — works like a filter, helping the LLM include only specific types of nodes, relationships, and properties." ASOasis: "Ingestion: parse documents → chunk text → extract entities/relations → upsert to Neo4j. Schema: (Document)-[:CONTAINS]->(Chunk), (Chunk)-[:MENTIONS]->(Person|Organization|Topic), (Person)-[:AFFILIATED_WITH]->(Organization), (Document)-[:CITES]->(Document)." BigDataBoutique: "LlamaIndex SchemaLLMPathExtractor: pass enums for entity and relation types, produces typed triplets. Both LangChain and LlamaIndex integrate with Neo4jPropertyGraphStore." Build: (1) Parse documents → chunk text. (2) LLM extracts entities (Person, Org, Topic) and relationships. (3) Optional schema constrains extraction to specific types. (4) Upsert nodes and relationships to graph database. (5) Create vector index for chunks. (6) Hybrid retrieval: vector recall + graph traversal.

Want a self-hosted AI company brain that does all of this out of the box?
Book a demo →