Chiazam – Python, LLM, RAG

A Retrieval-Augmented Generation system that routes support queries across multiple knowledge backends, including PCX and Alfred RAG, using a single-LLM classifier. The product supports host-based backend selection, retrieval hit/miss detection, and automated fallback to structured contact information when no relevant answer is found.

• Designed and implemented an LLM-based intent classifier to route support queries between direct-answer, RAG-backed, and fallback paths.
• Built dynamic host/backend selection logic to query the correct knowledge source based on request context.
• Implemented hit/miss detection on retrieval results to distinguish confident answers from low-relevance matches.
• Engineered automated fallback to structured contact YAML, reducing dead-end responses for users.
• Added a regex-based fallback layer to maintain routing reliability when LLM classifier output was ambiguous.

A planner-LLM architecture that classifies incoming user intent and dispatches requests across specialist agents, including account, transaction, search, and knowledge base support agents. The product includes a dedicated intent-classification layer and rule-based fallback to maintain robust routing when the LLM classifier is uncertain.

• Architected a planner LLM to sit in front of multiple specialist agents and dispatch requests based on classified intent.
• Defined agent-handoff logic between the planner and downstream agents (e.g., knowledge base agent, order/cart agent).
• Reduced misrouted requests by introducing a dedicated intent-classification layer ahead of agent selection.
• Built fallback handling to preserve system reliability when classification confidence was low.

An LLM-orchestrated, multi-agent system for autonomously analyzing disaster-recovery compliance checkpoints, identifying failures, generating code and test fixes, and dispatching changes across two version-control systems as fully formed pull requests. The product replaces a manual, specification-driven development workflow with an end-to-end agentic pipeline coordinated through a custom MCP server.

• Architected a multi-agent pipeline with distinct specialist agents for bug detection, spec-to-code generation, test generation, and PR-description authoring, coordinated through a custom MCP server acting as the orchestration layer.
• Built an autonomous "Fix with AI" agent that reasons over checkpoint failures, generates the corresponding code, test, and documentation changes, and self-commits under the originating engineer's identity, no manual diff writing required.
• Designed agent-to-repo handoff logic enabling the system to autonomously push and open PRs across two separate remotes (internal GitHub, third-party Azure DevOps) with repo-specific output scoping (e.g., excluding internal versioning artifacts from the externally-owned repo).
• Implemented a spec-driven development framework, versioned YAML specs and changelogs as a machine-readable source of truth, so downstream agents could generate and validate code changes without human-authored prompts per fix.
• Built fallback and validation logic (test execution, schema checks) to keep autonomous commits reliable when LLM-generated fixes required review before reaching the PR stage.
• Reduced manual remediation and review turnaround time by automating the full detection to generate, test, and commit to the PR lifecycle for compliance checkpoint fixes.

An agentic AI system for analyzing architectural floor plans for accessibility compliance under the Ontario Building Code (OBC Section 3.8). The product combines YOLOv8-based fixture detection with a LangGraph-orchestrated multi-agent system, where specialized agents reason about measurements, compliance rules, spatial layout, and code citations before aggregating their findings into a structured compliance report. The report is delivered through a Django REST API to a React frontend.

• Architected a coordinator agent to sit in front of four specialist agents (Measurement, Compliance Checker, Spatial Analysis, Code Reference) and dispatch shared state across them based on YOLO detection output.
• Defined agent handoff logic using LangGraph's shared-state model, allowing each agent to read prior agents' outputs and append its own findings before returning control to the coordinator.
• Built a Compliance Checker agent that validates real-world measurements against OBC Section 3.8 and generates severity-ranked issues (Critical/Major/Minor) with a computed compliance score.
• Built a Code Reference agent that retrieves and cites exact OBC requirement text to ground every flagged issue in verifiable code language, reducing hallucinated compliance claims.
• Integrated a computer vision layer (YOLOv8) as the perception front-end, converting pixel-space detections into real-world measurements consumed by downstream reasoning agents.
• Designed the system to degrade gracefully; partial or uncertain detections still produce a structured, explainable report rather than a hard failure.
• Shipped the full pipeline end-to-end: Django REST API orchestration, PostgreSQL/JSONB storage of agent outputs, and a React dashboard for reviewing annotated floor plans, scores, and recommendations.