Case Study: Cimbology

An AI Knowledge Assistant for Utility Engineers

By Shawn Weekly | Deep Research Project | 2024-2025

Executive Summary

The Problem

The electrical utility industry loses decades of irreplaceable expertise every time a senior engineer retires. How do you capture and make accessible 30+ years of tacit knowledge, specifications, and domain understanding?

The Hypothesis

Can combining Knowledge Graphs with RAG (Retrieval-Augmented Generation) across unstructured, information rich documentation ( called GraphRAG) create a verifiable, trustworthy AI assistant for engineering decisions?

The Proof

I built a full-stack GraphRAG system and tested it against a real Professional Engineering (PE) exam. Results: 84.85% accuracy with full citation traceability vs. 77% for baseline LLM with zero traceability.

Key Insight

"A baseline LLM behaves like a 'dumb-but-fast' intern who has read every book but understood nothing. Add structured knowledge via a Knowledge Graph and you get an assistant that can reason, cite sources, and be trusted."

The Business Problem: The "Jack and Susan" Scenario

Meet Jack and Susan, two pillars of expertise at their electrical engineering firm.

Jack

A master substation physical designer with over 30 years of experience.

Jack creates the physical layouts and ensures that substations are properly designed for construction and maintenance.

With exceptional skills in AutoCAD and Autodesk Inventor, he's the go-to expert that colleagues rely on daily.

Susan

An electrical engineer with 30+ years designing protection and control schemes for the substations her company designs and builds.

Susan knows AutoCAD Electrical like the back of her hand.

She always knows exactly where to find the right standards, specifications, and information needed for any project.

The Challenge

Jack and Susan are retiring next month. Although they've shared all their specifications, drawings, files, and documents with their team, it's an overwhelming amount of information.

How will the team digest this wealth of knowledge?

How can they find what they need when they need it?

Why This Matters

This scenario plays out across the electrical utility industry every day. Organizations lose not just employees, but decades of hard-won knowledge about:

  • Design standards and best practices specific to their region/utility
  • Tacit knowledge about "why" certain decisions were made historically
  • Tribal knowledge about reliable vendors, proven solutions, and lessons learned
  • The location and meaning of thousands of specifications, drawings, and documents

Traditional knowledge & document management systems (SharePoint, Autodesk Vault, ProjectWise, file servers) preserve the documents but not the expertise to navigate and apply them effectively. And many of the systems above are often improperly configured and don't (or simply can't) deliver good search results.

The Architectural Solution: GraphRAG

I architected Cimbology to test whether a hybrid approach that combined the structured reasoning of Knowledge Graphs, the proven capabilities of RAG based search, and the flexibility of Large Language Models could solve the "verifiable expertise" problem.

System Architecture

graph TB User[User/Engineer] -->|Query| WebUI[Web Interface
HTML/AlpineJS] User -->|Query| AutoCAD[AutoCAD Plugin
WPF/.NET] WebUI --> API[API Gateway
ASP.NET Core / .NET 9] AutoCAD --> API API --> QS[Query Service
Semantic Kernel Orchestration] QS --> KG[Knowledge Graph Query
SPARQL Service] QS --> VS[Vector Search
RAG Service] KG --> GraphDB[(GraphDB
RDF Triplestore
CIM Ontology)] VS --> Qdrant[(Qdrant
Vector Database
Document Embeddings)] QS --> LLM[LLM Provider
Azure OpenAI / Google Gemini] LLM --> Response[AI Response with
Citations & Traceability] Response --> API API --> WebUI API --> AutoCAD API --> SQLite[(SQLite
Session Storage)] style User fill:#e1f5ff style Response fill:#d4edda style GraphDB fill:#fff3cd style Qdrant fill:#fff3cd style SQLite fill:#fff3cd style LLM fill:#f8d7da style QS fill:#d1ecf1

Core Components

Knowledge Graph (RDF Triplestore)

Uses GraphDB and SPARQL to store structured domain knowledge based on the IEC 61970/61968 CIM standard. This provides the "reasoning backbone"; the means for the system to understand the relationships between Substations, ConductingEquipment, Measurements, etc.

