Artem Krivenkov
ML Engineer
Node JS
Python
Model Architecture & Training: 5/10
Data Pipeline & Feature Engineering: 5/10
Experimentation & Evaluation: 5/10
Active 14 days ago
+7 (905) 3221017 Invite to interview
Message
Download CVCV
Overview
Technical skills
Timeline
Roles
Overview
A practical LLM engineer who designs and implements end-to-end RAG, agentic workflows and adapter-based fine-tuning pipelines at a senior level. The strongest proven skill is building production-shaped LLM systems and pipelines, demonstrated by the RAG pipeline, agent executor, vector-store adapters and the PEFT training/inference runners (e.g., training.train, rag.pipeline, agent executor and vector_store/Qdrant adapters). There is limited evidence of novel research contributions or low-level efficiency engineering such as custom CUDA/Triton kernels or peer-reviewed paper reproductions in public code.
Technical skills
Node JS• Senior
Python• Senior
Python
FastAPI
Asyncio
Pydantic
Databases
Qdrant
RabbitMQ
PostgreSQL
AI/ML
ChatGPT
LangChain
LLM
NumPy
OpenCV
Pandas
SciPy
YOLO
TensorFlow
PyTorch
PEFT
Bitsandbytes
OpenAI SDK
Embeddings
Fine-tuning
CNN
Computer Vision
Keras
NLP
OpenRouter
Transformers
DevOps
Git
Analytics
Matplotlib
Timeline
ML Engineer
•
Middle
The Founder Academy
•
Full-Time
Participated in applied tasks at the intersection of Python, AI tools, and digital products. Applied knowledge from data science, neural networks, chatbots, and pretrained models to solve practical problems. Prepared materials and solutions for demonstrations and organized results for team sharing and review.
Python
Saratov State University
Master's Degree •
Mathematical support and administration of information systems
Python Developer (Internship)
•
Junior
Aston
•
Internship
Completed an internship focused on practical Python development. Worked on core language concepts including functions, modules, OOP, exception handling, and integration of code into working solutions. Implemented training and practical tasks by translating requirements into functioning implementations and addressing feedback within a team workflow.
Pythonsince 2024
Senior AI/ML Engineer
Confidence: Medium LLM Engineer
A practical LLM engineer who designs and implements end-to-end RAG, agentic workflows and adapter-based fine-tuning pipelines at a senior level. The strongest proven skill is building production-shaped LLM systems and pipelines, demonstrated by the RAG pipeline, agent executor, vector-store adapters and the PEFT training/inference runners (e.g., training.train, rag.pipeline, agent executor and vector_store/Qdrant adapters). There is limited evidence of novel research contributions or low-level efficiency engineering such as custom CUDA/Triton kernels or peer-reviewed paper reproductions in public code.
Model Architecture & Training
5/10
How well models are designed and trained
Practical, production-aware LLM training and adapter handling with PEFT/quantization support and a real training entrypoint; not cutting-edge research but solid applied model engineering.
Evidence
llm-finetuning-inference-lab/lab/training/train.py: _train_with_peft uses AutoModelForCausalLM, BitsAndBytesConfig, prepare_model_for_kbit_training, get_peft_model and a Trainer-based training loop
llm-finetuning-inference-lab/lab/training/config.py: LoraConfigPlan and quantization argument handling
Data Pipeline & Feature Engineering
5/10
How data is prepared for models
Well-structured data ingestion and chunking pipeline with parsers, deterministic chunk hashing and vectorization, plus event-driven ingestion adapters for robust pipelines.
Evidence
agentic-rag-platform/app/rag/chunker.py: TextChunker.chunk_documents and chunking logic
agentic-rag-platform/app/rag/parser.py: parse_text_folder and multiple file parsers
event-driven-ai-platform/ai_platform/vector/qdrant.py: QdrantDocumentIndexer hashing_vector and deterministic vector logic
Experimentation & Evaluation
5/10
How results are measured and tested
Clear evaluation and metric collection pipelines with a runnable evaluation CLI, metric implementations and CI-friendly mock evaluation/reporting.
Evidence
agentic-rag-platform/app/evaluation/runner.py: run_evaluation orchestration and summary generation
llm-finetuning-inference-lab/lab/evaluation/report.py: build_report and mock evaluation/reporting logic
MLOps & Deployment
5/10
How models are shipped to production
Production-oriented service wiring and adapters - FastAPI endpoints, outbox pattern with transactional Postgres adapter, RabbitMQ and Qdrant integration, and adapter-based inference serving.
Evidence
event-driven-ai-platform/ai_platform/runtime/production.py: ProductionIngestionPipeline wiring repository, broker, indexer and dispatch semantics
agentic-rag-platform/app/main.py and app/api/routes.py: FastAPI-based service surface and route definitions
llm-finetuning-inference-lab/lab/inference/api.py: Adapter-based inference endpoint supporting mock/real generator
Computational Efficiency
5/10
How efficiently computing resources are used
Deliberate efficiency work around quantized training/inference and VRAM checks, plus training-mode flags for 4bit/8bit handling; practical optimizations rather than low-level kernel work.
Evidence
llm-finetuning-inference-lab/lab/training/train.py: BitsAndBytesConfig and conditional quantization for 4bit/8bit
llm-finetuning-inference-lab/lab/inference/generate.py: current_vram_mb and generation paths with quantization-aware model loading
Research Depth & Innovation
3/10
Depth of research and new ideas
Evidence of thoughtful system design (agent planner, RAG loop, outbox), but no novel algorithms, custom layers or peer-reviewed research replication present.
Evidence
agentic-rag-platform/app/agents/planner.py: LLMPlanner and fallback planning with JSON extraction
agentic-rag-platform/app/agents/executor.py: AgentExecutor implementing planning, tool execution and recovery steps
Expertise
AI Agents & Agentic Workflows• Senior
RAG• Senior
MLOps & Model Lifecycle• Senior
Industries
Artificial Intelligence• Senior
Technologies
LangChain
ChatGPT
OpenCV
Qdrant
YOLO
SciPy
Computer Vision
NLP
TensorFlow
Pandas
NumPy
Keras
Git
PyTorch
CNN
OpenRouter
Embeddings• mentioned only
Fine-tuning• mentioned only
LLM• mentioned only
LoRA• mentioned only
PostgreSQL• mentioned only
QLoRA• mentioned only
RabbitMQ• mentioned only
RAG• mentioned only
Recommendations
- Lead development of production RAG/agent systems - ingestion, vector-store adapters, planner and execution loop.
- Implement and maintain fine-tuning/adapter pipelines with PEFT and quantization-aware training for adapter releases.
- Build and extend event-driven ingestion and outbox integrations for reliable, idempotent document indexing and processing.
- Own evaluation tooling and CI-friendly mock/real evaluation flows to measure retrieval, grounding and agent metrics.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Senior Data Scientist
Confidence: High Data Engineer
A production-minded backend engineer working at the intersection of LLMs and retrieval systems at a senior (early) level. The strongest proven skill is building RAG and agent-style retrieval pipelines with concrete artifacts in the RagPipeline, VectorStore implementations, and AgentExecutor that wire chunking, embedding, retrieval, reranking, and LLM providers. What is not evidenced are extensive statistical analyses or business-metric driven evaluation - there are basic metrics and mock cost outputs but no deep causal/statistical work or explicit product impact analysis.
Statistical Rigor
2/10
Correct use of statistics
Basic retrieval evaluation metrics are implemented, but there is no sign of statistical hypothesis testing, uncertainty quantification, multiple-comparison corrections, or causal analysis.
Evidence
app/evaluation/retrieval_metrics.py: hit_rate_at_k, mean_reciprocal_rank, precision_at_k
app/evaluation/agent_metrics.py: tool_selection_accuracy, latency_summary
Data Wrangling & Cleaning
6/10
Preparing and cleaning data
Strong evidence of production-minded ingestion and cleaning: parser, chunker, and pipeline layers handle document parsing, chunking, embedding, and upsert into a vector store with metadata filtering and validation.
Evidence
app/rag/parser.py: parse_text_folder, _parse_csv, _parse_pdf, _parse_docx
app/rag/chunker.py: TextChunker.chunk_document and chunk_documents (overlap/ids)
app/rag/pipeline.py: ingest_documents wiring chunker -> embedder -> vector_store.upsert
Exploratory Analysis & Visualization
Exploring and visualizing data
Not evidenced in public code
Predictive Modeling
5/10
Building models that predict
Concrete model training and inference scaffolding exists (PEFT/LoRA flow, transformer usage, quantization args, adapter inference), but there is limited evidence of experimental design, advanced model evaluation, hyperparameter tuning automation, or calibration/error-analysis beyond basic metrics.
Evidence
llm-finetuning-inference-lab/lab/training/train.py: _train_with_peft integrates AutoModelForCausalLM, BitsAndBytesConfig, PEFT LoraConfig and Trainer
llm-finetuning-inference-lab/lab/inference/generate.py: AdapterGenerator.load and generate using AutoTokenizer/AutoModel and optional PeftModel
Business Insight & Impact
2/10
Turning analysis into business value
Some evaluation outputs and cost placeholders exist, but there's little evidence of business-metric framing, cost-of-error analysis, or actionable recommendations tying model outputs to product KPIs.
Evidence
llm-finetuning-inference-lab/lab/evaluation/report.py: build_report emits mock cost and quality summaries
app/evaluation/runner.py: run_evaluation returns hit/mrr/precision and latency summaries but without business-impact interpretation
Reproducibility & Notebook Hygiene
5/10
Clean, repeatable analysis
Good reproducibility practices in code: deterministic dataset splits, seed usage, dry-run mode, tests covering core components, and explicit config-to-json helpers; missing pinned environment files or data versioning in the analyzed files.
Evidence
llm-finetuning-inference-lab/lab/training/train.py: seed usage, dry-run path, config_to_json and deterministic split
tests/test_training_runner.py and multiple tests under tests/ validating chunker, pipeline, factory, and evaluation runner
Technologies
Python• Senior
Bitsandbytes
FastAPI
Fine-tuning
Embeddings
Matplotlib
OpenAI SDK
PEFT
Transformers
LLM
Pydantic
LoRA• mentioned only
Qdrant• mentioned only
QLoRA• mentioned only
RAG• mentioned only
Reranking• mentioned only
Recommendations
- Develop production RAG backends and agent runtimes that integrate vector stores, rerankers, and LLM provider abstractions (use the RagPipeline, VectorStore, AgentExecutor patterns).
- Build fine-tuning and adapter training pipelines (PEFT/LoRA) with reproducible CI and benchmarking for inference (extend lab/training and lab/inference scaffolding).
- Implement robust evaluation dashboards and experiment tracking that translate retrieval/model metrics into business KPIs and include uncertainty quantification and statistical tests.
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 strong backend engineer with production-oriented patterns focused on API-driven AI systems, operating at a lower senior level. The most proven skill is building RAG/agent backends and integration adapters, demonstrated by the planner/executor pipeline and provider/vector-store adapters (for example the planner, AgentExecutor and vector_store implementations). There is limited public evidence of large-scale operationalization such as metrics/alerting, rate limiting, schema migration history or measurable performance tuning.
API Design
6/10
How well APIs are designed
APIs are well-structured with FastAPI routes, an API-key gate and test coverage, but lack explicit versioning, pagination conventions and a documented error contract across services.
Evidence
agentic-rag-platform/app/api/routes.py
agentic-rag-platform/app/api/auth.py
agentic-rag-platform/tests/test_api.py
Data Layer & Database
7/10
Working with databases
Concrete data-layer design with an outbox+job transactional insert, explicit idempotency handling, and pluggable vector store backends; shows awareness of schema concerns and indexable payloads.
Evidence
event-driven-ai-platform/ai_platform/storage/postgres.py
agentic-rag-platform/app/rag/vector_store.py
agentic-rag-platform/app/rag/pipeline.py
Scalability & Performance
6/10
Handling load and speed
Scalability patterns are present - outbox pattern for asynchronous durability, async I/O and retry/backoff logic for provider calls - but there is limited evidence of measured load testing, caching invalidation, or global rate-limiting policies.
Evidence
event-driven-ai-platform/ai_platform/runtime/production.py
browser-ai-agent/src/server/llm/OpenAIProvider.js
agentic-rag-platform/app/rag/vector_store.py
System Architecture
6/10
Overall system structure
Clear modular architecture with separations for planner, executor, pipeline, provider adapters and production adapters; service boundaries, interfaces and factory wiring are explicit and reusable.
Evidence
agentic-rag-platform/app/factory.py
agentic-rag-platform/app/agents/planner.py
agentic-rag-platform/app/rag/pipeline.py
Security & Auth
4/10
Protecting data and access
Basic auth and input validation are present (API key, pydantic schemas) and providers normalize errors, but there is no evidence of token lifecycle management, secrets rotation, or security hardened input sanitization across all boundaries.
Evidence
agentic-rag-platform/app/api/auth.py
agentic-rag-platform/app/api/schemas.py
browser-ai-agent/src/server/llm/OpenAIProvider.js
Reliability & Observability
5/10
Stability and monitoring
Reliability practices appear: retries/backoff, dead-letter handling in worker tests, idempotency and transactional outbox, and async patterns; limited evidence for structured logs, metrics or alerting configuration.
Evidence
browser-ai-agent/src/server/llm/OpenAIProvider.js
event-driven-ai-platform/ai_platform/storage/postgres.py
event-driven-ai-platform/tests/test_workers.py
Expertise
Backend AI & LLM• Middle
Databases & Vector Storage• Middle
Messaging & Real-time• Middle
Microservices & API Architecture• Middle
Python• Middle
Industries
Artificial Intelligence• Middle
Technologies
Node JS• Senior
PostgreSQL
RabbitMQ
Asyncio
Qdrant• mentioned only
Recommendations
- Develop production RAG/agent backends and provider adapters (LLM abstraction, rerankers, vector-store integration).
- Implement event-driven ingestion pipelines with durable outbox, idempotency and async workers (Postgres outbox, RabbitMQ, worker DLQ).
- Build browser-automation agent features and tooling (Playwright controller, compact observation and security policy integration).
- Own medium-scale API services and their integration tests, focusing next on observability (structured logs, metrics) and documented error contracts.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: