Skip to content
Skills Library
AI & agents · Building & coding

graphrag-patterns

/graphrag-patterns

Implement GraphRAG combining knowledge graphs with RAG for multi-hop reasoning. Use this skill when building knowledge graph RAG, implementing multi-hop queries, using Neo4j with RAG, or connecting entities across documents. Activate when: GraphRAG, knowledge graph, multi-hop reasoning, Neo4j RAG, entity extraction, relationship queries, graph database, connected data.

Licence
MIT
Last repository change
04.11.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
5
Deprecation

No signals detected. Repository changed on 04.11.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Implement GraphRAG combining knowledge graphs with RAG for multi-hop reasoning. Use this skill when building knowledge graph RAG, implementing multi-hop queries, using Neo4j with RAG, or connecting entities across documents. Activate when: GraphRAG, knowledge graph, multi-hop reasoning, Neo4j RAG, entity extraction, relationship queries, graph database, connected data.

Original author description

Implement GraphRAG combining knowledge graphs with RAG for multi-hop reasoning. Use this skill when building knowledge graph RAG, implementing multi-hop queries, using Neo4j with RAG, or connecting entities across documents. Activate when: GraphRAG, knowledge graph, multi-hop reasoning, Neo4j RAG, entity extraction, relationship queries, graph database, connected data.

How it works

  1. When to Use GraphRAG vs Vector RAG
  2. Core Architecture
  3. Pattern 1: Entity Extraction → Knowledge Graph
  4. Pattern 2: Graph-Enhanced Retrieval
  5. Pattern 3: Text-to-Cypher for Direct Graph Queries
  6. Pattern 4: Hybrid Vector + Graph Retrieval
  7. Pattern 5: Path-Based Retrieval (Explain Connections)
  8. Pattern 6: Microsoft GraphRAG (Community Summaries)
  9. When to Use Each Pattern
  10. Best Practices
Original SKILL.md headings · 374 lines, 1,659 words
SKILL.md preview
---
name: graphrag-patterns
description: |
  Implement GraphRAG combining knowledge graphs with RAG for multi-hop reasoning.
  Use this skill when building knowledge graph RAG, implementing multi-hop queries,
  using Neo4j with RAG, or connecting entities across documents.
  Activate when: GraphRAG, knowledge graph, multi-hop reasoning, Neo4j RAG,
  entity extraction, relationship queries, graph database, connected data.
---

# GraphRAG Patterns

**Combine knowledge graphs with RAG for complex reasoning over connected data.**

## When to Use GraphRAG vs Vector RAG

| Use Case | Vector RAG | GraphRAG |
|----------|------------|----------|
| Simple Q&A | ✅ | Overkill |
| Factual lookup | ✅ | ✅ |
| Multi-hop reasoning | ❌ | ✅ |
| "How is X related to Y?" | ❌ | ✅ |
| Entity relationships | ❌ | ✅ |
| Compliance/audit trails | ❌ | ✅ |
| Summarizing themes | ❌ | ✅ |
| Explaining *why* items are connected | ❌ | ✅ (the path is the explanation) |

## Core Architecture

```
┌─────────────────────────────────────────────────────────────┐
│                      User Query                              │
└─────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────┐
│                    Query Analyzer                            │
│         (Determine: vector, graph, or hybrid?)               │
└─────────────────────────────────────────────────────────────┘
                    │                    │
          ┌────────┴────────┐  ┌────────┴────────┐
          ▼                 ▼  ▼                 ▼
┌─────────────────┐  ┌─────────────────┐
│  Vector Search  │  │  Graph Traverse │
│  (Semantic)     │  │  (Structured)   │
└─────────────────┘  └─────────────────┘
          │                    │
          └────────┬──────────┘
                   ▼
┌─────────────────────────────────────────────────────────────┐
│                  Context Fusion                              │
└─────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────┐
│                    LLM Generation                            │
└─────────────────────────────────────────────────────────────┘
```

## Pattern 1: Entity Extraction → Knowledge Graph

> **Model IDs:** `CHAT_MODEL` in these examples is a placeholder. Set it to a current chat model ID from your provider's models page (for example `CHAT_MODEL = os.environ["CHAT_MODEL"]`); model IDs are retired over time.

