Sheikh Sami
ML Engineer
6+ years exp
SQL
Bash
Python
JavaScript
Data Pipeline & Feature Engineering: 6/10
MLOps & Deployment: 4/10
Computational Efficiency: 4/10
Active 21 day ago
+7 (966) 9337603 Invite to interview
Message
Download CVCV
Overview
Technical skills
Timeline
Roles
Overview
A production-oriented LLM/agent engineer at a senior level who builds end-to-end RAG and document-intelligence systems. The strongest proven skill is retrieval and pipeline engineering, evidenced by the hybrid dense+BM25 retrieval implementation (backend/pipelines/retrieval_pipeline.py) and the ingestion/OCR pipeline (backend/pipelines/ingestion_pipeline.py). The codebase shows limited custom model training, no experiment-tracking runs, and a few files contain incomplete import fragments so there is no evidence of low-level model optimization or full production hardening in public code.
Technical skills
SQL• Middle • 6y+
Bash• Middle • 4y+
Python• Middle • 3y+
JavaScript• Junior
Databases
Apache Kafka
Neo4j
pgvector
PostgreSQL
AI/ML
Claude
Claude Code
Cursor
LightGBM
NLP
NumPy
Pandas
Sentiment Analysis
Streamlit
LightFM
Llama
spaCy
Airflow
CatBoost
Embeddings
Fine-tuning
LangChain
LangGraph
LLM
MLFlow
Prompt Engineering
PyTorch
RAG
TensorFlow
Tokenization
Transformers
XGBoost
Scikit-learn
DevOps
Docker
Docker Compose
Git
Rest API
QA
Playwright
Timeline
AI/ML Engineer
•
Middle
Thinkplus
•
Full-Time
Worked on an enterprise automation platform with AI components as part of a small team. Integrated OpenAI and Anthropic Claude APIs into backend services via REST endpoints. Built RAG pipelines using PostgreSQL with pgvector, and implemented agentic multi-step workflows with LangChain and LangGraph for tool calling and state handling. Designed event-driven async processing with Kafka, and supported model development with PyTorch plus gradient boosting using CatBoost/XGBoost, including experiment tracking and deployment automation with MLflow/Airflow and Docker.
Python
PyTorch
TensorFlow
CatBoost
XGBoost
Transformers
LangChain
LangGraph
LLM
RAG
Embeddings
PostgreSQL
pgvector
Neo4j
Apache Kafka
Docker
Docker Compose
MLFlow
Airflow
Rest API
Playwright
Git
Prompt Engineering
Fine-tuning
Tokenization
Enterprise RAG Platform
AI/ML
Built a production-ready RAG system for enterprise document search. Implemented hybrid dense+BM25 retrieval pipeline with OCR fallback, document ingestion, chunking, and metadata enrichment. Developed agentic multi-step workflows using LangGraph with tool calling and state persistence. Integrated OpenAI and Anthropic APIs via FastAPI backend, deployed with Docker.
Peter the Great Saint Petersburg Polytechnic University
Master's Degree •
Computer Science / Artificial Intelligence
Technical Support Specialist
•
Middle
Galeries Lafayette
•
Full-Time
Diagnosed and resolved hardware and software issues to minimize system downtime. Prepared internal troubleshooting documentation and instructions for recurring problems. Cooperated with the support team to optimize technical support processes based on observed incidents.
Damascus University
Bachelor's Degree •
Information Technology Engineering / Software Engineering
Linux Administrator
•
Middle
BeeOrder
•
Full-Time
Administered and optimized Linux servers to ensure stable operation of critical infrastructure. Automated recurring system administration tasks with Bash scripts. Configured and maintained network services such as DNS and DHCP, implemented backup procedures, and analyzed system logs to identify and prevent security issues.
Bash
Middle AI/ML Engineer
Confidence: Medium LLM Engineer
A production-oriented LLM/agent engineer at a senior level who builds end-to-end RAG and document-intelligence systems. The strongest proven skill is retrieval and pipeline engineering, evidenced by the hybrid dense+BM25 retrieval implementation (backend/pipelines/retrieval_pipeline.py) and the ingestion/OCR pipeline (backend/pipelines/ingestion_pipeline.py). The codebase shows limited custom model training, no experiment-tracking runs, and a few files contain incomplete import fragments so there is no evidence of low-level model optimization or full production hardening in public code.
Model Architecture & Training
2/10
How well models are designed and trained
Minimal model-building or training code - the project uses pretrained LLM/embedding libraries (llama-cpp, sentence-transformers) without custom training loops, loss functions, or schedulers.
Evidence
backend/core/llm_client.py:get_llm, generate, chat
backend/core/embedding_client.py:embed / get_embedding_model
Data Pipeline & Feature Engineering
6/10
How data is prepared for models
Robust document ingestion and feature pipeline - file-type specific loaders, OCR fallback, deterministic language detection, chunking, and metadata enrichment are implemented end-to-end.
Evidence
backend/pipelines/ingestion_pipeline.py:load_document, chunk_text, IngestionPipeline.prepare
backend/pipelines/ocr_pipeline.py:ocr_image, ocr_pdf, detect_layout
Experimentation & Evaluation
3/10
How results are measured and tested
Basic evaluation and test coverage present - an evaluation script with deterministic metrics and a suite of unit tests exist, but there is no evidence of experiment tracking, ablations, or systematic benchmarking.
Evidence
eval/evaluate.py:QA_PAIRS and result writing to eval/results.json
tests/test_nlp.py, tests/test_rag.py, tests/test_agents.py
MLOps & Deployment
4/10
How models are shipped to production
Application-level serving and deployment concerns addressed (FastAPI endpoints, Streamlit UI, deployment docs and instrumentation hints), but no full CI/CD runs, container manifests, or production-grade model lifecycle tooling are present in code.
Evidence
backend/api/main.py:startup, upload, query endpoints (FastAPI handlers)
docs/deployment.md:deployment instrumentation references (Prometheus / OpenTelemetry)
Computational Efficiency
4/10
How efficiently computing resources are used
Thoughtful efficiency choices at the system level - hybrid dense+BM25 retrieval, min-max normalisation, lightweight reranking to avoid heavy cross-encoders, and threaded index rebuilds; no low-level GPU/quantization optimizations.
Evidence
backend/pipelines/retrieval_pipeline.py:hybrid dense + BM25 fusion and overlap re-ranking
examples/batch_ingestion.py:concurrent.futures.ThreadPoolExecutor usage for parallel ingestion
Research Depth & Innovation
3/10
Depth of research and new ideas
Some custom engineering and novel glue (hybrid retrieval, LangGraph orchestrator with fallback routing) but not research-level contributions or reproduced paper implementations.
Evidence
backend/pipelines/retrieval_pipeline.py:custom fusion strategy and reranking heuristic
backend/agents/orchestrator_agent.py:LangGraph-based routing and fallback logic
Expertise
RAG• Middle
Document Intelligence & OCR• Middle
Industries
Artificial Intelligence• Middle
Software• Middle
Technologies
PostgreSQL
Cursor
LangGraph
Rest API
Claude
Neo4j
LightFM
CatBoost
Airflow
Docker Compose
pgvector
Claude Code
MLFlow
XGBoost
Fine-tuning
Embeddings
Scikit-learn
Prompt Engineering
NLP
LightGBM
Transformers
TensorFlow
Pandas
NumPy
Git
PyTorch
Docker
Apache Kafka
LLM
Tokenization
Sentiment Analysis
Computer Vision• mentioned only
Hybrid Search• mentioned only
LangGraph• mentioned only
NER• mentioned only
NLP• mentioned only
Python• mentioned only
Vision• mentioned only
Recommendations
- Lead development of retrieval-augmented systems, RAG orchestration and agent fallback logic (RAG pipelines, retrieval tuning, agent graphs).
- Implement end-to-end document ingestion and search products that integrate OCR, NER and embeddings (ingestion pipeline, OCR, chunking and metadata).
- Hardening production deployments with full CI/CD and model lifecycle tooling - add container manifests, deployment pipelines and runtime monitoring (traces/alerts).
- Extend evaluation & experimentation - add reproducible experiment tracking (W&B/MLflow), benchmarks and ablation scripts for retrieval/generation choices.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle Data Scientist
Confidence: Medium Data Engineer
A data engineer who builds production-ready document ingestion and retrieval pipelines and orchestrates RAG/NLP/OCR agents (senior-level engineering depth). The strongest proven skill is pipeline and retrieval engineering - evidenced by the hybrid dense+BM25 RetrievalPipeline and the ingestion pipeline with OCR fallback and robust metadata handling. There is limited evidence of formal statistical analysis, model tuning, or enterprise-grade reproducibility (data versioning / CI) in the public artifacts.
Statistical Rigor
2/10
Correct use of statistics
Minimal statistical evaluation practice is present (simple deterministic metrics for RAG), but there are no hypothesis tests, uncertainty quantification, or deeper statistical rigor.
Evidence
ai-document-intelligence/eval/evaluate.py: defines answer_accuracy and precision_at_5 metrics and writes results to eval/results.json
Data Wrangling & Cleaning
7/10
Preparing and cleaning data
Strong data wrangling and ingestion code - robust extraction paths (PDF text layer fallback to OCR), normalization, language detection, chunking, and metadata enrichment with guarded error handling and deterministic seeds.
Evidence
ai-document-intelligence/backend/pipelines/ingestion_pipeline.py: load_document, _load_pdf with OCR fallback, _normalise_whitespace, detect_language, chunk_text, IngestionPipeline.prepare
ai-document-intelligence/backend/core/db.py: MetadataStore upsert_document, update_status, query_metrics and thread-safe SQLite connection handling
Exploratory Analysis & Visualization
2/10
Exploring and visualizing data
Basic presentation and visualization for users via a Streamlit app, but no exploratory data analysis or narrative-driven visual EDA is present in code artifacts.
Evidence
ai-document-intelligence/frontend/app.py: Streamlit UI shows metrics, document lists, entity tables and summaries (UI-level reporting)
ai-document-intelligence/tests/test_nlp.py: tests for NLP outputs (indirect support for analysis but not EDA)
Predictive Modeling
4/10
Building models that predict
Solid engineering for retrieval and embedding pipelines (hybrid dense + BM25, embedding client), and integration with LLMs for generation, but not classical predictive-model development, tuning or advanced error analysis workflows.
Evidence
ai-document-intelligence/backend/pipelines/retrieval_pipeline.py: hybrid dense+BM25 retrieval, min-max normalization, fused scoring and re-ranking
ai-document-intelligence/backend/agents/rag_agent.py: RAG agent interface integrating retrieval + LLM chat generation
ai-document-intelligence/backend/pipelines/embedding_pipeline.py: embedding pipeline and ChromaDB integration (imports and usage)
Business Insight & Impact
3/10
Turning analysis into business value
Some product-awareness via dashboard metrics and document/agent traces, but limited explicit business-impact analysis (no cost/ROI reasoning or FP/FN tradeoff assessments in code).
Evidence
ai-document-intelligence/frontend/app.py: displays metrics (chunks, queries, avg latency) and shows agent trace and confidence on answers
ai-document-intelligence/backend/core/db.py: query_metrics table records latency and confidence for later analysis
Reproducibility & Notebook Hygiene
4/10
Clean, repeatable analysis
Reproducibility basics are present - pinned requirements, pytest tests, and settings via pydantic - but no data versioning, CI manifests, or explicit seeding across the whole stack.
Evidence
ai-document-intelligence/requirements.txt: pinned dependencies for environment reproducibility
ai-document-intelligence/tests/conftest.py and tests/: pytest-based tests and fixtures
ai-document-intelligence/backend/core/config.py: pydantic-based Settings/get_settings for centralised configuration
Expertise
Big Data• Middle
Analytics• Middle
Industries
Financial Services• Middle
Professional Services• Middle
Technologies
LangChain
spaCy
Llama
RAG
Streamlit
Computer Vision• mentioned only
Hybrid Search• mentioned only
LangGraph• mentioned only
LLM• mentioned only
NER• mentioned only
NLP• mentioned only
Vision• mentioned only
Recommendations
- Develop production document ingestion and vector search systems (ETL, chunking, embedding, ChromaDB or vector DB integration).
- Build and extend RAG platforms and orchestrators that combine retrieval, LLM generation and OCR pipelines with fallback logic.
- Implement observability and MLOps for retrieval and RAG systems - e.g., CI pipelines, data/versioning (DVC), and richer evaluation dashboards.
- Hardening for scale - add sharding/async processing, stronger concurrency controls, and integration with managed vector stores and monitoring stacks.
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
A backend-focused AI/LLM engineer at a Senior level who designs retrieval and ingestion pipelines. The strongest proven skill is hybrid retrieval and orchestration as implemented in backend/pipelines/retrieval_pipeline.py and backend/agents/orchestrator_agent.py. There is limited public evidence of production ops (deploy/migrations/robust auth, distributed storage and measured SRE practices).
API Design
2/10
How well APIs are designed
Minimal explicit API design artifacts surfaced - frontend calls and basic endpoints are present but there is little evidence of versioning, idempotency, or a consistent error contract in the analyzed human-authored files.
Evidence
frontend/app.py: _post_json/_post_file functions calling /query and /upload endpoints
frontend/app.py: chat and OCR UI wiring showing expected endpoint payloads and response fields
Data Layer & Database
4/10
Working with databases
Deliberate data-layer choices are visible: a thread-safe SQLite metadata store with schema, parameterized queries and upsert behavior, plus an integrated hybrid retrieval pipeline that avoids repeated fetches and re-ranks results.
Evidence
backend/core/db.py: MetadataStore with _SCHEMA, contextmanager _connect, upsert_document (ON CONFLICT) and query_stats
backend/pipelines/retrieval_pipeline.py: use of embeddings.collection.query and construction of RetrievedChunk objects combining metadata and scores
Scalability & Performance
4/10
Handling load and speed
Performance-aware design appears in the retrieval stack (dense + BM25 fusion, min-max normalisation, limited re-ranking) and chunking for ingestion; however system-level scaling (connection pooling, distributed stores, measured load testing) is not evidenced.
Evidence
backend/pipelines/retrieval_pipeline.py: hybrid dense+sparse fusion, fetch_k/rerank_top_k logic, _ensure_bm25 with locking
backend/pipelines/ingestion_pipeline.py: chunk_text using RecursiveCharacterTextSplitter and pre-embedding chunk metadata
System Architecture
5/10
Overall system structure
Clear module boundaries and orchestration patterns are present - a LangGraph-based orchestrator routes between specialized agents and pipelines are cleanly separated, indicating deliberate architecture and component decomposition.
Evidence
backend/agents/orchestrator_agent.py: OrchestratorAgent with OrchestratorState, _build_graph and fallback routing (RAG -> NLP -> vision)
backend/pipelines/retrieval_pipeline.py: RetrievalPipeline singleton pattern and separation from embedding pipeline
Security & Auth
3/10
Protecting data and access
Some security-aware decisions exist (parameterized SQL, supported-file checks, defensive exception handling), but there is little evidence of full auth/authz, secret management, or SSRF/SSQL hardening in the analyzed files.
Evidence
backend/core/db.py: parameterized SQLite queries (use of ? placeholders) and check_same_thread handling
backend/pipelines/ingestion_pipeline.py: _SUPPORTED_EXT whitelist and explicit errors for unsupported file types
Reliability & Observability
3/10
Stability and monitoring
Observability and basic reliability are present - log messages, query metrics table and try/except fallbacks in agents - but engineering for production reliability (timeouts with backoff, circuit breakers, graceful shutdown hooks, structured correlation ids) is not shown.
Evidence
backend/core/db.py: query_metrics table plus record_query implementation
backend/agents/orchestrator_agent.py: try/except around agent calls with log.error and trace accumulation
Expertise
Backend AI & LLM• Middle
Databases & Vector Storage• Middle
Python• Middle
Industries
Artificial Intelligence• Middle
Recommendations
- Lead development of RAG and document-intelligence backend components - retrieval, chunking, embedding pipelines and orchestrator logic.
- Implement production hardening - service timeouts, retries with backoff, graceful shutdown, and structured correlation ids/observability.
- Own vector-store integrations and scaling work (Chroma/Qdrant/FAISS) including schema/evolution, indexing strategies and load testing.
- Build and document API contracts (versioning, idempotency keys, consistent error schemas) for teams that consume the service.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: