Most teams defend Large Language Models (LLMs) against prompt-injection and jailbreak attacks using Supervised Fine-Tuning (SFT) on a static dataset of known attacks. The problem? As soon as an attacker crafts an Out-Of-Distribution (OOD) prompt that doesn't look like the training data, SFT models crumble.

To solve this, I built MAPPO-Sec, a two-agent adversarial reinforcement learning framework using PyTorch, Hugging Face Transformers, LoRA, and Multi-Agent Proximal Policy Optimization (MAPPO) where an Attacker LLM and a Defender LLM continuously co-evolve.

Architecture: Centralized Training with Decentralized Execution (CTDE)

Instead of training a defender in isolation, MAPPO-Sec pits two LoRA-adapted models against each other in a zero-sum game using Centralized Training with Decentralized Execution (CTDE):

                 ┌───────────────────────────────────────────┐
                 │         Centralized Critic V(s)           │
                 │  (Evaluates Joint State & Computes GAE)   │
                 └─────────────┬───────────────┬─────────────┘
                               │               │
             ┌─────────────────▼──┐         ┌──▼─────────────────┐
             │   Attacker Agent   │         │   Defender Agent   │
             │   (LoRA Policy)    ├────────>│   (LoRA Policy)    │
             └────────────────────┘ Adversarial └────────┬───────────┘
                                     Prompt          │ Safe / Compromised
                                                     ▼
                                           [ Trajectory Buffer ]

• The Attacker Agent: Generates adversarial prompt-injection payloads attempting to hijack the system instruction.
• The Defender Agent: Processes the untrusted input and responds while maintaining policy compliance and helpfulness.
• Centralized Critic & GAE: During training, a centralized critic observes the joint state of both agents, stores rollouts in a trajectory buffer, and computes variance-reduced advantage estimates using Generalized Advantage Estimation (GAE). At inference time (decentralized execution), only the hardened Defender policy is deployed.

Core Implementation: GAE & Clipped MAPPO Objective in PyTorch

To keep training stable while both policies shift simultaneously, we use Low-Rank Adaptation (LoRA) to fine-tune attention weights efficiently and compute GAE over the trajectory buffer:

import torch
import torch.nn as nn

def compute_gae(rewards, values, next_values, dones, gamma=0.99, lam=0.95):
    """
    Computes Generalized Advantage Estimation (GAE) for CTDE rollouts.
    """
    advantages = torch.zeros_like(rewards)
    last_gae_lam = 0

    for t in reversed(range(len(rewards))):
        non_terminal = 1.0 - dones[t]
        delta = rewards[t] + gamma * next_values[t] * non_terminal - values[t]
        advantages[t] = last_gae_lam = delta + gamma * lam * non_terminal * last_gae_lam

    returns = advantages + values
    return advantages, returns

def mappo_policy_loss(log_probs, old_log_probs, advantages, clip_eps=0.2):
    """
    Clipped surrogate objective for updating Attacker and Defender LoRA policies.
    """
    ratio = torch.exp(log_probs - old_log_probs)
    surr1 = ratio * advantages
    surr2 = torch.clamp(ratio, 1.0 - clip_eps, 1.0 + clip_eps) * advantages
    return -torch.min(surr1, surr2).mean()

Why Co-Evolution Works

In static SFT, the defender memorizes surface-level refusal patterns. In MAPPO-Sec, whenever the Defender patches a vulnerability, the Attacker is rewarded for discovering a new semantic bypass. This forces the Defender to learn robust internal representations of instruction boundaries rather than keyword filtering.

Benchmark Results: MAPPO-Sec vs. SFT Baseline

When we evaluated both approaches against unseen, Out-Of-Distribution (OOD) prompt-injection attacks, the difference was stark:

Conclusion

As LLM applications move into production, static guardrails are no longer sufficient. By combining parameter-efficient LoRA adapters with Multi-Agent RL (MAPPO), we can proactively red-team and harden language models against novel prompt injections before attackers find them in the wild. Explore the implementation on my GitHub.

Medical AI often fails in real-world clinical settings for two reasons: doctors don't trust "black-box" image predictions without visual proof, and patients can't understand dense radiology reports filled with clinical jargon.

When building CareLink (a finalist project at the VIT Bhopal Health Hackathon in collaboration with Johns Hopkins University), I designed a dual-interface AI diagnostic platform using Next.js, Node.js, TensorFlow, Firebase, and Socket.io that bridges the gap between radiologists and patients. Here is how the three core pipelines work under the hood.

System Architecture

                       ┌──> [DenseNet121 + Grad-CAM] ──> Doctor View (91% Acc Heatmap)
[X-Ray / Report Input]─┤
                       └──> [Tesseract OCR -> FAISS RAG (MedlinePlus)] ──> Patient Plain-Language View
                                                                                 │
[Browser Sensor APIs] ────> [Socket.io Safety Layer] ────────────────────────────┴──> <3s GPS SOS Alert

1. Explainable Radiology with DenseNet121 & Grad-CAM

For chest X-ray classification, raw probability scores aren't enough for a clinician. We trained a DenseNet121 Convolutional Neural Network in TensorFlow (achieving 91% classification accuracy) and integrated Grad-CAM (Gradient-weighted Class Activation Mapping).

Grad-CAM extracts the gradients of the target pathology flowing into the final convolutional layer (conv5_block16_concat in DenseNet121) to generate a localized heatmap highlighting the exact lung regions that triggered the prediction:

import tensorflow as tf
import numpy as np
import cv2

def generate_gradcam_heatmap(img_array, model, last_conv_layer_name="conv5_block16_concat"):
    grad_model = tf.keras.models.Model(
        [model.inputs], 
        [model.get_layer(last_conv_layer_name).output, model.output]
    )

    with tf.GradientTape() as tape:
        last_conv_layer_output, preds = grad_model(img_array)
        class_channel = preds[:, tf.argmax(preds[0])]

    grads = tape.gradient(class_channel, last_conv_layer_output)
    pooled_grads = tf.reduce_mean(grads, axis=(0, 1, 2))

    heatmap = last_conv_layer_output[0] @ pooled_grads[..., tf.newaxis]
    heatmap = tf.squeeze(heatmap)
    heatmap = tf.maximum(heatmap, 0) / tf.math.reduce_max(heatmap)
    return heatmap.numpy()

2. Translating Medical Jargon with Tesseract OCR + FAISS RAG

When a patient uploads a physical lab report, feeding it directly to a generic LLM risks dangerous hallucinations. Instead, we built a grounded pipeline:

1. Text Extraction: Tesseract OCR parses raw text from scanned diagnostic reports.
2. Vector Retrieval: We indexed verified medical definitions from MedlinePlus into a FAISS vector database.
3. Grounded Generation: Retrieved clinical context is injected into the prompt so the patient gets an accurate, plain-language explanation.

import pytesseract
from PIL import Image
from langchain_community.vectorstores import FAISS
from langchain_huggingface import HuggingFaceEmbeddings

embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
vector_db = FAISS.load_local("medlineplus_faiss_index", embeddings, allow_dangerous_deserialization=True)

def explain_medical_report(image_path: str):
    raw_report_text = pytesseract.image_to_string(Image.open(image_path))
    
    retrieved_docs = vector_db.similarity_search(raw_report_text, k=3)
    context = "\n".join([doc.page_content for doc in retrieved_docs])
    
    prompt = f"""
    Using ONLY the verified MedlinePlus context below, explain this medical report 
    in simple, empathetic plain language for a patient.
    
    Verified Context:
    {context}
    
    Patient Report:
    {raw_report_text}
    """
    return prompt

3. Sub-3-Second Fall Detection & SOS Dispatch via Socket.io

To protect high-risk patients at home, we built a real-time safety layer on the frontend using browser DeviceMotionEvent sensor APIs paired with a low-latency Socket.io WebSocket server in Node.js.

When sudden acceleration spikes followed by stillness are detected on the client device, the browser immediately grabs GPS coordinates and emits a high-priority WebSocket event, delivering emergency SOS alerts to caregivers in under 3 seconds:

window.addEventListener('devicemotion', (event) => {
  const { x, y, z } = event.accelerationIncludingGravity;
  const magnitude = Math.sqrt(x * x + y * y + z * z);

  if (magnitude > 28.5) {
    navigator.geolocation.getCurrentPosition((pos) => {
      socket.emit('emergency_sos', {
        patientId: currentUser.id,
        timestamp: Date.now(),
        coordinates: {
          lat: pos.coords.latitude,
          lng: pos.coords.longitude,
        },
        impactG: (magnitude / 9.8).toFixed(2),
      });
    });
  }
});

Wrapping Up

By separating the clinician workflow (DenseNet121 + Grad-CAM) from the patient workflow (OCR + FAISS RAG + WebSocket SOS), CareLink demonstrates how combining computer vision, retrieval-augmented generation, and real-time event streaming can create safer, more transparent healthcare tools. Check out the full source code on my GitHub

.

