Ehsan Rassekh
5+ years exp
Python
Data Pipeline & Feature Engineering: 4/10
Active 3 days ago
Invite to interview
Message
Download CVCV
Overview
Technical skills
Roles
Overview
Backend-focused Python developer at a Middle level specializing in building local RAG pipelines and small backend tools. The strongest proven skill is integrating document ingestion, chunking, embedding generation and Chroma vector stores as implemented in app/ingest.py and app/pdf_processor.py. There is little evidence of production-grade security, testing, migration history or observability and monitoring in the public code.
Technical skills
Python• Middle • 5y+
Python
Beautiful Soup
FastAPI
Pydantic
Django
C++
TensorFlow C++
Databases
SQLite
AI/ML
LangChain
Streamlit
Scikit-learn
XGBoost
Pandas
huggingface_hub
NumPy
LLM
Analytics
Matplotlib
Seaborn
Middle AI/ML Engineer
Confidence: Medium LLM Engineer
LLM-focused ML engineer (mid-level) building practical RAG and classical ML systems with a strong end-to-end orientation. The strongest proven skill is assembling retrieval-augmented pipelines and local LLM integration as shown by the PDF ingestion, chunking and Chroma/HuggingFaceEmbeddings usage together with Streamlit and ChatOllama invocation. There is limited evidence of production-grade MLOps, automated testing, profiling, or custom model research in the public code.
Model Architecture & Training
3/10
How well models are designed and trained
Basic model-building and selection using classical ML and embeddings; no custom architectures or training loops.
Evidence
customer-churn-prediction-platform/notebooks/01_eda.ipynb: training pipelines for LogisticRegression, RandomForest, XGBClassifier and GridSearchCV
rag-research-assistant/app/ingest.py: create_vectorstore uses HuggingFaceEmbeddings('BAAI/bge-base-en-v1.5')
rag-research-assistant/app/rag_qa.py: generate_answer constructs LLM prompt and invokes ChatOllama
Data Pipeline & Feature Engineering
4/10
How data is prepared for models
Practical data preparation and feature engineering with clear preprocessing pipelines and input validation.
Evidence
customer-churn-prediction-platform/notebooks/01_eda.ipynb: data cleaning (TotalCharges conversion), ColumnTransformer and OneHotEncoder pipeline
customer-churn-prediction-platform/app/schema.py: CustomerData pydantic schema for validated API inputs
rag-research-assistant/app/pdf_processor.py and ingest.py: PDF loading, chunking and section metadata assignment
Experimentation & Evaluation
3/10
How results are measured and tested
Reproducible experimentation at a basic level using cross-validation and grid search; no experiment tracking or systematic ablations.
Evidence
customer-churn-prediction-platform/notebooks/01_eda.ipynb: cross_val_score and GridSearchCV usage with printed CV metrics
customer-churn-prediction-platform/notebooks/01_eda.ipynb: evaluation metrics (accuracy, precision, recall, f1) and confusion matrices
MLOps & Deployment
3/10
How models are shipped to production
Simple deployment artifacts and serving code present (FastAPI, Streamlit, model serialization), but limited production-level MLOps (no CI/CD, monitoring, or container orchestration shown).
Evidence
customer-churn-prediction-platform/app/main.py: FastAPI predict endpoint loading joblib model
rag-research-assistant/app/streamlit_app.py: Streamlit UI that calls process_pdf and RAG retrieval/answer generation
rag-research-assistant/app/pdf_processor.py and ingest.py: Chroma.from_documents persist_directory usage for vector persistence
Computational Efficiency
1/10
How efficiently computing resources are used
Minimal evidence of computational optimization or efficiency engineering; embeddings and model calls are used but not optimized or profiled.
Evidence
rag-research-assistant/app/ingest.py: HuggingFaceEmbeddings instantiation without batching or device placement
rag-research-assistant/app/rag_qa.py: ChatOllama invoked directly with no performance tuning
Research Depth & Innovation
1/10
Depth of research and new ideas
Some applied RAG patterns and heuristics (section detection, metadata-based filtering) but no novel research contributions or reproduced paper-level results.
Evidence
rag-research-assistant/app/ingest.py and pdf_processor.py: detect_section heuristics and chunk metadata assignment
rag-research-assistant/app/rag_chain.py: search_documents uses MMR retriever settings
Expertise
RAG• Middle
LLM• Middle
Industries
Artificial Intelligence• Middle
Telecommunications• Middle
Technologies
Beautiful Soup
TensorFlow C++
Computer Vision• mentioned only
Docker• mentioned only
LLM• mentioned only
NLP• mentioned only
Ollama• mentioned only
RAG• mentioned only
Systems• mentioned only
Vector• mentioned only
Recommendations
- Build production MLOps glue: add CI/CD, container specs (Dockerfile), and a deployment manifest so models and vectorstores can be reproducibly deployed and updated.
- Add unit and integration tests around ingestion, retrieval, and the FastAPI/Streamlit endpoints to improve reliability and enable safe refactors.
- Introduce experiment tracking (W&B or MLflow) and structured eval scripts to record hyperparameters, seeds and reproducible results for model comparisons.
- Implement basic performance and resource profiling (batching embeddings, device placement, caching) and add a minimal monitoring/observability plan for inference
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
Middle-level RAG and ML engineer specializing in end-to-end document RAG pipelines and deployed churn prediction APIs. The strongest proven skill is building ingestion and vectorization pipelines with PDF loading, chunking, metadata tagging and Chroma-backed embeddings as shown in rag-research-assistant/app/ingest.py and app/pdf_processor.py. There is limited evidence of automated testing, CI/CD, large-scale production hardening or advanced statistical causal analysis.
Statistical Rigor
4/10
Correct use of statistics
Uses cross-validation and hyperparameter search and reports standard classification metrics, but lacks formal uncertainty quantification, assumption checks and causal analysis.
Evidence
customer-churn-prediction-platform/notebooks/01_eda.ipynb: cross_val_score usage
customer-churn-prediction-platform/notebooks/01_eda.ipynb: GridSearchCV and classification_report output
Data Wrangling & Cleaning
6/10
Preparing and cleaning data
Concrete data cleaning and preprocessing steps are present, plus document ingestion and chunking pipelines with metadata tagging and vectorstore creation.
Evidence
customer-churn-prediction-platform/notebooks/01_eda.ipynb: TotalCharges cleaning and dtype conversion
rag-research-assistant/app/ingest.py: split_documents and create_vectorstore
rag-research-assistant/app/pdf_processor.py: process_pdf with metadata chunk_id and section tagging
Exploratory Analysis & Visualization
5/10
Exploring and visualizing data
Exploratory plots, crosstabs and basic interpretation are present, but notebooks have limited narrative reasoning and few documented hypothesis checks.
Evidence
customer-churn-prediction-platform/notebooks/01_eda.ipynb: crosstab analysis for Contract/InternetService vs Churn
customer-churn-prediction-platform/notebooks/01_eda.ipynb: sns.countplot and boxplot visualizations
Predictive Modeling
5/10
Building models that predict
Baseline-first modeling discipline with Logistic Regression, Random Forest and XGBoost plus CV and GridSearch; model serving via FastAPI is implemented but deeper error analysis, calibration and robustness tests are limited.
Evidence
customer-churn-prediction-platform/notebooks/01_eda.ipynb: pipelines for LogisticRegression, RandomForestClassifier and XGBClassifier with metrics
customer-churn-prediction-platform/app/main.py: FastAPI predict endpoint loading models/churn_model.pkl
Business Insight & Impact
3/10
Turning analysis into business value
The problem is sensibly framed (customer churn) and EDA links variables to churn, but there is little code-level treatment of business metrics, cost-sensitive decisions or error-cost tradeoffs.
Evidence
customer-churn-prediction-platform/notebooks/01_eda.ipynb: crosstabs showing churn rates by Contract and InternetService
customer-churn-prediction-platform/notebooks/01_eda.ipynb: confusion matrix and classification_report outputs
Reproducibility & Notebook Hygiene
4/10
Clean, repeatable analysis
Some reproducibility practices exist (requirements files, random_state use, model artifact saving), but there is no pinned environment, CI, tests, data versioning or deployment hardening evidence.
Evidence
rag-research-assistant/requirements.txt: declared Python dependencies
customer-churn-prediction-platform/notebooks/01_eda.ipynb: joblib.dump('../models/churn_model.pkl')
customer-churn-prediction-platform/notebooks/01_eda.ipynb: use of random_state in train_test_split and model constructors
Expertise
Analytics• Middle
Industries
Artificial Intelligence• Middle
Telecommunications• Middle
Technologies
LangChain
XGBoost
FastAPI
Scikit-learn
Seaborn
Matplotlib
huggingface_hub
Pandas
NumPy
LLM
Streamlit
Pydantic
Computer Vision• mentioned only
NLP• mentioned only
Ollama• mentioned only
RAG• mentioned only
Vision• mentioned only
Recommendations
- Hardening and productionization: add unit and integration tests, CI pipeline, and pinned dependency versions to improve deploy safety and reproducibility.
- MLOps improvements: add model validation, calibration, monitoring and data/version tracking (DVC or similar) for produced models and vectorstores.
- Scale retrieval: benchmark and implement efficient vector search strategies (batching, approximate nearest neighbours, or distributed vector stores) and add fallback handling when local LLMs are unavailable.
- Improve analysis depth: incorporate cost-sensitive metrics, business KPIs and uncertainty quantification for churn decisions, plus documented hypothesis-driven EDA in notebooks.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle Backend Developer
Confidence: High Generalist
Backend-focused Python developer at a Middle level specializing in building local RAG pipelines and small backend tools. The strongest proven skill is integrating document ingestion, chunking, embedding generation and Chroma vector stores as implemented in app/ingest.py and app/pdf_processor.py. There is little evidence of production-grade security, testing, migration history or observability and monitoring in the public code.
API Design
2/10
How well APIs are designed
Minimal API design artifacts; the project exposes a Streamlit UI and local function boundaries but lacks versioning, consistent error contracts, idempotency handling or documented pagination/filtering strategies.
Evidence
rag-research-assistant/app/streamlit_app.py: Streamlit-based UI acting as the user-facing interface without API versioning or error contract
rag-research-assistant/app/rag_qa.py: generate_answer and retrieve_context serve as thin service boundaries but do not implement idempotency, status codes or structured error responses
Data Layer & Database
3/10
Working with databases
Basic data-layer integration with Chroma vectorstore and embedding generation is present, but there is no evidence of schema evolution, migrations, transaction boundaries or tuned queries/indexes.
Evidence
rag-research-assistant/app/ingest.py: create_vectorstore uses Chroma.from_documents with HuggingFaceEmbeddings
rag-research-assistant/app/pdf_processor.py: process_pdf chunks documents and persists to a per-PDF Chroma directory
Scalability & Performance
2/10
Handling load and speed
Some retrieval tuning (MMR fetch_k/lambda) shows awareness of relevance tuning, but there is no caching strategy, no queue-based decoupling, no connection pooling controls, and no measured performance work.
Evidence
rag-research-assistant/app/rag_chain.py: retriever.as_retriever configured with search_type='mmr' and search_kwargs including fetch_k and lambda_mult
multiple-client-server-via-socket/server.py: threaded TCP server using threading.Thread for concurrency (basic scaling pattern without connection limits or timeouts)
System Architecture
3/10
Overall system structure
Code is modularized into ingestion, processing, retrieval, QA and UI components showing deliberate separation of concerns, but there is little evidence of documented service contracts, config/secret management, or graceful degradation strategies.
Evidence
rag-research-assistant/app/: separate modules ingest.py, pdf_processor.py, rag_chain.py, rag_qa.py and streamlit_app.py show modular pipeline decomposition
multiple-client-server-via-socket/: separate client and server modules implementing a simple socket-based design
Security & Auth
1/10
Protecting data and access
Security and auth are mostly absent; unsafe shell execution and minimal input validation are present and there is no token lifecycle, rate limiting or dependency audit evident.
Evidence
multiple-client-server-via-socket/server.py: os_Result/os_Compute call subprocess/check_output with shell=True and unsanitized input from client
rag-research-assistant/app/streamlit_app.py: uploaded files are written to disk with no sanitization or size/type checks
Reliability & Observability
1/10
Stability and monitoring
Very limited reliability and observability work; there are few timeouts, no retry/backoff patterns, minimal exception handling and no structured logging or metrics.
Evidence
multiple-client-server-via-socket/server.py: top-level accept loop catches Exception and prints it but lacks structured logging, timeouts or graceful shutdown handling
rag-research-assistant/app/*: no instrumentation, metrics or retry/backoff patterns around vectorstore or LLM calls
Expertise
Backend AI & LLM• Middle
Databases & Vector Storage• Middle
Python• Middle
Industries
Artificial Intelligence• Middle
Technologies
Python• Middle • 5y+
Django
SQLite
Vector• mentioned only
Recommendations
- Build and harden production-ready RAG services: add structured logging, timeouts, retries with backoff, input validation and CI tests around app/ingest.py and app/rag_qa.py.
- Improve security posture for networked code: replace shell=True patterns, validate/escape client inputs, and add authentication and rate limiting for any network endpoint (multiple-client-server-via-socket).
- Add observability and reliability features: instrument metrics, add graceful shutdown and connection limits for the socket server, and include health checks and alerts.
- Evolve data layer practices: introduce migration/versioning for vectorstore schemas or metadata, and add tests that validate embedding/indexing correctness and search quality.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: