# Agentic Ai Projects And Mastery
All Agentic Ai Projects And Mastery notes →What is LangGraph
LangChain's graph-based orchestration library — agents as a StateGraph of nodes and edges, with durable checkpointing and human-in-the-loop interrupts as native graph mechanics rather than bolted-on features.
LlamaIndex Workflows
The API surface behind LlamaIndex's event-driven orchestration layer — Workflow/Step/Event class mechanics, Context state and fan-out/fan-in, and how a Workflow sits directly on top of the existing Index/QueryEngine retrieval stack.
OpenAI Agents SDK
Python SDK for OpenAI's Agents framework — the concrete API surface: Agent/Runner construction, the function_tool and handoff() call shapes, Session-backed state, guardrail decorators, and built-in tracing.
1.1 Setting Up the Development Environment
Python project setup, virtual environments, and installing the OpenAI SDK, LangChain, and LangGraph so the rest of the book's code samples run without friction.
1.2 Creating a Tool-Using Agent
Designing an agent from scratch — defining tools, wiring tool calling, building prompt templates, and generating a final response, without a framework in the way.
1.3 Building Agents with LangGraph
Why LangGraph exists, its state-management model, nodes, edges, conditional routing, and how the execution flow maps onto the five-component agent loop.
1.4 Testing and Debugging Agents
Unit testing tools in isolation, mocking LLM calls, debugging a live agent flow, and a troubleshooting guide for the failure scenarios that recur across every agent built in this book.
2. Build an MCP Server
A guided, hands-on build of a Model Context Protocol server exposing a real tool (e.g., an observability query tool) with schema-validated inputs and outputs, deployable and testable end to end.
3. Build an Agent with Memory
Hand-rolling short-term and long-term memory for an agent — SQLite-backed storage for conversation history and investigation history across sessions.
4.1 Building an Operational Knowledge Base
Turning runbooks, playbooks, architecture documents, incident reports, and best practices into a RAG corpus an investigation agent can actually retrieve from.
4.2 Retrieval-Augmented Generation (RAG)
Why RAG exists, document processing and chunking strategy, embeddings, vector database choice, and the retrieval pipeline that feeds relevant context into an agent's prompt.
5. Build a Coding Agent
A guided, hands-on build of a coding agent that reads a repository, plans a change, edits files, and runs tests in a sandboxed loop with a human-review checkpoint before merge.
6. Build a Multi-Agent System
A guided, hands-on build of a multi-agent system applying the supervisor and orchestrator-worker patterns from Part 00 of AI Architecture & System Design to a concrete task, with message-passing and failure-handling code.
7.1 Connecting Agents to Grafana
Wiring an agent's tool layer to Grafana's HTTP API and Prometheus datasource — authentication, the metrics query surface, and the error handling an agent needs when a query fails mid-investigation.
7.2 Building a Log Investigation Tool
Exposing Loki's API and LogQL as an agent tool — time-range filtering, log summarization, and pattern detection so an agent can search logs the way an SRE would.
7.3 Building a Trace Investigation Tool
Exposing Tempo's trace retrieval API as an agent tool — span analysis, latency investigation, and service dependency analysis from a single trace ID.
7.4 Automated Root Cause Analysis
Correlating metrics, logs, and traces into one evidence trail, scoring confidence in a candidate root cause, and generating an incident summary an on-call engineer can trust.
8. Build an Enterprise AI Platform
A guided, hands-on build of a minimal enterprise AI platform slice - gateway, registry, and one deployed agent - wiring together the architecture covered in Part 01 of AI Architecture & System Design into working infrastructure.
9. Production Deployment
Containerizing and deploying an agent through Docker, Kubernetes, and CI/CD — and the one thing that is actually agent-specific: versioning prompts and models as deploy artifacts.
10. Capstone Project
Assembling every Part of this book into one deployable system — architecture, project structure, end-to-end workflow, RCA generation, dashboards, and deployment.
1. Technical Strategy for AI
Covers writing a multi-year technical strategy for AI adoption inside an engineering org, including how to sequence platform investment against product-team AI feature demand.
2. Build vs Buy Decisions
Covers the decision framework for build-vs-buy on AI platform components (vector DB, agent framework, evaluation tooling), with a worked cost/lock-in/velocity comparison a Staff engineer would present to leadership.
3. AI Platform Roadmaps
Covers translating an AI technical strategy into a quarter-by-quarter platform roadmap with explicit dependency sequencing and the trade-off calls a roadmap forces onto paper.
4. Architecture Reviews
Covers running or presenting in an architecture review for an AI system - the review rubric, common objections a review board raises to agentic designs, and how to defend a proposal under scrutiny.
5. Engineering RFCs & ADRs
Covers writing RFCs and ADRs specifically for agentic-system decisions, where the reversibility and blast radius of a decision (e.g., granting an agent write access) changes how much rigor the document needs.
6. Organizational Design for AI Teams
Covers the organizational design trade-offs between a centralized AI platform team, embedded AI engineers per product team, and a hybrid model, and how ownership boundaries shift as the platform matures.
7. AI Governance at Scale
Covers scaling AI governance across an enterprise - model approval workflows, audit logging requirements, and policy-as-code enforcement for what agents are allowed to do in which environments.
8. AI Economics & ROI
Covers building the cost model and ROI narrative for an AI platform investment in the form a CFO or VP Engineering would actually accept — which benefits are measurable, which are hand-wavy, and how build-vs-buy economics change the answer.
9. Interview Case Studies (L6/L7)
Walks through full mock L6/L7 system-design interview transcripts on agentic-AI topics, with the interviewer's follow-up probes and what separates a passing answer from a borderline one.
10. The Future of Agentic AI
Closes the book with a forward-looking synthesis of where agentic AI architecture is heading (standardized protocols, autonomous operations, agent-to-agent economies) and which of today's patterns are likely to age well.
A. Agent Framework Comparison Matrix
A reference matrix comparing agent frameworks (LangGraph, AutoGen, CrewAI, custom) across state management, tool-calling model, and production-readiness, for quick lookup rather than narrative reading.
B. Prompt Engineering Cheat Sheet
A condensed reference of prompt-engineering techniques (few-shot, chain-of-thought, structured output constraints) with when-to-use guidance rather than the full tutorial treatment given earlier in the book.
C. Agent Design Pattern Catalog
A condensed reference table of every architecture pattern covered in Part 00 of AI Architecture & System Design, listing each pattern's applicability criteria and trade-offs in one scannable page for interview-day review.
D. AI Security Checklist
A checklist reference for auditing an agent system's security posture - prompt injection defenses, tool-permission scoping, secrets handling - meant for a pre-launch review rather than first-time learning.
E. Production Readiness Checklist
A pre-launch checklist reference covering observability, rollback plan, rate limiting, and on-call ownership for shipping an agentic system to production.
F. AI System Design Interview Questions
A bank of practice system-design prompts specific to agentic AI, organized by difficulty, for timed self-practice ahead of an L6/L7 interview loop.
G. OpenAI, Anthropic & Google API Comparison
A reference comparison of the OpenAI, Anthropic, and Google model APIs - tool-calling formats, context window and pricing tiers, and streaming semantics - for choosing a provider without re-reading three sets of docs.
H. MCP Reference Guide
A condensed reference for the Model Context Protocol specification - message types, capability negotiation, and server/client lifecycle - as a lookup companion to the hands-on MCP server build in Part 00.
I. AI Engineering Glossary
A glossary defining the agentic-AI terminology used throughout the book (agent, tool, orchestrator, grounding, hallucination, context window, etc.) for quick reference rather than sequential reading.
J. Recommended Papers, Books & Open-Source Projects
An annotated reading list of foundational papers, books, and open-source projects referenced throughout the book, for readers who want to go deeper on a specific topic after finishing it.
Agentic AI: Projects & Engineering Mastery
A book-shaped table of contents for Agentic AI: Projects & Engineering Mastery: hands-on practitioner builds, Principal/Staff-level technical leadership, and the lookup appendices and vendor/framework reference notes for the whole series. Book 6 of the AI Systems Engineering series.
AutoGen
Microsoft's open-source framework for conversational multi-agent systems — the concrete API surface: AssistantAgent/UserProxyAgent setup, GroupChat/GroupChatManager wiring, tool registration, and the parameters that actually terminate a run.
Haystack Agents
Haystack's Agent component and Pipeline/Tool wiring — the API surface: how a Pipeline gets built and connected, how Agent slots in as one more Component, and how ComponentTool turns an existing retriever into a tool with no re-integration work.
Semantic Kernel
Microsoft's SDK for adding tool-calling and planning to an existing .NET or Python application — the API surface: Kernel construction, KernelFunction/plugin registration, the automatic-function-calling planner, and where .NET/Python SDK parity actually diverges.