Danil Alekseev
ML Engineer
9+ years exp
4+ years ML exp
TypeScript
SQL
Python
C++
JavaScript
Bash
Invite to interview
Download CVCV
Overview
Technical skills
Projects
Timeline
Roles
Overview
A practical LLM/RAG-focused engineer at a middle level who produces reliable integration code and ingestion tooling. The strongest proven skill is building RAG ingestion and runtime glue - evidenced by the indexer and embedding-fallback logic in lightrag-kb/index_docs.py. There is little public evidence of custom model training, research depth, performance engineering, or production-grade monitoring in the human-authored artifacts.
Phone
Technical skills
Languages
6
TypeScript
SQL
Python
C++
JavaScript
Bash
Python
4
FastAPI
Requests
Asyncio
SQLAlchemy
Databases
4
MySQL
PostgreSQL
pgvector
MinIO
AI/ML
22
LightFM
QLoRA
Qwen
Whisper
CUDA Toolkit
vLLM
Airflow
Computer Vision
GGUF
LLM
OpenAI SDK
NumPy
CrewAI
Gemini
LangGraph
LoRA
Unsloth
LangChain
Transformers
NLP
OpenCV
PyTorch
DevOps
3
Docker
CI/CD
Gitea
Other
20
aiogram
Alembic
Qdrant
ClickHouse
ControlNet
Gradio
MediaPipe
PEFT
SDXL
Stable Diffusion
SQLite
Git
Rest API
AI Agents
llama.cpp
RAG
Embeddings
AI/ML
Fine-tuning
Google ADK
Projects
- Backend in Python/FastAPI: layered architecture (routes → services → adapters), task dispatching, PostgreSQL with pgvector, Alembic migrations
- Integrated 6+ ML services under one contract: OCR/cover scanning (Scanfinity → Orthocover), image captioning (Pictograph), speech transcription (SpeechText, Whisper), automated bibliographic record generation (RusMARC, Qwen-RusMARC on a custom LLM pipeline over llama-server) - Frontend in React/TypeScript: operator workstations — a step-by-step document processing card, a request registry, USB camera capture (Canon EOS + gphoto2) for digitizing books
- Auth: phone-verification SSO (call-based confirmation via a separate service), JWT
- Pipelines: chained multi-service workflows (e.g. transcription → LLM summarization)
- Process: maintain documentation as the source of truth — epics, ADRs, release notes, a spec methodology
- DevOps: docker-compose deployment, image delivery to production servers, DB migrations
In short — designed and shipped a production system for digitizing library/archive holdings: from photographing a book to a finished bibliographic record, orchestrating multiple ML models along the way.
Python
TypeScript
SQL
Bash
Timeline
ML Engineer
•
Middle
ITGS Region
•
Full-Time
Fine-tuned an LLM (Qwen) using QLoRA and built an end-to-end MLOps workflow from dataset creation and training to deployment. Designed production ML services for OCR, document/ID processing, transcription, and contact verification, including monitoring and auditing. Implemented RAG in production using pgvector with hybrid retrieval and automated the service lifecycle with containerization and CI/CD.
Qwen
QLoRA
PostgreSQL
MinIO
FastAPI
TypeScript
Docker
CUDA Toolkit
pgvector
vLLM
Whisper
GGUF
CI/CD
Gitea
Data Analyst
•
Middle
ITGS Region
•
Full-Time
Developed and supported data pipelines (ETL/ELT) in Apache Airflow, integrating MySQL and external REST sources. Built analytical dashboards with drill-down, row-level security, anomaly detection, and threshold-based alerts. Designed SQL queries and stored procedures to create reporting/OLAP data marts and improved performance of dataset retrieval.
Airflow
MySQL
SQL
ML Engineer (Computer Vision / ML)
•
Middle
Yasno Restaurants
•
Full-Time
Implemented an exit monitoring system by combining periodic camera capture, zone segmentation, and object detection to find blocked evacuation exits. Triggered automated email alerts to security and management after repeated violations. Developed a menu recommendation feature using collaborative filtering and LightFM and evaluated recommendation quality using hit@3.
LightFM
Computer Vision
System Administrator
•
Middle
Yasno Restaurants
•
Full-Time
Administered and automated IT infrastructure, including a fleet of 200+ PCs, servers, and VDS environments. Managed and maintained a MySQL server and supported IP telephony and electronic document workflow systems. Automated internal processes, performed expense analysis, and implemented a cloud file-sharing solution.
MySQL
Junior AI/ML Engineer
Confidence: Medium LLM Engineer
A practical LLM/RAG-focused engineer at a middle level who produces reliable integration code and ingestion tooling. The strongest proven skill is building RAG ingestion and runtime glue - evidenced by the indexer and embedding-fallback logic in lightrag-kb/index_docs.py. There is little public evidence of custom model training, research depth, performance engineering, or production-grade monitoring in the human-authored artifacts.
Model Architecture & Training
1/10
How well models are designed and trained
Minimal evidence of model architecture or training work in the HUMAN-AUTHORED files - only LLM/RAG integration points and embedding calls are present, no custom model code or training loops.
Evidence
lightrag-kb/index_docs.py:_safe_bge_embed
lightrag-kb/index_docs.py:LightRAG(..., llm_model_func=openai_complete)
Data Pipeline & Feature Engineering
3/10
How data is prepared for models
Clear document ingestion and preprocessing pipeline for a RAG indexer - file collection, skip rules, padding to handle embedding edge-cases and memory collection are implemented.
Evidence
lightrag-kb/index_docs.py:collect_project
lightrag-kb/index_docs.py:collect_memory
lightrag-kb/index_docs.py:_pad_for_bge
Experimentation & Evaluation
1/10
How results are measured and tested
Very light experimentation / evaluation artifacts - no experiment tracking, metrics or reproducible experiment harness in the HUMAN-AUTHORED files.
Evidence
lightrag-kb/index_docs.py:LightRAG initialization (llm_model_kwargs) - integration only
MLOps & Deployment
3/10
How models are shipped to production
Basic MLOps and deployment engineering for a knowledge-base service - startup/initialization of LightRAG storages and an MCP tool endpoint are present with sensible error handling.
Evidence
lightrag-kb/index_docs.py:await rag.initialize_storages() / await rag.ainsert(...)
lightrag-kb/mcp_server.py:search_knowledge_base (FastMCP tool wrapper)
Computational Efficiency
1/10
How efficiently computing resources are used
Little to no evidence of computational efficiency engineering (GPU/batching/quantization) within the HUMAN-AUTHORED files; only simple padding/fallback to avoid an embedding bug.
Evidence
lightrag-kb/index_docs.py:_safe_bge_embed (padding and NaN fallback)
Research Depth & Innovation
1/10
Depth of research and new ideas
No substantive research-depth artifacts (no paper implementations, ablations or custom layers) in the HUMAN-AUTHORED files.
Evidence
lightrag-kb/index_docs.py uses LLM embedder and ainsert but contains no custom model/research implementations
Expertise
RAG• Junior
LLM• Junior
Industries
Artificial Intelligence• Junior
Health Care• Junior
Technologies
SQL• since 2023
C++
MySQL• since 2017
PostgreSQL• since 2024
LangGraph
Rest API• since 2026
LangChain
llama.cpp
Qwen• since 2024
LightFM• since 2022
Airflow• since 2023
ClickHouse• since 2026
pgvector• since 2024
OpenCV• since 2026
Qdrant
Stable Diffusion
LoRA
SQLAlchemy• since 2026
vLLM• since 2024
CUDA Toolkit• since 2024
MinIO• since 2024
FastAPI• since 2024
Fine-tuning
Computer Vision• since 2022
AI Agents
NLP• since 2024
ControlNet
GGUF• since 2024
Gradio
PEFT
QLoRA• since 2024
SDXL
Unsloth
CI/CD• since 2024
Transformers
Git• since 2026
SQLite
PyTorch• since 2026
Docker• since 2024
CrewAI
Gemini
LLM
RAG
MediaPipe
Whisper• since 2024
Google ADK
aiogram
Gitea• since 2024
Claude• mentioned only
Claude Code• mentioned only
ControlNet• mentioned only
MediaPipe• mentioned only
Ollama• mentioned only
SDXL• mentioned only
Recommendations
- Develop RAG-powered knowledge-base services and tools (indexers, embedding pipelines, ingestion connectors) that integrate local and remote LLMs.
- Build and harden LLM tooling and API wrappers (MCP/agent tools, robust embedding fallbacks, error handling) for internal developer platforms.
- Prototype safe, privacy-conscious LLM integrations (on-prem embeddings, local LLM bindings) and productionize them with storage initialization and simple operational scripts.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Junior Data Scientist
Confidence: Medium Data Engineer
A pragmatic data-engineer-level practitioner who builds tooling for RAG indexing and agent integration. The strongest proven skill is document ingestion and embedding-safe indexing with concrete fallback handling and workspace initialization (lightrag-kb/index_docs.py). There is little or no evidence of statistical analysis, predictive-model engineering, production-grade distributed pipelines, testing, or dataset/versioning in the authored code.
Statistical Rigor
Correct use of statistics
Not evidenced in public code
Data Wrangling & Cleaning
4/10
Preparing and cleaning data
Clear ETL-style document collection and sanitization logic, file filtering and robust embedding fallback handling for a RAG indexer; demonstrates practical data-wrangling and ingestion work.
Evidence
lightrag-kb/index_docs.py:collect_project
lightrag-kb/index_docs.py:_pad_for_bge
lightrag-kb/index_docs.py:_safe_bge_embed
Exploratory Analysis & Visualization
Exploring and visualizing data
Not evidenced in public code
Predictive Modeling
Building models that predict
Not evidenced in public code
Business Insight & Impact
1/10
Turning analysis into business value
Minimal product/business reasoning - integration choices (MCP tool, query modes) show product-awareness but there is no cost-of-error reasoning or linkage to business metrics.
Evidence
lightrag-kb/mcp_server.py:search_knowledge_base
lightrag-kb/questions_rag.py:query
Reproducibility & Notebook Hygiene
3/10
Clean, repeatable analysis
Basic reproducibility and hygiene: explicit working directory, environment-driven config, async entrypoint and try/finally cleanup; however no pinned environment files, CI, tests, or data versioning were found in the human-authored code.
Evidence
lightrag-kb/index_docs.py:WORKING_DIR and main (uses await rag.finalize_storages in finally)
lightrag-kb/questions_rag.py:query (structured error handling for connection and HTTP errors)
Expertise
Data Science• Junior
Industries
Artificial Intelligence• Junior
Technologies
AI/ML
Embeddings
OpenAI SDK
NumPy
Claude• mentioned only
Claude Code• mentioned only
ControlNet• mentioned only
MediaPipe• mentioned only
Ollama• mentioned only
RAG• mentioned only
SDXL• mentioned only
Recommendations
- Harden production readiness: add pinned environment file (requirements/poetry), CI checks, unit/integration tests and a reproducible runbook for indexing jobs.
- Add observability and metrics to the indexing and MCP server (timings, failure counts, embedding success rates) and implement retry/backoff around remote LLM/embedding calls.
- Expand reproducibility and data governance: add explicit data/versioning (DVC or storage metadata), provenance for indexed documents, and validation steps to detect drift/duplicate content.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Junior Backend Developer
Confidence: Medium API Engineer
A practical backend API/tooling developer at a solid junior-to-middle level who builds ingestion and adapter utilities for LLM/RAG stacks. The strongest proven skill is building robust document ingestion and RAG wiring, demonstrated by index_docs.py's async ingestion flow and the _safe_bge_embed fallback for Ollama NaN issues. There is little public evidence of ops-grade system design, data migrations, production observability or production-grade security practices.
API Design
3/10
How well APIs are designed
Basic, pragmatic API tooling and error handling for a local RAG service and an MCP tool; lacks formal versioning, idempotency or pagination contracts.
Evidence
lightrag-kb/mcp_server.py: search_knowledge_base - MCP tool wrapper that POSTs to /query and returns JSON with try/except and timeout
lightrag-kb/questions_rag.py: query - CLI client using requests.post with timeout and HTTP error handling
Data Layer & Database
1/10
Working with databases
Minimal data-layer work - uses LightRAG storage initialization and works with file-based content; no migrations, DB transactions, or tuning present.
Evidence
lightrag-kb/index_docs.py: LightRAG(...) initialization with working_dir and storage setup
lightrag-kb/index_docs.py: collect_project - file scanning, reading and basic filtering for ingestion
Scalability & Performance
2/10
Handling load and speed
Some operational concerns addressed (timeouts, async ingestion, fallback embeddings) but no caching, queuing, or explicit scalability architecture.
Evidence
lightrag-kb/index_docs.py: asyncio-based main() and LightRAG configured with timeouts and llm_model_max_async
lightrag-kb/questions_rag.py: requests.post with timeout and explicit exception handling
System Architecture
3/10
Overall system structure
Clear modular tooling for document collection and a separate MCP adapter - reasonable module boundaries for a small utility service but not a multi-service production architecture.
Evidence
lightrag-kb/index_docs.py: collect_project, collect_memory and an async main() that orchestrates LightRAG ingestion
lightrag-kb/mcp_server.py: separate MCP adapter exposing search_knowledge_base
Security & Auth
1/10
Protecting data and access
Very limited security posture - runtime secrets read from env with default placeholders and no secret management or auth flow for the local LLM/API.
Evidence
lightrag-kb/index_docs.py: llm_model_kwargs uses os.getenv('LLM_BINDING_API_KEY', 'no-key') without secret handling
lightrag-kb/mcp_server.py: direct HTTP call to LIGHTRAG_URL without authentication
Reliability & Observability
3/10
Stability and monitoring
Practical reliability patterns visible - timeouts, try/finally, and a concrete fallback for a broken embedding model - but limited observability and no metrics/structured tracing.
Evidence
lightrag-kb/index_docs.py: _safe_bge_embed handles Ollama NaN bug with a normalized fallback vector and exception handling
lightrag-kb/index_docs.py: try/finally around rag.ainsert with await rag.finalize_storages()
Expertise
Backend AI & LLM• Junior
Python• Junior
Microservices & API Architecture• Junior
Industries
Health Care• Junior
Technologies
Python• Junior
Asyncio
Requests
Recommendations
- Develop RAG ingestion and retrieval APIs - document ingestion pipelines, embedding resilience, and retry/timeouts (extend the index_docs.py pattern into a reusable service).
- Implement small production-safe wrappers for LLM endpoints - add authentication, structured logging, metrics and graceful shutdown to the MCP adapter (lightrag-kb/mcp_server.py).
- Build tooling for embedding quality and monitoring - automatic validation, batching, backoff and alerts around the _safe_bge_embed path and LLM latency/failure modes.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: