I build AI systems that survive contact with production. Multi-agent workflows on LangGraph that hold state through crashes, RAG pipelines answering over 100K+ documents in under two seconds, and the evaluation harnesses that prove they are actually right.
The through-line of my work is trusting what a model tells you. That question took me from building LLM observability at Humanitarians AI to independent research on hallucination detection — where I found that a model's own hidden states betray its confabulations at 0.956 AUROC, beating SelfCheckGPT by 59 points with no labels and no second model. Three years of data and ML engineering underneath it all means I can take an idea from a research notebook to a containerized service on AWS without handing it off.
Built a multi-agent RAG platform on LangChain, LangGraph, and PGVector delivering semantic search over 100K+ documents at 99.8% retrieval accuracy.
Designed stateful multi-agent workflows in LangGraph with tool calling, conditional routing, and multi-step reasoning, serving 10K+ daily user queries at sub-2-second latency.
Engineered Sentence Transformers embedding pipelines over 100K+ research papers, cutting content generation time by 95% for 25K+ active users.
Implemented LLM observability and evaluation in LangSmith — agent tracing, prompt evaluation, and hallucination monitoring — surfaced through a Next.js analytics dashboard that lifted satisfaction to 4.9/5 NPS.
Containerized and deployed AI services to AWS ECS with Docker, Terraform, and GitHub Actions CI/CD: 98% availability, 40% lower infrastructure cost, fully automated releases.
Data Scientist
Jan 2025 – May 2025
ClinicMind · Florida
Developed a GPU-accelerated claim denial prediction model (XGBoost on RAPIDS cuML, explained with SHAP) over 500K+ healthcare records, reaching 91% accuracy and reducing denials by 18%.
Built a real-time anomaly detection system with TensorFlow/Keras autoencoders, cutting billing errors by 25% and saving ~$120K annually.
Designed and validated ML evaluation frameworks using precision, recall, F1, AUROC, bootstrap confidence intervals, and A/B testing across multiple healthcare datasets.
Shipped an NLP claim classification pipeline with statistical feature engineering to automate insurance routing, collapsing turnaround from 3 days to same-day.
Developed Airflow ETL pipelines and AWS QuickSight dashboards for 10+ insurance providers, halving data processing latency.
Data Engineer
Jul 2021 – Jul 2023
Wipro Limited · India
Built and maintained scalable pipelines for a medical equipment client, unifying procurement, inventory, and supply chain data in PostgreSQL and reducing order delays by 40%.
Designed Python/SQL ETL pipelines consolidating multiple enterprise systems, reducing inter-service data coupling by 60% and enabling unified cross-functional reporting.
Engineered a real-time multi-warehouse inventory sync platform on Redis and RabbitMQ, driving oversell incidents to 0% and reconciliation from 3 hours to 10 minutes.
Replaced PostgreSQL LIKE scans across a 10K+ SKU catalog with Elasticsearch full-text search — sub-200ms responses, 30x faster queries.
Automated CI/CD with GitHub Actions, Docker, and AWS ECS, cutting deployments from 4 hours to under 18 minutes at a 100% success rate.
Implemented RBAC with JWT, OAuth 2.0, and Redis session management across three enterprise applications, with zero vulnerabilities found in penetration testing.
Research Intern
Jul 2019 – Aug 2019
Bharat Electronics Limited · India
Performed EDA in Python (Pandas, NumPy, SciPy) and SQL to identify supply chain bottlenecks, reducing manual reporting by 40%.
Researched and developed predictive demand forecasting models using regression and time-series techniques to support procurement planning for senior leadership.
Built a React.js, Node.js, and PostgreSQL analytics dashboard, cutting procurement report generation from 2 days to 4 hours.
Skills
LLM & Agent Frameworks
LangChain
LangGraph
LlamaIndex
CrewAI
AutoGen
Anthropic Claude API
OpenAI API
Groq
Ollama
MCP
Function / Tool Calling
Prompt Engineering
RAG & Retrieval
RAG Pipeline Design
PGVector
FAISS
ChromaDB
Sentence Transformers
BM25 Hybrid Retrieval
Cross-Encoder Reranking
Chunking Strategies
Semantic Search
Embedding Pipelines
Multi-Agent Systems
Task Orchestration
Agent Delegation
Hierarchical Workflows
Stateful Graphs
Conditional Routing
Checkpointing & Persistence
Conversation Memory
Long-Term Memory Design
Query Decomposition
Evaluation & Observability
LangSmith
Langfuse
RAGAS
LLM-as-Judge
Agent Tracing
Hallucination Detection
MLflow
AUROC & Bootstrap CIs
A/B Testing
Benchmarking
Reliability & Safety
Guardrails
Prompt-Injection Defense
Input/Output Validation
Provider Fallback Chains
Sandboxed Execution
Graceful Degradation
RBAC
PHI De-identification
ML, DL & Fine-Tuning
PyTorch
TensorFlow
Hugging Face Transformers
PEFT / LoRA
4-bit Quantization (BitsAndBytes)
HF Accelerate
Representation Learning
XGBoost
RAPIDS cuML
SHAP
NLP
PCA
Data & Databases
PostgreSQL
MongoDB
Redis
Elasticsearch
MySQL
Amazon Redshift
BigQuery
Apache Airflow
dbt
ETL/ELT Pipelines
SQL Optimization
Dimensional Modeling
Cloud & MLOps
AWS (SageMaker, Lambda, ECS, S3, IAM)
GCP (Vertex AI, Cloud Run, BigQuery)
Docker
Kubernetes
Terraform
GitHub Actions CI/CD
FastAPI
Server-Sent Events
Projects
Selected work from github.com/VelCharitha77. Each project links to its repository, with the skills it actually exercised listed underneath.
Agentic Research Assistant
Self-critiquing LangGraph agent, served as a production API
A LangGraph agent that takes a topic, researches it with a search tool, drafts a document, critiques its own draft, and revises until the critique passes or a hard revision cap stops it. Built as a real service rather than a notebook: job-based API, crash-resumable state, live streaming, and guardrails.
What it does
Orchestrated as a LangGraph StateGraph — Research → Draft → Critique → Revise/Finalize, with a separate Fail path once research exhausts its retries. Retry logic lives in the tool layer, not duplicated at the graph level.
Postgres-backed LangGraph checkpointer, proven to survive a mid-run crash and resume without re-executing completed nodes.
Async FastAPI job API: POST /runs returns immediately, GET /runs/{id} polls status, and /runs/{id}/stream pushes live per-node progress over SSE with a 60s timeout guard against orphaned runs.
Provider-agnostic by design — Anthropic Claude by default, OpenAI behind the same LLMClient interface via a single config value.
Guardrails as first-class code: topic input validation, a revision cap enforced as a tested safety limit, and an explicit prompt-injection defense clause in every node that consumes untrusted web content.
Structured JSON logs correlated by run_id, wrapped once around every node instead of scattered per-node.
A study-abroad intelligence platform that scrapes exchange program pages, visa requirement sites, cost-of-living databases, student blogs, and Reddit threads, then produces personalized recommendations with budget estimates, quality-scored advice, and voice-narrated city guides. The interesting engineering is the retrieval and evaluation stack behind it.
What it does
Dual-agent RAG architecture on Groq (qwen-qwq-32b + llama-3.1-8b) with PGVector semantic search, BM25 hybrid retrieval, and cross-encoder reranking — sub-2s end-to-end response latency.
Embedding pipeline using Sentence Transformers (BAAI/bge-small-en-v1.5) producing 384-dimensional vectors, enabling real-time semantic search across 100+ sources in under 500ms.
Content-adaptive Mixture-of-Experts router that selects the right model per query type, plus an LLM-as-Judge quality gate that blocks weak recommendations before they reach the user.
Retrieval quality measured rather than assumed — a RAGAS evaluation suite with MLflow experiment tracking across runs.
Purpose-built source parsers per domain (university, visa, cost-of-living, blogs, Reddit) feeding a chunk → embed → vectorstore pipeline, with FAISS in development and PGVector in production.
LangGraph multi-agent orchestration with tool-calling agents, conditional routing, and query decomposition, exposed to clients through a FastMCP server.
Drag infrastructure components onto a canvas, connect them, and get real-time AI analysis of the design — a whiteboard that talks back. Every canvas change triggers a three-agent LangGraph pipeline that evaluates impact, matches the topology against known patterns and anti-patterns, and returns concrete recommendations.
What it does
Three-node LangGraph pipeline: Graph Analyst reads the topology → RAG Advisor retrieves relevant design knowledge → Impact Reporter turns it into actionable advice, e.g. "removing Redis increases read latency ~40x; suggest adding a CDN cache".
ChromaDB knowledge base covering 31 infrastructure components across 9 categories plus 8 documented anti-patterns — distributed monolith, circular dependencies, single point of failure, missing rate limiting, no caching, and more — embedded with all-MiniLM-L6-v2.
Agent mode where the chatbot mutates the canvas directly through tool calls, adding, removing, and connecting components on the user behalf.
Resilient LLM layer with an explicit fallback chain: Claude primary → GPT-4o → Gemini 2.5 Flash, so one provider outage does not take the product down.
Architecture simulation with configurable traffic load and chaos engineering, letting a design be stress-tested before it is built.
Protocol-labeled edges (HTTP, gRPC, TCP, WebSocket) over a Supabase-backed layer for email auth, saved designs, and chat history.
An AI-powered collaborative whiteboard (Figma/Miro with an agent). The unifying design idea: the AI agent manipulates the canvas through the same Yjs CRDT operations a human uses — so it is not a bolted-on chatbot, it is just another live collaborator with the same primitives and the same conflict resolution.
What it does
Agent edits flow through Yjs CRDT operations identical to human edits, so real-time multiplayer conflict resolution and presence work for the agent for free.
pnpm monorepo spanning four deployables: a Next.js web app (canvas UI, REST, OAuth, webhook, and agent route handlers), a Node y-websocket CRDT sync/presence/snapshot server, a Python FastAPI document service, and shared TypeScript packages.
Document service converts PDFs and images into editable canvas shapes via OCR, and generates embeddings that power a per-board document query endpoint.
Two-way integrations with GitHub, Slack, and Notion through OAuth callbacks and webhook handlers.
Typed contract between agent and canvas — shape and tool schemas live in a shared package, so the agent cannot emit an operation the canvas cannot render.
Deployed on GCP Cloud Run with Cloud SQL and Cloud Storage, a Prisma/MySQL data layer, and CI plus deploy pipelines in GitHub Actions.
A hackathon build running Gemma (E4B) entirely on-device via Ollama — no cloud inference, no data leaving the machine. The centerpiece is a self-extending tool registry: when the agent finds no tool matching a request, it generates a new Python tool, validates it, runs it in a sandbox, and offers to persist it for future reuse.
What it does
Dynamic capability generation — asked to increase the contrast of every image in a folder with no matching tool available, the agent writes the tool, validates it, executes it in a Python sandbox, and saves it to the registry for immediate reuse.
Fully local inference stack: Gemma E4B served through Ollama, so the agent runs with no network dependency.
Environmental awareness with root-cause reasoning — instead of reporting "no internet", it inspects the machine, recognizes an unfamiliar Wi-Fi network, explains the cause, and proposes connecting.
Breadth of built-in tools: connectivity and Wi-Fi control, Gmail (API, browser, and AppleScript paths), browser automation and web search, document handling, and filesystem access.
Sandboxed execution boundary for model-authored code, keeping generated tools contained from the host environment.
Pluggable tool registry behind a debug chat UI for inspecting tool selection and agent reasoning turn by turn.
An end-to-end healthcare data platform: containerized connectors pull from seven source systems into a dimensional warehouse with tested data quality and HIPAA-style access controls, and a Claude-powered agent lets non-technical users query it in plain English.
What it does
Seven independently containerized source connectors (EHR, HubSpot CRM, HR, NPI registry, call center, region FX, and a mock EHR API), each with its own Dockerfile and extract logic.
Kimball-style star schema — 5 dimensions, 3 fact tables, 28,000+ encounters — with SCD Type 2 history tracking and 25 automated dbt data quality tests.
574x query performance improvement (43ms → 0.076ms) through composite indexes and materialized views.
Natural-language-to-SQL agent on the Anthropic Claude API with dual-layer security, so analytical access needs no SQL fluency and cannot bypass the access model.
Infrastructure as code in Terraform, with CI and deploy workflows in GitHub Actions.
A CLI tool (rs) that turns URLs, files, or raw text into a finished two-speaker podcast episode. An LLM-driven multi-step pipeline writes the script, OpenAI TTS voices each speaker, and the segments are stitched and normalized into a single episode with every artifact written to disk.
What it does
Four-stage orchestration — Ingest → Script → Voice → Assemble — with clean separation between content extraction, generation, synthesis, and audio assembly.
Agentic script generation using swarm agents in an analyze → plan → write → edit loop, producing a structured multi-speaker script rather than one undifferentiated block of text.
Graceful degradation built in: when swarm APIs are unavailable in the installed AutoGen build, it falls back to a single-call simple generator instead of failing.
Per-segment audio synthesis through OpenAI TTS with distinct voices per speaker, then pydub-based stitching and loudness normalization.
Typed PodcastScript models keep LLM output structured and validatable before any audio is generated.
Full artifact trail per episode — script.json, per-segment audio, agent final_state.json, and the assembled output.wav — making runs reproducible and debuggable.
A role-based web application for scheduling counseling sessions, tracking visits, and sharing resources across three distinct user roles. Included here for the data-layer work: much of the business logic lives in the schema itself, not only in the application code.
What it does
Three role-scoped experiences — students (registration, booking, notifications, resources), counselors (availability toggling, sessions, health records), and administrators (system stats and oversight).
Normalized 14-table MySQL schema on InnoDB and utf8mb4, covering departments, specializations, profiles, appointments, sessions, treatment plans, feedback, resources, and notifications.
Logic pushed into the database through triggers, stored procedures, and functions consumed directly by API routes, with a separate enhancement migration and a verification script.
Connection pooling via mysql2 for predictable behavior under concurrent load.
Next.js 15 App Router with React 19 and Tailwind v4, plus light/dark/system theming.
Custom JWT-oriented auth API with an optional NextAuth route, and a documented migration path for older installs.
Independent work on the question underneath everything else I build: can you tell when a language model is making things up?
Unsupervised Hallucination Detection in Large Language Models
Research paper · independent
Prior hallucination detectors either need labeled data or burn multiple sampled generations per query. This work shows the signal is already sitting in the model's own hidden states: fit a simple geometric model of “truthful” activations, and confabulations fall measurably outside it — unsupervised, with a single forward pass.
0.956
AUROC on HaluEval QA
+59 pts
over SelfCheckGPT
4
LLM architectures validated
7
cross-domain datasets
Contributions
Built an unsupervised hallucination detector using PCA and Mahalanobis distance over transformer hidden states — no labels, no second model, and no sampling loop, achieving 0.956 AUROC on HaluEval QA and outperforming SelfCheckGPT by 59 points.
Engineered a multi-layer probing pipeline across 6 functionally-motivated transformer layers, and found that mid-layer representations (25–50% depth) outperform the final-layer probing every prior method relies on.
Ran cross-domain experiments across 7 datasets, establishing a sharp boundary on what the method measures: hidden state geometry detects LLM confabulations, but not human-crafted distractors.
Validated the signal across 4 architectures — Llama-3-8B, Mistral-7B, Qwen2.5-7B, and Phi-3-mini — demonstrating that the hallucination signal in transformer representations is architecture-independent.
Implemented 4-bit quantized inference with BitsAndBytes, making large-scale multi-model experimentation feasible on consumer hardware (T4/A100) rather than a cluster.
Proposed two novel unsupervised LLM verification frameworks (LSJ and PHSV) based on hidden state consistency, in collaboration with an Adobe Software Development Engineer.
Skills used
PyTorch
Hugging Face Transformers
BitsAndBytes (4-bit Quantization)
Hidden State Analysis
Representation Learning
PCA
Mahalanobis Distance
Scikit-learn
SciPy
AUROC & Bootstrap CIs
Unsupervised Learning
Experimental Design
Paper and code available on request — get in touch.
