drvivekpoojary/gvp-modules-rag-chunks

GVP Modules RAG Chunks

Structured chunked corpus of EMA Good Pharmacovigilance Practices (GVP) modules, prepared for Retrieval-Augmented Generation (RAG).

This dataset is designed to be used together with the Open-GVP family of models:

• drvivekpoojary/Open-GVP-Qwen3-4B-Instruct
• drvivekpoojary/Open-GVP-Qwen2.5-7B-Instruct
• drvivekpoojary/Open-GVP-Qwen2.5-14B-Instruct

Dataset Summary

Item	Details
Source	Official EMA GVP Module PDFs
Chunking	Sentence-aware packing (≈500 words, 2-sentence overlap) — identical to the chunking used for Open-GVP training data
Embeddings	BAAI/bge-small-en-v1.5 (L2-normalized)
Index	FAISS index included at faiss_index/gvp_embeddings.faiss

Fields

Field	Type	Description
chunk_id	string	Globally unique ID ({module}_{index:04d})
module	string	GVP module name (e.g. GVP_Module_VI)
section	string	Best-effort section / heading number
source_page	string	Page number or page range (e.g. "12" or "12-13")
source_file	string	Original PDF filename
text	string	Chunk content

How to Use

1. Load the dataset + FAISS index

from datasets import load_dataset
from huggingface_hub import hf_hub_download
from sentence_transformers import SentenceTransformer

DATASET_ID = "drvivekpoojary/gvp-modules-rag-chunks"

ds = load_dataset(DATASET_ID, split="train")

# Download and load the FAISS index
faiss_path = hf_hub_download(
    repo_id=DATASET_ID,
    filename="faiss_index/gvp_embeddings.faiss",
    repo_type="dataset"
)
ds.load_faiss_index("embeddings", faiss_path)

embedder = SentenceTransformer("BAAI/bge-small-en-v1.5")

2. Retrieve relevant chunks

query = "What are the reporting timeframes for fatal ICSRs according to GVP Module VI?"
query_emb = embedder.encode([query], normalize_embeddings=True)[0]

scores, retrieved = ds.get_nearest_examples("embeddings", query_emb, k=5)

for i, text in enumerate(retrieved["text"]):
    print(f"[{retrieved['module'][i]} | Page {retrieved['source_page'][i]} | {retrieved['section'][i]}]")
    print(text[:300], "...\n")

3. Full RAG Script (Transformers + Ollama)

Copy the complete script below. It supports two backends:

• transformers — for users/testers with a GPU (4B / 7B / 14B + bf16 / 8bit / 4bit)
• ollama — for users without a GPU (uses a local GGUF via Ollama)

"""
gvp_rag_query.py

Runs GVP RAG queries against the published dataset + FAISS index (downloaded
from HF Hub -- read-only here, no upload logic) and generates an answer via
one of two backends, covering all three scenarios in one script:

  My use / Testers (real GPU, 4B-14B range)
      -> BACKEND = "transformers"
      -> PRECISION selects bf16 / 8bit / 4bit per available VRAM, so the
         same script serves your own machine and any tester regardless of
         card size. This replaces hardcoding torch.bfloat16 + device_map="auto".

  Users (no GPU)
      -> BACKEND = "ollama"
      -> Talks to a local Ollama server running a GGUF build of the model.
         Retrieval (embedding + FAISS) is CPU-native either way, so only the
         generation step changes between backends.

Confirmed model repos:
  4B  -> drvivekpoojary/Open-GVP-Qwen3-4B-Instruct
  7B  -> drvivekpoojary/Open-GVP-Qwen2.5-7B-Instruct
  14B -> drvivekpoojary/Open-GVP-Qwen2.5-14B-Instruct (coming soon)

Each model repo ships a Modelfile. For Ollama:
  download the GGUF + Modelfile, then
  `ollama create <tag> -f Modelfile`
  and set OLLAMA_MODEL_NAME to <tag>.
"""

import requests
from datasets import load_dataset
from huggingface_hub import hf_hub_download
from sentence_transformers import SentenceTransformer

# ====================== SHARED CONFIG ======================
DATASET_ID = "drvivekpoojary/gvp-modules-rag-chunks"
FAISS_FILENAME = "faiss_index/gvp_embeddings.faiss"
EMBEDDING_MODEL = "BAAI/bge-small-en-v1.5"
TOP_K = 5

BACKEND = "transformers"  # "transformers" (My use / Testers) | "ollama" (Users)

# --- transformers backend ---
MODEL_TIERS = {
    "4b": "drvivekpoojary/Open-GVP-Qwen3-4B-Instruct",
    "7b": "drvivekpoojary/Open-GVP-Qwen2.5-7B-Instruct",
    "14b": "drvivekpoojary/Open-GVP-Qwen2.5-14B-Instruct",  # not yet uploaded
}
MODEL_TIER = "7b"
MODEL_ID = MODEL_TIERS[MODEL_TIER]

PRECISION = "4bit"  # "bf16" | "8bit" | "4bit" -- set per available VRAM
# Rough VRAM guide:
#   14B  bf16 ~28GB | 8bit ~14GB | 4bit ~8-9GB
#    7B  bf16 ~14GB | 8bit ~7GB  | 4bit ~5GB
#    4B  bf16 ~8GB  | 8bit ~4GB  | 4bit ~3GB

# --- ollama backend ---
OLLAMA_HOST = "http://localhost:11434"
OLLAMA_MODEL_NAME = "gvp-model:latest"  # tag from your `ollama create` / Modelfile
# =============================================================

SYSTEM_PROMPT = """You are an expert pharmacovigilance assistant specialized in EMA Good Pharmacovigilance Practices (GVP).
Answer the user's question accurately using ONLY the provided regulatory context.
If the context does not contain sufficient details, explicitly state the limitation.
Always reference the specific GVP Module, section, or page numbers where available."""


# ---------------- retrieval (shared, CPU-safe) ----------------
def load_retriever():
    print("Loading dataset + FAISS index...")
    ds = load_dataset(DATASET_ID, split="train")
    faiss_path = hf_hub_download(
        repo_id=DATASET_ID, filename=FAISS_FILENAME, repo_type="dataset"
    )
    ds.load_faiss_index("embeddings", faiss_path)
    embedder = SentenceTransformer(EMBEDDING_MODEL)
    return ds, embedder


def retrieve(ds, embedder, query: str, k: int = TOP_K) -> str:
    query_emb = embedder.encode([query], normalize_embeddings=True)[0]
    _scores, retrieved = ds.get_nearest_examples("embeddings", query_emb, k=k)
    parts = []
    for i in range(len(retrieved["text"])):
        parts.append(
            f"--- Chunk {i + 1} | {retrieved['module'][i]} | "
            f"Page {retrieved['source_page'][i]} | {retrieved['section'][i]} ---\n"
            f"{retrieved['text'][i]}"
        )
    return "\n\n".join(parts)


def build_user_content(query: str, context_str: str) -> str:
    return f"""CONTEXT FROM OFFICIAL EMA GVP GUIDELINES:
{context_str}

USER QUESTION:
{query}

INSTRUCTIONS:
Provide a precise, objective, and compliant regulatory response based strictly on the context above.
Cite the Module and page/section whenever possible."""


# ---------------- transformers backend (My use / Testers) ----------------
def load_transformers_model():
    import torch
    from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig

    tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)

    kwargs = {"device_map": "auto"}
    if PRECISION == "bf16":
        kwargs["torch_dtype"] = torch.bfloat16
    elif PRECISION == "8bit":
        kwargs["quantization_config"] = BitsAndBytesConfig(load_in_8bit=True)
    elif PRECISION == "4bit":
        kwargs["quantization_config"] = BitsAndBytesConfig(
            load_in_4bit=True,
            bnb_4bit_quant_type="nf4",
            bnb_4bit_compute_dtype=torch.bfloat16,
        )
    else:
        raise ValueError(f"Unknown PRECISION: {PRECISION}")

    model = AutoModelForCausalLM.from_pretrained(MODEL_ID, **kwargs)
    return tokenizer, model


def generate_transformers(tokenizer, model, user_content: str) -> str:
    import torch

    messages = [
        {"role": "system", "content": SYSTEM_PROMPT},
        {"role": "user", "content": user_content},
    ]
    prompt = tokenizer.apply_chat_template(
        messages, tokenize=False, add_generation_prompt=True
    )
    inputs = tokenizer([prompt], return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model.generate(
            **inputs,
            max_new_tokens=768,
            temperature=0.1,
            top_p=0.9,
            repetition_penalty=1.05,
            do_sample=True,
        )
    return tokenizer.decode(
        outputs[0][inputs["input_ids"].shape[1]:], skip_special_tokens=True
    ).strip()


# ---------------- ollama backend (Users, no GPU) ----------------
def generate_ollama(user_content: str) -> str:
    resp = requests.post(
        f"{OLLAMA_HOST}/api/chat",
        json={
            "model": OLLAMA_MODEL_NAME,
            "messages": [
                {"role": "system", "content": SYSTEM_PROMPT},
                {"role": "user", "content": user_content},
            ],
            "stream": False,
            "options": {"temperature": 0.1, "top_p": 0.9},
        },
        timeout=300,
    )
    resp.raise_for_status()
    return resp.json()["message"]["content"].strip()


# ---------------- dispatch ----------------
def answer_gvp_query(query: str, ds, embedder, model_state) -> str:
    context_str = retrieve(ds, embedder, query)
    user_content = build_user_content(query, context_str)

    if BACKEND == "transformers":
        tokenizer, model = model_state
        return generate_transformers(tokenizer, model, user_content)
    elif BACKEND == "ollama":
        return generate_ollama(user_content)
    else:
        raise ValueError(f"Unknown BACKEND: {BACKEND}")


if __name__ == "__main__":
    ds, embedder = load_retriever()

    if BACKEND == "transformers":
        model_state = load_transformers_model()
    else:
        model_state = None  # Ollama serves the model itself

    query = "What are the specific timeframes for reporting fatal or life-threatening ICSRs according to GVP Module VI?"
    print("\n=== RESPONSE ===")
    print(answer_gvp_query(query, ds, embedder, model_state))

Requirements

pip install datasets sentence-transformers transformers torch huggingface_hub faiss-cpu requests
# Optional (for 4bit/8bit):
pip install bitsandbytes
# Optional (for Ollama backend):
# Install Ollama separately and create the model from the GGUF + Modelfile

Intended Use

• Building offline / local RAG systems for pharmacovigilance
• Grounding Open-GVP models in official EMA GVP text
• Research and education on regulatory RAG pipelines

Not intended for clinical decision-making or regulatory submissions without qualified human expert review.

Dataset Creation

1. Official GVP Module PDFs were extracted with block-level reading-order sorting.
2. Text was split into sentences with abbreviation- and heading-aware period protection.
3. Sentences were packed into ~500-word chunks with a 2-sentence overlap (identical logic to the Open-GVP training data pipeline).
4. Each chunk received a globally unique chunk_id, module name, approximate section heading, and source page(s).
5. Embeddings were computed with BAAI/bge-small-en-v1.5 and a FAISS index was built.

License

Apache License 2.0

---

Disclaimer: This dataset is an independent academic resource prepared for research and educational purposes. It is not affiliated with, endorsed by, or an official product of the European Medicines Agency (EMA) or the Heads of Medicines Agencies.