Dinislam Kulmukhametov
Python
Data Pipeline & Feature Engineering: 5/10
MLOps & Deployment: 5/10
Experimentation & Evaluation: 4/10
Active 16 days ago
Invite to interview
Download CVCV
Overview
Technical skills
Roles
Overview
Senior backend engineer specializing in API-first services and resilient LLM gateway design with strong emphasis on typed contracts and safety at service boundaries. The strongest proven skill is building OpenAI-compatible API gateways and streaming-safe provider adapters, evidenced by app/api/routes/v1.py and app/providers/openai_compatible.py. There is limited public evidence of large-scale production deployment automation or formal platform/infra ownership such as Kubernetes operators, full CI/CD runbooks or multi-region operational leadership.
Phone
Technical skills
Python
Python
FastAPI
SQLAlchemy
Pydantic
Boto3
Asyncio
HTTPX
Alembic
Uvicorn
Databases
PostgreSQL
Redis
Databases
AI/ML
LLM
OpenAI
Embeddings
RAG
AI/ML
Senior AI/ML Engineer
Confidence: Medium LLM Engineer
Senior-level LLM engineer and backend systems developer focused on production-grade agent orchestration, RAG pipelines and secure OpenAI-compatible APIs. The strongest proven skill is building reliable agent and service architecture with observable, tested components, as evidenced by the agent graph/worker/locks (ai-agent-platform/app/agent and app/worker) and the RAG ingestion/evaluation pipelines (rag-knowledge-service/services and scripts/evaluate_rag.py). There is little to no public evidence of custom model training, large-scale model optimization (quantization/GPU kernels), or experiment tracking infrastructure in code.
Model Architecture & Training
1/10
How well models are designed and trained
Almost no evidence of custom model architecture or training pipelines; the code integrates external LLM providers and includes a simple deterministic demo embedding only.
Evidence
rag-knowledge-service/app/integrations/ai.py:deterministic_embedding
llm-api-gateway/app/providers/openai_compatible.py:OpenAICompatibleProvider (adapter for external models; no training code)
Data Pipeline & Feature Engineering
5/10
How data is prepared for models
Clear, production-minded data pipeline work for document ingestion, chunking and embedding generation, including file validation, chunking strategies and a knowledge indexer.
Evidence
rag-knowledge-service/app/services/chunking.py:RecursiveCharacterChunker
ai-agent-platform/app/services/knowledge_indexer.py:KnowledgeIndexer.index_directory
rag-knowledge-service/app/services/document_processing.py:process_document
Experimentation & Evaluation
4/10
How results are measured and tested
Honest evaluation and test-driven approach with an evaluation CLI for retrieval and broad unit/integration test coverage, but no experiment tracking or ML run management integrations.
Evidence
rag-knowledge-service/scripts/evaluate_rag.py:calculate_metrics
llm-api-gateway/tests/test_v1_api.py:test_list_models_returns_mock_models
ai-agent-platform/tests/unit/test_llm_client.py:test_structured_completion_success
MLOps & Deployment
5/10
How models are shipped to production
Strong MLOps and deployment awareness at the application level: Alembic migrations, async DB/session lifecycle, worker queueing and recovery, health/readiness and metrics endpoints.
Evidence
ai-agent-platform/alembic/versions/0001_create_agent_run_state.py:upgrade (migrations)
ai-agent-platform/app/worker/queue.py:RedisRunQueue (worker queue abstraction)
llm-api-gateway/app/main.py:create_app (application factory, lifespan management)
Computational Efficiency
3/10
How efficiently computing resources are used
Some efficiency-minded engineering (async IO, streaming, caching of model catalog) but no GPU/quantization/low-level optimization or profiling evidence.
Evidence
llm-api-gateway/tests/test_llm_service.py:test_model_catalog_is_cached
llm-api-gateway/app/providers/openai_compatible.py:stream_chat_completion (streaming, non-blocking I/O)
rag-knowledge-service/app/integrations/ai.py:deterministic_embedding (embedding normalization for demo)
Research Depth & Innovation
3/10
Depth of research and new ideas
Thoughtful safety and guardrail design is present (content scanning, allowlisted tools, rate limits), but there is no evidence of original research or paper-level algorithmic innovation.
Evidence
ai-agent-platform/app/services/guardrail_service.py:GuardrailService
ai-agent-platform/app/core/content_scanner.py:DeterministicContentScanner
llm-api-gateway/app/middleware/security.py:RequestSizeLimitMiddleware
Expertise
AI Agents & Agentic Workflows• Senior
RAG• Middle
LLM• Middle
Industries
Artificial Intelligence• Senior
Software• Senior
Data & Analytics• Middle
Recommendations
- Develop production-grade agent orchestration and tool integrations, including robust worker recovery, distributed locks and idempotency handling.
- Implement RAG pipelines and document ingestion services that include chunking, embedding, retrieval, and evaluation metrics.
- Build OpenAI-compatible API gateways and provider adapters with streaming, retries, rate limiting and usage accounting.
- Harden security-sensitive parts (API key lifecycle, JWT rotation, checksum race handling highlighted in TODOs) before production rollout.
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
Backend AI systems engineer (senior-level) specializing in building reliable async LLM, RAG and agent orchestration infrastructure. The strongest proven skill is designing production-ready async LLM integrations, streaming and worker orchestration, evidenced by ai-agent-platform/app/agent/graph.py and llm-api-gateway/app/providers/openai_compatible.py. The public code shows limited evidence of applied statistical modeling, notebook-style analysis or production ML training pipelines.
Statistical Rigor
2/10
Correct use of statistics
Minimal formal statistical rigor; a small evaluation CLI and tests compute retrieval hit/latency but there is no deeper uncertainty quantification, hypothesis testing, or causal analysis.
Evidence
rag-knowledge-service/scripts/evaluate_rag.py:calculate_metrics
rag-knowledge-service/tests/test_evaluate_rag.py:test_calculate_metrics_counts_hit_and_source_match
Data Wrangling & Cleaning
5/10
Preparing and cleaning data
Solid data wrangling and cleaning for document-based pipelines: chunking, text extraction, normalization and deduplication are implemented with validation and safeguards.
Evidence
rag-knowledge-service/app/services/document_processing.py:process_document
rag-knowledge-service/app/services/chunking.py:RecursiveCharacterChunker
rag-knowledge-service/app/services/text_normalization.py:normalize_text
Exploratory Analysis & Visualization
1/10
Exploring and visualizing data
Exploratory analysis / visualization is minimal; the project reports simple aggregate metrics in a CLI but does not include EDA notebooks or visual storytelling.
Evidence
rag-knowledge-service/scripts/evaluate_rag.py:main
Predictive Modeling
1/10
Building models that predict
Predictive modeling work is not present; there are integration clients and deterministic demo embeddings but no model training, feature engineering, or evaluation notebooks.
Evidence
rag-knowledge-service/app/integrations/ai.py:deterministic_embedding
Business Insight & Impact
3/10
Turning analysis into business value
Some business-aware work: usage tracking, rate limiting and usage-aggregation tools show awareness of operational metrics, but there is limited explicit product/FP-FN cost modeling or recommendations.
Evidence
llm-api-gateway/app/services/usage.py:UsageService
ai-agent-platform/app/tools/usage_statistics.py:UsageStatisticsTool
Reproducibility & Notebook Hygiene
5/10
Clean, repeatable analysis
Good reproducibility hygiene via extensive unit and integration tests, typed settings, and app factory patterns; environment pinning and data versioning are not present but test coverage and app factories aid reproducibility.
Evidence
llm-api-gateway/tests/test_v1_api.py:test_list_models_returns_mock_models
ai-agent-platform/tests/unit/test_agent_run_api.py:api_client fixture
Expertise
Streaming• Senior
Data Science• Middle
Industries
Artificial Intelligence• Senior
Data & Analytics• Middle
Technologies
Databases
AI/ML
Python• Senior
PostgreSQL
Redis
Embeddings
LLM
RAG
Asyncio
OpenAI
Recommendations
- Build production LLM gateways and provider adapters with robust retry, monitoring and SSE streaming (useful given the OpenAI-compatible adapter and streaming routes).
- Implement agent orchestration and worker recovery systems that require durable checkpoints, locking and idempotency (leverage the AgentGraphRunner and Redis-run-queue patterns).
- Develop RAG indexing and retrieval pipelines including document ingestion, chunking, deterministic embeddings and evaluation tooling (extend document_processing, chunking and evaluate_rag).
- Own rate limiting, API key management and usage tracking for high-throughput async APIs (extend RedisRateLimiter and UsageService implementations).
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Senior Backend Developer
Confidence: High API Engineer
Senior backend engineer specializing in API-first services and resilient LLM gateway design with strong emphasis on typed contracts and safety at service boundaries. The strongest proven skill is building OpenAI-compatible API gateways and streaming-safe provider adapters, evidenced by app/api/routes/v1.py and app/providers/openai_compatible.py. There is limited public evidence of large-scale production deployment automation or formal platform/infra ownership such as Kubernetes operators, full CI/CD runbooks or multi-region operational leadership.
API Design
7/10
How well APIs are designed
Clear, consistent API contracts with OpenAI-compatible envelopes, streaming/SSE support, explicit error mapping and rate-limited dependencies; idempotency and schema validation are tested though pagination and long-term versioning strategy are minimal.
Evidence
llm-api-gateway/app/api/routes/v1.py: OpenAI-compatible endpoints, create_chat_completion, streaming SSE and error envelope handling
strategy-lab/apps/web/src/lib/schemas.ts: runtime zod schemas used to validate API contract
ai-agent-platform/tests/unit/test_agent_run_api.py: idempotency and API-level behavior tests for agent run creation
Data Layer & Database
7/10
Working with databases
Production-aware data layer with Alembic migration history, typed SQLAlchemy models, data integrity constraints and repository/session boundaries; transactional patterns and schema constraints are applied and tested.
Evidence
ai-agent-platform/alembic/versions/0001_create_agent_run_state.py: full migration creating tables and constraints
ai-agent-platform/app/db/models/agent_run.py: ORM models with CheckConstraints, UniqueConstraints and typed columns
llm-api-gateway/app/db/session.py and app/db/base.py: async SQLAlchemy session lifecycle and base metadata
Scalability & Performance
6/10
Handling load and speed
Evidence of queue-based decoupling, Redis-backed workers/locks and retry/backoff tuning for external providers plus performance benchmarking; lacks documented large-scale load testing or complex caching invalidation strategies.
Evidence
ai-agent-platform/app/worker/queue.py: RedisRunQueue and queue abstraction for worker decoupling
llm-api-gateway/app/providers/openai_compatible.py: retry/backoff logic and timeout handling for upstream providers
strategy-lab/benchmarks/pandas_vs_polars.py: micro-benchmarking comparing pandas vs polars
System Architecture
6/10
Overall system structure
Deliberate multi-service layout and clear module boundaries with explicit orchestration patterns, typed config and documented architecture; decomposition is pragmatic rather than microservice-splintered and shows thought about ownership of responsibilities.
Evidence
strategy-lab/AGENTS.md: high-level architecture rules and runtime boundaries
llm-api-gateway/README.md: service decomposition (app/api, app/core, app/db, providers)
ai-agent-platform/app/tools/registry.py and app/agent/graph.py: explicit componentization and tool registry patterns
Security & Auth
7/10
Protecting data and access
Strong security awareness: API key auth, admin JWT validation, provider URL validation, request size limiting and defensive config checks, with tests exercising security boundaries and production-only guards.
Evidence
llm-api-gateway/app/api/auth.py: API key verification, rate-limited lease pattern and admin JWT checks
llm-api-gateway/app/core/url_validation.py: provider base URL validation to prevent unsafe targets
llm-api-gateway/tests/test_security_hardening.py and tests/test_jwt_auth.py: tests asserting security and config validation behavior
Reliability & Observability
6/10
Stability and monitoring
Good observability and reliability primitives: request IDs, Prometheus metrics, structured logging, graceful release of rate-limit slots for streaming and retries; some robust patterns present though full operational runbooks or SLO-driven tooling are not visible.
Evidence
ai-agent-platform/app/api/middleware.py: request observability middleware and metrics instrumentation
llm-api-gateway/app/middleware/request_id.py and app/core/logging.py: request id propagation and JSON access log formatting
llm-api-gateway/app/api/routes/v1.py and app/api/auth.py: careful handling to release rate-limiter slots in streaming and error flows
Expertise
Backend AI & LLM• Senior
Python• Senior
Microservices & API Architecture• Senior
Databases & Vector Storage• Senior
Technologies
SQLAlchemy
FastAPI
Pydantic
HTTPX
Uvicorn
Boto3
Alembic
Recommendations
- Lead implementation of production deployment and observability runbooks - add Kubernetes manifests/Helm, CI pipelines and production chaos/load tests to validate scaling assumptions.
- Extend vector storage/embedding path to a pgvector-backed flow with migration chain and explicit eviction/indexing policies to show production-grade vector ops.
- Hardening: add documented SLOs, alerting rules and failure-injection tests for provider failover paths and rate-limiter behavior under load.
- Expose explicit end-to-end benchmarks and cache invalidation strategies (hot-path model catalog, embeddings cache) with measurable before/after results.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: