How to Optimize DB‑GPT RAG Pipelines for Better Retrieval and Knowledge Processing

Background

In the past two years, Retrieval‑Augmented Generation (RAG) has become a core component for enhancing intelligent agents by combining retrieval and generation capabilities, but practical deployments often suffer from low retrieval accuracy, noise, incomplete recall, and hallucinations.

RAG Key Process Source Code Overview

The DB‑GPT framework implements knowledge processing and RAG pipelines, including knowledge loading, chunking, information extraction, embedding, graph construction, and storage.

1.1 Knowledge Processing

Knowledge loading → knowledge chunking → information extraction → knowledge processing (embedding/graph/keywords) → knowledge storage.

Knowledge loading: instantiate various document formats via the KnowledgeFactory class.

# Knowledge factory instantiation
KnowledgeFactory -> create() -> load() -> Document
- markdown
- pdf
- docx
- txt
- html
- pptx
- url
- ...

To extend, inherit the Knowledge interface and implement load(), support_chunk_strategy(), and default_chunk_strategy().

class Knowledge(ABC):
    def load(self) -> List[Document]:
        """Load knowledge from data loader."""
    @classmethod
    def document_type(cls) -> Any:
        """Get document type."""
    def support_chunk_strategy(cls) -> List[ChunkStrategy]:
        """Return supported chunk strategy."""
        return [ChunkStrategy.CHUNK_BY_SIZE, ChunkStrategy.CHUNK_BY_PAGE, ChunkStrategy.CHUNK_BY_PARAGRAPH, ChunkStrategy.CHUNK_BY_MARKDOWN_HEADER, ChunkStrategy.CHUNK_BY_SEPARATOR]
    @classmethod
    def default_chunk_strategy(cls) -> ChunkStrategy:
        """Return default chunk strategy."""
        return ChunkStrategy.CHUNK_BY_SIZE

Knowledge chunking is handled by ChunkManager, which routes data to the appropriate chunk processor based on user‑specified strategies.

class ChunkManager:
    """Manager for chunks."""
    def __init__(self, knowledge: Knowledge, chunk_parameter: Optional[ChunkParameters] = None, extractor: Optional[Extractor] = None):
        self._knowledge = knowledge
        self._extractor = extractor
        self._chunk_parameters = chunk_parameter or ChunkParameters()
        self._chunk_strategy = (chunk_parameter.chunk_strategy if chunk_parameter and chunk_parameter.chunk_strategy else self._knowledge.default_chunk_strategy().name)
        self._text_splitter = self._chunk_parameters.text_splitter
        self._splitter_type = self._chunk_parameters.splitter_type

Knowledge extraction supports vector extraction, knowledge‑graph extraction, and keyword extraction.

@abstractmethod
    def embed_documents(self, texts: List[str]) -> List[List[float]]:
        """Embed search docs."""
    @abstractmethod
    def embed_query(self, text: str) -> List[float]:
        """Embed query text."""

Configuration examples for different embedding models (OpenAI, Qwen, Qianfan) are provided.

Knowledge graph extraction uses large‑model‑generated (subject, predicate, object) triples.

class TripletExtractor(LLMExtractor):
    """TripletExtractor class."""
    def __init__(self, llm_client: LLMClient, model_name: str):
        super().__init__(llm_client, model_name, TRIPLET_EXTRACT_PT)

Keyword extraction and inverted‑index creation are also supported, with implementations for Elasticsearch and OpenSearch.

1.2 Knowledge Retrieval

The retrieval flow is: question → rewrite → similarity_search → rerank → context_candidates. DB‑GPT provides EmbeddingRetriever, DBSchemaRetriever, and other retrievers that can be combined in a RetrieverChain.

class EmbeddingRetriever(BaseRetriever):
    """Embedding retriever."""
    def __init__(self, index_store: IndexStoreBase, top_k: int = 4, query_rewrite: Optional[QueryRewrite] = None, rerank: Optional[Ranker] = None, retrieve_strategy: Optional[RetrieverStrategy] = RetrieverStrategy.EMBEDDING):
        ...
    async def _aretrieve_with_score(self, query: str, score_threshold: float, filters: Optional[MetadataFilters] = None) -> List[Chunk]:
        ...

Metadata filtering, chunk‑level strategies, and custom ranking models can be applied to improve relevance.

Knowledge Processing and Retrieval Optimization Ideas

Key pain points in RAG applications include noisy large knowledge bases, low recall completeness, poor relevance to user intent, and static‑only answers. Optimization suggestions:

Convert unstructured data to structured formats (e.g., PDF/Markdown) to improve parsing.

Preserve table and image metadata during chunking.

Keep chunk size within LLM token limits.

Enrich extraction with knowledge graphs, doc‑tree structures, QA pairs, and metadata.

Apply post‑retrieval filtering, multi‑strategy mixing, and re‑ranking models.

Workflow Customization

DB‑GPT supports a visual, customizable knowledge‑processing workflow where users can define arbitrary extraction, transformation, and indexing steps.

RAG Process Optimization

Static knowledge RAG can be enhanced by question classification, query rewriting, slot extraction, and multi‑stage retrieval (e.g., vector, graph, full‑text). Dynamic knowledge RAG incorporates tool assets: tool selection, parameter filling, validation, and execution to fetch real‑time data.

Evaluation

Evaluation metrics include retriever hit rate, MRR, similarity, and answer relevancy. These metrics help identify bottlenecks in both retrieval and generation stages.

Case Studies

Data Infrastructure Ops : A DB‑GPT‑based agent uses GraphRAG and tool execution to diagnose database alerts, combining static knowledge graphs with dynamic tool calls for deterministic, professional assistance.

Financial Report Analysis : DB‑GPT powers a financial report assistant that extracts structured data from reports and answers queries using RAG techniques.

Conclusion

Building domain‑specific asset libraries (knowledge, tools, graphs) and tailoring the RAG pipeline—knowledge processing, retrieval, evaluation—are essential for high‑quality AI assistants.