Asheesh Patel
MLOps Specialist
SeniorAI/ML Engineer
7years in AI/ML
4years in tech
2years leading teams
Overview
An LLM engineer (senior-level by practical system integration) focused on building agentic RAG and Text-to-SQL production pipelines with multi-tier caching and observability. The strongest proven skill is building end-to-end LLM-backed services with caching and observability, evidenced by the text_to_sql/sql_executor pipeline, tier1/tier2 cache implementations and Phoenix/Langfuse tracing integrations. There is limited evidence of custom model training, rigorous experiment tracking, or unit test coverage in public code.
Phone
Timeline
Data Scientist
·
Middle
Entirety
·
Full-Time
Built and maintained quantitative portfolio risk models including Historical Simulation, Variance-Covariance, and Monte Carlo VaR, with validation using Kupiec’s test and Basel Traffic Light. Developed backtesting and portfolio performance monitoring pipelines using 5+ years of historical data. Created an LLM-based system for financial news summarization and sentiment extraction using Groq with Llama 3.1, and deployed analytics workflows on AWS EC2 with data and outputs stored in AWS S3.
Python
LangChain
LangGraph
Groq
Llama
Langfuse
Docker
Amazon EC2
Amazon S3
Chhatrapati Shahu Ji Maharaj University (Kanpur University)
Bachelor's Degree ·
Mathematics
Projects
Developed a multi-agent investment research application using LangGraph and Groq (Llama 3.1) to produce structured research outputs. Implemented data pipelines for gathering and preparing market information, including sentiment classification and deduplication. Built a Streamlit-based full-stack interface and applied modular prompt engineering across agent workflows.
Built a GenAI tool that generates structured docstrings and project overviews for codebases from AST-based analysis. Implemented token-efficient prompting and an AST-safe insertion approach to preserve semantic equivalence across file and repository inputs. The workflow supports processing across code structures and packaged archives as well as GitHub repository inputs.
Designed a production-grade text-to-SQL system that translates natural language into read-only PostgreSQL queries using LangChain with OpenAI models. Reduced inference latency and improved cost efficiency through pipeline optimizations. Added Langfuse observability to track tokens, latency, errors, and cost, and packaged/deployed the app with Docker and a Streamlit interface.
Technical skills
Languages
2
Python
SQL
Python
4
SQLAlchemy
Requests
FastAPI
Pydantic
DevOps
6
GitHub
Git
Amazon S3
Amazon EC2
Docker
AWS
AI/ML
9
Streamlit
LangChain
Llama
LangGraph
Langfuse
LLM
Groq
Pandas
OpenAI
Other
23
Chroma
PostgreSQL
NumPy
PyTorch
Scikit-learn
AWS Lambda
Embeddings
RAG
FAISS
Pinecone
Qdrant
Hugging Face
MLFlow
SciPy
Deep Learning
Uvicorn
ETL/ELT
CI/CD
AI Agents
DVC
Machine Learning
Prompt Engineering
Function Calling
Senior AI/ML Engineer
Confidence: Medium LLM Engineer
An LLM engineer (senior-level by practical system integration) focused on building agentic RAG and Text-to-SQL production pipelines with multi-tier caching and observability. The strongest proven skill is building end-to-end LLM-backed services with caching and observability, evidenced by the text_to_sql/sql_executor pipeline, tier1/tier2 cache implementations and Phoenix/Langfuse tracing integrations. There is limited evidence of custom model training, rigorous experiment tracking, or unit test coverage in public code.
Model Architecture & Training
2/10
How well models are designed and trained
No custom model training or novel architecture; primary work is prompt engineering and using hosted LLMs/embeddings with safe-generation checks.
Evidence
Text2SQL/llm/text_to_sql.py: ChatPromptTemplate + ChatOpenAI usage and validate_sql() safety checks
assesment/backend/app/rag/vectorstore.py: get_llm() and get_embed_model() building Ollama LLM and embedding clients
Data Pipeline & Feature Engineering
4/10
How data is prepared for models
Document ingestion and chunking pipeline with contextualization and use of token-based splitting; CSV upload utilities and DB ingestion are present.
Evidence
assesment/backend/app/rag/ingest.py: _page_texts(), TokenTextSplitter, _contextualize(), ingest_file() and ingest_samples()
Text2SQL/db/csv_to_neon.py: csv-to-DB upload utilities (signatures present)
Experimentation & Evaluation
3/10
How results are measured and tested
Basic evaluation and benchmarking artifacts exist (RAG evaluation script and cache benchmarking) but no rigorous experiment tracking or ablation suites.
Evidence
assesment/backend/eval/run_ragas.py: RAGAS evaluation driver using dataset.json and run_agentic_rag()
Text2SQL/benchmark_cache.py: run_query() and summarize() for latency and cost benchmarking
MLOps & Deployment
4/10
How models are shipped to production
Concrete MLOps and deployment engineering: FastAPI endpoints, lifecycle wiring, observability integrations and a Langfuse/Phoenix client are implemented for tracing and prompts management.
Evidence
assesment/backend/app/observability/phoenix.py: init_tracing(), prompt seeding and Phoenix client integration
Text2SQL/observability/langfuse_client.py: Langfuse client-like mock and trace helpers
assesment/backend/app/main.py: FastAPI app lifecycle and startup wiring (lifespan, seed_prompts, init_db hooks)
Computational Efficiency
3/10
How efficiently computing resources are used
Practical cost/latency work through multi-tier caching (L1 memory, L2 persistent) and benchmark scripts; no GPU/batching/quantization work visible.
Evidence
Text2SQL/cache/tier2_cache.py: persistent cache implementation with hashing and save/get logic
Text2SQL/cache/tier1_cache.py: in-memory L1 cache (signatures present)
Text2SQL/benchmark_cache.py: measures latency and estimates cost savings from cache
Research Depth & Innovation
2/10
Depth of research and new ideas
Uses agentic patterns and RAG orchestration (CrewAI, LlamaIndex) but contains no novel algorithms, formal evaluation of new methods, or custom layer implementations.
Evidence
assesment/backend/app/agents/crew.py: agent construction, task orchestration and tool integration for agentic RAG
assesment/README.md: describes Agentic RAG architecture and components (documented design intent)
Expertise
AI / LLM Engineering (Agents)· Senior
RAG· Middle
Industries
Artificial Intelligence· Senior
Software· Middle
Technologies
Deep Learning
LangGraph· since 2024
DVC
LangChain· since 2022
Pinecone
FAISS
Qdrant
Groq· since 2024
MLFlow
Embeddings
Scikit-learn
Prompt Engineering
SciPy
Function Calling
AI Agents
Langfuse· since 2023
Llama· since 2023
CI/CD
NumPy
Git· since 2005
PyTorch
AWS
Docker· since 2022
RAG· since 2026
AWS Lambda
Amazon EC2· since 2022
Hugging Face
GitHub· since 2008
Amazon S3· since 2022
Machine Learning
Recommendations
- Develop production RAG and LLM orchestration systems with observability and cost-saving caches (agent orchestration, L1/L2 cache design).
- Build Streamlit or API dashboards that surface LLM traces, token usage and cache metrics for SRE and product teams.
- Implement robust CI, unit/integration tests and experiment tracking (W&B / MLflow) to make evaluation and regressions auditable.
- Extend ingestion pipelines and vectorstore connectors for larger corpora and add monitoring for data drift and retrieval quality.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Senior Data Scientist
Confidence: Medium Data Engineer
A data engineer-level developer (senior band) focused on building production-style LLM-powered Text-to-SQL and retrieval systems with caching and observability as the main strength. The strongest proven skill is building LLM integration, multi-tier caching, and observability around query execution as evidenced by Text2SQL/llm/text_to_sql.py, Text2SQL/cache/tier2_cache.py, and Text2SQL/llm/sql_executor.py. There is limited evidence of formal statistical analysis, model training pipelines, automated tests, or pinned reproducible environments in public code.
Statistical Rigor
Correct use of statistics
Not evidenced in public code
Data Wrangling & Cleaning
5/10
Preparing and cleaning data
Solid data ingestion and cleaning patterns are present for document ingestion and CSV upload, with chunking, contextualization, and persistent cache handling.
Evidence
assesment/backend/app/rag/ingest.py:ingest_file
Text2SQL/db/csv_to_neon.py:upload_all_csv
Text2SQL/cache/tier2_cache.py:save_to_cache
Exploratory Analysis & Visualization
3/10
Exploring and visualizing data
Basic, useful visualizations and UI elements exist (Streamlit dashboard, data table display, CSV download) but exploratory analysis and narrative-driven charts are minimal.
Evidence
Text2SQL/app/app.py:st.dataframe and Streamlit UI components
Text2SQL/benchmark_cache.py:summarize (printed cache metrics and latency breakdown)
Predictive Modeling
3/10
Building models that predict
There is applied engineering around LLMs, embeddings and retrieval (vectorstore, embed model, agent pipeline) but no model training workflows, hyperparameter tuning, or rigorous ML evaluation artifacts.
Evidence
assesment/backend/app/rag/vectorstore.py:get_embed_model and get_llm
assesment/backend/app/agents/crew.py:run_agentic_rag
Text2SQL/llm/text_to_sql.py:generate_sql
Business Insight & Impact
3/10
Turning analysis into business value
Work shows awareness of operational/business metrics (token cost tracking, cache hit rates, benchmark tooling) but limited evidence of translating results to business KPIs or cost-risk tradeoffs beyond cost estimation.
Evidence
Text2SQL/benchmark_cache.py:estimated no-cache cost and cost-savings prints
Text2SQL/cache/cache_metrics.py:get_metrics and hit_rate
Reproducibility & Notebook Hygiene
3/10
Clean, repeatable analysis
Some reproducibility hygiene is present (requirements, load_dotenv usage, Streamlit secrets handling), but pinned environments, CI, tests, data versioning, and deterministic seeds are missing.
Evidence
Text2SQL/llm/text_to_sql.py:load_dotenv and get_secret use
Text2SQL/app/app.py:session_state and interactive flow
Expertise
Data Science· Middle
Industries
Artificial Intelligence· Middle
Technologies
Python· since 2022 · Senior
PostgreSQL
SQLAlchemy
Pandas
LLM
Streamlit· since 2019
OpenAI
ETL/ELT
Deep Learning· mentioned only
Keras· mentioned only
TensorFlow· mentioned only
Recommendations
- Develop production LLM-backed data access APIs and services that require schema-aware SQL generation, caching and observability.
- Build ingestion and vectorization pipelines for document and knowledge-base systems, including chunking, contextualization, and persistent vector stores.
- Implement monitoring and cost-control tooling for LLM usage, such as more robust benchmark suites, alerting, and cost attribution dashboards.
- Harden reproducibility and delivery by adding tests, CI, pinned dependency files, and a data/versioning strategy (DVC or similar).
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
A practical backend API engineer (Middle) focused on LLM-driven features and query-serving pipelines with multi-tier caching as a core strength. The strongest proven skill is building a Text-to-SQL flow with multi-tier caching and observability, demonstrated by Text2SQL/llm/text_to_sql.py together with Text2SQL/llm/sql_executor.py and Text2SQL/cache/tier2_cache.py. There is limited public evidence of production-grade concerns such as migration histories, formal auth/token lifecycle handling, load testing, or advanced DB tuning.
API Design
4/10
How well APIs are designed
Practical API endpoints and streaming responses are present with reasonable request/response shaping, but versioning, formal error contract, idempotency and pagination strategies are minimal or implicit rather than explicit.
Evidence
assesment/backend/app/api/chat.py: chat_completions - FastAPI POST endpoints and StreamingResponse usage
assesment/backend/app/api/chat.py: _stream_payload and _completion_payload - response shaping for stream vs non-stream
Data Layer & Database
4/10
Working with databases
Clear database interactions and a persistent cache table are implemented with sensible JSONB storage and parameterized writes, but there is no migration history, limited transaction/isolation handling, and no explicit N+1 or index tuning evidence.
Evidence
Text2SQL/cache/tier2_cache.py: ensure_cache_table - CREATE TABLE query_cache with JSONB, and INSERT ... ON CONFLICT DO NOTHING
Text2SQL/cache/tier2_cache.py: get_cached_result/save_to_cache - use of hashed cache_key and parameterized queries
Text2SQL/llm/sql_executor.py: fetch_df and execute usage around SQL execution and caching
Scalability & Performance
5/10
Handling load and speed
Thoughtful caching strategy (L1 memory + L2 persistent) plus benchmarking and promotion logic demonstrates practical performance thinking, although there is no evidence of measured load testing, connection pooling configuration, or advanced rate limiting.
Evidence
Text2SQL/llm/sql_executor.py: L1/L2 cache lookup, promotion to L1, and cache metrics tracking
Text2SQL/cache/tier2_cache.py: persistent L2 cache design and cache key hashing
Text2SQL/benchmark_cache.py: benchmarking harness to measure L1 vs L2 latencies and estimate cost savings
System Architecture
4/10
Overall system structure
Modules are reasonably decomposed (llm, cache, db, observability, rag/ingest) and single-responsibility is visible, but there is limited evidence of multi-service contracts, config/secret orchestration across environments, or graceful degradation strategies beyond basic fallbacks.
Evidence
Text2SQL/llm/text_to_sql.py: separation of SQL generation, cleaning, validation and observability traces
assesment/backend/app/rag/ingest.py: ingestion pipeline separated into page extraction, contextualization, embedding and index insertion
Security & Auth
4/10
Protecting data and access
There are explicit safety checks (SELECT-only validation) and secret retrieval fallbacks, indicating some security awareness, but no end-to-end authn/authz, token lifecycle, or dependency-audit evidence beyond basic environment secret handling.
Evidence
Text2SQL/llm/text_to_sql.py: validate_sql - enforces SELECT-only and blocks forbidden DDL/DML keywords
Text2SQL/llm/text_to_sql.py: get_secret - reads from Streamlit secrets and environment as a fallback
Reliability & Observability
5/10
Stability and monitoring
Good observability is implemented with tracing spans, error reporting and flush semantics (Langfuse/Phoenix hooks), and the code contains explicit tracing around generation and execution, though circuit breakers, retries with backoff and structured alerting are not present.
Evidence
Text2SQL/llm/text_to_sql.py: langfuse.start_trace, generation.update/end and langfuse.flush
Text2SQL/llm/sql_executor.py: trace.start_span for sql-execution with error reporting and flush
assesment/backend/app/observability/phoenix.py: init_tracing and seed_prompts wiring for Phoenix collector
Expertise
Backend AI & LLM· Middle
Databases & Vector Storage· Middle
Python· Middle
Microservices & API Architecture· Middle
Technologies
FastAPI
Pydantic
Uvicorn
Requests
Rust· mentioned only
Recommendations
- Develop LLM-backed query features and RAG ingestion pipelines that need schema-aware SQL generation and multi-tier caching.
- Integrate and harden vector storage and embedding pipelines (PGVector/PGVectorStore) for scalable semantic search.
- Implement production hardening tasks such as DB migrations, connection pooling, rate limiting and load testing.
- Add automated tests and CI for critical flows, and expand observability to include metrics/alerts and retry/backoff policies.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Job preferences
- Work permits
- India
- Citizenship
- India
- Employment type
- Full-Time
- Locations
- New Delhi, Noida, Gurgaon, Lucknow, Hyderabad, Pune
Open to AI agents: they read this profile and start a dialog through Alion
alion.io/@asheesh-patel/mcpAlion · People, companies and AI agents in one graphalion.io/@asheesh-patel