Andrei Kukunov
Data Scientist
SQL
Java
Python
JavaScript
Data Pipeline & Feature Engineering: 5/10
MLOps & Deployment: 5/10
Experimentation & Evaluation: 4/10
Active 8 days ago
+7 (910) 8800365 Invite to interview
Message
Download CVCV
Overview
Technical skills
Timeline
Career analytics
Roles
Overview
A senior-level llm-engineer specializing in building retrieval-augmented chat systems and production inference pipelines; the strongest proven skill is integrating LLM-driven agents and RAG/serving infrastructure as shown by the Telegram webhook and agent workflow plus the Streamlit RAG app and ONNX-based inference pipeline; there is limited public evidence of large-scale experiment management, custom training/optimization, or rigorous reproducibility infrastructure.
Technical skills
SQL
Java
Python
JavaScript• Middle
Python
Beautiful Soup
FastAPI
Flask
Celery
Requests
Databases
ClickHouse
FAISS
Redis
AI/ML
CatBoost
Computer Vision
Embeddings
Gradio
Hadoop
Keras
LangChain
LlamaIndex
MLFlow
NLP
NLTK
NumPy
Pandas
Phi
Prompt Engineering
RAG
Scikit-learn
SciPy
Sentence-Transformers
Spark
Streamlit
TensorBoard
TensorFlow
Time Series Forecasting
Transformers
XGBoost
OpenAI SDK
LLM
Frontend
React.js
Tailwind CSS
Zustand
Vite
autoprefixer
React Router
DevOps
Docker
Git
Rest API
Analytics
Matplotlib
Plotly
Seaborn
QA
Selenium
Timeline
Data Scientist
•
Middle
CMS Platforms (Club First, Community.tech)
•
Full-Time
Confirmed by code
80%
Worked on community analytics and retention topics, including churn and membership extension drivers and LTV analysis. Built segmentation and clustering of participants by behavioral patterns and prepared analytics reports for customers. Contributed to R&D by developing community data models, analytical and recommender algorithms, and solutions using LLMs.
LLMsince 2024
Data Scientist
•
Middle
CMS Platforms
•
Full-Time
Confirmed by code
80%
Worked on community analytics and R&D to identify drivers of churn and membership renewal, including LTV analysis. Built segmentation and clustering of members based on behavioral patterns and prepared analytical reports for customer stakeholders. Developed community data models and analytics/recommendation approaches, including solutions using large language models.
LLM
Data Science Mentor
•
Middle
SkillFactory (Skillbox Holding Limited, VK)
•
Full-Time
Partially confirmed
50%
Mentored Data Science students by supporting them in the chat, reviewing their code, and helping with assignments. Focused on improving the overall learning and customer experience. Provided guidance to help students complete tasks successfully.
Data Science Mentor
•
Middle
SkillFactory
•
Full-Time
Partially confirmed
50%
Mentored students in Data Science through chat support and helped them complete course assignments. Reviewed and analyzed student code and provided guidance to improve implementations. Contributed to improving the learning and client experience by supporting students and iterating on course materials quality.
Career analytics
Verified work history and code activity in one view - open-source impact, work rhythm, trust signals and a forecast of when this candidate is likely to move.
6
Years active
283
Commits analyzed
Work rhythm
UTC+0
12 AM6 AM12 PM6 PM12 AM
Code activity
Low
Peak
Last activity
Apr 2026 · 116 Days
Typical work hours
10 AM - 6 PM
Open source & impact
1
Stars earned
Collaboration Quality
Middle AI/ML Engineer
Confidence: High LLM Engineer
A senior-level llm-engineer specializing in building retrieval-augmented chat systems and production inference pipelines; the strongest proven skill is integrating LLM-driven agents and RAG/serving infrastructure as shown by the Telegram webhook and agent workflow plus the Streamlit RAG app and ONNX-based inference pipeline; there is limited public evidence of large-scale experiment management, custom training/optimization, or rigorous reproducibility infrastructure.
Model Architecture & Training
3/10
How well models are designed and trained
Integration-focused model work: ONNX inference and a custom classifier wrapper are present, but there is no evidence of extensive custom training loops, optimizer/scheduler design or large-scale experimental rigor.
Data Pipeline & Feature Engineering
5/10
How data is prepared for models
Clear, practical data pipelines for audio and text including denoising, silence-based segmentation, tokenization and RAG document splitting; Redis-based session/profile storage for conversational context.
Evidence
gravek/my_projects/agcalls/Dockerfiles_wo_models/api_app.py: preprocess_audio (noise reduction, silence splitting, normalization, spectrograms)
gravek/ai_mentor/app.py: load_vectorstore (Markdown splitting, RecursiveCharacterTextSplitter, FAISS.from_documents)
gravek/realty-tg-bot/api/telegram_webhook.py: Redis usage for profiles, history and caching (get_chat_history, save_chat_history)
Experimentation & Evaluation
4/10
How results are measured and tested
Basic but meaningful evaluation and experimentation artifacts: unit tests for inference, notebook metrics and visualization, and some logging; limited experiment tracking or reproducible runs.
MLOps & Deployment
5/10
How models are shipped to production
Concrete MLOps and deployment work: FastAPI + Celery async pipeline, ONNX for inference, Gradio demo and Streamlit RAG app, with logging, temp-file cleanup and API-key gating.
Evidence
gravek/my_projects/agcalls/Dockerfiles_wo_models/api_server.py: FastAPI endpoints, Celery tasks (transcribe_audio) and classify_call orchestration
gravek/my_projects/agcalls/Dockerfiles_wo_models/demo_app.py: Gradio demo wiring inference and transcription
gravek/my_projects/agcalls/Dockerfiles_wo_models/api_app.py: ONNX-based inference to serve predictions
Computational Efficiency
4/10
How efficiently computing resources are used
Some efficiency work: ONNX model usage and batching for inference, CPUExecutionProvider and batch tokenization; no evidence of quantization experiments, GPU memory profiling or distributed training optimizations.
Research Depth & Innovation
2/10
Depth of research and new ideas
Research/innovation depth is limited; the notebook contains useful applied pipelines and a custom classifier wrapper but no novel algorithms or reproduced SOTA work.
Expertise
RAG• Middle
Conversational AI & Chatbots• Middle
Audio & Speech Processing• Middle
Technologies
Python
SQL
Redis
LangChain
Hadoop
CatBoost
Spark
ClickHouse
Flask
FAISS
LlamaIndex
Sentence-Transformers
MLFlow
XGBoost
FastAPI
Embeddings
Scikit-learn
Prompt Engineering
SciPy
Beautiful Soup
Computer Vision
NLP
Gradio
OpenAI SDK
Transformers
TensorFlow
Pandas
NumPy
Keras
Git
Docker
LLM
RAG
Celery
NLTK
TensorBoard
Streamlit
Phi
Time Series Forecasting
LlamaIndex• mentioned only
Recommendations
- Develop production RAG chatbots and agent workflows that integrate retrieval, tool-calls and context caching (use the Telegram webhook + Runner/Agent pattern already present).
- Build scalable audio transcription and classification services using ONNX inference and Celery workers, improving monitoring and resource-aware batching.
- Harden ML lifecycle: add experiment tracking, reproducible training scripts, CI for model artifacts and structured evaluation pipelines.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle Backend Developer
Confidence: Medium API Engineer
Backend engineer (middle) focused on building LLM-backed chatbots and Telegram integrations for a real-estate mini-ecosystem. The strongest proven skill is integrating LLM RAG pipelines and vector search as shown by ai_mentor/app.py using FAISS and HuggingFaceEmbeddings together with agent orchestration in elaj_agent_1.py. There is limited evidence of production-grade operational hardening such as migrations, strong auth/token lifecycle, comprehensive tests or measured performance tuning.
API Design
4/10
How well APIs are designed
Practical HTTP/webhook handlers and simple API endpoints with basic error handling and CORS support, but no versioning, idempotency keys, pagination, or formal error contract.
Evidence
realty-tg-bot/api/telegram_webhook.py: webhook() endpoint with asyncio.new_event_loop() and request handling
realty-tg-bot/api/log_event.py: handler.do_POST implementing JSON request parsing, CORS preflight in do_OPTIONS and responses
realty-tg-bot/.github/scripts/handle_telegram.py: GitHub Actions webhook -> Telegram flow and OpenAI call
Data Layer & Database
4/10
Working with databases
Clear use of Redis for caching, user/profile storage and event lists with TTLs and hashes, but no relational schema, migrations, or explicit transaction/isolation handling.
Evidence
realty-tg-bot/api/telegram_webhook.py: redis_client.hgetall/hset/hmset, setex and expire usage for profile and chat history
realty-tg-bot/api/log_event.py: redis_client.rpush/hincrby/hset for events and user_stats
ai_mentor/app.py: FAISS vectorstore construction and use (vector storage evidence)
Scalability & Performance
4/10
Handling load and speed
Practical caching and batching patterns (Redis caching of image-checks, FAISS vectorstore caching, service-worker caching), and some batching for network calls, but no rate limiting, connection-pool tuning, or load testing evidence.
Evidence
realty-tg-bot/api/telegram_webhook.py: check_image_urls_batch with Redis caching and batch head requests
ai_mentor/app.py: @st.cache_resource load_vectorstore() returning FAISS.from_documents(...) and use of HuggingFaceEmbeddings
aj-realty-mini-app/public/service-worker.js: static caching strategy
System Architecture
3/10
Overall system structure
Reasonable separation of components (frontend mini-app, webhook API, agent workflow, mentoring app) showing modularity, but no explicit inter-service contracts, service discovery, or graceful degradation design.
Evidence
aj-realty-mini-app/vite.config.js and src/*: separate frontend app
realty-tg-bot/api/telegram_webhook.py and api/elaj_agent_1.py: agent orchestration and webhook glue
ai_mentor/app.py: separate RAG/mentoring Streamlit service using FAISS
Security & Auth
2/10
Protecting data and access
Some boundary checks and minimal protections exist, but security practices are limited: plaintext passwords, no formal auth on APIs, and limited input validation or secrets lifecycle handling.
Evidence
ai_mentor/app.py: authenticate_user() compares plaintext passwords stored in students.json
realty-tg-bot/api/log_event.py: accepts and stores incoming event JSON with only basic user_id presence validation
realty-tg-bot/api/telegram_webhook.py: user-provided text used directly in prompts and downstream agent calls
Reliability & Observability
3/10
Stability and monitoring
Basic observability and error handling present (logging, try/except, trace metadata for agent runs), but missing structured tracing, retry/backoff strategies, circuit breakers, metrics, and graceful shutdown for long-running services.
Evidence
realty-tg-bot/api/telegram_webhook.py: logging.basicConfig and many logger.info/print calls and try/except around message handling
elaj_agent_1.py: use of trace() and RunConfig(trace_metadata=...) when calling Runner.run
realty-tg-bot/api/log_event.py: logging via logger and explicit HTTP response helpers
Expertise
Backend AI & LLM• Middle
Databases & Vector Storage• Middle
Messaging & Real-time• Middle
Python• Middle
Industries
Artificial Intelligence• Middle
Education• Middle
Real Estate• Middle
Technologies
Python• Senior
Redis
Rest API
Flask
FAISS
Requests
Recommendations
- Develop LLM-backed chatbot features and RAG prototypes that combine FAISS vectorstores and LangChain-style orchestration.
- Implement and harden webhook-based integrations and real-time flows for messaging platforms (Telegram) with Redis-backed caching and history.
- Build small-to-medium APIs and event collectors with better security (auth, input validation) and observability (metrics, structured logs, tracing).
- Prototype educational tools or internal tools around vector search and streaming UIs using Streamlit or lightweight frontends.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle Frontend Developer
Confidence: Medium UI Engineer
Front-end UI engineer (mid-level) focused on small React-based map and Telegram WebApp interfaces. The strongest proven skill is client-side integration and state coordination, demonstrated by the user-id caching and analytics flow in src/utils/analytics.js together with the zustand store in src/store.js. Public code does not show automated tests, accessibility work on custom widgets, or advanced async-state patterns like cancellation and optimistic updates.
UI Component Architecture
3/10
How interface parts are built
Modular small-app structure with a zustand store and utility modules but no evidence of a custom component library, detailed composition patterns or component test coverage.
Responsive & Cross-browser
3/10
Works on all screens and browsers
Uses Tailwind for responsive breakpoints and supports prefers-color-scheme, but no advanced responsive techniques, container queries or explicit RTL/i18n patterns are present.
Performance Optimization
3/10
Speed of the interface
Some practical client-side caching to reduce requests (localStorage userId) and small polling windows for async readiness, but no measured perf work, bundle analysis, virtualization or advanced code-splitting strategies.
Accessibility & Semantics
2/10
Usable for everyone
Minimal accessibility evidence - page lang attribute and semantic HTML exist, but there are no ARIA patterns, keyboard/focus management for custom widgets or a11y testing scripts.
State Management & Data Flow
3/10
Managing data in the app
Reasonable server-state separation with a zustand store, error handling in data loading and a bounded polling approach to wait for Telegram userId, but lacks request cancellation, optimistic updates or more robust race-condition handling.
UX & Visual Polish
4/10
Look and feel quality
Good visual polish for a small app - theme support, custom animations and map legend styling improve perceived UI quality, though UX fallbacks and thorough empty/error states are not fully realized.
Expertise
React• Middle
PWA & Web APIs• Junior
Frontend Architecture & Build Tools• Middle
Industries
Real Estate• Middle
Technologies
JavaScript• Middle
Zustand
Tailwind CSS
React.js
Vite
React Router
autoprefixer
Recommendations
- Build small-to-medium React single-page applications that integrate mapping libraries and third-party WebApp SDKs (Telegram, Yandex Maps).
- Implement Telegram WebApp frontends or other messaging-platform embedded UIs where lightweight client-side state and telemetry are required.
- Prototype location-aware real-estate or listing MVPs combining map overlays and catalog browsing.
- Improve developer-facing infra such as test coverage, CI pipelines and accessibility audits to raise production readiness.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: