Maksim Kunitsyn

AI/ML • Middle
Python
Data Pipeline & Feature Engineering: 4/10
Active 9 days ago
Invite to interview
Message
Download CVCV
Overview
Technical skills
Roles

Overview

Data engineer at a Middle level specializing in building LLM-powered RAG and batch text-processing systems. The strongest proven skill is implementing retrieval and vector-search pipelines using FAISS and HuggingFace embeddings as implemented in app/services/rag_service.py and related vectorstore initialization code. Not evidenced are model training workflows, rigorous statistical evaluation, automated tests or mature production-grade security and secrets handling.

Technical skills

Python• Middle
Python
FastAPI
Pydantic
Uvicorn
Requests
Databases
FAISS
AI/ML
Gradio
LangChain
huggingface_hub
OpenAI SDK
Pandas
RAG
Groq
Middle AI/ML Engineer Confidence: Medium LLM Engineer
LLM engineer (Middle) focused on building retrieval-augmented generation and lightweight multi-agent LLM prototypes. The strongest proven skill is retrieval engineering and integration of embeddings + FAISS for RAG workflows, as shown by the RAGService and _build_vectorstore implementations using RecursiveCharacterTextSplitter and FAISS.from_documents. There is little evidence of custom model training, formal evaluation pipelines, extensive test coverage, or production-grade MLOps and monitoring.
Model Architecture & Training
1/10
How well models are designed and trained
Minimal model architecture or training work; primarily calls hosted LLM APIs without custom layers, training loops, or optimizer/schedule design.
Evidence
llm-customer-analyzer/app/services/llm_batch_analyzer.py: client.chat.completions.create usage with OpenAI
rag-company-faq/app/services/rag_service.py: Groq client.chat.completions.create usage (llama-3.3-70b)
Data Pipeline & Feature Engineering
4/10
How data is prepared for models
Clear data preparation and retrieval engineering: document splitting, chunking and vectorstore construction plus CSV/Excel ingestion and batch processing.
Evidence
company-multi-agent-assistant/tools/retriever_tool.py: initialize_rag uses RecursiveCharacterTextSplitter and FAISS.from_texts
llm-customer-analyzer/app/services/llm_batch_analyzer.py: CSV/Excel reading and process_batch converting dataframe to records
rag-company-faq/app/services/rag_service.py: _build_vectorstore uses RecursiveCharacterTextSplitter.create_documents and FAISS.from_documents
Experimentation & Evaluation
2/10
How results are measured and tested
Basic experimentation and evaluation practices exist (logging, summary prints, saving outputs) but no formal metrics tracking, experiment management, or reproducible evaluation pipelines.
Evidence
llm-customer-analyzer/app/services/llm_batch_analyzer.py: _print_summary and save_results write CSV/JSON and log summary
llm-customer-analyzer/app/services/llm_batch_analyzer.py: logging.basicConfig used for run-time logs
MLOps & Deployment
3/10
How models are shipped to production
Lightweight deployment artifacts: FastAPI endpoints, Gradio UIs and CLI entrypoints are present but no production MLOps (monitoring, model versioning, CI/CD, or drift detection).
Evidence
llm-customer-analyzer/app/api.py: FastAPI /ask endpoint wiring to RAGService
rag-company-faq/app/gradio_app.py and llm-customer-analyzer/app/gradio_app.py: Gradio ChatInterface and launch code
Computational Efficiency
3/10
How efficiently computing resources are used
Some engineering for throughput and efficiency (FAISS for vector search, chunk sizing, ThreadPoolExecutor for parallel batch inference) but no profiling, quantization or GPU/throughput optimization evidence.
Evidence
company-multi-agent-assistant/tools/retriever_tool.py: chunk_size=600, chunk_overlap=100 and FAISS usage
llm-customer-analyzer/app/services/llm_batch_analyzer.py: ThreadPoolExecutor and as_completed for parallel analysis
Research Depth & Innovation
1/10
Depth of research and new ideas
No research-level contributions or novel algorithms; the code implements known patterns (RAG, multi-agent prompts) without paper re-implementation or custom model internals.
Evidence
company-multi-agent-assistant/agents/agent.py: simple agent functions wiring prompts and LLM calls
prompts/prompts.py: role-specific ChatPromptTemplate definitions (supervisor/researcher/retriever/writer)
Expertise
RAG• Middle
AI Agents & Agentic Workflows• Middle
LLM• Middle
Industries
Food & Beverages• Middle
Technologies
Groq
RAG
LangGraph• mentioned only
LLM• mentioned only
Python• mentioned only
Recommendations
  • Develop production-ready RAG assistants for customer support that include document ingestion pipelines, vectorstore versioning and evaluation hooks.
  • Build multi-agent prototypes that add tool retries, error handling and structured orchestration (retries/backoff, timeouts, agent handoff logs).
  • Implement experiment tracking and evaluation for LLM outputs (W&B/MLflow or simple metrics storage) and add unit/integration tests for core services.
  • Harden deployment: add CI/CD, container images, health checks, and basic observability for latency and error rates.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
