"A professional-grade medical assistant that grounds every answer in verified documents — not hallucinations."

     

1. 🩺 What is MediQuery.ai?
2. 📸 UI Showcase
3. 📊 Live Project Dashboard
4. ✨ Key Features
5. 🧠 RAG Pipeline
   • 5.1 🔄 Pipeline Flow
   • 5.2 📐 Architecture Diagram
   • 5.3 ⚡ Sequence Diagram
6. 🛠️ Tech Stack
7. 📂 Project Structure
8. 🔬 Experimental Phase
9. 🧪 Sample Queries — Zero Hallucination Proof
10. 📦 Getting Started
    • 10.1 🔧 Prerequisites
    • 10.2 ⬇️ Install & Configure
    • 10.3 🗄️ Build Vector Index
    • 10.4 🖥️ Run Locally
11. 🐳 Docker Quick Start
12. 🏗️ Enterprise Infrastructure Showcase
    • 12.1 🏗️ Infrastructure Setup
    • 12.2 ⚙️ GitHub Actions CI/CD
13. ⚡ Performance
14. 🗺️ Roadmap
15. 🤝 Contributing
16. 📄 Changelog
17. 👤 Author
18. ⭐ Show Your Support

MediQuery.ai is a production-grade Retrieval-Augmented Generation (RAG) medical assistant. Unlike standard LLMs that rely on pre-trained data alone, MediQuery.ai grounds every response in your indexed medical documents — delivering accurate, traceable, and hallucination-resistant healthcare insights.

🔑 The core guarantee: If the answer isn't in the indexed documents, the model says so — no fabrication.

🌙 Dark Mode — Default Cyber-Neon Experience

⚡ Thinking Indicator animates while Groq LPU™ processes · Glassmorphism panels with cyan neon glow · Dark/Light toggle top-right

☀️ Light Mode — Clean Clinical Interface

🩺 Source Attribution visible per response · Same RAG accuracy · Optimised for daytime clinical use

🔌 Service	📡 Status	📝 Description
⚙️ CI/CD Pipeline		GitHub Actions → ECR → EC2 auto-deploy
🌐 Production App		mediquery-ai.streamlit.app — primary serverless host
🏗️ AWS EC2		Enterprise scalability showcase (Docker + ECR)
🗄️ Vector DB		Index: medical-chatbot
🧠 Inference Engine		Real-time neural inference via Groq LPU™

MediQuery.ai follows a strict 5-stage RAG pipeline:

graph TD
    U[👤 USER QUERY] -->|HTTP POST| FL[🌐 Flask App — app.py]

    subgraph Ingestion ["📄 INGESTION — store_index.py"]
        PDF[📋 Medical PDFs<br/>data/]
        CHUNK[✂️ Text Splitter<br/>Semantic Chunks]
        EMBED[🔢 HuggingFace Embeddings<br/>all-MiniLM-L6-v2]
    end

    PDF --> CHUNK --> EMBED

    subgraph VectorStore ["🗄️ VECTOR STORE"]
        PC[📌 Pinecone Index<br/>medical-chatbot]
    end

    EMBED -->|Index vectors| PC

    subgraph RAG ["🧠 RAG PIPELINE — app.py"]
        RET[🔍 LangChain Retriever<br/>Top-k similarity search]
        CTX[📄 Retrieved Context<br/>Relevant chunks]
        GEN[⚡ Groq Llama 3.3 70B<br/>Answer generation]
    end

    FL -->|Embed query| PC
    PC -->|Top-k vectors| RET
    RET --> CTX
    CTX --> GEN
    GEN -->|Grounded answer| FL
    FL -->|JSON response| U

    subgraph DevOps ["☁️ CI/CD — GitHub Actions"]
        GH[🔀 git push]
        ECR[📦 AWS ECR<br/>Docker image]
        EC2[🖥️ AWS EC2<br/>Docker run :8080]
    end

    GH --> ECR --> EC2

    classDef user fill:#0a1a2e,stroke:#0ea5e9,stroke-width:2px,color:#fff;
    classDef app fill:#0f172a,stroke:#06b6d4,stroke-width:2px,color:#fff;
    classDef ingest fill:#0a2e0a,stroke:#10b981,stroke-width:2px,color:#fff;
    classDef store fill:#0a1a2e,stroke:#008080,stroke-width:2px,color:#fff;
    classDef rag fill:#1e1b0a,stroke:#FF6B35,stroke-width:2px,color:#fff;
    classDef devops fill:#2e1a0a,stroke:#FF9900,stroke-width:2px,color:#fff;

    class U user;
    class FL app;
    class PDF,CHUNK,EMBED ingest;
    class PC store;
    class RET,CTX,GEN rag;
    class GH,ECR,EC2 devops;