```python
import json
import re
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from neo4j import GraphDatabase

# Step 1: Extract entities and relationships from documents
EXTRACTION_PROMPT = """Extract entities and relationships from this text.

Text: {text}

Return JSON format:
{{
  "entities": [
    {{"name": "...", "type": "Person|Organization|Concept|Event|Location", "description": "..."}}
  ],
  "relationships": [
    {{"source": "...", "target": "...", "type": "WORKS_FOR|USES|PART_OF|RELATED_TO", "description": "..."}}
  ]
}}
"""

async def extract_knowledge(text: str, llm: ChatOpenAI) -> dict:
    """Extract entities and relationships from text."""
    prompt = ChatPromptTemplate.from_template(EXTRACTION_PROMPT)
    chain = prompt | llm
    result = await chain.ainvoke({"text": text})
    return json.loads(result.content)


# Step 2: Normalize entity names so "AWS" and "Amazon Web Services" become one node
ALIASES = {"aws": "Amazon Web Services", "amazon web services": "Amazon Web Services"}

def normalize(name: str) -> str:
    key = re.sub(r"\s+", " ", name).strip().lower()
    return ALIASES.get(key, name.strip())


# Step 3: Store in Neo4j
# Cypher cannot take labels or relationship types as parameters, so validate them
# against your schema before interpolating. Extracted text is untrusted input.
ENTITY_TYPES = {"Person", "Organization", "Concept", "Event", "Location"}
REL_TYPES = {"WORKS_FOR", "USES", "PART_OF", "RELATED_TO"}

class KnowledgeGraph:
    def __init__(self, uri: str, user: str, password: str):
        self.driver = GraphDatabase.driver(uri, auth=(user, password))

    def add_entity(self, name: str, entity_type: str, properties: dict | None = None):
        if entity_type not in ENTITY_TYPES:
            entity_type = "Concept"
        with self.driver.session() as session:
            session.run(
                f"MERGE (e:Entity:{entity_type} {{name: $name}}) SET e += $properties",
                name=normalize(name),
                properties=properties or {},
            )

    def add_relationship(self, source: str, target: str, rel_type: str, description: str = ""):
        if rel_type not in REL_TYPES:
            rel_type = "RELATED_TO"
        with self.driver.session() as session:
            session.run(
                f"""
                MATCH (a:Entity {{name: $source}})
                MATCH (b:Entity {{name: $target}})
                MERGE (a)-[r:{rel_type}]->(b)
                SET r.description = $description
                """,
                source=normalize(source),
                target=normalize(target),
                description=description,
            )
```

Use the same model and prompt for every document so entity types stay consistent, and keep the schema (`ENTITY_TYPES`, `REL_TYPES`) under version control: it will change as the corpus grows.

## Pattern 2: Graph-Enhanced Retrieval

```python
from llama_index.core import PropertyGraphIndex
from llama_index.graph_stores.neo4j import Neo4jPropertyGraphStore

def create_property_graph_index(documents):
    """Create a property graph index with LlamaIndex."""

    # Connect to Neo4j
    graph_store = Neo4jPropertyGraphStore(
        username="neo4j",
        password="password",
        url="bolt://localhost:7687",
    )

    # Build index - automatically extracts entities/relationships
    index = PropertyGraphIndex.from_documents(
        documents,
        property_graph_store=graph_store,
        show_progress=True,
    )

    return index


def query_with_graph(index, query: str):
    """Query using both vector and graph retrieval."""

    # Create retriever that uses both paths
    retriever = index.as_retriever(
        include_text=True,  # Include original text chunks
        similarity_top_k=5,
    )

    # Get results
    nodes = retriever.retrieve(query)
    return nodes
```

## Pattern 3: Text-to-Cypher for Direct Graph Queries

```python
from langchain_neo4j import GraphCypherQAChain, Neo4jGraph  # pip install langchain-neo4j

def create_text_to_cypher_chain():
    """Create a chain that converts natural language to Cypher queries."""

    # Connect to Neo4j
    graph = Neo4jGraph(
        url="bolt://localhost:7687",
        username="neo4j",
        password="password"
    )

    # Print schema for debugging
    print(graph.schema)

    # Create chain
    chain = GraphCypherQAChain.from_llm(
        llm=ChatOpenAI(model=CHAT_MODEL, temperature=0),
        graph=graph,
        verbose=True,
        validate_cypher=True,  # Validate before executing
        return_intermediate_steps=True,
        allow_dangerous_requests=True,  # required opt-in: use a read-only DB user
    )

    return chain


# Usage
chain = create_text_to_cypher_chain()
result = chain.invoke({
    "query": "What companies has John Smith worked for?"
})
# Generated Cypher: MATCH (p:Person {name: 'John Smith'})-[:WORKED_AT]->(c:Company) RETURN c.name
```

## Pattern 4: Hybrid Vector + Graph Retrieval

```python
class HybridGraphRAG:
    """Combine vector similarity with graph traversal."""

    def __init__(self, vector_store, graph_store):
        self.vector_store = vector_store
        self.graph_store = graph_store

    def retrieve(self, query: str, top_k: int = 5) -> list[dict]:
        # 1. Vector search for relevant chunks
        vector_results = self.vector_store.similarity_search(query, k=top_k)

        # 2. Extract entities from query
        query_entities = self._extract_entities(query)

        # 3. Graph traversal from those entities
        graph_context = []
        for entity in query_entities:
            # Get 1-hop neighbors. Pass the entity as a parameter, never via f-string.
            neighbors = self.graph_store.query(
                """
                MATCH (e:Entity {name: $name})-[r]-(n)
                RETURN e.name, type(r), n.name, n.description
                LIMIT 10
                """,
                params={"name": normalize(entity)},
            )
            graph_context.extend(neighbors)

        # 4. Combine results
        combined = {
            "vector_chunks": [r.page_content for r in vector_results],
            "graph_context": graph_context,
            "entities": query_entities
        }

        return combined

    def _extract_entities(self, text: str) -> list[str]:
        # Use NER or LLM to extract entities
        # Simplified version:
        prompt = f"Extract entity names from: {text}"
        # ... LLM call
        return entities
```

### Variant: Expand From Entities in Retrieved Chunks

If chunks were tagged with the entities they mention at ingest time, start from the vector results instead of the query. This also works when the query names no entity:

```python
def expand_from_chunks(vector_results: list, graph_store, max_entities: int = 5) -> list[str]:
    entities = []
    for doc in vector_results:
        for e in doc.metadata.get("entities", []):
            if e not in entities:
                entities.append(e)
    facts = []
    for entity in entities[:max_entities]:          # cap expansion to control prompt size
        rows = graph_store.query(
            "MATCH (e:Entity {name: $name})-[r]->(n) RETURN e.name AS s, type(r) AS rel, n.name AS o LIMIT 10",
            params={"name": entity},
        )
        facts.extend(f"{r['s']} -[{r['rel']}]-> {r['o']}" for r in rows)
    return facts
```

Pass these facts to the prompt under a separate "Entity relationships" heading so the model can tell them apart from text chunks.

## Pattern 5: Path-Based Retrieval (Explain Connections)

For "How is X related to Y?", retrieve the path itself. The path is both the context and the explanation:

```python
def explain_connection(driver, entity_a: str, entity_b: str) -> list[str]:
    # Variable-length bounds (the 4 in [*..4]) cannot be query parameters in Cypher;
    # keep them as validated literals.
    query = """
    MATCH (a:Entity {name: $a}), (b:Entity {name: $b})
    MATCH path = shortestPath((a)-[*..4]-(b))
    RETURN [n IN nodes(path) | n.name] AS names,
           [r IN relationships(path) | type(r)] AS rels
    """
    with driver.session() as session:
        record = session.run(query, a=normalize(entity_a), b=normalize(entity_b)).single()
    if record is None:
        return []  # no path: fall back to vector retrieval
    names, rels = record["names"], record["rels"]
    hops = [f"{names[i]} -[{rels[i]}]- {names[i + 1]}" for i in range(len(rels))]
    return hops
```

Keep hop limits small (2-4). Unbounded variable-length patterns can traverse much of the graph.

## Pattern 6: Microsoft GraphRAG (Community Summaries)

Microsoft's GraphRAG extracts an entity graph, groups entities into a hierarchy of communities (Leiden clustering), and pre-writes a summary for each community. **Global search** answers corpus-wide questions ("What are the main themes?") from those summaries; **local search** answers entity-specific questions from the entity's neighborhood and source text.

It is driven by a CLI and a `settings.yaml` file rather than a Python API you call inline. As documented at the time of writing:

```bash
python -m pip install graphrag
mkdir -p ./ragtest/input && cp ./documents/*.txt ./ragtest/input/
cd ./ragtest
graphrag init            # writes settings.yaml and .env; set GRAPHRAG_API_KEY and models there
graphrag index           # builds the graph, communities, and summaries into ./output

graphrag query "What are the main themes in these documents?"            # global search (default)
graphrag query "What is Company X's main product?" --method local        # entity-focused
```

