AI Engineering
LLMs, engineered into real products.
From a single prompt to autonomous, tool-using agents that reason over your own data — built to ship, measure and trust.
Generative AI & Autonomous Agents
AI Engineering
Top Highlight — Autonomous AI
Agents That Reason, Retrieve & Act
I build AI that does more than chat — systems that think in steps, reach for tools, and ground every answer in real data. Using LangGraph I model an agent’s reasoning as an explicit, stateful graph: branch, loop, retry, pause for a human, resume. No black-box “hope the prompt works” — a controllable flow you can trace, test, and trust.
Each agent is given hands through MCP servers and function calling — it queries databases, hits APIs, parses documents, drives a browser, files a ticket. And it’s given memory through retrieval: before it speaks, it pulls the right context from a vector store, so it answers from your knowledge, not the model’s imagination. Human-in-the-Loop checkpoints keep a person in command wherever the stakes are high.
The Anatomy of an Intelligent System
The pieces that turn a raw language model into something dependable. Wield them together and you stop “using AI” and start engineering it. 🤖✨
Prompt Engineering
The art of the precise instruction — coaxing a model toward exactly the answer you need. The difference between a vague oracle and a reliable colleague: part linguistics, part psychology, part stubborn iteration.
Context Management
The working memory of the machine. A model only knows what fits in its window, so every token is real estate — I curate what it sees, compress what it doesn't need, and stream in fresh knowledge the moment it matters.
Function Calling, Tool Calling & MCP
These give the model hands. Left alone an LLM can only talk; wired to tools it can do — read a file, run a query, call an API, act in the real world. MCP is the universal socket that lets any model plug into any tool, cleanly and safely.
Async with asyncio & FastAPI
The nervous system underneath it all. AI workloads are I/O-bound — forever waiting on models, tools and retrievals. Async streams tokens to thousands of users and fans out dozens of tool calls in parallel, never blocking. FastAPI makes it clean, typed and production-grade.
Vector Embeddings
Meaning rendered as geometry — words and documents mapped into a space where closeness equals similarity. The quiet mathematics that lets a machine find the one relevant paragraph among a million.
Deep Dive — RAG & CAG
The Retrieval Engine Room
A language model is brilliant but forgetful — and it will confidently invent what it doesn’t know. Retrieval-Augmented Generation fixes that by feeding the model the right slice of your data at the right moment, so every answer is grounded, current, and citable.
Getting it right is an engineering craft: how you split documents, how you search, and how you rank what comes back decides whether the system feels brilliant or brittle.
Agent Design Patterns
The reasoning blueprints behind a dependable agent. Picking the right pattern for the job is what keeps a system both capable and predictable.
ReAct
Reason → act → observe → repeat. The model thinks, calls a tool, reads the result, and loops until the task is genuinely done.
Reflection
The agent critiques and revises its own output before returning it — catching mistakes a single forward pass would happily ship.
Planning
Break a fuzzy goal into an explicit plan of steps, then execute and re-plan as new information arrives.
Multi-Agent
Specialised agents — researcher, writer, reviewer — collaborate under an orchestrator, each doing the one thing it's best at.
Tool Use
Reach for the right tool — search, SQL, API, code execution — instead of guessing from memory. Capability, not confabulation.
Routing
A lightweight classifier sends each request down the cheapest capable path — small model, big model, or a fixed workflow.
Orchestration & Frameworks
The gears that turn a single prompt into a dependable, multi-step system.
What I Build with AI
Data Stays Home
Private, On-Prem AI with Ollama
Not every prompt should leave your network. For data you can’t send to a third-party API — patient records, financials, proprietary code — I serve open-source models locally with Ollama, running entirely inside your own LAN or air-gapped environment.
The result: full data residency, zero per-token billing, and no vendor lock-in — the same RAG and agent capabilities, with your data never crossing the wire.
Production-Grade AI
The Trust Layer — Evaluation & Observability
Anyone can wire up an impressive demo. The hard part — the part that separates a toy from a product — is proving it keeps working. I treat AI like any other production system: measured, traced, and guarded.
With LangSmith I trace every step of a chain or agent, evaluate prompt and RAG quality against real datasets, and catch hallucinations before users do. Guardrails enforce safety and policy on both input and output, so the system stays helpful, accurate, and secure under real-world load.
Project Experience
Representative engagements showing how these building blocks come together into systems that ship.
Grounded Knowledge Assistant
- Problem
- Teams losing hours digging through scattered internal docs and PDFs.
- Approach
- RAG pipeline — document parsing → smart chunking → embeddings in pgvector → hybrid search + reranking → grounded, cited answers.
Instant, source-linked answers from a private knowledge base — no hallucinated facts.
Autonomous Operations Agent
- Problem
- Repetitive multi-step back-office tasks needing judgment at each turn.
- Approach
- A LangGraph agent with tool calling over internal APIs, plus Human-in-the-Loop approval gates before any irreversible action.
A reliable agent that drafts and executes workflows while a human stays in command.
Generative BI — Chat With Your Data
- Problem
- Business users stuck waiting on analysts for every metric, and dashboards that can't answer ad-hoc questions.
- Approach
- Stood up WrenAI as a GenBI layer over the warehouse — modelled business terms, metrics and relationships in a governed semantic layer (MDL), so plain-English questions become validated SQL, charts and summaries with dry-plan checks before anything runs.
Self-serve analytics — non-technical teams query the warehouse in plain English and get trustworthy, governed answers.
Embedded Product Copilot
- Problem
- Users struggling to discover features inside a complex app.
- Approach
- An in-app copilot streaming answers over FastAPI/asyncio, acting on the product through MCP tools, aware of the user's current screen.
A natural-language layer over the product that both answers and acts.
LLM-Powered Workflow Automation
- Problem
- Manual triage, routing and data-entry scattered across disconnected tools and inboxes.
- Approach
- n8n flows with LLM nodes wired into existing systems — automating email & support-ticket triage, lead capture with CRM enrichment, invoice and document data extraction, meeting-notes and thread summarization, content repurposing across channels, and scheduled report generation — each routed to the right person or system.
Hands-off automation of judgment-heavy back-office steps across the whole operation.
Manual Operations, Automated in Layers
- Problem
- An operations-heavy business running on phone calls, forms and spreadsheets — staff manually capturing requests, matching resources, and chasing status updates all day.
- Approach
- Introduced AI automation in graduated levels — first extracting structured data from messy human input, then auto-matching and assigning, then closing the loop with confirmations — keeping a human in control at each step and handing more to the agent as trust grew.
Repetitive coordination and data entry handled automatically, with the level of autonomy dialled up safely as confidence increased.
Got an AI idea?
Let's scope a prototype.
From RAG to autonomous agents — tell me the problem and I'll map the fastest path to a working, production-ready system.
Start a conversation