Prometheus Chatbot: Knowledge Graph Collaborative Large Language Model for Computer Components Recommendation

📝 Paper Summary

Knowledge Graph-based Recommender Systems LLM-integrated Chatbots

Prometheus combines a proprietary Neo4j knowledge graph of computer components with GPT-4 to translate natural language user queries into precise database lookups for compatibility recommendations.

Core Problem

Traditional recommender systems struggle with the cold-start problem and lack the ability to process natural language inputs for complex, rule-based domains like computer hardware compatibility.

Why it matters:

Computer components have complex inter-dependencies (e.g., CPU socket compatibility, power constraints) that standard filtering algorithms miss.
Users need to express requirements in natural language (e.g., 'recommend a power supply for GFX 3050') rather than navigating rigid filters.
Existing systems often fail to map ambiguous entity names in user queries to specific nodes in a structured database.

Concrete Example: A user asks 'Tell me the GFX3050 T3 rule about M70t Gen5.' A standard keyword search might fail or return irrelevant parts. Prometheus extracts '3050' and 'M70t Gen5', generates a Cypher query to match specific `name` and `project name` attributes in the KG, and retrieves the exact T3 compatibility rule.

Key Novelty

LLM-Driven Knowledge Graph Querying for Hardware

Integrates a Neo4j graph database storing component compatibility rules with GPT-4 via LangChain.
Uses the LLM primarily as a translation layer to convert natural language into Cypher queries (graph database query language) rather than relying on the LLM's internal knowledge base.
Combines top-down (rule-based) and bottom-up (data extraction) approaches to build a specialized Knowledge Graph from Lenovo's proprietary databases.

Architecture

The LLM Structure Data Query Architecture. It illustrates the cyclic flow of data: User Question → LLM → Cypher Query → Knowledge Graph → Result Data → LLM → Natural Language Answer.

Evaluation Highlights

Constructed a Knowledge Graph containing 32,776 nodes and 24,971 relationships specifically for the 'Derive' rule type of computer components.
Demonstrated successful conversion of complex natural language queries (e.g., compatibility checks for specific GPU and chassis models) into executable Cypher queries.
Successfully deployed as an internal tool within Lenovo for desktop computing development.

Breakthrough Assessment

4/10

This is a practical application paper demonstrating a standard RAG/Tool-use pattern (Text-to-Cypher) in a specific industrial domain. While useful for Lenovo, it applies existing techniques (LangChain, GPT-4, Neo4j) rather than introducing novel ML architectures or algorithms.

⚙️ Technical Details

Problem Definition

Setting: Retrieval of compatibility rules and component recommendations from a structured database using natural language.

Inputs: Natural language user query (e.g., 'What components are recommended if I buy an intel i7 CPU?')

Outputs: Structured recommendation or compatibility rule presented in natural language or tabular format.

Pipeline Flow

User Interface (Streamlit) → Input Processing (LLM) → Query Execution (Neo4j) → Response Generation (LLM) → Output Display

System Modules

Prometheus Chatbot Interface

Accepts user input and displays results (tabular/graphical)

Model or implementation: Streamlit

Query Translator

Interprets user intent and translates natural language into Cypher queries

Model or implementation: GPT-4 / ChatGPT via Azure OpenAI Service

Knowledge Graph

Stores component entities and compatibility rules; executes Cypher queries

Model or implementation: Neo4j Database

Response Generator

Synthesizes retrieved graph data into a natural language answer

Model or implementation: GPT-4 / ChatGPT via Azure OpenAI Service

Novel Architectural Elements

Dual-method KG Construction: Combines top-down conceptual modeling with bottom-up raw data extraction from proprietary SQLite databases to structure hardware rules.
Direct integration of proprietary hardware logic (Text-rule, Derive, Select) into a graph schema queryable by LLMs.

Modeling

Base Model: GPT-4 / ChatGPT (via Azure OpenAI Service)

Reproducibility

Code: https://github.com/iamryanshengwang/Prometheus-Chatbot

Code available (https://github.com/iamryanshengwang/Prometheus-Chatbot), but the Lenovo database (T3.db) is not open access. Researchers must contact the authors for potential data sharing.

📊 Experiments & Results

Evaluation Setup

Qualitative evaluation and case studies within Lenovo's internal development environment.

Metrics:

Statistical methodology: Not explicitly reported in the paper

Experiment Figures

A screenshot of the Prometheus Chatbot interface showing a successful query result.

A detailed view of the 'Derive' type Knowledge Graph visualization.

Main Takeaways

Successfully constructed a massive KG from raw SQL data: For the 'Derive' rule type alone, 32,776 nodes and 24,971 relationships were created.
The system can accurately parse specific product codes (e.g., 'M70t Gen5', 'GFX 3050') and retrieve complex hierarchical rules (parent-child relationships in component constraints).
Graph visualization (via Neo4j and Streamlit) helps engineers visually verify the 'should/should not' compatibility relationships, which is difficult with raw text rules.

📚 Prerequisite Knowledge

Prerequisites

Basic understanding of Knowledge Graphs (nodes, edges, properties)
Familiarity with Large Language Models (LLMs) and Prompt Engineering
Understanding of graph database query languages (Cypher)

Key Terms

KG: Knowledge Graph—a structured representation of data where entities are nodes and relationships are edges.

Cypher: A query language for Neo4j graph databases, similar to SQL but optimized for graph traversal.

Neo4j: A popular graph database management system used to store and query connected data.

Streamlit: An open-source Python framework for building machine learning and data science web apps.

LangChain: A framework designed to simplify the creation of applications using large language models, often used for chaining prompts and managing context.

Cold-start problem: The difficulty recommender systems face when trying to provide suggestions for new users or items with no prior interaction history.

RAG: Retrieval-Augmented Generation—technique where an LLM fetches relevant external data to ground its responses.

Text-rule/Derive/Select: Specific proprietary rule types in Lenovo's database defining compatibility constraints between computer components.