Nurmukhamed Ashekey
Python
TypeScript
MLOps & Deployment: 5/10
Active 18 days ago
Invite to interview
Message
Download CVCV
Overview
Technical skills
Roles
Overview
A capable LLM-engineering practitioner focused on building production agent systems and RAG-powered assistants, operating at a lower-senior engineering level. The strongest proven skill is architecting and implementing multi-channel agent workflows and tool-calling orchestration (e.g., nanobot AgentLoop, SubagentManager and the RAG tool integration in rag_service.py). There is limited or no evidence of custom model training, model research, GPU/quantization optimizations, or formal experiment-tracking for ML experiments.
Technical skills
Python• Middle
TypeScript• Junior
Python
aiogram
FastAPI
Databases
Qdrant
PostgreSQL
AI/ML
AI/ML
RAG
Frontend
React.js
Next.js
Tailwind CSS
Vite
DevOps
Prometheus
Middle AI/ML Engineer
Confidence: High LLM Engineer
A capable LLM-engineering practitioner focused on building production agent systems and RAG-powered assistants, operating at a lower-senior engineering level. The strongest proven skill is architecting and implementing multi-channel agent workflows and tool-calling orchestration (e.g., nanobot AgentLoop, SubagentManager and the RAG tool integration in rag_service.py). There is limited or no evidence of custom model training, model research, GPU/quantization optimizations, or formal experiment-tracking for ML experiments.
Model Architecture & Training
2/10
How well models are designed and trained
LLM orchestration and provider integration are well engineered, but there is no evidence of custom model training, loss/optimizer design, or training loops.
Evidence
nanobot/providers/openai_codex_provider.py: custom OpenAI Codex request/stream handling and SSE consumer
nanobot/providers/litellm_provider.py: provider adapter and response parsing
Data Pipeline & Feature Engineering
3/10
How data is prepared for models
Application-level data pipelines, memory/storage and scraping tasks exist (DB services, memory layers, web scraping), but no ML feature engineering or augmentation pipelines.
Evidence
Solo-Business/apps/shared/db/memory_service.py: project memory read/upsert/append helpers
Marketer-Agent/app/signals/reddit_collector.py: Reddit collection and filtering pipeline
KBTU-Pulse/RAGbot/tools/rag_service.py: vector search wrapper (Qdrant + reranking with VoyageAI)
Experimentation & Evaluation
3/10
How results are measured and tested
Good test coverage and integration tests for application logic are present, but no experiment tracking or formal ML evaluation infrastructure.
Evidence
Solo-Business/tests/integration and tests/unit: many integration/unit tests for worker graphs, API endpoints and mcp servers
KBTU-Pulse/RAGbot/tests/test_rag_search.py and related tests: unit tests for RAG tool behavior
MLOps & Deployment
5/10
How models are shipped to production
Clear attention to deployment/observability - ASGI services, cron workers, Prometheus metrics and Sentry integration, Docker/compose instructions and background workers are present.
Evidence
KBTU-Pulse/RAGbot/monitors/monitor.py: FastAPI monitor with Prometheus and Sentry integrations
nanobot/cron/service.py: standalone CronService with persistence and scheduler logic
KBTU-Pulse/RAGbot/pyproject.toml and README.md: pinned runtime dependencies (FastAPI, uvicorn, prometheus-client, sentry-sdk) and docker-compose commands
Computational Efficiency
2/10
How efficiently computing resources are used
Asynchronous and concurrency-aware design is used widely (asyncio, workers), but there is no evidence of GPU work, quantization, memory-profiling or other ML efficiency engineering.
Evidence
nanobot/agent/loop.py: async agent loop, locks and task lifecycle management
KBTU-Pulse/nanobot/channels/mochat.py: heavy asyncio concurrency and fallback worker patterns
Research Depth & Innovation
2/10
Depth of research and new ideas
Strong applied engineering and system design for agent workflows but no novel research contributions or paper implementations.
Evidence
nanobot/agent/loop.py: orchestrates tools, tool-calling iterations and consolidation logic
Solo-Business/apps/worker/graphs/marketer.py: LangGraph-based agent graph design for marketer pipeline
Expertise
AI Agents & Agentic Workflows• Middle
MLOps & Model Lifecycle• Middle
RAG• Middle
Industries
Sales & Marketing• Middle
Technologies
AI/ML
Qdrant
FastAPI
Prometheus
RAG
aiogram
Recommendations
- Lead development of LLM application features - agent orchestration, new tool integrations and RAG pipelines.
- Build production RAG connectors and retrieval pipelines (Qdrant + reranker integration, search quality evaluation).
- Implement end-to-end ML evaluation and experiment tracking for retrieval and reranking changes (W&B / MLflow or simple reproducible benchmark scripts).
- Contribute to MLOps work such as inference efficiency (batching, prompt caching) and deployment policies for hosted LLMs.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Junior Frontend Developer
Confidence: Medium App Engineer
A frontend app engineer at a middle level who ships production web apps with React/Next-style stacks and good attention to visual detail. The strongest proven skill is building polished interactive landing and SPA surfaces (evidence: Blunder-Therapist-Frontend/Landing Page.html and Landing Page Dark.html) combined with pragmatic client/server wiring (api.ts and middleware.ts). There is limited evidence of advanced system design, measured performance work, formal a11y testing, or complex server-state machines in the human-authored code.
UI Component Architecture
5/10
How interface parts are built
Hand-crafted component composition and multiple small, reusable UI functions (landing components) show deliberate UI work but no evidence of a published design system or large component library.
Evidence
Blunder-Therapist-Frontend/Landing Page.html: Nav, Hero, Features, and Footer implemented as small React components in one file
Blunder-Therapist-Frontend/Landing Page Dark.html: parallel component variants and theme-aware sections
Responsive & Cross-browser
6/10
Works on all screens and browsers
Responsive choices are explicit (clamp() typography, layout grids, breakpoint-aware behavior) and mobile-specific CSS exists; not many advanced feature-detection or RTL artifacts.
Evidence
Blunder-Therapist-Frontend/Landing Page.html: clamp() font sizes and layout adjustments for responsiveness
Uni-Bot-Frontend/src/index.css: mobile rules and utility classes (mobile-only / oc-mobile-only patterns)
Performance Optimization
4/10
Speed of the interface
Some practical performance awareness (lazy worker loading, route matcher exclusions, server-side session refresh) but no measured/benchmarked optimizations or bundle-analysis artifacts.
Evidence
Blunder-Therapist-Frontend/src/lib/stockfish.ts: lazy Worker creation to avoid SSR issues and light-weight message parsing
Blunder-Therapist-Frontend/src/middleware.ts: route matcher excludes static assets and performs server-side session refresh
Accessibility & Semantics
4/10
Usable for everyone
Pages use semantic HTML and native controls, with some ARIA/alt usage and keyboard-native buttons, but no evidence of automated a11y testing or complex custom widget focus management.
Evidence
Blunder-Therapist-Frontend/Landing Page.html: use of <nav>, <section>, headings and accessible <button> elements
Uni-Bot-Frontend/index.html: correct lang attribute and basic semantic structure
State Management & Data Flow
5/10
Managing data in the app
Server/client data flow is reasonably organized: consistent API wrappers, server middleware for auth, and stateful worker/engine wrappers - but advanced server-state discipline (request cancellation, optimistic updates with rollback, state machines) is not present in the human-authored bundle.
Evidence
Blunder-Therapist-Frontend/src/lib/api.ts: get/post wrappers with auth header handling and structured typed responses
Uni-Bot-Frontend/src/api.js: apiRequest with content-type checks and unified error handling
Blunder-Therapist-Frontend/src/middleware.ts: server-side Supabase client usage to refresh session and redirect flows
UX & Visual Polish
6/10
Look and feel quality
Strong visual polish on landing pages - considered typographic scale, dark/light variants, transitions and small micro-interactions, but UX edge states and skeletons are minimal in the provided human-authored pages.
Evidence
Blunder-Therapist-Frontend/Landing Page.html: polished hero, stats row, animated previews and interactive feature tabs
Blunder-Therapist-Frontend/Landing Page Dark.html: dark-mode variant and careful visual tokens
Blunder-Therapist-Frontend/tailwind.config.js: custom color tokens used to match the visual design
Expertise
React• Junior
HTML & CSS• Junior
Industries
Gaming• Junior
Technologies
TypeScript• Junior
Tailwind CSS
Next.js
React.js
Vite
Recommendations
- Develop interactive SPA features that need robust client/server flows - dashboards, auth-protected pages and integration with Supabase or similar.
- Build and maintain product landing pages and marketing sites that require polished visuals and light interactivity (dark/light theming, animations).
- Implement medium-complexity UX components that connect to backend APIs (forms with validation, import jobs, agent session UIs) where the current API wrappers and middleware patterns can be extended.
- Work on integrations where a Web Worker or background engine is required (e.g., chess engine, analysis engine) because of demonstrated Stockfish worker handling.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Intern Backend Developer
Confidence: Medium Generalist
A junior generalist primarily working in Python on small, self-contained projects and coursework-grade applications. The strongest proven capability is basic backend data handling - parameterized SQL, transactions and simple upsert patterns as seen in the phonebook CLI (add_contact, register/login). There is little evidence of production-grade API design, migrations, observability, concurrency controls, or system-level architecture in the publicly visible human-authored files.
API Design
How well APIs are designed
Not evidenced in public code
Data Layer & Database
2/10
Working with databases
Basic, correct use of parameterized SQL, transactions with commit/rollback and some upsert logic (ON CONFLICT). No migration history or advanced tuning/evidence of isolation-level or N+1 avoidance beyond simple queries.
Evidence
KBTU_PP2/TSIS1/phonebook.py: add_contact uses ON CONFLICT upsert and explicit commit/rollback
KBTU_PP2/Practice7/phonebook.py: register/login use parameterized queries and cursor handling
Scalability & Performance
1/10
Handling load and speed
Minor attention to pagination and LIMIT/OFFSET in interactive listing; no caching, queueing, pooling configuration or measured performance work in the human-authored files.
Evidence
KBTU_PP2/TSIS1/phonebook.py: paginated_navigation implements LIMIT/OFFSET-based paging
KBTU_PP2/TSIS1/phonebook.py: list_contacts_sorted uses ORDER BY with LIMIT/OFFSET patterns
System Architecture
1/10
Overall system structure
Single-file, monolithic CLI/apps and small game modules - clear, pragmatic structure for small projects but no multi-service decomposition, config/secret management or service contracts in the human-authored material.
Evidence
KBTU_PP2/TSIS1/phonebook.py: CLI menu-driven single-file app
KBTU_PP2/TSIS2/paint.py and KBTU_PP2/TSIS3/racer.py: self-contained application modules
Security & Auth
2/10
Protecting data and access
Shows basic security awareness - uses argon2 for password hashing and parameterized SQL to avoid injection; however some insecure practices remain (e.g., printing hashes) and token/session lifecycle or auth flows are not implemented.
Evidence
KBTU_PP2/Practice7/phonebook.py: hash_password and check_password use argon2 PasswordHasher
KBTU_PP2/TSIS1/phonebook.py: parameterized queries with %s placeholders are used consistently
Reliability & Observability
2/10
Stability and monitoring
Reasonable error handling with try/except/finally, explicit commit/rollback and resource cleanup. No structured logging, retries/backoff, timeouts, or observability/metrics in the human-authored files.
Evidence
KBTU_PP2/TSIS1/phonebook.py: functions wrap DB operations in try/except and commit/rollback/close in finally
KBTU_PP2/Practice7/phonebook.py: similar try/except/finally patterns around DB usage
Expertise
Python• Intern
Databases & Vector Storage• Intern
Industries
Education• Intern
Technologies
Python• Middle
PostgreSQL
Recommendations
- Assign to build or extend small Python-backed features and web endpoints that require safe DB access (CRUD with parameterized queries and simple transactional logic).
- Have the developer implement and harden auth flows (password hashing, login, session tokens) into a small FastAPI service to grow API-design and auth lifecycle skills.
- Task with improving reliability and observability for an existing service - add structured logging, timeouts, basic metrics and unit tests around DB interactions.
- Pair with a senior engineer to introduce schema migrations, connection pooling, and simple performance profiling for Postgres queries.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: