Build Knowledge Graph out of initial output file which was created during indexing

[sachithrangana]

HI Team,

I'm checking for the proper way of recreating the knowledge graph out of the output files of the "indexing phase"
And I'll be checking the feasibility on using that remote knowledge graph for Graph RAG

Highly appreciate your suggestions on this.

Thank you,
Sachith

[Juyel (juyelhushen)]

If your goal is to reuse the knowledge graph generated during the indexing phase, I would avoid rebuilding it from the raw documents.

The indexing output already contains the extracted graph-related artifacts (entities, relationships, communities, etc.). You can use those outputs as the source for loading the graph into a remote graph database.

A possible approach would be:

1. Run the normal GraphRAG indexing pipeline.
2. Use the generated entity and relationship tables as the source data.
3. Create nodes from the entity records and edges from the relationship records, preserving the entity IDs/names used by GraphRAG.
4. Load those nodes/edges into your remote graph database.
5. For GraphRAG querying, implement the retrieval layer so that it can query the remote graph instead of relying on the local storage.

The important part is that simply copying the output files to another location won't make GraphRAG automatically treat that system as a remote knowledge graph—you need an adapter/integration between GraphRAG's retrieval layer and the graph database.

If you're considering a specific graph database (Neo4j, Neptune, Cosmos DB, etc.), the integration approach would depend on which one you're using.

[Sanjay Kumar M (sanjaykumar-xe)]

Great breakdown by Juyel. To add to that, if you are looking to operationalize this for a remote graph store (like Neo4j or Cosmos DB), writing a lightweight ingestion script over the Parquet/CSV outputs (create_final_entities.parquet and create_final_relationships.parquet) is usually the most efficient path.

A quick Python pattern using pandas and neo4j driver looks like this:

Python
import pandas as pd
from neo4j import GraphDatabase

Load GraphRAG indexing outputs

entities_df = pd.read_parquet("output/create_final_entities.parquet")
relationships_df = pd.read_parquet("output/create_final_relationships.parquet")

Connect to your remote graph database

driver = GraphDatabase.driver("bolt://your-remote-db:7687", auth=("neo4j", "password"))

def load_graph(tx):
# Create nodes preserving GraphRAG entity IDs and descriptions
for _, row in entities_df.iterrows():
tx.run(
"MERGE (e:Entity {id: $id}) SET e.name = $name, e.type = $type, e.description = $description",
id=row["id"], name=row["name"], type=row["type"], description=row["description"]
)

# Create relationships
for _, row in relationships_df.iterrows():
    tx.run(
        """
        MATCH (source:Entity {id: $source_id})
        MATCH (target:Entity {id: $target_id})
        MERGE (source)-[r:RELATED {weight: $weight}]->(target)
        SET r.description = $description
        """,
        source_id=row["source"], target_id=row["target"], 
        weight=row.get("weight", 1.0), description=row["description"]
    )

with driver.session() as session:
session.execute_write(load_graph)

driver.close()
As Juyel noted, the main catch is that GraphRAG's default query engine expects local parquet/text storage artifact formats during retrieval. To make a remote database fully active in the pipeline, you'll need to override or subclass the query search methods (like global/local search search prompt builders) to fetch context directly via Cypher/SQL queries against your remote instance instead of reading the local table fragments.