llm-customer-analyzer rag-company-faq company-multi-agent-assistant
Middle Data Scientist Confidence: High Data Engineer
Data engineer at a Middle level specializing in building LLM-powered RAG and batch text-processing systems. The strongest proven skill is implementing retrieval and vector-search pipelines using FAISS and HuggingFace embeddings as implemented in app/services/rag_service.py and related vectorstore initialization code. Not evidenced are model training workflows, rigorous statistical evaluation, automated tests or mature production-grade security and secrets handling.
Statistical Rigor
2/10
Correct use of statistics
Very limited statistical rigor; outputs rely on LLM JSON with a single 'confidence' field and no formal tests, significance checks or uncertainty quantification.
Evidence
llm-customer-analyzer/app/services/llm_batch_analyzer.py:AnalysisResult model
llm-customer-analyzer/app/services/llm_batch_analyzer.py:_print_summary
Data Wrangling & Cleaning
4/10
Preparing and cleaning data
Solid basic data wrangling for text pipelines: CSV/XLS support, chunking and embeddings creation; some error handling but no explicit leakage or train/test contamination checks.
Evidence
llm-customer-analyzer/app/services/gui_analyzer.py:analyze_file
company-multi-agent-assistant/tools/retriever_tool.py:initialize_rag
Exploratory Analysis & Visualization
2/10
Exploring and visualizing data
Minimal exploratory analysis: simple counts and printed summaries but no visualizations or narrative-driven EDA.
Evidence
llm-customer-analyzer/app/services/llm_batch_analyzer.py:_print_summary
llm-customer-analyzer/app/main.py:main
Predictive Modeling
2/10
Building models that predict
No model training or validation workflows; uses pretrained LLMs and embeddings in inference mode without CV, calibration or error-analysis pipelines.
Evidence
rag-company-faq/app/services/rag_service.py:_build_vectorstore
llm-customer-analyzer/app/services/llm_batch_analyzer.py:analyze_single
Business Insight & Impact
2/10
Turning analysis into business value
Basic business framing exists (categories, sample documents) but there is no reasoning about business metrics, cost of errors, or actionable impact analysis.
Evidence
llm-customer-analyzer/app/services/llm_batch_analyzer.py:AnalysisResult
rag-company-faq/app/services/rag_service.py:system_prompt
Reproducibility & Notebook Hygiene
3/10
Clean, repeatable analysis
Repository shows repeatable runs via requirements and dotenv and modular services, but lacks pinned dependency versions, tests, data/versioning or CI for reproducible production deployment.
Evidence
llm-customer-analyzer/requirements.txt
llm-customer-analyzer/app/main.py:load_dotenv
Expertise
Analytics• Middle
Industries
Commerce• Middle
Food & Beverages• Middle
Transportation & Logistics• Middle
Technologies
Python• Middle
LangChain
FAISS
FastAPI
Gradio
OpenAI SDK
huggingface_hub
Pandas
Pydantic
LangGraph• mentioned only
LLM• mentioned only
Python• mentioned only
RAG• mentioned only
Recommendations
  • Develop production-ready RAG services and APIs that integrate FAISS, embeddings and LLM inference with proper secret management and input validation.
  • Build batch text-processing pipelines and tooling for customer-feedback analysis with robust error handling, logging and monitoring (use the BatchAnalyzer as base).
  • Prototype conversational interfaces and internal knowledge assistants using LangChain and Gradio, then harden them with tests and deployment automation.
  • Add data governance: dataset versioning, leakage checks, evaluation pipelines and structured error analysis for LLM outputs.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
llm-customer-analyzer rag-company-faq company-multi-agent-assistant
Middle Backend Developer Confidence: Medium API Engineer
A Python backend engineer (middle) focused on small LLM-powered services and RAG tooling with a strength in implementing end-to-end prototype pipelines. The strongest proven skill is building retrieval-augmented systems and LLM integration backed by RAGService classes and the BatchAnalyzer parallel processing code. There is limited evidence of production-grade concerns such as persistent vector DB management, API versioning/idempotency, formal security controls, automated tests or deployment orchestration.
API Design
3/10
How well APIs are designed
Basic REST API endpoints are implemented with FastAPI and pydantic models, but there is no formal versioning, idempotency handling, pagination, detailed error contract, or API stability strategy.
Evidence
llm-customer-analyzer/app/api.py: FastAPI endpoints /ask and / with pydantic Query model
rag-company-faq/app/api.py: FastAPI /ask using RAGService.rag_chat
Data Layer & Database
3/10
Working with databases
Uses in-memory vectorstore (FAISS) and embeddings with sensible text-splitting, but no persistence/migration history, transaction boundaries, or advanced query tuning are present.
Evidence
rag-company-faq/app/services/rag_service.py:_build_vectorstore uses RecursiveCharacterTextSplitter + FAISS.from_documents
llm-customer-analyzer/app/services/rag_service.py: uses HuggingFaceEmbeddings and FAISS (vectorstore) patterns
Scalability & Performance
3/10
Handling load and speed
Some attention to parallelism and polling is present (ThreadPoolExecutor for batch LLM calls and polling loop for image generation), but there is no caching strategy, backoff with jitter, queue-based decoupling or rate limiting.
Evidence
llm-customer-analyzer/app/services/llm_batch_analyzer.py: process_batch uses ThreadPoolExecutor + as_completed for parallel processing
vibe-creative-pipeline/api_client.py: generate_image polls generation status with a timeout loop
System Architecture
3/10
Overall system structure
Code is modular with clear service boundaries (RAGService, BatchAnalyzer, agents, api/gradio layers) suitable for small services, but there is no evidence of multi-service contracts, deployment orchestration, or explicit config/secret management beyond dotenv.
Evidence
rag-company-faq/app/services/rag_service.py: RAGService class encapsulates vectorstore and LLM client
vibe-creative-pipeline/agents.py and main.py: separated agent logic and runtime script
Security & Auth
2/10
Protecting data and access
Environment secrets are read from dotenv and used in API calls, and input models are validated minimally with pydantic, but there is no evidence of authn/authz design, token lifecycle management, input sanitization for downstream model responses, or dependency security auditing.
Evidence
vibe-creative-pipeline/api_client.py: reads VIBE_API_TOKEN from env and sets Authorization header
llm-customer-analyzer/app/api.py: pydantic Query model used for /ask endpoint
Reliability & Observability
3/10
Stability and monitoring
Basic observability and reliability practices exist: logging, exception handling, timeouts/polling and handling of failures in batch processing, but no structured correlation ids, metrics, retries with backoff+jitter, or alerting integrations.
Evidence
llm-customer-analyzer/app/services/llm_batch_analyzer.py: logging setup, try/except in analyze_single and logging of errors, + _print_summary
vibe-creative-pipeline/api_client.py: raise_for_status, polling loop with timeout and raised exceptions on failures
Expertise
Backend AI & LLM• Middle
Python• Middle
Databases & Vector Storage• Middle
Microservices & API Architecture• Middle
Industries
Food & Beverages• Middle
Technologies
Uvicorn
Requests
Recommendations
  • Develop small to medium LLM-backed APIs and RAG proof-of-concepts that expose search and chat endpoints with FastAPI and Gradio.
  • Build batch inference pipelines and tooling for customer feedback analysis that use parallel processing and structured result schemas (extend BatchAnalyzer).
  • Prototype vector-search features and embeddings workflows, then add persistence, migrations and upgrade paths for the vectorstore.
  • Harden API production readiness: add versioning, error contracts, idempotency keys, input validation, and token lifecycle handling.
  • Introduce observability and reliability: structured logs with correlation ids, metrics, retries with backoff, and basic CI/tests.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
vibe-creative-pipeline llm-customer-analyzer rag-company-faq