Indexing makes many LLM calls per document, so try it on a sample of the corpus and check the cost before indexing everything. Check the Get Started page for the current commands and options; the CLI has changed between releases.

## When to Use Each Pattern

| Pattern | Use When |
|---------|----------|
| Entity Extraction → KG | Building from scratch, custom schema |
| Property Graph Index | Quick setup, LlamaIndex ecosystem |
| Text-to-Cypher | Existing graph, complex queries |
| Hybrid Vector + Graph | Need both semantic + structural |
| Path-Based Retrieval | "How is X related to Y?", explainable answers |
| Microsoft GraphRAG | Large corpus, summarization queries |

## Best Practices

1. **Define your schema** - Know what entities and relationships matter, and version it
2. **Start simple** - Begin with 2-3 entity types, expand as needed
3. **Extract consistently** - Same model and prompt for every document
4. **Normalize entities** - Merge aliases ("AWS" / "Amazon Web Services") into one node
5. **Validate Cypher** - Validate generated queries, run them as a read-only database user, and never build Cypher from untrusted strings
6. **Limit depth** - 2-3 hops is usually enough; cap expansion fan-out
7. **Cache graph queries** - Graph traversals can be expensive
8. **Combine with vector** - Pure graph misses semantic similarity
9. **Test multi-hop** - Ensure 2-3 hop queries perform acceptably

## Common Pitfalls

- **Over-extraction**: Too many entities = noisy graph
- **Missing relationships**: Entities without connections are useless
- **Schema drift**: Inconsistent entity types break queries
- **Duplicate entities**: Unnormalized aliases split one entity's facts across several nodes
- **Cypher injection**: Entity names or relationship types from LLM output interpolated into queries
- **No fallback**: Graph-only fails when entities not found

## Tools & Resources

- **Neo4j**: Production graph database
- **LlamaIndex PropertyGraphIndex**: Easy Python integration
- **Microsoft GraphRAG**: Community-based approach
- **Amazon Neptune**: Managed graph database
- **LangChain GraphCypherQAChain**: Text-to-Cypher chains

## References

- Microsoft GraphRAG docs: https://microsoft.github.io/graphrag/get_started/
- From Local to Global: A Graph RAG Approach to Query-Focused Summarization (Edge et al., 2024): https://arxiv.org/abs/2404.16130
- LlamaIndex PropertyGraphIndex with Neo4j: https://developers.llamaindex.ai/python/examples/property_graph/property_graph_neo4j/
- LangChain Neo4j (`langchain-neo4j`, `GraphCypherQAChain`): https://python.langchain.com/docs/integrations/graphs/neo4j_cypher/
- Cypher variable-length patterns: https://neo4j.com/docs/cypher-manual/current/patterns/variable-length-patterns/

Versions

The database has no other skills named graphrag-patterns.

Database snapshot: 13.11.2026 · package version 1035927bce95 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100ns-graphrag
    (NS) GraphRAG process. Use for GraphRAG, knowledge graph over documents, multi-hop retrieval, entity/relationship extractors, indirect-link analytics, or grounded structured extraction — even if they only say RAG, NER, knowledge graph, or cited Q&A. Do NOT use for Postgres…
  • 100knowledge-graph-enhanced-rag-graphrag
    Use this skill when extracting entities and relationships to build structured knowledge graphs that augment semantic RAG retrieval.
  • 100graph-rag
    Knowledge-graph-augmented retrieval. Entity and triple extraction, graph construction (Neo4j, LlamaIndex PropertyGraphIndex), hierarchical community summarization (Microsoft GraphRAG), personalized PageRank (HippoRAG), multi-hop traversal retrieval, and hybrid graph + vector…
  • 90graph-rag
    Use when needing global or relational understanding of codebases or knowledge corpora. Keywords: GraphRAG, knowledge graph, entity extraction, community summarization, graph traversal, Microsoft GraphRAG.
  • 100knowledge-graph-builder
    Activates KnowledgeGraph — an expert in building, querying, and reasoning over knowledge graphs. Use when you need entity extraction, relationship mapping, ontology design, Neo4j/RDF graph construction, graph-RAG pipelines, or complex multi-hop reasoning over structured knowledge.
  • 100evaluate-knowledge-graph-rag
    Evaluate Knowledge Graph RAG — measure entity extraction accuracy, relationship precision, graph traversal quality, hybrid retrieval effectiveness, multi-hop reasoning. Use when: evaluate, benchmark graph RAG.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.