David – AI agent development, Python, LangChain

The project is an automated corporate due-diligence research platform. A company arrives as a message envelope from an upstream pipeline, five risk categories (identity & ownership, sanctions, litigation, financial and reputational risk — 22 codified risk factors) are researched in parallel against the live web by LLM agents, and structured JSON evidence artifacts are written to cloud storage for a downstream ingestion pipeline. No human reads a report; the output is machine-consumable, auditable evidence.

• Built the production research pipeline on top of a fork of GPT Researcher, replacing the open-source report-writing path with a deep-research orchestration layer that fans out five risk categories concurrently via asyncio.gather, each running its own multi-iteration search-scrape-compress-curate loop.
• Designed dual entry points — a FastAPI REST endpoint and a RabbitMQ consumer — sharing a single validated message-handling core, so HTTP and queue-driven runs cannot drift; unmodelled envelope fields survive the round trip while the business-critical slice is Pydantic-validated.
• Integrated Google Vertex AI (Gemini) for generation and embeddings, and Brave Search / Brave News as per-category retrievers, with a process-global rate limiter and configurable freshness, query-length and result-count budgets.
• Implemented a deterministic entity-match pre-filter: a diacritics-folded, word-boundary matcher built from legal-name variants, native names, aliases, key people and the recursive beneficial-ownership chain, cutting irrelevant pages out of LLM curation while retaining them in the artifact for audit.
• Built an LLM source curator that attributes each accepted page to a single risk factor with a verbatim supporting quote, and gated it on entity evidence so non-matching runs skip the LLM call entirely — materially reducing token spend per run.
• Migrated all prompts to Langfuse-managed versioned prompts with automated seeding, drift detection at startup and optional auto-publish, decoupling prompt iteration from code deploys.
• Instrumented the full pipeline with nested Langfuse tracing and per-category quality scores (URLs found, scrape success rate, entity-match rate, end-to-end duration), grouping every run into a single session keyed by request ID for debugging and evaluation.
• Delivered the GCS artifact layer: six JSON artifacts per run (one per category plus a deduplicated cross-category article index), signed-URL delivery, and per-URL provenance linking every article back to the queries and risk-factor codes that surfaced it.
• Maintained a pytest suite (unit + gated live-LLM integration tests against frozen fixtures) and drove SonarQube quality gates on new code.

A regulated escrow platform for B2B transactions, holding funds until every contractual condition is verified and released. Covers AML/KYC onboarding, transaction lifecycle management, dispute handling and an operational back office for compliance reporting.

• Designed the REST API underpinning the escrow lifecycle — fund holding, condition verification, staged release — with explicit state transitions so no transaction could be released without every condition being satisfied.
• Integrated third-party AML and KYC verification providers into onboarding, blocking transaction creation until identity and sanctions checks cleared.
• Built an automated dispute-resolution flow with evidence submission, timed escalation windows and an audit trail of every state change, cutting manual case handling.
• Delivered the compliance back office in Django templates: transaction monitoring, user activity views and exportable compliance reports for operations staff.
• Built a real-time notification layer (email + SMS) tied to transaction state changes and outstanding compliance requirements.

The project is a semantic recommendation engine. It converts a multilingual catalog of books, audiobooks, and articles into vector embeddings and matches them against an LLM-generated profile of each reader — their department, favorite categories, and reading history — to serve personalized, diverse recommendations through a REST API consumed by the main product.

• Improved recommendation relevance by redesigning the user query vector as a weighted fusion of four embedding signals — the LLM-generated reader profile, long-term favourite categories, recently consumed categories, and recent item descriptions — separating long-term taste from short-term interest.
• Implemented MMR (Maximal Marginal Relevance) re-ranking with a configurable diversity threshold, eliminating near-duplicate recommendations while capping the candidate set to keep API latency low.
• Designed the LLM prompting layer (Azure OpenAI via LangChain) that turns raw reading history into a natural-language reader profile, and tuned the BGE embedding model's query instruction for retrieval quality.
• Extended the filtering pipeline with per-category caps, a recommendation-frequency filter backed by a new recommendation log table, and overstock prioritisation, so results stay fresh and aligned with library stock.
• Built asynchronous Celery/Redis jobs for catalogue embedding in batches, scheduled refresh of stale reader profiles for active users only, and retention cleanup of recommendation logs.
• Added PostgreSQL/pgvector schema changes through Alembic migrations, and fixed an embedding dimensionality mismatch that silently degraded similarity search.
• Introduced a pytest suite covering the recommendation endpoint and service layer, and moved hard-coded tuning parameters (weights, thresholds, batch sizes) into environment-driven settings for safe per-environment tuning.

The project is a Romanian-language AI virtual assistant embedded in the client portal, answering customer questions about invoices, consumption, meter readings and technical revisions from live account data, and handing off to human agents when a case needs one. It cuts contact-centre load while keeping answers grounded in the customer's own billing data and the company knowledge base.

• Designed and built a multi-node agentic pipeline in LangGraph, routing each query through an LLM classifier into domain-specific branches and 13 specialised tool nodes (invoice types, consumption analytics, meter reading, technical revisions, portal navigation) for accurate, auditable answers.
• Implemented retrieval-augmented generation over the company knowledge base using Databricks Vector Search with hybrid semantic + keyword retrieval and Azure OpenAI embeddings, grounding general energy and product questions in source documentation.
• Engineered LLM-driven escalation to human agents with strict Pydantic structured outputs, encoding business rules for prosumer billing, sales intent, repeated failed attempts and direct agent requests, plus confirmation steps and an auto-generated case summary for the receiving agent.
• Integrated Langfuse for end-to-end tracing and centralised prompt management, allowing business stakeholders to iterate on prompts without redeploying and giving the team per-node visibility into latency, cost and answer quality.
• Optimised cost and latency by tiering Azure OpenAI deployments per node (GPT-4.1 for reasoning-heavy paths, GPT-4.1-mini for classification and lightweight routes), narrowing retrieval breadth and reusing pre-computed classifications from the API layer to avoid duplicate model calls.
• Built a Jinja2 template layer that renders only the account sections a query needs (invoices, balance, consumption history, meter data) into prompts, reducing token usage and preventing hallucinated account details.
• Modelled the full customer data contract with Pydantic, with backward-compatible converters that kept the AI service stable across breaking changes in the upstream API.
• Maintained conversational context and time awareness across turns (rolling history window, injected current-date context) so follow-up and relative-date questions resolve correctly.
• Delivered through Azure DevOps CI/CD as a versioned internal Python package, with automated linting and publishing to a private artifact feed consumed by the production API.

Production LLM service that reads a live e-commerce checkout DOM and returns the CSS selectors needed to apply a discount code automatically — coupon input, submit button, final price, error alert, remove-code control — removing the need for hand-written per-retailer scrapers.

• Built a multi-stage extraction pipeline on FastAPI + LangChain: a reasoning model (o3-mini) classifies which checkout stage a page is in, then routes to a stage-specific chain with its own prompt and Pydantic output schema, giving strictly typed, validated selector responses.
• Cut LLM token cost and latency with a rule-based DOM reduction pass (BeautifulSoup) that strips scripts, media, ads/tracking, hidden elements and non-structural attributes before the model ever sees the page.
• Designed the evaluation framework that scores predictions by resolving both predicted and ground-truth selectors against the DOM and comparing the matched elements rather than selector strings, reporting accuracy / precision / recall / FPR / F1 per selector. Reached 0.91–1.00 per-selector accuracy (F1 ≥ 0.95 on 5 of 6 selectors) on a labelled benchmark of ~195 real checkout DOMs.
• Integrated Langfuse for versioned, environment-labelled prompts and full request tracing, so prompts could be iterated and compared in production without redeploys.
• Built a Selenium automation harness that crawls a 1,004-brand list, drives real add-to-cart and coupon-redemption flows, and logs per-site failure reasons — used both as regression coverage and to grow the labelled DOM dataset.
• Curated train/validation splits (120/30) to fine-tune a smaller, cheaper extraction model, with a held-out test set to compare against the prompt-based baseline.

An AI tutoring platform with a real-time, voice-driven learning assistant — a FastAPI backend streaming audio and text between learners and realtime LLM models, orchestrating content-retrieval agents and persisting session history across Redis and PostgreSQL. Scope of work: the authentication and session-security layer of that API.

• Designed and implemented the platform's JWT authentication layer from scratch — sign-up, login, logout and token-refresh endpoints — using short-lived access tokens and long-lived refresh tokens signed with python-jos.
• Built a Redis-backed token store so every issued token is server-side revocable, with Redis TTLs mirroring JWT expiry claims and old tokens revoked on each login to enforce a single active session per user.
• Hardened token delivery by moving tokens out of response bodies into HttpOnly, Secure, SameSite=Lax cookies, removing the XSS token-theft surface and mitigating CSRF.
• Wrote a reusable FastAPI dependency for token validation (signature, expiry, token type, and the Redis-stored copy) and applied it across every protected REST and content-delivery endpoint, replacing ad-hoc per-endpoint checks.
• Added bcrypt password hashing via passlib and an Alembic migration introducing unique constraints on username and email to close a duplicate-account gap.
• Refactored authentication out of the request handlers into a dedicated auth module (token issuance, cookie management, Redis token service), cutting the main router's size and making the auth flow independently testable.
• Expanded the pytest suite with async tests covering sign-up, login, logout, refresh and rejection of missing, tampered and expired tokens — keeping the GitLab CI pipeline green against its coverage gate, mypy strict typing and ruff/pre-commit checks.
• Moved CORS allowed origins into typed pydantic-settings configuration for per-environment control instead of hardcoded values.

A clinical-documentation LLM application that reads free-text physician notes and proposes applicable ICD-10 diagnostic codes, plus flags sepsis risk indicators. Built for traceability: every suggested code is tied back to the exact passage in the source note that justified it.

• Built a RAG pipeline over large medical reference documents so ICD-10 code suggestions were retrieved and justified rather than generated from model memory.
• Added a relevance-checking stage that scored retrieved documents with a language model and discarded non-relevant ones before generation, reducing spurious code suggestions.
• Implemented a dedicated hallucination-detection step that verified each generated answer against the retrieved source material and rejected ungrounded output.
• Delivered source-span highlighting, surfacing the exact document segments each suggestion was derived from — the feature clinical reviewers relied on to audit results.
• Reduced manual coding review effort substantially by automating first-pass code assignment, with clinicians retained as final approvers.

A text-summarization model trained with reinforcement learning from a reward model, tuned to produce summaries that score highly on a learned quality signal rather than on token overlap alone.

• Fine-tuned FlanT5 for the target summarization domain using PEFT/LoRA, keeping training cost within a single-GPU budget.
• Trained and applied a RoBERTa-based reward model to drive the RL loop, aligning generated summaries with the preferred output style.
• Ran quantitative evaluation (ROUGE-family metrics) alongside qualitative side-by-side review to confirm the RL-tuned model beat the supervised baseline.
• Deployed and managed training and evaluation workloads on AWS SageMaker.

A domain-specific conversational assistant for accounting questions and decision support, answering from a curated body of accounting documentation via retrieval-augmented generation rather than open-ended model output.

• Benchmarked retrieval and model options against cost-per-query and answer quality, and selected the stack that met accuracy targets at the lowest run cost.
• Built the RAG pipeline — document chunking, embedding, retrieval and grounded generation — over the accounting knowledge base.
• Designed the deployment for multi-tenant use so the same solution served businesses of different sizes without per-client rework.
• Automated the full CI/CD pipeline, removing manual deployment steps entirely.

A routing layer sitting in front of several chatbot and LLM providers, dispatching each incoming request to the provider best suited to that query type and returning a normalised response to the calling product.

• Designed the routing logic that classified incoming queries and selected the best-performing provider per use case, improving answer quality without changing the client integration.
• Built REST API endpoints exposing the ML routing system to the main product behind a single stable contract.
• Ran a requirements-gathering pass with the client to map query categories to provider strengths before implementation.