End-to-end analytics platform for talent management — ingesting psychometric assessment data (AON cognitive, Saville behavioural, Assessment Center) via PostgreSQL FDW, transforming it through a 3-layer dbt pipeline, and serving embedded Superset dashboards with per-tenant, per-user Row-Level Security. Primary owner of the dbt transformation layer (~109 models, 56 marts, 13 AI precompute tables).
ga-dbt · lead
AI analytics layer (13 marts)
Designed and built the full AI precompute layer: SWOT classification, 9-box matrix, risk shadow effect, Big Five / 4H aggregates, and EQ / sales / leadership impact-risk scores — migrating Analyzer features from in-memory Python to materialized SQL marts.
ga-dbt
Dashboard mart pipeline
Built behavioural & risk scoring models, sales-potential and leadership-impact marts, employee score facts, and canonical seed refactors across staging → intermediate → marts for 8+ embedded dashboards.
ga-dbt
Native RLS in dbt
Implemented PostgreSQL native RLS via the apply_native_rls post-hook macro, access_map_employee visibility table, and cross-tenant smoke tests — fixing RLS dependency issues that blocked the entire mart layer.
ga-workspace
Local analytics dev stack
Set up local DB provisioning, dbt quick-start scripts, schema-comparison tooling, and mock-source integration so the full FDW → dbt → Superset loop runs with a single docker compose up.
ga-analytics-api
Multi-tenant API & UAT deploy
Led the multi-tenancy refactor, UAT analytics-api configuration & Dockerfile, tenant-level GitLab CI security tests, and RLS alignment between the API and dbt layers.
ga-superset · ops
Production unblock & TR localisation
Fixed schema drift (candidate_user) blocking 130+ downstream models before a live demo; stabilised Superset Docker startup; updated Turkish UI translations and filter localisation (tr-TR).
Core ownership — dbt transformation layer
Primary engineer on the dbt pipeline (~109 models): from early local-dev setup and canonical score normalisation (AON, Saville, AC → STEN) through the full mart catalogue and AI precompute layer. Segment discovery and feature engineering started in
Behavioral Clustering R&D (Aug 2025) before productionising scores as SQL marts. Platform scaffolding (K8s, CI, guest-token API) was built in parallel by the team; my focus was the data models, RLS, and making dashboards actually work end-to-end.
dbt Core 1.11
PostgreSQL 16
Apache Superset 6
FastAPI
Kubernetes
Argo Workflows
Redis / Celery
FDW
Native RLS
JWT
B2B corporate AI coaching platform — multi-agent orchestration (Companion, Coach, Advisor, Mentor) with LangGraph, modular POML prompts, Parquet-grounded personalization, real-time voice via OpenAI Realtime API, and HR analytics dashboards. Built the evaluation framework, early voice stack, and POML prompt foundation.
prompts · lead
Pattern system & POML migration
Implemented the advanced pattern engine (Chain-of-Thought, Tree-of-Thoughts, Planning, and 4 more) with mode-based selection; migrated all prompt files from Turkish to English and fixed naming/path inconsistencies across the 49-file POML library.
coach · lead
Referee Agent — LLM-as-Judge
Designed and built the end-to-end evaluation system: AI Client Simulator, multi-turn Coach integration, unified 5-dimension evaluator (role/style, techniques, principles, safety, flow), dynamic conversation closure, and OpenAI Evals export.
coach
Voice integration (OpenAI Realtime)
Pioneered real-time voice coaching: WebSocket voice server, RealtimeVoiceSession bridge, POML system prompts in voice path, voice_config.py, and agent-chat-ui React components with Web Audio API (24 kHz PCM16).
coach
Memory & state persistence
Fixed coach memory persistence (Context Messages: 0 bug), LangChain v0.3+ compatibility in coach submodule, and client-side memory optimization (last 6 messages, 40% token savings).
coach
Client simulator & eval tooling
Improved AI client simulator with turn-based progression guides and anti-repetition rules (49% fewer turns, score 7.88→8.2); added coaching evaluation reports and single-scenario test scripts.
coach · docs
Contributor onboarding
Wrote comprehensive setup guide for new contributors (submodule init, Python 3.13+, dependency fixes) and expanded Referee Agent README with scenarios, token costs, and result JSON examples.
Core ownership — evaluation & voice layer
Primary engineer on coach quality assurance and early product surfaces: built the Referee Agent to objectively score coaching sessions before production rollout, and shipped the first OpenAI Realtime voice path with POML-aware prompts. Analytics, company-wide chat, and performance-data grounding were developed in parallel by the team; my focus was making the coach testable, measurable, and voice-ready.
LangGraph
FastAPI
POML
OpenAI Realtime
Langfuse
Streamlit
Parquet / pandas
WebSocket
UV workspace
Corporate behavioral analytics platform — a LangChain ReAct agent that answers natural-language HR questions over psychometric data (Saville, 360°, 9-box, competency profiles) via dbt mart tables with native PostgreSQL RLS. Dual-service architecture: Analyzer (analysis engine) + Analyzer API (voice/text conversation layer). Lead engineer on security architecture, config bootstrap, and service integration.
analyzer · lead
4-layer security & RLS pipeline
Shipped the full RLS-security branch (33 commits): JWT auth on HTTP + WebSocket, UserContext via ContextVar, execute_rls on all SQL paths, InputGuard/OutputGuard with YAML-driven threat patterns, cross-tenant isolation guard, and QueryValidationPipeline before every LLM call.
analyzer
Config bootstrap & schema layer
Introduced backend/core/bootstrap/ (ConfigPathResolver, agent_config, mod_loaders); consolidated application/schema; moved position_models and security types; eliminated duplicate config packages and hardcoded prompt strings.
analyzer
Master prompt & agent reliability
Fixed master_prompt.yaml rendering (dict sections → block strings), build_master_prompt() guards, PostgreSQL TCP keepalive + stale-connection retry, SQL alias ambiguity fixes, and chat history trimming for context overflow.
analyzer
Domain mods & analysis fixes
Fixed FourHProfileRiskMod runtime TypeError, resolved tools/__init__ circular import via PEP 562 lazy loading, unified SwotPatternType enums, and enhanced ProfileTransformer for employee_user_id identity validation.
ga-analyzer-api
Voice layer integration
Langfuse trace propagation across analyzer client and chat API caller; fail-fast startup validation for analyzer service URL; global 500 error logging; improved employee ID extraction from nested survey payloads.
analyzer · observability
Langfuse tracing
Integrated Langfuse callbacks in AnalizciAgent and WebSocket endpoints for end-to-end LLM trace propagation; docker-compose config and utility module for observability across the analysis pipeline.
Core ownership — security & platform foundation
Primary engineer on the security and configuration foundation that made production deployment possible: merged JWT + RLS + guard pipeline into main, built the bootstrap config system agents run on, and wired observability across both analyzer engine and conversation API. ReAct agent skills, company analytics chat, and enum refactors were developed in parallel by the team; my focus was tenant-safe data access, prompt architecture, and making the dual-service stack production-ready.
LangChain
LangGraph
FastAPI
PostgreSQL RLS
OpenAI Realtime
Langfuse
POML / YAML prompts
JWT auth
WebSocket streaming
AI microservice that recommends SMART-aligned KPIs for any job position — grounded in the APQC Process Classification Framework (lexical + category-prior retrieval, no vector DB), calibrated via a corporate Golden Dataset, and validated through an offline LLM-as-judge pipeline with human-in-the-loop feedback. Primary engineer on the generation engine, retrieval layer, eval pipeline, and production integration.
kpi-advisor · lead
KPI generation service & APQC retrieval
Built the core FastAPI service: OpenAI JSON-mode structured output, hybrid lexical + category-prior retrieval over 1631 PCF nodes and 2680 metrics, diversity selection, confidence-aware fallback, and prompt assembly with domain-expert persona and corporate rules.
kpi-advisor
Retrieval optimization & prompt engineering
Pre-tokenized lexical similarity for latency; modularized APQC constants and schemas; industry-specific standards in prompts (DORA, LCR/EVE, CAC/LTV); few-shot selection from Golden Dataset xlsx; Redis SHA-256 cache with graceful degradation.
kpi-advisor
Offline quality pipeline
Implemented step2 LLM-as-judge eval (SMART ×0.35 + Relevance ×0.40 + Clarity ×0.25), step3 Excel export for human review, and step4 feedback import into golden dataset — closing the synthetic data → eval → human flywheel loop.
kpi-advisor
Schema evolution & backward compatibility
Refactored PositionInput with LeadershipLevel and PositionGroup models; model_validator accepts legacy flat payloads alongside canonical nested format; optional ID field; detailed OpenAI usage logging per request.
kpi-advisor · infra
CI/CD, testing & Docker
GitLab CI pipeline with pre-commit (Ruff, MyPy), pytest + coverage, smoke tests for schema integrity; multi-stage Docker with healthchecks; catalog-mode position sourcing for pipeline bootstrap.
ai-api-monorepo
CORE gateway integration
Wired Streamlit UI to the agent gateway via /api/v1/agents/ga-kpi-advisor/invoke with {input}/{output} envelope, dev auth bypass headers, and monorepo endpoint configuration for local and UAT flows.
Core ownership — generation engine & quality flywheel
Primary engineer on the KPI recommendation stack: from the initial APQC-grounded generation service through Redis caching, few-shot calibration, and the four-step offline eval pipeline. Observability refactor, Streamlit UI polish, and extended prompt rules were developed in parallel by the team; my focus was structured output quality, embedding-free retrieval, dataset flywheel, and shipping production-ready CI/CD.
FastAPI
OpenAI JSON mode
Pydantic v2
Redis
APQC PCF
LLM-as-judge
Streamlit
GitLab CI
Few-shot RAG
AI advisor that selects exactly 12 competency dimensions from a closed dictionary (~900-line dimensions.json) for any job title — supporting Ocean and Saville assessment frameworks, with Turkish rationales for HR evaluators. Dual inference path: LangChain single-pass JSON mode or DSPy 5-expert ensemble with adjudicator consensus. Primary engineer on the founding product, SME expert system, closed-dictionary pipeline, and multi-layer caching.
skills-advisor · lead
Founding competency assessment system
Built the initial AI-powered competency suggestion flow (Aug 2025): Ocean/Saville test types, dimension scoring with Turkish reasoning, Streamlit two-column UI, and manual dimension add/remove — establishing the product before the modular FastAPI refactor.
skills-advisor
Closed dictionary & data layer
Moved dimensions and mappings into dimensions.json with /dimensions API endpoints; injected mapping context into LLM prompts; shuffle per request to reduce positional bias; whitelist validation + dedupe + cap@12 on every response.
skills-advisor
DSPy SME expert ensemble
Implemented dynamic SME weight system and arithmetic-mean adjudicator (Oct–Nov 2025): five parallel expert personas merged into consensus lists with category balance — alternative to single-pass LangChain for higher-stakes role assessments.
skills-advisor
LangChain path & prompt variants
PromptBuilder with BASIC / ONET / INSIGHTS / BOTH variants; insights.txt + mindmaps.json RAG-lite injection; PydanticOutputParser on json_object responses; use_expert_engine flag to switch engines without API contract changes.
skills-advisor
Multi-layer caching
SHA256 LLM-level cache in base_llm.py plus request-level cache in LangChainService (May 2026); switched default to gpt-4o-mini @ temperature 0 for cost/latency — identical role+test+group requests skip OpenAI entirely.
skills-advisor · platform
Production integration
JWT + tenant whitelist via grid-auth; OTEL and prompt logging hooks; Docker netrc secrets for private PyPI; pairs with Agent API Gateway invoke path for downstream HR workflows.
Core ownership — competency selection engine
Primary engineer from the first competency UI through the production FastAPI service: closed-dictionary constrained generation, DSPy multi-expert consensus, and caching strategy. O*NET API v2 client, LangChain v1 migration, dimension validation middleware, CI deploy components, and grid-observability adoption were developed in parallel by the team; my focus was making exactly-12-dimension selection reliable, explainable in Turkish, and cheap at scale.
FastAPI
LangChain
DSPy
OpenAI JSON mode
Streamlit
JWT / grid-auth
O*NET API
LangSmith
In-process cache
Corporate AI agent gateway — a FastAPI monorepo that exposes multiple downstream AI microservices through one standard invoke API: shared JWT auth, request/response envelope, structured logging, and OpenTelemetry hooks. Teams ship thin agent handlers + httpx proxies; domain logic stays in separate services (KPI Advisor, Analyzer, etc.). Primary engineer on platform bootstrap, auth integration, Docker topology, dynamic CI, and the Cookiecutter-based agent scaffold.
ai-api-monorepo · lead
Platform bootstrap & gateway core
Created the initial monorepo structure: core router factory, InvokeRequest/InvokeResponse schemas, agent registration in main.py, a Cookiecutter template for new agents, and an API.md integration guide so teams could add services with the same contract and deployment pattern.
core
JWT auth & invoke pipeline
Integrated grid-auth for token verification on every /invoke call; dev bypass vs production auth paths; streamlined API responses (operational metadata logged, not returned); enhanced agent invoke logging and error handling.
infra
Per-agent Docker Compose topology
Restructured compose to per-agent includes (agents/ga_kpi_advisor/docker-compose.yml); dev overlay with external KPI Advisor path; multi-stage Dockerfiles with non-root user, OCI labels, HEALTHCHECK, and build-arg versioning.
ci
Dynamic GitLab child pipelines
Built generate_agents_pipeline.py to scan agents/ for Dockerfiles and emit per-agent CI child pipelines; added GitLab CI + pre-commit (Ruff, MyPy); iterated trigger-agents, Docker host, and job dependency rules for reliable builds.
kpi-advisor agent
First production agent integration
Wired ga-kpi-advisor as the reference agent: httpx proxy to downstream KPI service, env-based URL config, validation error logging, and end-to-end invoke flow from Streamlit through the gateway.
kpi-advisor agent
Cross-service contract alignment
Kept gateway payloads in sync with KPI Advisor schema evolution: leadershipLevel, positionGroup, name/definition fields, optional id — ensuring monorepo invoke examples match the downstream Pydantic models.
Core ownership — agent gateway platform
Primary engineer from initial commit through production-ready gateway: monorepo layout, first agent wiring, JWT auth, per-agent Docker/compose pattern, dynamic CI pipeline generation, and the Cookiecutter scaffold for new agents. create_gateway_app refactor, CORS settings, and scaffolding improvements were developed in parallel by the team; grid-observability adoption was led by another engineer. My focus was the platform contract, deployment topology, and making new agents plug in with minimal boilerplate.
FastAPI
httpx
Pydantic v2
Cookiecutter
JWT / grid-auth
OpenTelemetry
Docker Compose
GitLab CI
Gateway pattern
FastAPI chatbot for the QKare corporate website — answers visitor questions about the company through a cost-optimized cascade: rule-based QA matching first, then semantic cache (FAISS or Milvus), then web-scraping RAG over live site content, and finally OpenAI for open-ended replies. Hybrid security (local pattern + AI analysis) guards against prompt injection. Sole author — full rewrite from architecture through Docker deployment.
qkare-chatbot · lead
Cascade inference architecture
Designed the rule → semantic cache → RAG → LLM pipeline in app.py: instant QA hits for FAQs, embedding similarity for repeat questions, scraped site context when knowledge is stale, and LLM only when earlier layers miss — minimizing cost per message.
qkare-chatbot
Semantic cache & vector stores
Built cache_service and milvus_service with configurable FAISS or Milvus backends; similarity-threshold tuning; cache write-back after LLM responses so recurring visitor questions skip expensive inference.
qkare-chatbot
RAG & web scraping layer
rag_service scrapes QKare site pages (BeautifulSoup, html2text) for fresh grounding; LangChain + OpenAI assembly when rules and cache miss; keeps corporate answers aligned with public content.
security
Hybrid security system
security/hybrid_security.py combines local regex patterns and AI-based threat analysis; PromptInjectionError handling, configurable thresholds, and get_security_metrics for production monitoring.
qkare-chatbot · infra
Production packaging
Organized services/ layout (qa, cache, milvus, rag, llm); Docker Compose for Milvus + Attu admin UI; structured logging, custom exceptions, /health endpoint, and env-driven config validation in config.py.
Core ownership — enterprise chatbot stack
Sole engineer on the Jul 2025 rewrite: end-to-end FastAPI chatbot with hybrid security, dual vector-store support, and four-layer inference cascade. This predates the later HR analytics and agent-gateway work at Qkare but established patterns — semantic cache, RAG grounding, and security-first request handling — reused across subsequent AI services.
FastAPI
OpenAI
LangChain
FAISS
Milvus
RAG
BeautifulSoup
Docker
Hybrid security
Research workspace for segmenting employees and candidates from behavioral and performance data — comparing K-Means, hierarchical clustering, DBSCAN, and GMM on the same feature matrix, with PCA/t-SNE visualization and silhouette / Calinski-Harabasz / Davies-Bouldin evaluation. Outputs segment profiles as CSV and static/interactive plots for HR analytics decisions. Sole author — end-to-end pipeline from EDA through feature engineering to multi-algorithm benchmarking.
clustering-rd · lead
Feature engineering pipeline
Built feature_engineering.py to transform raw HR/assessment inputs into scaled, model-ready matrices — bridging exploratory data and clustering modules via consistent preprocessing and joblib serialization.
clustering-rd
Multi-algorithm clustering comparison
Implemented clustering_model.py and advanced_model.py to run K-Means, hierarchical, DBSCAN, and GMM on the same dataset; scored each run with silhouette, Calinski-Harabasz, and Davies-Bouldin indices for side-by-side selection.
clustering-rd
EDA & dimensionality reduction
EDA.py for exploratory profiling; PCA and t-SNE projections with matplotlib, seaborn, and Plotly — dual-channel reporting (static PNG + interactive HTML) for segment visualization.
clustering-rd
AutoML & multi-cluster analysis
autoMl1.py for automated model search experiments; multi_cluster_analysis.py for cross-algorithm segment comparison and H2O/sklearn output export to CSV artifacts.
Core ownership — comparative clustering research
Sole engineer on this R&D track: designed the full offline analytics loop from raw behavioral data through feature engineering, algorithm benchmarking, and visual segment profiling. Research outputs informed the Analytics Platform (dbt marts, AI precompute layers) but this repo intentionally stays script-based — no API or production deploy scope.
Python
scikit-learn
Pandas
Plotly
PCA / t-SNE
H2O
matplotlib
DBSCAN · GMM
joblib
AI · Backend
CVAnalyzerAI — Resume Analysis Platform
Intelligent resume analysis platform using MCP and multiple AI services. Analyzes CVs to extract strengths, weaknesses, and job-fit insights using LLMs and structured parsing. Integrated into Claude via MCP.
Helps HR teams reduce review time and gain AI-driven insights about candidates.
Data Platform · AI
Personal Finance Analytics — Multi-Source Platform with an AI Insight Engine
End-to-end analytics platform turning raw bank transactions, budgets, and investments into clean analytical tables via a layered dbt pipeline, with an AI engine grounded on a versioned dbt mart (not free-form prompts) that generates natural-language insights. Instrumented with OpenTelemetry tracing across every service and visualized in Apache Superset.
Demonstrates a production-grade pattern for grounding LLM insights in tested, lineage-tracked data instead of ungrounded prompting.
MSc Thesis · ML
Payment Method Preference Classification — Hybrid ABC-PSO Optimization
Master's thesis pipeline classifying digital payment method preferences on the DCPC 2024 dataset. Optimizes Random Forest hyperparameters with PSO, ABC, and a custom Hybrid ABC-PSO swarm algorithm, benchmarked against standard test functions, with SHAP for global/local interpretability.
Hybrid ABC-PSO improves balanced accuracy over single-algorithm optimization, with full experiment reproducibility via a single pipeline script.
AI · Evaluation
OpenEval — LLM-as-Judge Evaluation Framework
Lightweight Python framework for automatically evaluating LLM outputs, supporting OpenAI API and local Ollama models. Scores question/answer pairs in batch across five dimensions — faithfulness, relevance, clarity, safety, and consistency — using an LLM-as-judge approach.
Gives teams a provider-agnostic, repeatable way to score LLM output quality instead of relying on manual spot-checks.
Computer Vision
Antenna Behaviour Analysis
Analyzed insect antenna movement using DeepLabCut to extract behaviour patterns from biological footage. Labeled keypoints, trained custom models, and analyzed movement trends.
Enabled high-accuracy behavioural studies in entomological experiments.
Deep Learning
Pollen Classification
Built a deep learning model to classify pollen images with over 90% accuracy. Created a labeled dataset, applied data augmentation, and trained CNN models.
Assisted agricultural researchers in automating pollen type recognition.
Machine Learning
Marketing Campaign Prediction
Prediction engine for banking marketing campaigns to forecast customer subscription behaviour. Applied feature engineering, handled class imbalance with SMOTE, and built a Streamlit interface.
Enabled accurate targeting for cost-effective campaign execution.
AI · AgriFood
TOP4HONEYCHAINS — Smart Agri-Food
ML solutions in honey value chains for traceability and quality assurance. Collected field data, trained predictive models, and created RESTful endpoints.
Improved transparency across agri-food stakeholders and streamlined quality tracking.
AI · Food
Yemek Chatbot — Multilingual Food Assistant
Multilingual food assistant built with RAG, Mem0, and Milvus. Recommends recipes from available ingredients, supports dietary preferences like gluten-free, vegan, and keto, and is set up for fine-tuning.
Makes recipe discovery more contextual with preference-aware, memory-backed suggestions.
