Design and Implementation of a Generalized Retrieval‑Augmented Generation (RAG) Framework with Graph RAG Support

Retrieval‑Augmented Generation (RAG) combines information retrieval with large language models to mitigate hallucinations; recent research and open‑source frameworks have accelerated its adoption across AI engineering domains.

Overview – RAG enhances generation by feeding retrieved documents as prompts to LLMs, and can be extended with prompt engineering, fine‑tuning, and knowledge graphs.

Traditional RAG – Consists of three stages (indexing via embeddings, similarity search, and generation) but suffers from knowledge‑base incompleteness, Top‑K truncation, context loss, unrecognised useful information, prompt format errors, insufficient accuracy, and incomplete answers.

Graph RAG – Replaces vector stores with knowledge graphs, storing triples extracted by LLMs, enabling sub‑graph retrieval and richer context; it addresses many traditional RAG issues by improving knowledge certainty.

Generic RAG Architecture – Introduces an abstract IndexStore that can host VectorStore , GraphStore , or other index types; separates index processing ( TransformerBase ) from storage, and adds a Retriever/Synthesizer layer for unified RAG pipelines.

Key Components

TransformerBase with implementations for embedding, triple extraction ( TripletExtractor ), and translation.

ExtractorBase (LLExtractor) handles LLM interaction; TripletExtractor uses few‑shot prompts to produce (subject, predicate, object) triples.

KeywordExtractor extracts entity keywords and synonyms for sub‑graph queries.

IndexStoreBase abstracts storage; VectorStore , GraphStore (e.g., MemoryGraphStore , TuGraphStore ), and future Neo4jStore implementations.

KnowledgeGraphBase and BuiltinKnowledgeGraph provide graph‑based retrieval APIs.

Code Snippets

TRIPLET_EXTRACT_PT = (
    "Some text is provided below. Given the text, extract up to knowledge triplets ..."
    ...
)

async def aload_document(self, chunks: List[Chunk]) -> List[str]:
    for chunk in chunks:
        triplets = await self._triplet_extractor.extract(chunk.content)
        for triplet in triplets:
            self._graph_store.insert_triplet(*triplet)
        logger.info(f"load {len(triplets)} triplets from chunk {chunk.chunk_id}")
    return [chunk.chunk_id for chunk in chunks]

def insert_triplet(self, subj: str, rel: str, obj: str) -> None:
    subj_query = f"MERGE (n1:{self._node_label} {{id:'{subj}'}})"
    obj_query = f"MERGE (n2:{self._node_label} {{id:'{obj}'}})"
    rel_query = (
        f"MERGE (n1:{self._node_label} {{id:'{subj}'}})"
        f"-[r:{self._edge_label} {{id:'{rel}'}}]->"
        f"(n2:{self._node_label} {{id:'{obj}'}})"
    )
    self.conn.run(query=subj_query)
    self.conn.run(query=obj_query)
    self.conn.run(query=rel_query)

async def asimilar_search_with_scores(self, text, topk, score_threshold: float, filters: Optional[MetadataFilters] = None) -> List[Chunk]:
    keywords = await self._keyword_extractor.extract(text)
    subgraph = self._graph_store.explore(keywords, limit=topk)
    content = (
        "The following vertices and edges data after [Subgraph Data] are retrieved...\n"
        f"Keywords:\n{','.join(keywords)}\n"
        "---------------------\n"
        f"Subgraph Data:\n{subgraph.format()}\n"
    )
    return [Chunk(content=content, metadata=subgraph.schema())]

Testing & Deployment – Demonstrated with the Transformers story dataset on DB‑GPT, showing knowledge‑graph creation, preview, and conversational retrieval.

Optimization Directions – Improve graph metadata modeling, fine‑tune knowledge‑extraction models (e.g., OneKE), incorporate graph‑community summarization, explore multimodal KG, hybrid storage (vector + graph), graph‑language fine‑tuning, and integrate RAG with agents for planning and memory.

Conclusion – The presented universal RAG framework unifies vector, graph, and full‑text indexes, provides a complete open‑source Graph RAG stack (DB‑GPT + OpenSPG + TuGraph), and outlines future research avenues toward more robust, agent‑enabled retrieval‑augmented generation.