AI Agent Engineering: Build Production Ready Agentic Systems

Trace the evolution of ai from symbolic rules to autonomous agents, showing how hardware, data, and logic bottlenecks drove paradigm shifts, from backpropagation to transformers and agentic workflows.

Understand agentic ai as a shift from non-agentic workflows to autonomous, self-correcting systems that plan, reason, and use tools across five levels from basic to autonomous patterns.

Explore how agentic AI enables autonomous, goal-driven intelligence and adaptive decision-making, with multi-step reasoning and parallel execution that scales across domains to boost human productivity through tools and orchestration.

Master agentic design patterns: reflection, tool use, planning, and multi-agent collaboration—to iteratively refine outputs, leverage external tools, and coordinate agents toward robust, production-ready systems.

Explore how a highly autonomous agent designs and executes steps for user requests, using code-driven planning, json or text formats, and coordinating multi-agent workflows to boost accuracy.

Compare LangChain, LangGraph, and DeepAgent for building production-ready LLM-powered agents, from simple tool use to long-running workflows with planning, decomposition, sub-agents, and file-system context.

Compare MCP and A2A: MCP standardizes tool access for AI agents via a shared server and JSON RPC 2.0, while A2A enables agent-to-agent collaboration.

Learn to configure an OpenAI LLM provider, log in to the API platform, add credits, create and revoke API keys, and prepare production-ready agent systems.

Explore LangChain, a framework that provides ready abstraction and integration to build LLM-powered apps and agents quickly with the agent loop, tool, middleware, and guardrails.

Build production-ready agents with LangChain that use tools, keep memory, stream responses, and output structured JSON with guardrails and human approval, guided by LangChain docs and setup files.

Set up a reusable project by creating a python package named langchain, a src folder, and agent.py and tool.py, then install langchain and OpenAI and enable env reading.

Set up an agent with one tool, configure the openai api key, define a weather tool, and run a single tool invocation to fetch Delhi's weather.

Explore how an agent selects among multiple tools using agentic behavior, defining a second tool with a decorator, and executing a Python eval expression to return results.

Explore short-term memory for agents by implementing an in-memory checkpointer tied to a thread id, enabling context across invocations and production-ready persistent memory.

Learn to implement structured output to return validated data instead of freeform text. The session shows a Pydentik model with summary, steps, needs human, and description, plus exporting structured JSON.

Explore streaming tokens, updates, and custom progress for user experience. Implement streaming in the agent to handle messages and updates, printing token content live to power progress.

Master memory and context management for production agentic systems by applying trimming and summarization to the context window and implementing a summarization middleware with long-term memory for user preferences.

Implement guardrails around agents with a deterministic content filter and a PII middleware that redacts emails and credit card numbers. Use a human-in-the-loop to pause and approve actions before execution.

Learn how the model context protocol (MCP) exposes tools as MCP servers and connects multiple agents via a LangChain MCP adapter, using http transport and stateless or stateful sessions.

Explore multi-agent systems and why they matter, showing how a main agent coordinates sub-agents for parallelization, context management, and distributed development through patterns like sub-agents, hands-off, and router.

Learn Lang Graph as a low-level orchestration framework for long-running, stateful agents with durable execution and memory, defining graphs with nodes and edges to enable streaming and human-in-the-loop approval.

Set up a virtual environment, install lang graph, and build a minimal hello world graph with a state graph; add a node and invoke to return an ai hello world.

Define the core lang graph concepts: state, nodes, edges, and show reducers applying partial updates across super steps in a two step Python workflow for topic refinement and joke generation.

Learn to build a chat style graph with a message state and reducer, appending messages, and use conditional edges to route and loop nodes, including quality gates and stop conditions.

Build a tool-calling agent that binds basic arithmetic tools to a chat model using LangChain, and enable streaming updates for real-time, production-ready feedback.

Discover how persistence, interrupts, and time travel enable production ready agentic systems by using an in memory checkpointer to save, resume, and inspect state.

Explore short-term vs long-term memory in Lang Graph, including thread-level persistence, a store abstraction for cross-session data, and how subgraphs enable modular, multi-agent workflows.

Explore how the functional API lets you design agent workflows with entry points and tasks, enabling persistence, memory, interrupts, and streaming while maintaining simple procedural Python code.

Install the Python deep agent toolkit (pip install u-deep-agent) and travelly key, then build a hello world deep agent with planning, web search, tool use, and human in the loop.

Code a hello world deep agent by creating a deep agent with a system prompt and a weather tool, then invoke via LangChain init chat model and print the result.

Create a deep research agent that queries the internet with a web search tool to gather information and draft a short structured report by configuring tools and prompts.

Discover how deep agent uses file system access to create notes and drafts as first-class artifacts, offload memory to notes.md and draft.md, and safely navigate and edit files.

Explore how backends power deep agents by managing ephemeral state and long-term memory, using a hybrid scratchpad with memories, a composite backend, and memory persistence to store preferences and files.

See how sub-agents prevent context bloating by delegating work to specialized researchers and writers. Keep the main agent focused on high-level coordination with streaming updates.

An overview of human in the loop for ai agents, configuring interrupt-on to require approvals for sensitive tools, and using checkpoints and config files to manage tool execution.

Extend deep agent capabilities with skills by creating skill.md files, using progressive disclosure to match prompts, and integrate land graph docs to fetch and provide accurate guidance.

Isolate the agent's execution from the host system with sandboxes, exposing a shell command tool and file system access. Enable security, reproducibility, and flexible deployment across environments.

Discover Langfuse, an open source llm observability and analytics platform for production ai applications, covering observability and tracing, problem management, and evaluation.

Install langfuse locally via self-hosting, clone the repo, and run docker compose up. Sign up at localhost:3000, create an organization and project, then generate an API key for tracing.

learn to set up langfuse, configure tracing for a langchain agent, build a small add-numbers tool, run the agent, and view traces and logs in the langfuse dashboard.

Learn to centrally manage prompts with versioned control, compare changes like GitHub, and promote the latest prompt versions to production using experiments and metrics.

Configure evaluators and data sets with prompts and expected outputs, run traces, and use human or self annotation to judge agent performance with an LLM as the evaluator.

Explore FastAPI, a modern, high-performance Python web framework for building APIs. Learn to expose your agent via a production-ready backend with automatic OpenAPI documentation, health checks, and an MCP server.

Set up a production ready api with FastAPI and uvicorn, including boilerplate, environment loading, logging, and a healthcheck endpoint that returns 200. Configure cors and access the auto docs.

Explore how to design schemas for request and response, set up an asynchronous database connection with SQLAlchemy, and outline a chat history model to store agent interactions.

Expose a researcher agent through a new api endpoint, configure a lang chain agent with a basic system prompt, and test with swagger before enabling live information from the web.

Build an mcp server inside a fastapi app and expose it over http with a streamable json response. Organize a toolkit with a research paper analyzer tool for future tooling.

Explore building production-ready MCP tools by implementing the arxiv search tool, defining schemas, and enabling dynamic tool discovery for AI agent engineering.

Expose MCP server tools via a new API endpoint to external users after discovering and listing them on the MCP server.

Connect the MCP server with the AI agent client by wiring main.py to create a multiserver MCP client and an agent, then configure routers and tool calls for production deployment.

Explore the A2A protocol, an open standard that enables secure, interoperable agent-to-agent communication across diverse frameworks, enabling autonomous agents to collaborate with standardized contexts and support streaming and long-running tasks.

Explain why agents are not tools, contrasting single-task tools with adaptive, multi-turn agents that use mcp and e2a protocols to collaborate and plan across tasks.

Master the core concepts of A2A, including the user, client, and remote agents, agent cards, tasks, messages, parts, and artifacts, plus interaction patterns and security.

Explore how agents discover each other in an A2A protocol via the agent card. The card lists identity, service endpoint, capabilities, and skills.

Explore streaming and asynchronous operation in the A2A protocol, enabling real-time updates via server-sent events and reliable push notifications for long-running, multi-step tasks.

Set up a python-based A2A server with the A2A SDK and define an agent skill and agent card to describe capabilities and how the server handles tasks.

Implement an async agent executor with execute and cancel, updating task state and artifacts via an event queue, and connect a hello world agent to a starlet uvicorn server.

Build a2a server: fetch and display the agent card from localhost:9999, then send text messages with optional streaming to receive chunks.

Learn to integrate a large language model into an a2a architecture by initializing an agent, configuring a chat model, and performing asynchronous invocations with a system prompt.

Build production-ready, secure, governed AI agents by mastering the agentic threat landscape, secure architecture, identity and policy controls, data protection, monitoring, and multi-agent governance.

Explore prompt injection, goal hijacking, and tool misuse in AI agents, including indirect prompt injection via rag and memory. Learn defenses, detections, and layered safeguards for secure, aligned agents.

Secure the information layer in agentic AI by protecting data flows—from sources to memory and RAG retrieval—against disclosure, leakage, PII risks, memory poisoning, and cross-tenant threats.

Implement human oversight, monitoring, and production defense to intervene at high-risk actions. Establish approval queues, decision records, and the approve-edit-reject-respond workflow with policy validation and audit logs.

Secure multi-agent AI systems by defining trust boundaries, governance, and secure inter-agent communication. Explore isolation, monitoring, and deployment readiness to prevent cascading failures and rogue agents.