When scaling content-heavy developer platforms, hardcoding individual routes or duplicating layout logic across dozens of chapters quickly becomes a maintenance nightmare. During my time as an SDE Intern at SecPen Labs, we needed a way to scale multi-chapter technical content without creating per-page duplication, while simultaneously improving Core Web Vitals and search visibility.

Here is how we re-architected the frontend using a single-schema JSON pipeline in Next.js, reduced page-load time by 20%, and lifted organic traffic by 15%.

Architecture Overview

Instead of maintaining separate React templates for every chapter, we centralized all content into a strict JSON schema and used Next.js dynamic routing to hydrate pages on demand:

[ JSON Content Schema ] 
         │
         ▼
[ Dynamic Route: /chapters/[slug]/page.tsx ]
         ├──> Route-Level Code Splitting (Dynamic Imports)
         ├──> Schema-to-Component Mapper (Zero Duplication)
         └──> Automated Metadata & Sitemap Generator (SEO)

Step 1: Designing the Single-Schema JSON Pipeline

To eliminate per-page duplication, every chapter adheres to a unified JSON structure containing metadata, hierarchy, and modular content blocks:

{
  "slug": "network-pentesting-fundamentals",
  "title": "Network Penetration Testing Fundamentals",
  "SEO": {
    "description": "Learn the core methodology of network reconnaissance and exploitation.",
    "keywords": ["pentesting", "network security", "secpen"]
  },
  "sections": [
    {
      "type": "markdown",
      "content": "## Reconnaissance\nActive and passive scanning techniques..."
    },
    {
      "type": "code",
      "language": "bash",
      "snippet": "nmap -sC -sV -oA initial_scan 10.10.11.24"
    },
    {
      "type": "callout",
      "variant": "warning",
      "text": "Always ensure you have explicit written authorization before scanning targets."
    }
  ]
}

Step 2: Dynamic Chapter Routing & Route-Level Code Splitting

Using Next.js dynamic routes (app/chapters/[slug]/page.tsx), we mapped the JSON schema blocks to lazy-loaded React components. By applying route-level code-splitting with next/dynamic, heavy components (like syntax highlighters or interactive diagrams) are only downloaded when a chapter actually uses them:

import dynamic from 'next/dynamic';
import { notFound } from 'next/navigation';
import { getChapterBySlug } from '@/lib/contentPipeline';

const CodeBlock = dynamic(() => import('@/components/CodeBlock'), {
  loading: () => <div className="h-24 animate-pulse bg-slate-800 rounded-md" />,
});
const CalloutBox = dynamic(() => import('@/components/CalloutBox'));

export default async function ChapterPage({ params }: { params: { slug: string } }) {
  const chapter = await getChapterBySlug(params.slug);
  if (!chapter) return notFound();

  return (
    <article className="max-w-3xl mx-auto py-10 px-4">
      <h1 className="text-3xl font-bold tracking-tight mb-6">{chapter.title}</h1>
      <div className="space-y-6">
        {chapter.sections.map((section, idx) => {
          switch (section.type) {
            case 'code':
              return <CodeBlock key={idx} language={section.language} code={section.snippet} />;
            case 'callout':
              return <CalloutBox key={idx} variant={section.variant} text={section.text} />;
            default:
              return <p key={idx} className="leading-relaxed text-slate-300">{section.content}</p>;
          }
        })}
      </div>
    </article>
  );
}

Step 3: Tailwind CSS Optimization & Technical SEO

To push performance further, we paired our routing architecture with two key optimizations:

1. Asset & Tailwind CSS Optimization: We compressed static media assets, purged unused utility classes, and flattened nested DOM structures to reduce CSS bundle overhead.
2. Programmatic SEO & Sitemap Generation: Using the same JSON pipeline, we dynamically injected OpenGraph and structured metadata via Next.js generateMetadata and automated XML sitemap generation:

export async function generateMetadata({ params }: { params: { slug: string } }) {
  const chapter = await getChapterBySlug(params.slug);
  if (!chapter) return {};

  return {
    title: `${chapter.title} | SecPen Labs`,
    description: chapter.SEO.description,
    keywords: chapter.SEO.keywords,
    openGraph: {
      title: chapter.title,
      description: chapter.SEO.description,
      type: 'article',
    },
  };
}

Production Impact

Moving from static templates to a schema-driven Next.js pipeline delivered measurable results across the platform:

Key Takeaway

Treating your UI as a function of a clean JSON schema doesn't just make your codebase DRY—it makes performance optimization, code-splitting, and technical SEO repeatable across thousands of pages.