Featured resource
2025 Tech Upskilling Playbook
Tech Upskilling Playbook

Build future-ready tech teams and hit key business milestones with seven proven plays from industry leaders.

Check it out

Agentic AI: Reactive & Non-Conversational Agents

Course Summary

This course introduces developers to reactive, non-conversational agents: systems that quietly monitor, decide, and act without user interaction. Using LangGraph, LangChain Tools, and the Model Context Protocol (MCP), participants will build agents that observe metrics, trigger alerts, and take autonomous action. Participants will work to build a containerized agent deployed on Hugging Face Spaces ready for integration into ops, security, and finance environments.

Prerequisites
In order to succeed in this course, you will need:

  • Experience programming with Python
  • Familiarity with using external libraries and working with APIs
Purpose
Build reactive, non-conversational agents that monitor and act on real-time data
Audience
Developers building autonomous agents for backend operations, security, and finance
Role
Developers | DevOps Engineers | SREs | Cybersecurity Professionals
Skill level
Intermediate
Style
Lecture | Hands-on Exercises
Duration
2 days
Related technologies
Agentic AI | LangGraph | LangChain | Python
 
Course objectives
  • Identity high-ROI use cases for non-conversational agents
  • Connect event streams and wrap APIs as LangChain Tools
  • Build and wire reactive graphs in LangChain
  • Use MCP to register plugins and trigger external systems
  • Monitor and log decisions for observability and safety
  • Deploy a continuous agent to Hugging Face Spaces as a Docker microservice

What you'll learn:

In this course, you'll learn:
  • Agentic AI Primer (Core Concepts & Terminology)
    • Defining agentic systems and how they differ from standard automation
    • Agentic components: memory, tools, and reasoning loops
    • Comparing agentic workflows with RAG and fine-tuning
    • Shared terms: planner, executor, environment, guardrails 
  • What Makes an Agent “Reactive”?
    • Defining reactive agents and real-time use cases
    • Rule-based, event-based, and LLM-driven patterns
    • Internal use cases: ops, finance, security
  • Event Sources & Scheduling
    • Simulating logs and synthetic events
    • Cron, APScheduler, and webhooks
    • Timezones and idempotency
  • Building Tools & Data Connectors
    • Creating LangChain Tools with Pydantic
    • Wrapping APIs
    • Handling auth tokens, rate limits, and retry logic
  • First LangGraph Loop
    • Intro to LangGraph nodes and edges
    • Node roles: observation, decision-making, action
    • Adding correlation IDs and logging agent decisions
  • Guardrails, Retries, & Observability
    • Exponential backoff, dead-letter queues, and circuit breakers
    • Structured logging and Slack notifications
    • Observability stacks and cost monitoring
  • Model Context Protocol (MCP) & Plugins
    • MCP anatomy:
      • Manifest
      • Schema
      • Context handling
    • Registering and invoking plugins
    • Micro-permissioning and audit trail logging
  • Packaging as a Microservice
    • FastAPI wrapper for status endpoints
    • Docker basics and Hugging Face deployment
    • Managing secrets and config with env vars

Dive in and learn more

When transforming your workforce, it’s important to have expert advice and tailored solutions. We can help. Tell us your unique needs and we'll explore ways to address them.

Let's chat

By filling out this form and clicking submit, you acknowledge our privacy policy.