Why it matters: Structured knowledge is verifiable and can be reasoned over. RADICAL reduction in hallucinations.

Vector Database (Qdrant)

Stores embeddings of document chunks (PDF pages, sections, tables) enabling semantic search over unstructured content. Uses advanced chunking strategies (layout-aware, table extraction, multimodal image descriptions) to preserve context.

Why it matters: Unstructured documents contain the bulk of engineering knowledge. RAG makes them searchable and retrievable. Advanced chunking gets ALL of the information from the documents, not just the text in the paragraphs.

AI Orchestration (Semantic Kernel)

Coordinates queries across both the Knowledge Graph and Vector Database, then synthesizes results using an LLM (Google Gemini or Azure OpenAI). Provides prompt engineering, context management, and citation tracking.

Why it matters: The orchestrator ensures the LLM receives high-quality, verifiable context—not just "best guess" vectors.

Backend API (.NET 9)

RESTful API built with ASP.NET Core, Entity Framework Core, and dotnetRDF. Handles chat sessions, query routing, session persistence (SQLite), and multi-modal client support (web, AutoCAD plugin).

Why it matters: Enterprise-grade reliability, testability, and maintainability.

Key Design Decisions

  • Why .NET 9? Enterprise-ready, high-performance, excellent tooling. Strong typing reduces bugs in complex domain logic. DotNet is one of the primary technology stacks used in the utility industry due to the universal use of Windows as the primary OS.
  • Why Semantic Kernel? AI orchestration without vendor lock-in. Supports multiple LLM providers (Azure OpenAI, Google AI, local models). Written in dotnet.
  • Why dotnetRDF? The CIM standard is RDF-native. Using dotnetRDF means working with the domain model in its natural form (OWL/RDFS).
  • Why GraphDB + Qdrant (hybrid storage)? Different data needs different stores. Structured = Graph. Unstructured = Vectors. Best of both worlds.
  • Why Docker? Reproducible dev environment. Easy deployment. Supports local development and cloud deployment without code changes.

Research Methodology & Results

To prove the effectiveness of GraphRAG, I needed a real-world test. I purchased and used a Professional Engineering (PE) exam from 2025 and tested four different approaches against a corpus of 2017-era engineering standards documents.

The Challenge: If the system can answer 2025 exam questions using outdated 2017 documents, it proves the system truly understands context and relationships; it's not just keyword matching.

Four Approaches Tested

1. Baseline LLM (No RAG)

77.27% Accuracy

Sent questions directly to GPT-5-Mini on Azure OpenAI with zero context. Fast and surprisingly accurate, but completely unverifiable. A "black box."

Verdict: Untrustworthy for engineering decisions

2. Simple RAG

53.03% Accuracy

Used basic page-level embeddings and naive vector search against Google Gemini 2.5 Pro. Performed worse than baseline! Proved that "adding RAG" doesn't automatically improve results.

Verdict: Naive RAG is actively harmful

3. Advanced RAG

83.33% Accuracy

Used layout-aware chunking, table extraction, and multimodal image descriptions and went back to Azure OpenAI and GPT-5-Mini. Major improvement, proves context quality matters more than model size.

Verdict: Much better, but still missing structured, semantic reasoning

4. KG-Enhanced RAG (GraphRAG) along with the context from Step 3 above.

84.85% Accuracy

Combined Advanced RAG with Knowledge Graph reasoning. Achieved highest accuracy and provided full citation traceability.

Verdict: Winner. Accurate and trustworthy.

Key Findings

  • Context Quality > Model Size: Advanced chunking strategies improved accuracy by 30%+ over naive RAG.
  • Structure Matters: The Knowledge Graph added the final 7% accuracy boost, but more importantly, enabled citation and reasoning transparency.
  • Naive RAG is Dangerous: Simple RAG performed 24% worse than no RAG at all. That's a critical lesson for anyone implementing AI systems.
  • Traceability is Non-Negotiable: In engineering, you can't use an answer you can't verify. GraphRAG provides both accuracy and trust.

