# DBT Graph Loader
> Transform your DBT project's lineage and metadata into queryable knowledge graphs
DBT Graph Loader is a Python library that loads DBT (Data Build Tool) metadata into graph databases, enabling you to explore, query, and visualize your data lineage as an interactive knowledge graph.
## 🚀 Features
- **🔄 Multiple Graph Databases**: Native support for Neo4j and FalkorDB
- **📊 Complete DBT Coverage**: Models, sources, tests, macros, seeds, snapshots, and operations
- **🔗 Rich Relationships**: Dependencies, references, macro usage, and test coverage mapping
- **📁 Flexible Input**: Load from `manifest.json` and `catalog.json` files or strings
- **🛠️ Easy CLI**: Simple command-line interface for batch operations
- **🐍 Python API**: Programmatic access for integration into data pipelines
- **📈 Graph Analytics**: Built-in statistics and insights about your data lineage
- **🐳 Docker Ready**: Easy containerization and deployment
## 📦 Installation
### Using Poetry (Recommended)
```bash
poetry add dbt-graph-loader
```
### Using pip
```bash
pip install dbt-graph-loader
```
### Development Installation
```bash
# Clone the repository
git clone https://github.com/hipposys-ltd/dbt-graph-loader.git
cd dbt-graph-loader
# Install with Poetry
poetry install
# Or with pip
pip install -e .
```
## 🎯 Quick Start
### 1. Generate DBT Metadata Files
First, ensure you have the required DBT files:
```bash
cd your-dbt-project
dbt compile # Generates manifest.json
dbt docs generate # Generates catalog.json (optional but recommended)
```
### 2. Load into Neo4j
```bash
# Using CLI
dbt-graph-loader neo4j \
--uri bolt://localhost:7687 \
--username neo4j \
--password your_password \
--manifest target/manifest.json \
--catalog target/catalog.json
```
### 3. Load into FalkorDB
```bash
# Using CLI
dbt-graph-loader falkordb \
--host localhost \
--port 6379 \
--graph-name my_dbt_lineage \
--manifest target/manifest.json \
--catalog target/catalog.json
```
## 📋 Supported DBT Resources
| Resource Type | Description | Properties Captured |
|---------------|-------------|-------------------|
| **Models** | DBT models and their transformations | Materialization, dependencies, descriptions, tags |
| **Sources** | External data sources | Freshness rules, schemas, descriptions |
| **Seeds** | CSV files loaded as tables | File metadata, configurations |
| **Snapshots** | Slowly changing dimension tables | Strategies, unique keys, timestamps |
| **Tests** | Data quality tests | Severity levels, test parameters, attached nodes |
| **Macros** | Reusable SQL code blocks | Arguments, package info, usage patterns |
| **Operations** | Pre/post hooks and run operations | Execution context, dependencies |
## 🔗 Graph Relationships
The loader creates rich relationships between your DBT resources:
- **`DEPENDS_ON`**: Direct dependencies between any resources
- **`REFERENCES`**: Model-to-model references via `ref()` functions
- **`USES_MACRO`**: Macro usage relationships
- **`TESTS`**: Test-to-resource relationships
## 🛠️ Usage
### Command Line Interface
#### Neo4j Options
```bash
dbt-graph-loader neo4j --help
Options:
--uri TEXT Neo4j connection URI (required)
--username TEXT Neo4j username (required)
--password TEXT Neo4j password (required)
--manifest TEXT Path to manifest.json (required)
--catalog TEXT Path to catalog.json (optional)
```
#### FalkorDB Options
```bash
dbt-graph-loader falkordb --help
Options:
--host TEXT FalkorDB host (default: localhost)
--port INTEGER FalkorDB port (default: 6379)
--graph-name TEXT Graph name (default: dbt_graph)
--username TEXT FalkorDB username (optional)
--password TEXT FalkorDB password (optional)
--manifest TEXT Path to manifest.json (required)
--catalog TEXT Path to catalog.json (optional)
```
### Python API
#### Neo4j Integration
```python
from dbt_graph_loader.loaders.neo4j_loader import DBTNeo4jLoader
# Initialize the loader
loader = DBTNeo4jLoader(
neo4j_uri="bolt://localhost:7687",
username="neo4j",
password="your_password"
)
try:
# Load from files
loader.load_dbt_to_neo4j_from_files(
manifest_path="target/manifest.json",
catalog_path="target/catalog.json"
)
# View statistics
loader.get_graph_stats()
finally:
loader.close()
```
#### FalkorDB Integration
```python
from dbt_graph_loader.loaders.falkordb_loader import DBTFalkorDBLoader
# Initialize the loader
loader = DBTFalkorDBLoader(
host="localhost",
port=6379,
graph_name="dbt_lineage",
username="your_username", # if auth enabled
password="your_password" # if auth enabled
)
try:
# Load from files
loader.load_dbt_to_falkordb(
manifest_path="target/manifest.json",
catalog_path="target/catalog.json"
)
# Load from strings (useful for APIs)
with open("target/manifest.json") as f:
manifest_str = f.read()
with open("target/catalog.json") as f:
catalog_str = f.read()
loader.load_dbt_to_falkordb_from_strings(manifest_str, catalog_str)
# View statistics
loader.get_graph_stats()
finally:
loader.close()
```
#### Convenience Functions
```python
from dbt_graph_loader import load_to_neo4j, load_to_falkordb
# Simple Neo4j loading
load_to_neo4j(
uri="bolt://localhost:7687",
username="neo4j",
password="password",
manifest_path="target/manifest.json",
catalog_path="target/catalog.json"
)
# Simple FalkorDB loading
load_to_falkordb(
host="localhost",
port=6379,
graph_name="dbt_lineage",
manifest_path="target/manifest.json",
catalog_path="target/catalog.json"
)
```
## 🔍 Example Queries
Once your DBT metadata is loaded, you can query the graph using Cypher (Neo4j) or OpenCypher (FalkorDB).
### Neo4j Cypher Examples
```cypher
// Find all models that depend on a specific source
MATCH (m:Model)-[:DEPENDS_ON]->(s:Source {name: "raw_data.customers"})
RETURN m.name, m.materialized, m.description
// Get the complete downstream lineage from a model
MATCH path = (start:Model {name: "dim_customers"})-[:DEPENDS_ON*]->(downstream)
RETURN path
// Find models without any tests
MATCH (m:Model)
WHERE NOT EXISTS {
MATCH (t:Test)-[:TESTS]->(m)
}
RETURN m.name, m.schema, m.materialized
// Identify the most referenced models
MATCH (m:Model)<-[:REFERENCES]-(referencing)
RETURN m.name, count(referencing) as reference_count
ORDER BY reference_count DESC
LIMIT 10
// Find macro usage patterns
MATCH (m:Model)-[:USES_MACRO]->(macro:Macro)
RETURN macro.name, count(m) as usage_count
ORDER BY usage_count DESC
// Discover circular dependencies (if any)
MATCH path = (n)-[:DEPENDS_ON*]->(n)
WHERE length(path) > 1
RETURN path
```
### FalkorDB OpenCypher Examples
```cypher
// Models by materialization type
MATCH (m:Model)
RETURN m.materialized, count(m) as model_count
ORDER BY model_count DESC
// Source freshness analysis
MATCH (s:Source)
WHERE s.freshness_warn_after IS NOT NULL
RETURN s.name, s.freshness_warn_after, s.freshness_error_after
// Test coverage by schema
MATCH (m:Model)
OPTIONAL MATCH (t:Test)-[:TESTS]->(m)
RETURN m.schema,
count(m) as total_models,
count(t) as total_tests,
round(100.0 * count(t) / count(m), 2) as test_coverage_pct
ORDER BY test_coverage_pct DESC
```
## 🐳 Docker Integration
### FastAPI Integration Example
```python
from fastapi import FastAPI, UploadFile, File
from dbt_graph_loader.loaders.neo4j_loader import DBTNeo4jLoader
import os
app = FastAPI()
@app.post("/upload-dbt-metadata/")
async def upload_dbt_metadata(
manifest_file: UploadFile = File(...),
catalog_file: UploadFile = File(...)
):
manifest_content = await manifest_file.read()
catalog_content = await catalog_file.read()
loader = DBTNeo4jLoader(
neo4j_uri=os.getenv("NEO4J_URI"),
username=os.getenv("NEO4J_USERNAME"),
password=os.getenv("NEO4J_PASSWORD")
)
try:
loader.load_dbt_to_neo4j_from_strings(
manifest_content.decode('utf-8'),
catalog_content.decode('utf-8')
)
return {"status": "success", "message": "DBT metadata loaded"}
finally:
loader.close()
```
## 📊 Graph Schema
### Node Properties
**Models**
- `unique_id`, `name`, `database`, `schema`, `materialized`
- `description`, `tags`, `package_name`, `path`, `enabled`
- `language`, `checksum`, `access`, `relation_name`
**Sources**
- `unique_id`, `name`, `source_name`, `identifier`
- `database`, `schema`, `description`, `loader`
- `freshness_warn_after`, `freshness_error_after`, `columns`
**Tests**
- `unique_id`, `name`, `column_name`, `severity`, `enabled`
- `test_name`, `test_kwargs`, `package_name`
**Macros**
- `unique_id`, `name`, `package_name`, `path`
- `description`, `arguments`
**Seeds**
- `unique_id`, `name`, `database`, `schema`, `path`
- `delimiter`, `materialized`, `enabled`
**Snapshots**
- `unique_id`, `name`, `database`, `schema`, `strategy`
- `unique_key`, `updated_at`, `materialized`
## 🧪 Development
### Setup Development Environment
```bash
# Clone repository
git clone https://github.com/hipposys-ltd/dbt-graph-loader.git
# Install dependencies
poetry install
# Build package
poetry build
```
## 📋 Prerequisites
### For Neo4j
- Neo4j 4.0+ (local installation or cloud)
- Python 3.8+
### For FalkorDB
- FalkorDB instance (Redis-compatible graph database)
- Python 3.8+
### DBT Requirements
- DBT project with generated `manifest.json` (required)
- Generated `catalog.json` (optional but recommended for richer metadata)
Raw data
{
"_id": null,
"home_page": "https://github.com/hipposys-ltd/dbt-kg",
"name": "dbt-graph-loader",
"maintainer": null,
"docs_url": null,
"requires_python": "<4.0,>=3.8",
"maintainer_email": null,
"keywords": "dbt, graph, neo4j, falkordb, metadata, lineage",
"author": "Hipposys",
"author_email": null,
"download_url": "https://files.pythonhosted.org/packages/12/0c/94d9936c1610b234c6127aea84a413a21f7414636b26863a56580079ff11/dbt_graph_loader-0.1.0a1.tar.gz",
"platform": null,
"description": "# DBT Graph Loader\n\n> Transform your DBT project's lineage and metadata into queryable knowledge graphs\n\nDBT Graph Loader is a Python library that loads DBT (Data Build Tool) metadata into graph databases, enabling you to explore, query, and visualize your data lineage as an interactive knowledge graph.\n\n## \ud83d\ude80 Features\n\n- **\ud83d\udd04 Multiple Graph Databases**: Native support for Neo4j and FalkorDB\n- **\ud83d\udcca Complete DBT Coverage**: Models, sources, tests, macros, seeds, snapshots, and operations\n- **\ud83d\udd17 Rich Relationships**: Dependencies, references, macro usage, and test coverage mapping\n- **\ud83d\udcc1 Flexible Input**: Load from `manifest.json` and `catalog.json` files or strings\n- **\ud83d\udee0\ufe0f Easy CLI**: Simple command-line interface for batch operations\n- **\ud83d\udc0d Python API**: Programmatic access for integration into data pipelines\n- **\ud83d\udcc8 Graph Analytics**: Built-in statistics and insights about your data lineage\n- **\ud83d\udc33 Docker Ready**: Easy containerization and deployment\n\n## \ud83d\udce6 Installation\n\n### Using Poetry (Recommended)\n```bash\npoetry add dbt-graph-loader\n```\n\n### Using pip\n```bash\npip install dbt-graph-loader\n```\n\n### Development Installation\n```bash\n# Clone the repository\ngit clone https://github.com/hipposys-ltd/dbt-graph-loader.git\ncd dbt-graph-loader\n\n# Install with Poetry\npoetry install\n\n# Or with pip\npip install -e .\n```\n\n## \ud83c\udfaf Quick Start\n\n### 1. Generate DBT Metadata Files\n\nFirst, ensure you have the required DBT files:\n\n```bash\ncd your-dbt-project\ndbt compile # Generates manifest.json\ndbt docs generate # Generates catalog.json (optional but recommended)\n```\n\n### 2. Load into Neo4j\n\n```bash\n# Using CLI\ndbt-graph-loader neo4j \\\n --uri bolt://localhost:7687 \\\n --username neo4j \\\n --password your_password \\\n --manifest target/manifest.json \\\n --catalog target/catalog.json\n```\n\n### 3. Load into FalkorDB\n\n```bash\n# Using CLI\ndbt-graph-loader falkordb \\\n --host localhost \\\n --port 6379 \\\n --graph-name my_dbt_lineage \\\n --manifest target/manifest.json \\\n --catalog target/catalog.json\n```\n\n## \ud83d\udccb Supported DBT Resources\n\n| Resource Type | Description | Properties Captured |\n|---------------|-------------|-------------------|\n| **Models** | DBT models and their transformations | Materialization, dependencies, descriptions, tags |\n| **Sources** | External data sources | Freshness rules, schemas, descriptions |\n| **Seeds** | CSV files loaded as tables | File metadata, configurations |\n| **Snapshots** | Slowly changing dimension tables | Strategies, unique keys, timestamps |\n| **Tests** | Data quality tests | Severity levels, test parameters, attached nodes |\n| **Macros** | Reusable SQL code blocks | Arguments, package info, usage patterns |\n| **Operations** | Pre/post hooks and run operations | Execution context, dependencies |\n\n## \ud83d\udd17 Graph Relationships\n\nThe loader creates rich relationships between your DBT resources:\n\n- **`DEPENDS_ON`**: Direct dependencies between any resources\n- **`REFERENCES`**: Model-to-model references via `ref()` functions\n- **`USES_MACRO`**: Macro usage relationships\n- **`TESTS`**: Test-to-resource relationships\n\n## \ud83d\udee0\ufe0f Usage\n\n### Command Line Interface\n\n#### Neo4j Options\n```bash\ndbt-graph-loader neo4j --help\n\nOptions:\n --uri TEXT Neo4j connection URI (required)\n --username TEXT Neo4j username (required) \n --password TEXT Neo4j password (required)\n --manifest TEXT Path to manifest.json (required)\n --catalog TEXT Path to catalog.json (optional)\n```\n\n#### FalkorDB Options\n```bash\ndbt-graph-loader falkordb --help\n\nOptions:\n --host TEXT FalkorDB host (default: localhost)\n --port INTEGER FalkorDB port (default: 6379)\n --graph-name TEXT Graph name (default: dbt_graph)\n --username TEXT FalkorDB username (optional)\n --password TEXT FalkorDB password (optional)\n --manifest TEXT Path to manifest.json (required)\n --catalog TEXT Path to catalog.json (optional)\n```\n\n### Python API\n\n#### Neo4j Integration\n\n```python\nfrom dbt_graph_loader.loaders.neo4j_loader import DBTNeo4jLoader\n\n# Initialize the loader\nloader = DBTNeo4jLoader(\n neo4j_uri=\"bolt://localhost:7687\",\n username=\"neo4j\",\n password=\"your_password\"\n)\n\ntry:\n # Load from files\n loader.load_dbt_to_neo4j_from_files(\n manifest_path=\"target/manifest.json\",\n catalog_path=\"target/catalog.json\"\n )\n \n # View statistics\n loader.get_graph_stats()\n \nfinally:\n loader.close()\n```\n\n#### FalkorDB Integration\n\n```python\nfrom dbt_graph_loader.loaders.falkordb_loader import DBTFalkorDBLoader\n\n# Initialize the loader\nloader = DBTFalkorDBLoader(\n host=\"localhost\",\n port=6379,\n graph_name=\"dbt_lineage\",\n username=\"your_username\", # if auth enabled\n password=\"your_password\" # if auth enabled\n)\n\ntry:\n # Load from files\n loader.load_dbt_to_falkordb(\n manifest_path=\"target/manifest.json\",\n catalog_path=\"target/catalog.json\"\n )\n \n # Load from strings (useful for APIs)\n with open(\"target/manifest.json\") as f:\n manifest_str = f.read()\n with open(\"target/catalog.json\") as f:\n catalog_str = f.read()\n \n loader.load_dbt_to_falkordb_from_strings(manifest_str, catalog_str)\n \n # View statistics\n loader.get_graph_stats()\n \nfinally:\n loader.close()\n```\n\n#### Convenience Functions\n\n```python\nfrom dbt_graph_loader import load_to_neo4j, load_to_falkordb\n\n# Simple Neo4j loading\nload_to_neo4j(\n uri=\"bolt://localhost:7687\",\n username=\"neo4j\",\n password=\"password\",\n manifest_path=\"target/manifest.json\",\n catalog_path=\"target/catalog.json\"\n)\n\n# Simple FalkorDB loading\nload_to_falkordb(\n host=\"localhost\",\n port=6379,\n graph_name=\"dbt_lineage\",\n manifest_path=\"target/manifest.json\",\n catalog_path=\"target/catalog.json\"\n)\n```\n\n## \ud83d\udd0d Example Queries\n\nOnce your DBT metadata is loaded, you can query the graph using Cypher (Neo4j) or OpenCypher (FalkorDB).\n\n### Neo4j Cypher Examples\n\n```cypher\n// Find all models that depend on a specific source\nMATCH (m:Model)-[:DEPENDS_ON]->(s:Source {name: \"raw_data.customers\"})\nRETURN m.name, m.materialized, m.description\n\n// Get the complete downstream lineage from a model\nMATCH path = (start:Model {name: \"dim_customers\"})-[:DEPENDS_ON*]->(downstream)\nRETURN path\n\n// Find models without any tests\nMATCH (m:Model)\nWHERE NOT EXISTS {\n MATCH (t:Test)-[:TESTS]->(m)\n}\nRETURN m.name, m.schema, m.materialized\n\n// Identify the most referenced models\nMATCH (m:Model)<-[:REFERENCES]-(referencing)\nRETURN m.name, count(referencing) as reference_count\nORDER BY reference_count DESC\nLIMIT 10\n\n// Find macro usage patterns\nMATCH (m:Model)-[:USES_MACRO]->(macro:Macro)\nRETURN macro.name, count(m) as usage_count\nORDER BY usage_count DESC\n\n// Discover circular dependencies (if any)\nMATCH path = (n)-[:DEPENDS_ON*]->(n)\nWHERE length(path) > 1\nRETURN path\n```\n\n### FalkorDB OpenCypher Examples\n\n```cypher\n// Models by materialization type\nMATCH (m:Model)\nRETURN m.materialized, count(m) as model_count\nORDER BY model_count DESC\n\n// Source freshness analysis\nMATCH (s:Source)\nWHERE s.freshness_warn_after IS NOT NULL\nRETURN s.name, s.freshness_warn_after, s.freshness_error_after\n\n// Test coverage by schema\nMATCH (m:Model)\nOPTIONAL MATCH (t:Test)-[:TESTS]->(m)\nRETURN m.schema, \n count(m) as total_models,\n count(t) as total_tests,\n round(100.0 * count(t) / count(m), 2) as test_coverage_pct\nORDER BY test_coverage_pct DESC\n```\n\n## \ud83d\udc33 Docker Integration\n\n### FastAPI Integration Example\n\n```python\nfrom fastapi import FastAPI, UploadFile, File\nfrom dbt_graph_loader.loaders.neo4j_loader import DBTNeo4jLoader\nimport os\n\napp = FastAPI()\n\n@app.post(\"/upload-dbt-metadata/\")\nasync def upload_dbt_metadata(\n manifest_file: UploadFile = File(...),\n catalog_file: UploadFile = File(...)\n):\n manifest_content = await manifest_file.read()\n catalog_content = await catalog_file.read()\n \n loader = DBTNeo4jLoader(\n neo4j_uri=os.getenv(\"NEO4J_URI\"),\n username=os.getenv(\"NEO4J_USERNAME\"),\n password=os.getenv(\"NEO4J_PASSWORD\")\n )\n \n try:\n loader.load_dbt_to_neo4j_from_strings(\n manifest_content.decode('utf-8'),\n catalog_content.decode('utf-8')\n )\n return {\"status\": \"success\", \"message\": \"DBT metadata loaded\"}\n finally:\n loader.close()\n```\n## \ud83d\udcca Graph Schema\n\n### Node Properties\n\n**Models**\n- `unique_id`, `name`, `database`, `schema`, `materialized`\n- `description`, `tags`, `package_name`, `path`, `enabled`\n- `language`, `checksum`, `access`, `relation_name`\n\n**Sources** \n- `unique_id`, `name`, `source_name`, `identifier`\n- `database`, `schema`, `description`, `loader`\n- `freshness_warn_after`, `freshness_error_after`, `columns`\n\n**Tests**\n- `unique_id`, `name`, `column_name`, `severity`, `enabled`\n- `test_name`, `test_kwargs`, `package_name`\n\n**Macros**\n- `unique_id`, `name`, `package_name`, `path`\n- `description`, `arguments`\n\n**Seeds**\n- `unique_id`, `name`, `database`, `schema`, `path`\n- `delimiter`, `materialized`, `enabled`\n\n**Snapshots** \n- `unique_id`, `name`, `database`, `schema`, `strategy`\n- `unique_key`, `updated_at`, `materialized`\n\n\n## \ud83e\uddea Development\n\n### Setup Development Environment\n\n```bash\n# Clone repository\ngit clone https://github.com/hipposys-ltd/dbt-graph-loader.git\n\n# Install dependencies\npoetry install\n\n# Build package\npoetry build\n```\n\n\n## \ud83d\udccb Prerequisites\n\n### For Neo4j\n- Neo4j 4.0+ (local installation or cloud)\n- Python 3.8+\n\n### For FalkorDB \n- FalkorDB instance (Redis-compatible graph database)\n- Python 3.8+\n\n### DBT Requirements\n- DBT project with generated `manifest.json` (required)\n- Generated `catalog.json` (optional but recommended for richer metadata)\n",
"bugtrack_url": null,
"license": "MIT",
"summary": "Load DBT metadata into graph databases (Neo4j and FalkorDB)",
"version": "0.1.0a1",
"project_urls": {
"Homepage": "https://github.com/hipposys-ltd/dbt-kg",
"Repository": "https://github.com/hipposys-ltd/dbt-kg"
},
"split_keywords": [
"dbt",
" graph",
" neo4j",
" falkordb",
" metadata",
" lineage"
],
"urls": [
{
"comment_text": "",
"digests": {
"blake2b_256": "a9b0de7a8b6ae2c765d7a793edd35f3f21221ca9eddf76ef271f574bf6db97ec",
"md5": "d406961f8def736176167afa22933983",
"sha256": "8917511891f32deeb593536c76457ffbc41f03c6ca798036d7402f9cb3be8eb3"
},
"downloads": -1,
"filename": "dbt_graph_loader-0.1.0a1-py3-none-any.whl",
"has_sig": false,
"md5_digest": "d406961f8def736176167afa22933983",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": "<4.0,>=3.8",
"size": 19714,
"upload_time": "2025-08-03T14:42:03",
"upload_time_iso_8601": "2025-08-03T14:42:03.279806Z",
"url": "https://files.pythonhosted.org/packages/a9/b0/de7a8b6ae2c765d7a793edd35f3f21221ca9eddf76ef271f574bf6db97ec/dbt_graph_loader-0.1.0a1-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "120c94d9936c1610b234c6127aea84a413a21f7414636b26863a56580079ff11",
"md5": "c5a5def917bce9b4a9bec230cf9e78d9",
"sha256": "ee9c142be79a79692cbac979e157d568037eb4297e4aa4bb1e653436a38e6cdb"
},
"downloads": -1,
"filename": "dbt_graph_loader-0.1.0a1.tar.gz",
"has_sig": false,
"md5_digest": "c5a5def917bce9b4a9bec230cf9e78d9",
"packagetype": "sdist",
"python_version": "source",
"requires_python": "<4.0,>=3.8",
"size": 14756,
"upload_time": "2025-08-03T14:42:04",
"upload_time_iso_8601": "2025-08-03T14:42:04.506440Z",
"url": "https://files.pythonhosted.org/packages/12/0c/94d9936c1610b234c6127aea84a413a21f7414636b26863a56580079ff11/dbt_graph_loader-0.1.0a1.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2025-08-03 14:42:04",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "hipposys-ltd",
"github_project": "dbt-kg",
"travis_ci": false,
"coveralls": false,
"github_actions": true,
"lcname": "dbt-graph-loader"
}
JSON