sequenceDiagram
    autonumber
    participant U  as 👤 User
    participant FL as 🌐 Flask
    participant PC as 🗄️ Pinecone
    participant GR as ⚡ Groq LPU

    Note over U,FL: 💬 Query Phase
    U->>FL: POST /get { "msg": "What is hypertension?" }
    FL->>FL: Embed query via all-MiniLM-L6-v2

    Note over FL,PC: 🔍 Retrieval Phase
    FL->>PC: similarity_search(query_vector, top_k=3)
    PC-->>FL: Top-3 relevant medical chunks

    Note over FL,GR: 🧠 Generation Phase
    FL->>GR: prompt = system + context + user_query
    GR-->>FL: Grounded answer (Llama 3.3 70B)

    Note over FL,U: 📤 Response Phase
    FL-->>U: JSON { "answer": "Hypertension is..." }

🩺 MediQuery.ai/
│
├── 🌐 app.py                        # Flask entry point — routes & RAG logic
├── 🗄️ store_index.py                # Data ingestion & Pinecone indexing script
│
├── 🧠 src/
│   ├── 🔧 helper.py                 # Embedding logic & utility functions
│   └── 📝 prompt.py                 # System & RAG prompt templates
│
├── 📄 data/                         # Source medical PDFs (drop new PDFs here)
│   └── 📋 Medical_book.pdf
│
├── 🖼️ assets/                       # UI screenshots & demo images
│
├── 🎨 static/                       # CSS, JS, images
│   ├── 🌙 dark.css                  # Dark mode stylesheet
│   └── 📜 chat.js                   # AJAX real-time chat logic
│
├── 🖼️ templates/
│   └── 🌐 chat.html                 # Main chat UI template
│
├── 🔬 research/                     # Jupyter notebooks for experimentation
│
├── 🐳 Dockerfile                    # Container build (python:3.10-slim + HEALTHCHECK)
├── ⚙️ .github/workflows/cicd.yaml   # GitHub Actions CI/CD pipeline
├── 📦 requirements.txt              # Python dependencies
├── 🔧 setup.py                      # Project packaging config
└── 🔒 .env.example                  # Environment variable template

The research/ folder contains trials.ipynb — the engineering workbench used before settling on the final pipeline parameters. This was not a tutorial copy; it was active optimisation.

💡 All experiments are reproducible in research/trials.ipynb — open it to see the raw token latency and retrieval precision comparisons.

The table below demonstrates the RAG pipeline in action — showing how retrieved context from Medical_book.pdf directly shapes the grounded answer, with no fabrication.

🛡️ Row 4 is the most important: when the answer doesn't exist in the documents, the model says so — this is the hallucination guard in practice.

🛠️ Tool	📌 Version	🔗 Link
	≥ 3.10	python.org
	any	anaconda.com
🗄️ Pinecone account	free tier	pinecone.io
⚡ Groq API key	free tier	console.groq.com

📥 Step 1 — Clone

git clone https://github.com/salonyranjan/MediQuery.ai.git
cd MediQuery.ai

🐍 Step 2 — Create environment

# With Conda (recommended)
conda create -n medibot python=3.10 -y
conda activate medibot

# Or with venv
python -m venv .venv && source .venv/bin/activate  # Windows: .venv\Scripts\activate

📦 Step 3 — Install dependencies

pip install -r requirements.txt

# Required for create_retrieval_chain in newer LangChain versions
pip install langchain-classic

# Installs src/ as a local editable package via setup.py
# This lets app.py import from src/helper.py and src/prompt.py without path hacks
pip install -e .

🔐 Step 4 — Configure secrets

cp .env.example .env

Edit .env:

PINECONE_API_KEY=your_pinecone_api_key
GROQ_API_KEY=your_groq_api_key

🔐 Security Note: The project uses .gitignore to protect API keys (*.env), exclude virtual environments (venv_medical/, .venv/), and keep generated artifacts out of version control. This is a security-first practice — never hardcode credentials, never commit your venv/ or .env. If you accidentally track them, run git rm --cached .env to untrack without deleting.

Place your medical PDFs in the data/ folder, then run:

python store_index.py

✅ This embeds your PDFs with all-MiniLM-L6-v2 and pushes vectors to Pinecone. Run once per new PDF batch.

python app.py

🌐 Opens at http://localhost:8080

No conda, no venv — single command:

# Build
docker build -t mediquery .

# Run with secrets injected at runtime
docker run -d -p 8080:8080 \
  -e PINECONE_API_KEY="your_pinecone_key" \
  -e GROQ_API_KEY="your_groq_key" \
  --name mediquery_app \
  mediquery

🌐 Opens at http://localhost:8080

Recommended Dockerfile (slim + health-checked):

# slim base — ~200 MB vs ~900 MB for full python:3.10
FROM python:3.10-slim

WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .

EXPOSE 8080

# Health check — Docker/AWS monitors if Flask is responding
HEALTHCHECK --interval=30s --timeout=10s --start-period=30s --retries=3 \
  CMD curl -f http://localhost:8080/ || exit 1

CMD ["python", "app.py"]

💼 Recruiter note: While the app runs serverlessly on Streamlit Cloud for cost efficiency, this section demonstrates the full production-grade AWS infrastructure that can be activated for enterprise scale — showing Docker, ECR, EC2, and automated CI/CD are all in place.

Step 1 — IAM user for deployment

Create an IAM user with:

• AmazonEC2ContainerRegistryFullAccess
• AmazonEC2FullAccess

Save the AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY.

Step 2 — Create ECR repository

<account-id>.dkr.ecr.<region>.amazonaws.com/medicalbot
# Example: 577435557871.dkr.ecr.eu-north-1.amazonaws.com/medical_chatbot

Step 3 — Launch EC2 (Ubuntu) + install Docker

sudo apt-get update -y && sudo apt-get upgrade -y
curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh
sudo usermod -aG docker ubuntu && newgrp docker

⚠️ Open port 8080 in your EC2 Security Group inbound rules.

Step 4 — Register EC2 as self-hosted GitHub runner

Go to: GitHub repo → Settings → Actions → Runners → New self-hosted runner → follow the Linux install commands on your EC2 instance.

Step 5 — Add GitHub Secrets

Go to: Settings → Secrets and variables → Actions → add:

Step 6 — Push to trigger pipeline

git push origin main

On every push, GitHub Actions will:

git push → Build Docker image → Push to ECR → docker pull on EC2 → docker run :8080

💬 Open a feature request →

# 1. Fork on GitHub
# 2. Create your branch
git checkout -b feature/your-feature

# 3. Commit with conventional format
git commit -m "feat: add your feature"
# Prefixes: fix: | docs: | style: | refactor: | test: | chore:

# 4. Push & open a PR
git push origin feature/your-feature

Priority areas:

✦ Salony Ranjan 🤖 ML Engineer  ·  🧑‍💻 Full-Stack Dev  ·  ☁️ Cloud & DevOps "Building intelligent systems that are as trustworthy as they are fast."

If MediQuery.ai impressed you, helped your research, or gave you ideas for your own RAG system — show it some love! 🩺

💡 Pro Tip: Go to GitHub repo Settings → Social Preview and upload the dark-mode screenshot. When you share on LinkedIn, your Cyber-Neon UI shows instead of a generic GitHub card — instant recruiter attention.

     

Developed with 🩺 by Salony Ranjan  ·  © 2026 MediQuery.ai · MIT