Full Methodology: Tested against 66 PE exam questions. Documents included IEEE standards, NESC code, and utility design guides (all from 2017 or earlier). Used Google Gemini AND Azure OpenAI to ensure comparison across different vendor models. Accuracy measured by correct answer selection (A/B/C/D). See the full interactive analysis for question-by-question breakdown.

Technology Stack

Backend & Core Logic

  • .NET 9 - Enterprise-grade performance and tooling
  • C# - Strong typing for complex domain logic
  • ASP.NET Core - RESTful API framework
  • Entity Framework Core - ORM for session persistence

AI & Machine Learning

  • Microsoft Semantic Kernel - AI orchestration layer
  • Google Gemini and Azure OpenAI - LLM providers
  • RAG (Retrieval-Augmented Generation) - Document-based context retrieval
  • GraphRAG - Hybrid Knowledge Graph + RAG approach

Data Storage & Retrieval

  • Qdrant - Vector database for document embeddings
  • Ontotext GraphDB - RDF triplestore for Knowledge Graph
  • SQLite - Session and chat history persistence
  • SPARQL - Query language for Knowledge Graph

Standards & Domain Models

  • IEC 61970/61968 (CIM) - Common Information Model standard
  • dotTC57 - My open-source .NET library for CIM
  • dotnetRDF - RDF, OWL, and SPARQL processing library
  • RDF/OWL/SHACL - Semantic web technologies

Client Interfaces

  • HTML/JavaScript/AlpineJS - Web-based chat interface
  • AutoCAD (WPF) Plugin - In-CAD knowledge assistant

DevOps & Infrastructure

  • Docker & Docker Compose - Containerized deployment
  • Nginx - Reverse proxy and static file serving
  • Git/GitHub - Version control and collaboration

Proof of Work: See It In Action

Unlike many "research projects" that remain theoretical, Cimbology is fully implemented, tested, and deployed. Every component described above exists as working software.

System Demonstration

Watch this video demonstration showing Cimbology in action, including the GraphRAG query process, citation tracking, and real-time knowledge retrieval:

NOTE: If you see the infamous 153 error below, it's because YouTube wants folks to PAY them extra to embed content. Since I am not rich or a content creator, please click the link to watch directly on YouTube if you can't see it here.

Testing & Validation

The PE exam validation testing is fully documented and reproducible:

What I Learned

1. The Limits of AI: Why Knowledge Graphs Are Essential

My biggest learning: LLMs are incredibly powerful pattern matchers, but they don't "understand" in the way humans do. When I tested naive RAG and saw a 24% accuracy drop, it crystallized the problem: throwing vectors at an LLM without structure is like giving a student a library card but no dewey decimal system.

Knowledge Graphs provide the structured reasoning layer that makes AI trustworthy. They enforce relationships, validate data against schemas (SHACL), and enable transparent citation of sources.

2. Containerization at Scale: Docker Orchestration Lessons

Managing four containerized services (Qdrant, GraphDB, API, Web) taught me the importance of health checks, service dependencies, and volume management.

Key lesson: Infrastructure as Code only works if it's reproducible. Every developer should be able to run docker compose up and have a working environment in under 2 minutes.

3. The Importance of Testing: How I Validated Accuracy

Using a real PE exam as a test set was crucial. It forced me to confront real-world questions with objectively correct answers. This is vastly different from "testing" an AI with subjective questions where any plausible answer feels acceptable.

Key lesson: If you can't measure it, you can't improve it. The 66-question test set became my north star and every architectural change was validated against it.

4. Multimodal Matters: Tables and Images Are Critical

Engineering documents are rich with tables, diagrams, and figures. My early RAG attempts ignored these, treating them as "just more text." When I added table extraction and multimodal image descriptions, accuracy jumped significantly.

Key lesson: Engineering knowledge isn't just prose. Ignoring structured data (tables) and visual data (diagrams) means ignoring the most information-dense parts of a document.

Interested in This Approach?

I'm seeking opportunities to apply this expertise in a technical leadership role within the electrical utility industry. If you're facing similar knowledge management challenges, let's talk.