Maksim Li
AI Engineer
JavaScript
Python
SQL
Bash
C#
TypeScript
PHP
Model Architecture & Training: 6/10
MLOps & Deployment: 6/10
Computational Efficiency: 6/10
Active 12 days ago
+7 (700) 9791386 Invite to interview
Message
Download CVCV
Overview
Technical skills
Timeline
Roles
Overview
A pragmatic ML/AI engineer with multi-component experience (model serving, RAG, real-time audio/STT/TTS and web APIs) at a senior-but-practical level. The strongest proven skill is building real-time LLM + audio orchestration and memory/RAG infrastructure - evidenced by the MessageProcessor/processing.py audio/queueing logic, memory_v2.py and the FastAPI model-serving ModelManager. Missing or not evidenced are formal statistical methodology, rigorous experiment pipelines, CI-driven reproducibility (DVC/locks) and formal test coverage or A/B evaluation frameworks.
Technical skills
JavaScript
Python• Senior • 3y+
SQL• Junior • 3y+
Bash• Junior
C#• Middle
TypeScript
PHP
Python
Uvicorn
Celery
Beautiful Soup
FastAPI
Asyncio
Django
Mypy
Databases
SQLite
FAISS
Chroma
Redis
PostgreSQL• 3y+
Qdrant
MySQL
AI/ML
Fine-tuning
LangChain
LangGraph
LlamaIndex
LLM
Ollama
QLoRA
Whisper
LoRA
PEFT
Transformers
Bitsandbytes
Deep Learning
NumPy• 3y+
Pandas• 3y+
CrewAI
RAG
CatBoost
XGBoost
LightGBM
Scikit-learn
Spark
AI Agents
Claude
Model Context Protocol
Embeddings
ChatGPT
Cursor
MLFlow
PyTorch
Reranking
Prefect
Prompt Engineering
Hallucination
TensorFlow
Vertex AI
Claude Code
Copilot
DevOps
CI/CD
Docker Compose
Git
Prometheus
Cloudflare
Docker
Rest API
Azure
Kubernetes
gRPC
AWS
GCP
Vector
Jenkins
Analytics
Matplotlib
Design
Blender
QA
Playwright
Pytest
Game Dev
Unity
Frontend
React.js
Next.js
GraphQL
Headless UI
Mobile
React Native
Cybersecurity
FedRAMP
Timeline
AI & Automation Engineer
•
Middle
Freelance
•
Contractor
Developed and deployed asynchronous AI services using FastAPI to automate business processes. Designed multi-agent workflows with CrewAI for distributed analysis and reporting. Built RAG solutions using Qdrant for knowledge retrieval, and implemented resilient web parsers with Playwright and BeautifulSoup, including handling Cloudflare protections. Containerized services with Docker and deployed them on remote Linux servers.
Python
FastAPI
CrewAI
Qdrant
RAG
Playwright
Beautiful Soup
Cloudflare
Docker
Bash
Astana IT University
Master's Degree •
Software Engineering
AI & Gameplay Developer (Unity 3D / Python)
•
Middle
Barsyq Games
•
Full-Time
Implemented gameplay logic in Unity 3D using C#, including character interaction behavior and AI opponents. Integrated in-game systems with external backend APIs written in Python. Performed script profiling, improved memory usage, and fixed gameplay bugs to stabilize performance.
Unity
C#
Python
Rest API
Python Developer / Data Analyst
•
Middle
SmartRetail Systems
•
Full-Time
Built internal automation scripts to analyze marketplace sales for Kaspi.kz. Created Python ETL pipelines for exporting, cleaning, and structuring CRM and analytics data using Pandas and NumPy. Integrated CRM workflows with PostgreSQL databases and developed unit-economics calculation models and dashboards in Google Sheets.
Pythonsince 2023
Pandas
NumPy
PostgreSQL
SQL
Senior AI/ML Engineer
Confidence: Medium LLM Engineer
A practical LLM-focused engineer with production-facing experience building conversational agents, RAG memory systems and audio STT/TTS pipelines, operating at a solid mid-to-senior engineering level. The strongest proven skill is engineering LLM serving and integration (quantized model loading, PEFT/QLoRA hooks and a ModelManager) as seen in the FastAPI model manager and finetuning utilities. Missing from public artifacts are rigorous research contributions (novel architectures) and an exhaustive, reproducible experiment tracking history with complete run artifacts and baselines.
Model Architecture & Training
6/10
How well models are designed and trained
Solid engineering of model loading, quantization and fine-tuning hooks (PEFT/QLoRA/BitsAndBytes) and training callbacks; evidence of deliberate choices for dtype/quantization and generation controls.
Evidence
blender-ai-assistant/finetune.py: HuggingFaceDatasetAdapter / EarlyStoppingCallback / MetricsLoggerCallback
blender-ai-assistant/web_app_fastapi.py: ModelManager.load (BitsAndBytesConfig, quantization logic, torch.compile usage)
twaise/russian-ai-vtuber-milly/prompt.py: generate_response (vLLM vs local transformers branches)
Data Pipeline & Feature Engineering
5/10
How data is prepared for models
Reasonable data-prep and RAG ingestion pipelines plus domain knowledge ingestion; standard ETL and index-building patterns present.
Evidence
blender-ai-assistant/data_prep.py: dataset extraction/splitting and jsonl saving
blender-ai-assistant/rag_pipeline.py: RAGIndex / DocumentStore / FAISS index build and retrieval
twaise/russian-ai-vtuber-milly/memory_v2.py: semantic chunking + ChromaDB ingestion and cleanup
Experimentation & Evaluation
5/10
How results are measured and tested
Has evaluation and experiment artifacts (evaluation scripts, training metrics logging) and some plotting; reproducibility elements exist but not a full experiment tracking history.
Evidence
blender-ai-assistant/evaluate.py: evaluation harness for model answers
blender-ai-assistant/plot_training.py: plotting training metrics and LR
blender-ai-assistant/finetune.py: MetricsLoggerCallback for logging during training
MLOps & Deployment
6/10
How models are shipped to production
Clear MLOps and deployment engineering: FastAPI serving, three-tier cache, DB migrations, Celery integration, Prometheus metrics and model lifecycle management for quantized/LoRA models.
Evidence
blender-ai-assistant/web_app_fastapi.py: ThreeTierCache, init_db migrations, Celery task integration and Prometheus metrics
twaise/russian-ai-vtuber-milly/tts_server_faster.py: FastAPI endpoints for TTS streaming and health checks
twaise/russian-ai-vtuber-milly/tts_server_emotional.py: FastAPI TTS server with streaming and startup_event patterns
Computational Efficiency
6/10
How efficiently computing resources are used
Practical optimization for inference and STT/TTS: quantization (4/8-bit) options, compute dtype selection, torch.compile and int8 whisper compute; targeted GPU memory management is present.
Evidence
blender-ai-assistant/web_app_fastapi.py: ModelManager.load uses BitsAndBytesConfig, QUANT_BITS and torch.compile
twaise/russian-ai-vtuber-milly/stt_listener.py: WHISPER_COMPUTE=int8 and faster-whisper integration
twaise/russian-ai-vtuber-milly/processing.py and model.py: explicit torch.cuda.empty_cache and synchronization calls
Research Depth & Innovation
3/10
Depth of research and new ideas
Some research-minded patterns (hierarchical memory, Groq filtering, custom dataset adapter) but no novel algorithms or peer-reviewed reproductions; more applied engineering than original research.
Evidence
twaise/russian-ai-vtuber-milly/memory_v2.py: hierarchical memory design, Groq-based filtering logic
blender-ai-assistant/finetune.py: HuggingFaceDatasetAdapter and custom callbacks (EarlyStoppingCallback, MetricsLoggerCallback)
Verified artifacts
Expertise
Conversational AI & Chatbots• Middle
RAG• Middle
Audio & Speech Processing• Middle
MLOps & Model Lifecycle• Senior
Industries
Artificial Intelligence• Senior
Gaming• Middle
Media & Entertainment• Middle
Software• Middle
Technologies
SQL• Junior • 3y+
LangGraph
Rest API
LangChain
Docker Compose
Qdrant
LlamaIndex
LoRA
Fine-tuning
Beautiful Soup
Ollama
QLoRA
CI/CD
Pandas• 3y+
Git
SQLite
Docker
CrewAI
Cloudflare
LLM
RAG
Whisper
QLoRA• mentioned only
Recommendations
- Lead development of RAG-enabled conversational agents that require long-term user memory and audio integration (use memory_v2.py and the vtuber processing pipeline as foundations).
- Implement production LLM serving and inference optimization projects (quantization, batching, memory management) where the ModelManager and three-tier caching can be extended into robust APIs and autoscaling deployments.
- Build evaluation and experiment-tracking pipelines (MLflow/W&B) to make fine-tuning runs reproducible and to collect before/after efficiency metrics for quantization and torch.compile changes.
- Develop audio-first agent products requiring STT/TTS + subtitle sync and low-latency playback (extend STT listener, TTS servers and subtitle_sync for multi-device support).
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
A pragmatic ML/AI engineer with multi-component experience (model serving, RAG, real-time audio/STT/TTS and web APIs) at a senior-but-practical level. The strongest proven skill is building real-time LLM + audio orchestration and memory/RAG infrastructure - evidenced by the MessageProcessor/processing.py audio/queueing logic, memory_v2.py and the FastAPI model-serving ModelManager. Missing or not evidenced are formal statistical methodology, rigorous experiment pipelines, CI-driven reproducibility (DVC/locks) and formal test coverage or A/B evaluation frameworks.
Statistical Rigor
1/10
Correct use of statistics
Statistical analysis and hypothesis-driven rigor are effectively absent - no formal tests, uncertainty estimates, or causal analysis are present in the human-authored code.
Data Wrangling & Cleaning
6/10
Preparing and cleaning data
Strong, practical data wrangling and cleaning patterns are implemented (parsing, ingestion, duplicate checks, schema migrations and RAG data prep). There is explicit handling of duplicates, limits and cleanup in the Memory system and dedicated data-prep and RAG index building code.
Exploratory Analysis & Visualization
4/10
Exploring and visualizing data
Some tooling for plotting and evaluation exists (training plots, charts), but exploratory analysis is mostly utility-level rather than hypothesis-driven storytelling with interpretive commentary.
Predictive Modeling
6/10
Building models that predict
Substantial practical experience with model engineering is visible: model loading, quantization options, PEFT/QLoRA support, generation serving, and eval hooks. The code shows attention to GPU/quantization, stopping criteria and adapter handling for LoRA models.
Business Insight & Impact
2/10
Turning analysis into business value
Some product thinking is visible (APIs, caching tiers, attachments, chat UX and monetization flows like donations), but business-metric framing, explicit cost/benefit trade-offs or error-cost reasoning is limited.
Reproducibility & Notebook Hygiene
4/10
Clean, repeatable analysis
Reproducibility basics exist (requirements, scripted DB migrations, init_db, model-loading logic), but there is no evidence of pinned lockfiles, DVC, CI pipelines or data versioning for large artifacts.
Expertise
Streaming• Senior
Industries
Artificial Intelligence• Senior
Design & Creative• Middle
Gaming• Middle
Technologies
Deep Learning
Python• Senior • 3y+
PostgreSQL• 3y+
Redis
Chroma
FAISS
Bitsandbytes
FastAPI
PEFT
Transformers
NumPy• 3y+
Celery
Uvicorn
QLoRA• mentioned only
RAG• mentioned only
Whisper• mentioned only
Recommendations
- Ship and productionize real-time voice + LLM features - e.g., production-grade vTuber/inference service with robust metrics, backpressure and autoscaling (use the existing processing.py and web_app_fastapi.ModelManager as foundations).
- Implement end-to-end reproducibility and model-eval pipelines - add pinned environment files, CI integration, data versioning (DVC) and automated evaluation (the finetune/evaluate hooks are a good start).
- Harden RAG and memory components for scale - add batching, rate limits, instrumentation and clearer eviction policies for the chromadb-backed MemoryV2 to run reliably in production.
- Develop explicit safety and privacy controls - audit prompt templates, avoid embedding sensitive instructions in system prompts, and add logging/monitoring for safety-related model outputs.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Senior Backend Developer
Confidence: Medium API Engineer
A pragmatic backend engineer with solid end-to-end experience building LLM-backed services, real-time audio pipelines and APIs, operating at a lower-senior / strong-middle level. The strongest proven skill is building integrated LLM + RAG + runtime pipelines with memory and audio orchestration, evidenced by memory_v2.py (Chroma integration), ModelManager in web_app_fastapi.py (quantization and generation control), and processing.py (audio queue and player thread). Public code lacks formal tests, structured secrets/CI/CD evidence, and some security hardening (password hashing and trust_remote_code), which limit confidence for critical production deployments.
API Design
5/10
How well APIs are designed
API surface is well-structured with FastAPI endpoints, metrics, auth flows and file upload handlers; however there is limited evidence of API versioning, formal idempotency keys, or pagination patterns and some endpoints mix UI and backend concerns.
Evidence
blender-ai-assistant/web_app_fastapi.py: /api/send handler (full request flow, caching, attachments handling)
blender-ai-assistant/web_app_fastapi.py: /api/upload_pdf and /api/upload_blend (file sanitization and background ingestion)
blender-ai-assistant/web_app_fastapi.py: record_metrics_middleware and /metrics endpoint (consistent observability hooks)
Data Layer & Database
6/10
Working with databases
Concrete data-layer decisions are present: multi-DB support (Postgres/SQLite), dynamic migrations, parameterized queries, long-term RAG memory with Chroma and memory recall logic; transactional semantics and explicit isolation-level controls are not visible.
Evidence
blender-ai-assistant/web_app_fastapi.py: init_db() (Postgres + SQLite schema creation, ALTER TABLE migration attempts)
russian-ai-vtuber-milly/memory_v2.py: _save_memory, _is_duplicate, recall (ChromaDB usage, deduplication and cleanup)
blender-ai-assistant/web_app_fastapi.py: get_db() and message persistence (parameterized queries for both DB engines)
Scalability & Performance
6/10
Handling load and speed
Several explicit scalability and performance efforts exist: three-tier cache (L1/L2 semantic/L3 Redis), model quantization and torch.compile usage, Celery for background tasks, and audio processing threads; documented SLOs, measured load-testing, or proven cache invalidation policies are not present.
Evidence
blender-ai-assistant/web_app_fastapi.py: ThreeTierCache class (L1 local, semantic L2, Redis L3)
blender-ai-assistant/web_app_fastapi.py: ModelManager.load() (4-bit/8-bit quantization logic, torch.compile, device_map optimizations)
russian-ai-vtuber-milly/processing.py: audio player thread and queue_audio_for_playback (threaded audio pipeline, lock coordination)
System Architecture
5/10
Overall system structure
Project shows deliberate modular boundaries (API layer, model manager, retriever, memory, audio processing) and integration points (RAG, VTube Studio, STT), but it is a monolithic repo rather than a documented distributed microservice architecture and lacks explicit inter-service contracts and deployment/secret orchestration details.
Evidence
blender-ai-assistant/web_app_fastapi.py: separation of ModelManager, RAGRetriever, cache_manager and attachment_store
russian-ai-vtuber-milly/memory_v2.py and memory_rag.py: dedicated memory subsystem integrating ChromaDB
russian-ai-vtuber-milly/vtube_studio_api.py and processing.py: clearly separated runtime audio/animation integration
Security & Auth
4/10
Protecting data and access
Authentication, session management, input checks and file sanitization are implemented; there are some security weaknesses (use of sha256 for password hashing, broad excepts, trust_remote_code enabled for model loading) and no evidence of a dependency security audit or secret management integration.
Evidence
blender-ai-assistant/web_app_fastapi.py: register_post/login_post (password hashing uses hashlib.sha256, session middleware)
blender-ai-assistant/web_app_fastapi.py: api_ask (local-only restriction), api_upload_pdf (filename sanitization)
blender-ai-assistant/web_app_fastapi.py: model loading uses trust_remote_code=True in AutoModel.from_pretrained
Reliability & Observability
5/10
Stability and monitoring
There is good observability (Prometheus metrics, request latency histograms), mechanisms to cancel long-running model generations, and many defensive try/excepts; formal retry/backoff policies, structured tracing/correlation IDs, and documented alerting are not visible.
Evidence
blender-ai-assistant/web_app_fastapi.py: REQUEST_COUNT and REQUEST_LATENCY (Prometheus instrumentation) and /metrics endpoint
blender-ai-assistant/web_app_fastapi.py: cancel_flags and StopOnFlag stopping criteria for generation cancellation
russian-ai-vtuber-milly/processing.py: try/except around long-running loops and audio thread stop semantics
Expertise
Backend AI & LLM• Middle
Databases & Vector Storage• Middle
Python• Senior
Microservices & API Architecture• Middle
Messaging & Real-time• Middle
Industries
Artificial Intelligence• Middle
Gaming• Senior
Technologies
Prometheus
Recommendations
- Lead development of LLM-backed API services (FastAPI) that require RAG memory integration and model quantization tuning.
- Implement and own real-time audio/voice assistants or interactive streaming subsystems (STT/TTS pipelines, VTube integration).
- Build backend features that require Chroma/semantic vector storage and retrieval logic (memory systems, search ranking).
- Work on production hardening of ML backends: add structured logging, secret management, secure password storage, and CI/CD pipelines.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: