Milan Nair
Software Engineering Intern
7+ years exp
Lua
Python
Java
Experimentation & Evaluation: 5/10
Data Pipeline & Feature Engineering: 4/10
MLOps & Deployment: 4/10
Active 1 day ago
+1 (720) 4224471
Invite to interview
Message
Download CVCV
Overview
Technical skills
Timeline
Roles
Overview
An LLM-focused practitioner (senior-level evidence) who builds retrieval-augmented agents and tool integrations for domain scientific data. The strongest proven skill is architecting instrumented LLM orchestration and tool execution with traces and fallbacks as implemented in two_llm/cgmengine.py and agentic/apis/noaa_apis.py. There is limited evidence of formal statistical rigor, model training pipelines, pinned reproducible environments, or extensive data-engineering (ETL) infrastructure in public code.
Technical skills
Lua• 7y+
Python• Senior • 6y+
Java• 4y+
Python
Requests
AI/ML
LangChain
AI/ML
NumPy
Pandas
Streamlit
OpenAI SDK
Jupyter Notebook
huggingface_hub
Llama
DeepEval
Hallucination
LangGraph
LLM
RAG
TensorFlow
Frontend
PostCSS
Tailwind CSS
DevOps
AWS
Docker
Kubernetes
Rest API
Analytics
Matplotlib
Timeline
University of Washington
Bachelor's Degree •
Applied Mathematics or Computer Science (Intended)
Lead Developer
•
Lead
Boring Box (Independent Studio)
•
Full-Time
Led a small team to design and release a Roblox mountain-climbing video game. Coordinated regular update cycles to ship new content to a live player base and maintain uptime. Implemented climbing mechanics and progression systems using Luau, then used analytics and community feedback to iterate on gameplay and sustain retention across updates.
Luau
Tailwind CSS
Student ML Engineer
•
Middle
NOAA and University of Colorado Boulder
•
Full-Time
Developed an ML tool in Python using LangGraph and AWS that answered researchers’ questions in plain English using a library of research papers. Built a RAG system with LangGraph and AWS S3 to retrieve and generate answers for NOAA geomagnetism topics, reducing manual literature search time. Integrated geomagnetism REST APIs with an LLM to generate real-time geomagnetic plots and built a web app using React and Tailwind CSS for researchers to upload data to the NOAA CrowdMag platform. Evaluated the LLM using DeepEval and Opik, including hallucination risk assessment.
Python
LangGraph
AWS
RAG
Rest API
DeepEval
Hallucination
Tailwind CSSsince 2024
National Security Technical Intern
•
Junior
MITRE
•
Internship
Wrote Python programs and automation to test computer systems used for large-scale national security simulations. Created scripts to validate Docker container and Kubernetes cluster configurations to reduce manual verification work. Applied Bayesian optimization to tune Kubernetes runtime settings for improved pipeline throughput and trained a TensorFlow model to classify malicious URLs, contributing to an organization-wide competition win.
Pythonsince 2024
Docker
Kubernetes
TensorFlow
Senior AI/ML Engineer
Confidence: Medium LLM Engineer
LLM-focused engineer (senior level) building agentic RAG systems that integrate tool calling, retrieval, and domain APIs - the most important strength is practical orchestration of agents with tracing and evaluation instrumentation.
Model Architecture & Training
2/10
How well models are designed and trained
Little to no custom model architecture or training code; uses hosted/local LLMs and off-the-shelf embedding models but no custom training loops or optimizer/scheduler designs.
Evidence
LearningJourney.ipynb: HuggingFaceEmbeddings(model=EMBEDDING_MODEL) usage and MODEL_NAME selection
two_llm/cgmengine.py: Settings.llm = Ollama(...) and Settings.embed_model = HuggingFaceEmbedding(...)
Data Pipeline & Feature Engineering
4/10
How data is prepared for models
Reasonable RAG data pipeline and document handling with splitting, indexing and persistent vector store setup, but standard libraries and patterns are used without advanced feature engineering.
Evidence
LearningJourney.ipynb: RecursiveCharacterTextSplitter chunking and Chroma vector_store indexing logic
two_llm/cgmengine.py: SimpleDirectoryReader + SentenceSplitter and VectorStoreIndex creation
Experimentation & Evaluation
5/10
How results are measured and tested
Explicit evaluation pipeline and experiment artifacts are present including scripted goldens, evaluation runner, and integration with an Opik-based evaluation and tracing system.
Evidence
evaluation/eval_opik.py: uses opik.evaluation.evaluate and evaluation metrics
evaluation/goldens.py: utilities to build goldens and interact with OpenAI client
two_llm/cgmengine.py: opik integration and TracedResponse instrumentation (track decorators and finalize trace logic)
MLOps & Deployment
4/10
How models are shipped to production
Production-facing pieces exist - Streamlit UI, persistent vector store use, LLM serving via Ollama and artifact attachments - but full MLOps features like deployment orchestration, model versioning, drift detection or CI/CD are not evidenced.
Evidence
agentic/cgmwebsite.py: Streamlit app setup, setup_engine caching, and engine stream_invoke usage
two_llm/cgmengine.py: chroma PersistentClient usage, StorageContext and saving figure attachments to /tmp for traces
Computational Efficiency
1/10
How efficiently computing resources are used
Almost no explicit computational efficiency engineering - no quantization, batching, GPU/CPU profiling, or memory optimization beyond minor server-side choices.
Evidence
LearningJourney.ipynb: comments about swapping to lighter embedding models as a trade-off
agentic/apis/noaa_apis.py: matplotlib.use('Agg') to render plots server-side (small operational efficiency step)
Research Depth & Innovation
3/10
Depth of research and new ideas
Some research-oriented design and orchestration are present - a two-LLM variant, traced responses and evaluation integration - but there are no novel model architectures or reproduced SOTA experiments.
Evidence
two_llm/cgmengine.py: TracedResponse dataclass and multi-step orchestration between api_c_engine and geomagi_c_engine
two_llm/apis/noaa_apis.py: implemented gridplot/contour_map and map overlay logic showing domain-specific algorithmic work
Expertise
AI / LLM Engineering (Agents)• Senior
RAG• Senior
Industries
Science & Engineering• Middle
Technologies
LangGraph
LangChain
DeepEval
TensorFlow
Pandas
AWS
Docker
Kubernetes
LLM
RAG
Hallucination
Recommendations
- Develop agentic LLM systems that require RAG plus structured tool calling and robust tracing and evaluation pipelines.
- Build production inference endpoints from the Streamlit demo - add CI/CD, versioned model deployment, and monitoring for latency and drift.
- Extend the evaluation work into reproducible experiment tracking and benchmarking - integrate MLFlow or W&B and add automated ablation scripts.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Senior Data Scientist
Confidence: Medium ML Practitioner
An LLM-focused practitioner (senior-level evidence) who builds retrieval-augmented agents and tool integrations for domain scientific data. The strongest proven skill is architecting instrumented LLM orchestration and tool execution with traces and fallbacks as implemented in two_llm/cgmengine.py and agentic/apis/noaa_apis.py. There is limited evidence of formal statistical rigor, model training pipelines, pinned reproducible environments, or extensive data-engineering (ETL) infrastructure in public code.
Statistical Rigor
2/10
Correct use of statistics
Some evaluation harness and use of automated evaluation (opik, GEval/Hallucination metrics) are present, but there is little evidence of formal statistical testing, uncertainty quantification, multiple-comparison controls, or causal analysis.
Evidence
evaluation/eval_opik.py: uses opik.evaluate and Hallucination, GEval metrics
evaluation/goldens.py: goldens creation and corpus handling
Data Wrangling & Cleaning
4/10
Preparing and cleaning data
Robust practical data handling for API-driven datasets is implemented (date parsing, geocoding, grid fetches, error returns instead of exceptions), but there is limited evidence of large-scale data engineering (ETL orchestration, provenance/versioning beyond simple file layout).
Evidence
agentic/apis/noaa_apis.py: parse_date, get_coordinates, fetch_field_data with graceful error returns
two_llm/apis/noaa_apis.py: fetch_grid_data and get_coordinates with parameter handling and API URL filtering
Exploratory Analysis & Visualization
5/10
Exploring and visualizing data
Plots and visualizations are productionized (plot, plot_many, contour_map, Streamlit rendering) and the LearningJourney notebook contains explanatory narrative; visuals are tied to concrete questions rather than purely decorative templates.
Evidence
agentic/apis/noaa_apis.py: plot tool and save_figure_to_temp
agentic/cgmwebsite.py: Streamlit UI display_agent_step and plot rendering
LearningJourney.ipynb: narrative walkthrough and RAG/plotting examples
Predictive Modeling
1/10
Building models that predict
This is an LLM/agent orchestration project rather than a predictive-model training project; no evidence of model training, hyperparameter searches, or standard supervised ML experiments is present.
Evidence
two_llm/cgmengine.py: uses Llama/Ollama and HuggingFace embeddings for inference (no training pipeline)
LearningJourney.ipynb: demonstrates retrieval and inference rather than training
Business Insight & Impact
2/10
Turning analysis into business value
The project is domain-focused (geomagnetism) and user-facing (Streamlit UI, access restrictions), but there is little documented linkage to business metrics, cost-of-error reasoning, or operational SLAs.
Evidence
README.md: describes NOAA/CIRES geomagnetic domain and intended user audience
agentic/cgmwebsite.py: access restrictions in UI (email-domain gating) and user-facing display logic
Reproducibility & Notebook Hygiene
3/10
Clean, repeatable analysis
Some reproducibility practices are present (requirements.txt, .env usage, Streamlit caching), and the notebook includes explanatory cells, but execution metadata is missing (not executed), dependency versions are not pinned, and there is no evidence of CI, DVC, or structured experiment capture beyond opik tracing.
Evidence
agentic/requirements.txt: dependency list for environment setup
LearningJourney.ipynb: narrative notebook with '# NOTEBOOK META' but exec=none
two_llm/cgmengine.py and other modules: use of dotenv and opik traces for run capture
Expertise
Analytics• Middle
Industries
Artificial Intelligence• Middle
Science & Engineering• Middle
Technologies
AI/ML
Jupyter Notebook
Matplotlib
OpenAI SDK
Llama
huggingface_hub
NumPy
Streamlit
Recommendations
- Build domain-specific RAG + tool-using assistants that need reliable tool validation, tracing, and user-facing visualizations.
- Develop production inference orchestrators with tracing and graceful fallbacks for scientific or engineering domains (LLM orchestration, tool execution, opik-style tracing).
- Prototype Streamlit / demo frontends that expose LLM reasoning steps and generated visualizations for subject-matter experts.
- Extend evaluation pipelines (opik integration) into reproducible experiment runs with versioned datasets and statistical analysis.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle Backend Developer
Confidence: High API Engineer
Backend AI engineer (middle level) focused on building LLM-driven retrieval and tool-using agents with practical orchestration and tracing. The strongest proven skill is instrumented LLM orchestration and tool execution as shown by the traced response handling and opik-based span updates in two_llm/cgmengine.py. There is limited evidence of production-grade data-schema work, migrations, explicit security best practices for secrets, or formal load/test artifacts.
API Design
3/10
How well APIs are designed
API design shows practical tool wrappers and a ReAct-style tool registry but lacks consistent error contracts, versioning, idempotency handling, or explicit API stability/version strategies.
Evidence
agentic/apis/noaa_apis.py:noaa_mag_api (tool wrapper and docstring-driven interface)
two_llm/apis/noaa_apis.py:GeomagneticAPI.fetch_field_data (direct HTTP parameter mapping to NOAA endpoints)
Data Layer & Database
3/10
Working with databases
Uses a persisted vector store and document loaders for RAG, with some care for persistence and chunking, but no relational schema design, migrations, transaction boundaries, or hand-tuned queries are present.
Evidence
two_llm/cgmengine.py:get_shared_resources (Chroma vector store creation and index persistence)
agentic/cgm.py:setup_vector_store (document loaders, splitter, and vector store population)
Scalability & Performance
2/10
Handling load and speed
Some basic scalability considerations such as caching of engine setup and vector store persistence exist, but there is no evidence of queue-based decoupling, rate limiting, connection pooling tuning, or measured performance optimizations.
Evidence
agentic/cgmwebsite.py:@st.cache_resource setup_engine (caching of expensive startup)
two_llm/cgmengine.py:get_shared_resources (checks for existing DB and avoids reindexing)
System Architecture
4/10
Overall system structure
Clear modular decomposition between agent orchestration, API tools, and a two-LLM orchestration layer with tracing and fallback flows; the design shows deliberate separation of concerns for LLM tooling but does not demonstrate multi-service contracts or hardened service boundaries for production microservices.
Evidence
two_llm/cgmengine.py:TracedResponse and ChatGeoMagiEngine (orchestration and tracing abstractions)
agentic/cgm.py:ChatGeoMagi (agent setup, tools registration and vector store responsibilities)
Security & Auth
2/10
Protecting data and access
Minimal security hygiene is present such as a URL-sanitizer for API keys, but secrets placeholders are embedded and there are insecure patterns (instructions to place API keys in source). Input validation and robust auth/token lifecycle handling are not evident.
Evidence
two_llm/apis/noaa_apis.py:GEOCODE_API_KEY, MAPBOX_API_KEY placeholders and remove_api_keys usage
agentic/apis/noaa_apis.py:remove_api_keys function and CALC_API_KEY placeholder
Reliability & Observability
5/10
Stability and monitoring
Strong observability and tracing emphasis is evident through Opik instrumentation, granular spans, and comprehensive trace finalization; reliability fallbacks exist, but systematic retry/backoff strategies and graceful shutdown patterns are limited.
Evidence
two_llm/cgmengine.py:_get_api_recommendation, _execute_tool, _finalize_trace (opik_context spans and detailed trace updates)
agentic/cgm.py:use of OpikTracer and MemorySaver for checkpointing and tracing
Expertise
Backend AI & LLM• Middle
Databases & Vector Storage• Middle
Python• Middle
Industries
Science & Engineering• Senior
Technologies
Python• Senior • 6y+
Rest API
Requests
Recommendations
- Develop LLM-based retrieval agents and domain-specific tool integrations, including instrumented tracing and fallback flows.
- Harden API tooling for production: centralize secrets to env/config, unify return types, and add input validation and structured error contracts.
- Build vector-store ingestion pipelines and offline indexing workflows for RAG systems, adding tests and migration/versioning for persisted embeddings.
- Implement resilience patterns such as retries with exponential backoff, timeouts on external calls, and end-to-end load testing for the inference path.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: