GraphRAG Visualizer: Knowledge Graph-Enhanced RAG for Document Analysis

Introduction

GraphRAG Visualizer is a project for visualizing and exploring knowledge graphs extracted from document collections using Microsoft GraphRAG. The project combines:

GraphRAG Indexing Pipeline for extracting entities, relationships, and communities
GraphRAG API for local and global search queries
GraphRAG Visualizer for interactive exploration of the knowledge graph

While traditional RAG systems (Retrieval-Augmented Generation) rely on simple vector search, GraphRAG goes a step further: It extracts structured knowledge graphs from documents, enabling deeper semantic connections and better answers to complex questions.

Graph structure of an entity with its relationships

Problem Statement: Why GraphRAG?

Limitations of Traditional RAG

Classic RAG systems operate on a simple principle:

Chunking: Documents are divided into small text sections
Embedding: Each chunk is converted into a vector
Retrieval: Upon a query, the semantically most similar chunks are retrieved
Generation: An LLM generates an answer based on the retrieved chunks

The Problem: This method fails with questions that require global knowledge across the entire document corpus.

Example:

"What are the main themes in these 100 research papers?"

A traditional RAG system would only retrieve a few semantically similar chunks – but the question requires a synthesis across all documents.

GraphRAG's Solution

GraphRAG addresses this limitation through:

Knowledge Graph Extraction: Entities and relationships are extracted from the text
Community Detection: Related entities are grouped into thematic clusters
Hierarchical Summarization: Summaries are generated for each community
Global Search: Queries can be answered using all community reports

GraphRAG

traditional RAG

Architecture & Technology Stack

System Overview

My GraphRAG Architecture

Technologies Used

Component	Technology	Description
Indexing	Microsoft GraphRAG	Knowledge Graph Extraction Pipeline
LLM	OpenAI GPT-4o-mini	Community Report Generation
Embedding	OpenAI text-embedding-3-small	Query Embedding (for Local/Global Search)
API	graphrag-api	FastAPI Backend for Search Queries
Frontend	graphrag-visualizer	React-based Visualization
Graph Rendering	react-force-graph	2D/3D Force-Directed Graph

GraphRAG Indexing: Standard vs. Fast Method

GraphRAG offers two indexing methods with different trade-offs:

Standard Method (`graphrag index`)

The standard method uses an LLM for all reasoning tasks:

Entity Extraction: LLM extracts named entities with descriptions
Relationship Extraction: LLM describes relationships between entity pairs
Entity/Relationship Summarization: LLM summarizes all instances
Community Report Generation: LLM generates summaries for each community

Pros:

High-quality, semantically rich descriptions
Better graph quality for exploration

Cons:

High LLM costs (~75% of indexing costs)
Slow processing

Fast Method (`graphrag index --method fast`)

The fast method replaces LLM reasoning with classic NLP techniques:

Entity Extraction: Noun phrases are extracted using NLTK/spaCy (no descriptions)
Relationship Extraction: Relationships are based on text-unit co-occurrence
No Summarization: Not necessary
Community Report Generation: Only this step still uses the LLM

Pros:

Significantly lower costs
Faster processing

Cons:

Less semantically rich descriptions
"Noisier" graph

My Configuration: Fast Method with OpenAI

For this project, I chose the Fast Method to minimize costs and enable fast iterations:

// LLM settings
models:
  default_chat_model:
    type: openai_chat
    api_base: https://api.openai.com/v1
    model: gpt-4o-mini
    api_key: ${OPEN_AI_KEY}
    model_supports_json: true
    concurrent_requests: 3
    async_mode: threaded
    retry_strategy: native
    max_retries: 2
    tokens_per_minute: 100000
    requests_per_minute: 200
    completion_params:
      temperature: 0.0
      max_tokens: 1536
    encoding_model: cl100k_base

  default_embedding_model:
    type: openai_embedding
    api_base: https://api.openai.com/v1
    model: text-embedding-3-small
    api_key: ${OPEN_AI_KEY}
    concurrent_requests: 3
    async_mode: threaded

// Input settings
input:
  type: file
  file_type: text
  base_dir: "input"

chunks:
  size: 1200
  overlap: 100
  group_by_columns: [id]

// Workflow settings
embed_text:
  enabled: true

extract_graph_nlp:
  text_analyzer:
    extractor_type: regex_english # Fast NLP extraction

cluster_graph:
  max_cluster_size: 10

community_reports:
  model_id: default_chat_model
  graph_prompt: "prompts/community_report_graph.txt"
  text_prompt: "prompts/community_report_text.txt"
  max_length: 2000
  max_input_length: 8000

Important Configuration Points:

embed_text: enabled: true – LanceDB Vector Store is always created by default, even if disabled
extract_graph_nlp.extractor_type: regex_english – Uses regex-based noun phrase extraction instead of LLM
community_reports – The only step that uses the LLM

Indexing Pipeline in Detail

Data Flow

Cost Estimation (Fast Method)

For 2 text files (~100 KB):

Step	Token Usage	Cost (gpt-4o-mini)
NLP Steps	0	$0.00
Community Reports	~40-70k Input, ~5-10k Output	~$0.01-0.03
Total		~$0.02

For comparison: The Standard Method would cost about $0.20-0.50 for the same corpus.

Output: Parquet Files

After successful indexing, the following Parquet files are generated:

File	Content	Required for Visualizer
`entities.parquet`	Extracted entities (Noun Phrases)	✓ Required
`relationships.parquet`	Relationships between entities	✓ Required
`documents.parquet`	Input document metadata	Optional
`text_units.parquet`	Text chunks with entity references	Optional
`communities.parquet`	Community cluster assignments	Optional
`community_reports.parquet`	LLM-generated community summaries	Optional