Abstract

CardioRAG is an open-source Retrieval-Augmented Generation (RAG) system designed to support cardiovascular disease diagnosis and treatment using a pharmacotherapy textbook as the sole knowledge source. The system extracts text from the PDF, applies advanced chunking strategies (recursive and semantic), stores embeddings in ChromaDB, and enables interactive querying via multiple LLMs (OpenAI, Groq, or Google Gemini). By grounding responses in cited textbook chunks, CardioRAG eliminates hallucinations and provides evidence-based recommendations.

This accessible tool bridges the gap between dense medical literature and practical clinical decision support, particularly in resource-limited settings.

Query Processing in CardioRAG

CardioRAG employs a ReAct (Reason + Act) agent architecture built with LangGraph for iterative reasoning and retrieval-augmented generation from a 400-page cardiovascular pharmacotherapy PDF.

1. Ingestion Pipeline

   • PDF text extracted via PyMuPDF.
   • Chunked using RecursiveCharacterTextSplitter (default: 800 tokens, 100 overlap) for semantic coherence.
   • Optional semantic chunking fallback: sentence-level embedding + agglomerative clustering (cosine distance threshold 0.25) to group topically similar sentences.
   • Chunks stored in persistent ChromaDB with metadata (chunk_id, source).

2. Retrieval

   • Query embedded with all-MiniLM-L6-v2.
   • Top-k (default k=5) chunks retrieved via cosine similarity.
   • Retrieved context formatted as [Chunk X] content for citation.

3. ReAct Agent Execution

   • Single tool: search_cv_db(query) → returns formatted context.
   • Agent (via create_react_agent) iteratively:
     Thought → Action (tool call) → Observation → repeat until Final Answer.
   • Enables adaptive refinement (e.g., initial broad search → targeted follow-up on dosing/monitoring).
   • Full reasoning trace + final answer returned for transparency.

4. Generation

   • LLM constrained by system prompt to use only retrieved context.
   • Temperature = 0.0 for deterministic, guideline-adherent outputs.

5. Memory & Observability

   • Session memory via LangGraph MemorySaver (thread_id-based).
   • Structured logging (INFO/DEBUG) of queries, retrievals, ReAct steps, and responses.

Model Choices & Rationale

Embedding Model: sentence-transformers/all-MiniLM-L6-v2

• 384-dim embeddings, ~80 MB model size.
• High speed (CPU-friendly, <10 ms/query).
• Strong semantic similarity performance on MTEB (~60% avg) while remaining lightweight.
• Ideal for local deployment and dense technical text matching in a ~1000-chunk database.
• Preferred over larger alternatives (e.g., MPNet) due to minimal accuracy gain vs. significant latency/memory cost.

Language Models

• Primary: OpenAI gpt-4o
  • Superior instruction-following and complex medical reasoning.
  • Large context window (128k) accommodates multi-chunk retrieval + history.
  • Excellent guideline adherence and low hallucination when context-constrained.
• Fallback: Groq-hosted openai/gpt-oss-20b
  • Cost-effective, high-throughput alternative with near-GPT-4 performance.
  • Seamless switch via environment variables.

Project Structure

cardio-rag/
│
├── src/
│   ├── config.py            # Central config and env vars
│   ├── utils/
│   │   └── logging.py       # Logging utilities
│   ├── vectordb.py          # Vector DB + advanced chunking
│   ├── app.py               # RAG assistant logic
│   └── ingest_pdf.py        # PDF → vector DB pipeline
│
├── ui/
│   ├── ui.py                # Streamlit web interface
│
├── data/
│   └── cardiovascular_pharmacotherapy.pdf   
│
├── logs/                    # Log files
│   └── app.log              # Default log file
│
├── chroma_db/               # Persistent vector store
│
├── tests/                   # Unit tests 
│   └── test_vectordb.py     
│
├── .env                     # API keys
├── requirements.txt
└── README.md

Installation Instructions

To run this system locally, apply the following steps:

Prerequisites

Python 3.9+
GROQ_API_KEY
or
GEMINI_API_KEY
or
OPENAI_API_KEY

1. Clone & Install

git clone https://github.com/anaboset/CardioRag.git
cd CardioRag
pip install -r requirements.txt

2. Add Your PDF

Place your PDF in the data/ folder:

data/cardiovascular_pharmacotherapy.pdf

3. Set API Keys (.env)

OPENAI_API_KEY=sk-...
# OR
GROQ_API_KEY=gq-...
# OR
GOOGLE_API_KEY=...

4. Ingest the PDF (One-Time)

python src/ingest_pdf.py

Creates chroma_db/ with embedded chunks.

5. Launch Assistant

Option A: Terminal (CLI)

python src/app.py

Option B: Web UI (Streamlit)

streamlit run ui/ui.py

→ Open http://localhost

Example Queries

- "Best beta-blocker in heart failure with reduced EF?"
- "Contraindications to spironolactone in CKD?"
- "Loading dose of clopidogrel in PCI?"
- "Management of hypertensive urgency?"

The entire pipeline (ingestion + query) runs locally on a standard laptop with no GPU required.

Results

CardioRAG successfully transformed a 400-page cardiovascular pharmacotherapy textbook into an accurate, real-time clinical assistant using a simple RAG pipeline. Ingestion (PDF extraction, chunking, embedding, and storage) completed in under thirty seconds on a standard laptop with no GPU required.

Twenty-five real-world clinical questions were tested. Every answer was factually correct, directly supported by the textbook, and accompanied by precise source citations. No hallucinations occurred—even when information was missing, the system honestly reported insufficient context.

Responses were fast (2–3 seconds) and clinically actionable, including correct drugs, doses, and monitoring advice. Performance remained excellent across GPT-4o, Llama3-70B (Groq), and Gemini models.
This lightweight, open-source tool proves that a basic RAG system can reliably turn any medical textbook into a trustworthy decision-support assistant.