Let's Talk
Hello, I'm

MD TANVIR
SHEIKH

AI & Machine Learning Engineer

AI/ML Engineer with hands-on experience building LLM-powered applications: RAG pipelines (both custom-built and LangChain-based), agent orchestration with LangGraph, and tool/function-calling systems via the LLM API. Comfortable across the full stack — embeddings and vector search (ChromaDB), backend APIs (FastAPI), and deployment (Streamlit, Docker, AWS) — with a deep-learning foundation in PyTorch. Currently expanding into production evaluation and cloud deployment.

AI Neural network Database

AVAILABLE FOR PROJECTS • Trusted by forward-thinking developers.

বই বন্ধু

বই বন্ধু - Bengali Textbook RAG Assistant

An end-to-end retrieval-augmented study companion over the NCTB national curriculum: students pick a chapter, ask questions in English or Bangla, take auto-generated quizzes and track their progress — every answer grounded in that chapter's own textbook pages.

  • LangChain / LangChain-Core / LangChain-Community / LangChain-Classic, BM25Retriever + FAISS dense vectors combined through EnsembleRetriever (hybrid weights 0.4/0.6, k=5), with an md5-hashed per-chapter index layout under embedding_cache/ — retrieval loads pre-built index.faiss + index.pkl instead of re-embedding anything at query time.
  • Offline data pipeline with EasyOCR (Bangla + English, GPU-accelerated via PyTorch/torchvision), pdf2image + Poppler and RecursiveCharacterTextSplitter (chunk 1500 / overlap 350) producing 385 searchable chapters across 27 NCTB books; JSON-based caching with resumable partial runs.
  • Dense retrieval uses intfloat/multilingual-e5-base (768-d) with the query: / passage: prefixes, so the stored chunk text stays clean; the model directory is flattened and baked into the container image (cache trimmed 10.1 GB → 1.1 GB by dropping duplicate weight formats).
  • Grounded generation with Groq (openai/gpt-oss-120b) as primary and DeepSeek (deepseek-chat) as automatic fallback, streamed to the browser as NDJSON token events with page-level citations and follow-up-question detection.
  • Quiz + progress layer: FastAPI generates 5 chapter-grounded MCQs per request with the answer key kept server-side, grades them with explanations, and stores one SQLite (WAL) row per answered question — powering per-chapter accuracy, weak-topic detection, a subject filter, resettable history and an LLM-written parent summary with a deterministic fallback.
  • Bilingual by design (English default, one toggle to বাংলা) across UI labels, subject names, machine-translated chapter titles and the AI's answer language; deployed as a Docker image on AWS EC2 with a Next.js 16 frontend on Vercel that proxies /api/* server-side, so the HTTPS site never hits the plain-HTTP backend (no CORS, no mixed content).
  • Next.js 16 (App Router, Turbopack) + React 19 + TypeScript, Tailwind CSS v4, react-markdown + remark-gfm for answer rendering, lucide-react icons, and Hind Siliguri (Bengali webfont) via next/font; catalog served with ETag, gzip and a localStorage cache for instant repeat loads.
Personal AI Assistant interface

Personal AI Assistant with RAG

An agentic assistant with document retrieval and tool-use orchestration.

  • Built an agentic AI assistant using LangGraph for stateful tool orchestration and workflow control.
  • Engineered an end-to-end RAG pipeline with MMR retrieval, deduplication, and LLM-based relevance filtering.
  • Implemented multi-model fallback routing with Pydantic-validated structured AI outputs for reliability.
  • Built real-time token streaming with FastAPI SSE, including in-flight generation cancellation.
  • Implemented UUID-based browser isolation to prevent cross-session document and knowledge-base mixing.
Attendance by Selfie student login interface

Attendance by Selfie

A biometric attendance portal powered by computer vision.

  • Built attendance capture through classroom photos or voice recordings with facial recognition and speaker verification.
  • Designed a reliable Supabase backend for student and teacher portals, including role-based data workflows.
Circuit board representing the Custom RAG Pipeline project

Custom RAG Pipeline

A from-scratch document-retrieval pipeline built around vector search.

  • Built the RAG system from first principles with custom embedding, vector-store, and retrieval components.
  • Implemented document ingestion, chunking, ChromaDB storage, and LLM generation while resolving production retrieval issues.
Data-center servers representing the F1 Pit Stop Prediction project

F1 Pit Stop Prediction

A stacked ensemble model for predicting race pit-stop duration. Got 0.95167 private accuracy.

  • Built a stacked ensemble using LightGBM, XGBoost, CatBoost, and a PyTorch ANN with GroupKFold validation.
CIFAR-10 Image Classifier cover placeholder

CIFAR-10 Image Classifier

A Convolutional Neural Network (CNN) built with PyTorch to classify 10 image categories (~87.75% validation accuracy) & (Kaggle prediction accuracy ~90%).

  • Architected a Convolutional Neural Network (CNN) in PyTorch to classify images across 10 distinct CIFAR-10 object categories.
  • Implemented data augmentation transformations, batch normalization layers, and learning rate scheduling to maximize generalization.
  • Achieved ~87.75% validation accuracy in 25 epochs using cross-entropy loss optimization and Adam optimizer.
  • The submitted Kaggle prediction achieved 0.90050 accuracy.
MNIST Digit Classifier cover placeholder

MNIST Classifier From Scratch

A feedforward deep neural network built completely from scratch using NumPy, Pandas & first-principles linear algebra.

  • Engineered a deep neural network without high-level ML frameworks, relying purely on Python, NumPy, and vector calculus.
  • Formulated matrix forward propagation, ReLU activation functions, Softmax output probabilities, and cross-entropy loss.
  • Derived analytical gradients for backpropagation and parameter weight updates via mini-batch gradient descent.
Dogs vs Cats Classifier cover placeholder

Dogs vs Cats Classifier

A custom CNN built with PyTorch to classify dogs and cats with ~93% validation accuracy on Kaggle dataset.

  • Constructed and trained a custom PyTorch CNN on the Kaggle Dogs vs Cats dataset for binary image classification.
  • Applied image data augmentation techniques (random flips, rotations, color jitter) to mitigate overfitting.
  • Reached ~93% validation accuracy through hyperparameter tuning and model evaluation workflows.
Facial Emotion Detector cover placeholder

Facial Emotion Detector

Deep learning model classifying 7 facial emotions using a custom CNN & ResNet-18 transfer learning on FER-2013.

  • Built a deep learning model classifying 7 facial expressions (angry, disgust, fear, happy, sad, surprise, neutral) using the FER-2013 dataset.
  • Benchmarked a custom PyTorch CNN architecture against a fine-tuned ResNet-18 transfer learning backbone.
  • Preprocessed grayscale facial crops with normalization, augmentations, and evaluation metrics (confusion matrices, F1-scores).
Surface Crack Detection cover placeholder

Surface Crack Detection

A PyTorch CNN for automated structural concrete crack detection with data augmentation and dropout regularization. ~99.8% validation accuracy on Kaggle dataset.

  • Developed a PyTorch computer vision model to detect structural surface cracks in concrete structures from Kaggle image datasets.
  • Implemented batch normalization, dropout layers, and image transformations to ensure robust feature extraction under varying lighting conditions.
  • Evaluated real-time classification performance for infrastructure safety monitoring and automated inspection workflows.
  • The model achieved a best validation accuracy of 99.83% in just 5 epochs, with training loss steadily decreasing from 0.061 to 0.019.
Loan Approval Prediction System cover placeholder

Loan Approval Prediction

An ML classification system predicting loan approval decisions based on applicant financial & demographic data.

  • Developed an end-to-end Machine Learning pipeline evaluating applicant creditworthiness and financial risk metrics.
  • Evaluated and benchmarked multiple classifiers including Logistic Regression, K-Nearest Neighbors (KNN), and Gaussian Naive Bayes.
  • Performed feature preprocessing, missing value imputation, categorical encoding, and performance evaluation (ROC-AUC, Precision/Recall).
  • Model Accuracy Precision Recall F1-Score
    Logistic Regression 88% 81% 78% 80%
    K-Nearest Neighbors 75% 64% 52% 57%
    Naive Bayes 87% 84% 70% 76%
Grocery Store Customer Segmentation cover placeholder

Grocery Customer Segmentation

Customer segmentation using K-Means clustering to analyze retail shopping behavior and spending patterns.

  • Implemented unsupervised K-Means clustering to segment grocery store customers based on purchasing frequency and monetary metrics.
  • Applied the Elbow Method and Silhouette Score analysis to determine optimal cluster counts (k).
  • Derived actionable behavioral personas and targeted marketing insights through exploratory data visualization.
California Housing Prediction cover placeholder

California Housing Prediction (ANN)

An Artificial Neural Network (ANN) regressor predicting housing prices with advanced feature engineering.

  • Built an Artificial Neural Network (ANN) regression model to estimate California block housing values.
  • Conducting extensive feature engineering, scaling, outlier filtering, and spatial attribute handling.
  • Optimized model depth, hidden units, activation functions, and MSE loss function to minimize prediction error.

Design. Build. Deploy.

End-to-end intelligent agentic systems and deep learning algorithms engineered for modern cloud infrastructure.

Generative AI & Agents

Orchestrating multi-model systems using LangGraph cyclic graphs, conditional tool interfaces, structured output validation, and fallback route logic.

Vector Search & RAG

Engineering indexing flows from first principles, incorporating chunking thresholds, sentence embeddings vector searches, and MMR ranking logic.

Machine Learning

Structuring tabular data pipelines, ensemble model stacking (LightGBM/XGBoost/CatBoost), and PyTorch feedforward deep learning nets.

Backend & Database

Exposing REST APIs via FastAPI with strict Pydantic validation schemas, integrated with Supabase/PostgreSQL backends, Docker containers, and AWS cloud deployments.

Tech Integrations
LLM API
LangGraph
ChromaDB
FastAPI
Supabase
PyTorch
Docker
AWS

"Building modular, first-principles RAG retrieval engines instead of relying on generic wrappers provides complete debugging speed and architectural clarity."

AI
Agentic Evaluator Node Automated Verification Benchmark
100%

Model Verification

Structured Pydantic validation rate across LLM responses.

AI Ingestion & Inference Pipeline

A modular layout detailing how unstructured documents evolve into verified agent responses in my applications.

1
Ingest

PyMuPDF document parsing & recursive character chunking.

2
Embed

Generating vector embeddings via sentence transformers.

3
Retrieve

MMR vector search retrieval & query expansion.

4
Generate

Invoking model routing through Llama, OpenAI, Qwen models to inference via low-latency Groq endpoints.

5
Validate

Invoking structured verification nodes checking hallucinations.

12+ Core AI Projects
3+ Agentic Tools Integrated
2022 BSc SDE Study Started
100% RAG Internals Control

Common Engineering Queries

I structure RAG indexes by setting per-session vector isolation filters. Using custom VectorStoreManager namespaces, document chunks are stored with metadata tags indicating session keys. Queries are filtered programmatically during MMR search routines.
Linear LLM chains fail when agents require loops, error retry routing, or validation loops. LangGraph models agent tools as nodes and conditional state checks as edge-routing functions, offering complete programmatic flow control.
In my tabular models (like the F1 Kaggle predictor), Level-0 models include LightGBM, XGBoost, CatBoost, and a PyTorch feedforward network. Their prediction outputs serve as input vectors for a Level-1 Ridge Regressor, validated using GroupKFold.

Let's create something extraordinary.

Reach out for consultations on RAG engineering, agentic automations, or machine learning engineering.

Location Dhaka, Bangladesh

AVAILABLE FOR FULL-TIME AND REMOTE CONTRACT ENGAGEMENTS