# How to Export the Code‑Graph‑RAG Knowledge Graph: A Complete Guide

> Export your Code-Graph-RAG knowledge graph to a portable JSON file. This guide covers Python functions and CLI commands for seamless data export.

- Repository: [Vitali Avagyan/code-graph-rag](https://github.com/vitali87/code-graph-rag)
- Tags: how-to-guide
- Published: 2026-09-06

---

**Export your entire Code‑Graph‑RAG knowledge graph from Memgraph to a portable JSON file using either Python helper functions or the built‑in CLI command.**

Code‑Graph‑RAG persists its knowledge graph inside a transient **Memgraph** instance. To move this data into other tools—visualizers, static analyzers, or alternative graph databases—you need to serialize the graph to disk. This article walks through the export architecture, the `GraphData` schema, and both programmatic and command‑line approaches as implemented in the [vitali87/code‑graph‑rag](https://github.com/vitali87/code-graph-rag) repository.

---

## Export Architecture Overview

The export flow relies on three core components defined in the codebase:

1. **`MemgraphIngestor`** – connects to Memgraph and batches Cypher queries.
2. **`export_graph_to_dict()`** – serializes the live graph into a `GraphData` dictionary.
3. **`export_graph_to_file()`** – writes pretty‑printed JSON and prints a summary.

These are orchestrated through the public entry point in [`codebase_rag/main.py`](https://github.com/vitali87/code-graph-rag/blob/main/codebase_rag/main.py), with a parallel CLI wrapper in [`codebase_rag/graph_cli.py`](https://github.com/vitali87/code-graph-rag/blob/main/codebase_rag/graph_cli.py) that exposes the `cgr graph export` command.

---

## Export Methods for Code‑Graph‑RAG Knowledge Graphs

### Option 1: Python API (Programmatic Export)

For custom pipelines or Jupyter notebooks, import the connection helper and export function directly:

```python
from pathlib import Path
from codebase_rag.main import connect_memgraph, export_graph_to_file

# 1️⃣  Create the Memgraph ingestor (batch size from settings)

ingestor = connect_memgraph(batch_size=1000)

# 2️⃣  Define your output path

output_path = Path("my_graph_export.json")

# 3️⃣  Execute the export

if export_graph_to_file(ingestor, str(output_path)):
    print(f"✅ Graph exported successfully to {output_path.resolve()}")
else:
    print("❌ Export failed – see console logs for details")

```

The `connect_memgraph()` helper reads host, port, and credentials from [`codebase_rag/constants.py`](https://github.com/vitali87/code-graph-rag/blob/main/codebase_rag/constants.py), then instantiates a `MemgraphIngestor` with your specified batch size. The `export_graph_to_file()` function delegates to `_write_graph_json()` in [`codebase_rag/main.py`](https://github.com/vitali87/code-graph-rag/blob/main/codebase_rag/main.py) for actual disk I/O.

### Option 2: Command‑Line Interface (CLI)

For CI/CD pipelines or one‑off terminal usage, use the `cgr` CLI:

```bash
cgr graph export /path/to/export.json

```

Available flags:

- **`--project <NAME>`** – override the auto‑detected project name in metadata.
- **`--repo-path <DIR>`** – source directory to tag the export with (defaults to `$PWD`).

On success, the CLI prints a statistics table showing total nodes and relationships extracted from your Code‑Graph‑RAG knowledge graph.

---

## Understanding the Exported JSON Format

The output follows the **`GraphData`** schema defined in [`codebase_rag/types_defs.py`](https://github.com/vitali87/code-graph-rag/blob/main/codebase_rag/types_defs.py):

```json
{
  "metadata": {
    "exported_at": "2024-01-01T12:34:56Z",
    "total_nodes": 12345,
    "total_relationships": 67890
  },
  "nodes": [
    {
      "id": "n1",
      "label": "Function",
      "properties": {
        "name": "my_function",
        "path": "src/module.py"
      }
    }
  ],
  "relationships": [
    {
      "id": "r1",
      "type": "CALLS",
      "source": "n1",
      "target": "n2",
      "properties": {}
    }
  ]
}

```

| Field | Description |
|-------|-------------|
| **`metadata`** | ISO‑8601 timestamp and aggregate counts |
| **`nodes`** | Graph entities (Function, Class, Module) with unique IDs and property bags |
| **`relationships`** | Directed edges (`CALLS`, `IMPORTS`, `EXTENDS`, etc.) linking source/target node IDs |

Because this is plain JSON, you can import the Code‑Graph‑RAG knowledge graph into NetworkX, Neo4j, or D3.js visualizations without transformation.

---

## Practical Export Examples

### Standalone Export Script

Create [`export_graph_demo.py`](https://github.com/vitali87/code-graph-rag/blob/main/export_graph_demo.py) for reusable exports:

```python
from codebase_rag.main import connect_memgraph, export_graph_to_file

def main():
    ingestor = connect_memgraph(batch_size=500)
    success = export_graph_to_file(ingestor, "graph_dump.json")
    print("Exported successfully" if success else "Export failed")

if __name__ == "__main__":
    main()

```

Run with:

```bash
python export_graph_demo.py

```

### CI Pipeline Automation

Add this GitHub Actions workflow to export on every push:

```yaml
name: Export Graph
on:
  push:
    branches: [main]

jobs:
  export:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: pip install -e .
      - run: cgr graph export ./graph_export.json
      - uses: actions/upload-artifact@v4
        with:
          name: codegraph
          path: ./graph_export.json

```

### Reimporting into NetworkX

Process the exported Code‑Graph‑RAG knowledge graph with Python graph libraries:

```python
import json
import networkx as nx

with open("graph_export.json") as f:
    data = json.load(f)

G = nx.DiGraph()
for node in data["nodes"]:
    G.add_node(node["id"], **node["properties"])

for rel in data["relationships"]:
    G.add_edge(rel["source"], rel["target"], type=rel["type"])

print(f"Loaded {G.number_of_nodes()} nodes, {G.number_of_edges()} edges")

```

---

## Key Source Files in Code‑Graph‑RAG

| File | Purpose |
|------|---------|
| [`codebase_rag/main.py`](https://github.com/vitali87/code-graph-rag/blob/main/codebase_rag/main.py) | Core export helpers (`_write_graph_json`, `export_graph_to_file`) |
| [`codebase_rag/graph_cli.py`](https://github.com/vitali87/code-graph-rag/blob/main/codebase_rag/graph_cli.py) | CLI command group (`cgr graph export …`) |
| [`codebase_rag/services/graph_service.py`](https://github.com/vitali87/code-graph-rag/blob/main/codebase_rag/services/graph_service.py) | `MemgraphIngestor.export_graph_to_dict()` implementation |
| [`codebase_rag/types_defs.py`](https://github.com/vitali87/code-graph-rag/blob/main/codebase_rag/types_defs.py) | `GraphData` Pydantic schema for serialization |
| [`examples/graph_export_example.py`](https://github.com/vitali87/code-graph-rag/blob/main/examples/graph_export_example.py) | End‑to‑end runnable example |

---

## Summary

- **Two export paths**: Python API via `export_graph_to_file()` or CLI via `cgr graph export`.
- **Standardized output**: JSON matching the `GraphData` schema with `metadata`, `nodes`, and `relationships` keys.
- **Configurable batching**: Tune `batch_size` in `connect_memgraph()` for memory‑constrained environments.
- **Tool‑agnostic**: Consume exports in NetworkX, Neo4j, visualization suites, or custom analytics.

---

## Frequently Asked Questions

### What graph database does Code‑Graph‑RAG use?

Code‑Graph‑RAG uses **Memgraph** as its primary graph storage engine. The `MemgraphIngestor` class in [`codebase_rag/services/graph_service.py`](https://github.com/vitali87/code-graph-rag/blob/main/codebase_rag/services/graph_service.py) handles all Cypher query execution and connection pooling.

### Can I export partial graphs or filter by node type?

The current implementation in `export_graph_to_dict()` performs a full‑graph dump. For filtered exports, you would need to extend `MemgraphIngestor` with Cypher `WHERE` clauses or post‑process the resulting JSON.

### Is the exported JSON compatible with Neo4j?

Yes. The `nodes`/`relationships` structure maps cleanly to Neo4j's property graph model. Use `neo4j-admin import` or the APOC [`apoc.import.json`](https://github.com/vitali87/code-graph-rag/blob/main/apoc.import.json) procedure with minor field renaming.

### How do I automate exports on a schedule?

Combine the CLI with cron or GitHub Actions. Ensure your Memgraph instance is accessible from the automation environment and that [`codebase_rag/constants.py`](https://github.com/vitali87/code-graph-rag/blob/main/codebase_rag/constants.py) contains valid connection parameters.