I build vision and language systems that actually ship — from real-time detection on the edge to grounded RAG agents — designed to run reliably as distributed services, not just notebooks.

Distributed systems face unique challenges that don't exist in single-machine systems. Understanding these fundamental problems is crucial for designing resilient, scalable, and reliable distributed applications. Each challenge requires careful consideration and specific solutions.

• 🔬 AI Researcher working across Computer Vision and Neural Networks, affiliated with PIAIC.
• 👁️ I build real-time vision systems — object detection & tracking (YOLOv8/v11, ByteTrack/DeepSORT), self-supervised representation learning (DINOv2), OCR, and edge deployment (TensorRT / ONNX / Jetson).
• 🗣️ On the language side I build RAG pipelines, Autonomous Agents, and LLM apps — NL-to-SQL, grounded document QA, local/private LLMs, Distillation and fine-tuning.
• 🎮 I design reinforcement-learning environments — e.g. multi-step organic-reaction product prediction — framing real problems as RL tasks (states, actions, reward shaping).
• ⚙️ I care about the boring parts that make AI real: latency budgets, FPS targets, quantization, containerization, and reproducibility.
• 🌐 I design AI as distributed services, not scripts — thin edge devices talking to inference gateways, async model workers behind queues, vector stores separated from compute, and observability wired in from day one.
• 💬 Ask me about YOLO26, DINOv2, RF_DETR, ONNX, TensorRT on Jetson, Arm Cortex SOCs, production RAG pipelines, or splitting an AI workload cleanly across edge, gateway, and cloud.

Detection & Tracking   ▸ YOLOv8 / YOLOv11 / YOLOv3-v5 · ByteTrack · DeepSORT
Representation Learning ▸ DINOv2 (self-supervised) · CNN vs. VLM benchmarking
OCR & Document AI       ▸ CRNN · CRAFT / keras-ocr · docTR · MNIST/handwriting
Edge & Optimization     ▸ NVIDIA Jetson · TensorRT · ONNX · OpenVINO · TFLite
Applied CV              ▸ Quality control · aerial/satellite · anomaly detection · RGB-D
3D & Reconstruction     ▸ Dense RGB-D reconstruction · TSDF fusion · ICP registration · point-cloud measurement · Open3D

• 🎯 Real-time object detection + multi-object tracking with persistent IDs and event/zone alerting.
• 🧠 Self-supervised vision with DINOv2 — using foundation-model backbones for downstream classification and measuring efficiency vs. classic CNNs.
• ⚡ Edge deployment: exporting models to TensorRT/ONNX and hitting real-time FPS on constrained hardware like the Jetson Orin NX.

RAG & Retrieval   ▸ Advanced RAG · ReAct agents · query reformulation · grounded QA
LLM Apps          ▸ NL-to-SQL · document QA · local/private LLMs (Qwen) · knowledge bases
Agents            ▸ LangChain · LangGraph · tool-use & multi-step reasoning
Fine-tuning       ▸ LoRA / efficient fine-tuning of LLMs & VLMs
Classic NLP       ▸ Text classification · sentiment analysis (IMDB) · embeddings

• 🔎 Built multiple RAG systems — from cloud (AWS Bedrock + Athena NL-to-SQL) to fully local, private pipelines with no data leaving the machine.
• 🤖 Experience with agentic patterns (ReAct, LangGraph) for multi-step reasoning and tool use.
• 📝 Foundations in classic NLP — sentiment classification, embeddings, and sequence models.

Environments   ▸ custom Gym-style envs · multi-step decision tasks · reward shaping
Applied RL     ▸ organic-reaction product prediction (Chemistry-RL)
Agents         ▸ policy/agent training loops · RL for LLM/agent fine-tuning (GRPO-style)
Search         ▸ Monte-Carlo Tree Search for sequential decision making

• 🧪 Built a custom RL environment that frames multi-step organic-reaction prediction as a sequential decision problem — designing the state/action space and reward.
• 🤖 Comfortable connecting RL to modern agents — reward-driven fine-tuning of LLM/VLM agents and tree-search planning.

Model Serving      ▸ FastAPI + Uvicorn · WebSocket streaming · ONNX Runtime · TensorRT · dynamic batching
Edge ↔ Cloud       ▸ Jetson-side inference · thin backend gateways · async telemetry · offline-first fallback
Vector & Data      ▸ Qdrant (hybrid dense + BM25) · AWS S3 + Athena + Glue data lakes · Parquet columnar stores
Reliability        ▸ Exponential backoff · idempotent handlers · circuit-breaker patterns · graceful degradation · health probes
Observability      ▸ Structured logging · latency / FPS / GPU-util tracking · request-scoped tracing
Packaging & CI     ▸ Docker · reproducible Python envs · deterministic builds · pinned model artifacts

• 🛰️ Ship AI systems as edge + gateway + cloud splits: heavy inference on the device (Jetson / Arm SOC / RGB-D camera), thin FastAPI gateway for orchestration, cloud only for what actually needs it — keeps latency down and data local by default.
• 🧱 Treat vector stores, model workers, and stateless API layers as separate services so each scales, fails, and gets updated independently — the boring but load-bearing part of "production AI."
• 🔁 Build in the reliability patterns that keep distributed AI honest: retries with backoff, idempotency keys, timeouts and deadlines, health checks, and graceful degradation when a downstream model or store is slow.
• 📈 Instrument every path so real-world behaviour is observable — per-request latency, model FPS, GPU utilisation, retrieval hit rate, and error budgets — because "it worked on my machine" is not a deployment strategy.

_{⚡ Always exploring the frontier where vision and language models meet the real world — as distributed systems, not demos.}