skip to content
AZM

Start building AI Agents using New LangChain

ml , workshop , ai , langchain , agents , mcp , signoz

A focused half-day hands-on workshop proposal on building AI agents using LangChain harnesses, Model Context Protocol (MCP), A2A, and SigNoz observability.

Workshop Overview

This is a half-day, hands-on workshop focused directly on building practical AI agents using the modern LangChain agent harness.

Rather than getting lost in low-level graph mechanics, manual state channels, or prompt engineering theory, this workshop takes an ergonomic, developer-first approach. We introduce the high-level agent harness in modern LangChain—allowing developers to spin up production-ready, tool-calling agents without manually managing complex internal states. From there, we dive straight into exposing tools through the Model Context Protocol (MCP), coordinating multi-agent communication (A2A), and establishing full-stack observability with SigNoz alongside automated triggers.

Quick Facts

  • Duration: Half-day (~3.5 to 4 hours)
  • Format: 80% code-along & labs, 20% architectural walkthrough
  • Primary Focus: LangChain Agent Harness, Tool Calling, MCP, Agent-to-Agent (A2A) Coordination, SigNoz Observability
  • Target Audience: Developers and backend engineers looking to build agents without the boilerplate of low-level state graphs

Half-Day Agenda

[00:00 - 00:20] Quick Primer: Prompts & Context for Agent Tools
[00:20 - 01:10] The LangChain Agent Harness (Zero-State Setup)
[01:10 - 01:25] --- Break & Setup Q&A ---
[01:25 - 02:10] Expose Tools as MCPs (Model Context Protocol)
[02:10 - 03:00] Inter-Agent Communication (A2A)
[03:00 - 03:45] Observability with SigNoz & Event Triggers

1. Quick Primer: Prompts & Context for Agent Tools (20 mins)

A rapid warm-up covering strictly what the agent harness needs to operate reliably.

  • System Instructions for Agents: Directing agent behavior, setting boundaries, and preventing runaway loops.
  • Structured Tool Inputs: How tool schemas (Pydantic / function signatures) guide model execution under the hood.
  • Context Hygiene: Preventing context-window bloat during iterative tool calling.

2. The LangChain Agent Harness (50 mins)

Spinning up autonomous agents without low-level graph or state management.

  • The Modern Agent Harness:
    • How the modern LangChain agent harness abstracts the execution loop and state plumbing.
    • Moving away from manual StateGraph wiring: why most business applications only need the high-level agent harness.
  • Tool Definition & Binding:
    • Writing type-safe custom Python tools with the @tool decorator.
    • Registering tools with the harness and letting the model decide execution order.
  • Streaming & Invocations:
    • Invoking agents, handling streaming responses, and inspecting agent decision steps cleanly.
  • Hands-on Lab: Build a fully functional, tool-using assistant in under 20 lines of code using the LangChain harness.

Break (15 mins)

3. Expose Tools as MCPs (45 mins)

Decoupling tool implementations using the open Model Context Protocol.

  • Why MCP?: Moving from siloed, hardcoded tools to standard, reusable tool microservices.
  • Building a Fast MCP Server: Implement a lightweight Python MCP server exposing database queries or local utility scripts.
  • Plugging MCP into the LangChain Harness: Connect the agent harness to external MCP servers dynamically without rewriting tool logic.
  • Hands-on Lab: Launch a local MCP server and bind its tools directly to your agent harness.

4. Inter-Agent Communication (A2A) (50 mins)

Orchestrating multiple specialized agents without complicated state machines.

  • Agent-to-Agent (A2A) Patterns:
    • Agent-as-a-Tool: Exposing a specialized agent harness as a callable tool to an orchestrator agent.
    • Delegation & Handoffs: Clean message exchange between independent agent harnesses.
  • Preventing Deadlocks & Infinite Loops: Guardrails for peer-to-peer agent conversations.
  • Hands-on Lab: Create an A2A workflow where a primary Coordinator Agent delegates specialized research tasks to a dedicated Researcher Agent and reviews its findings.

5. Observability with SigNoz & Setting Triggers (45 mins)

Full-stack telemetry with OpenTelemetry and automating execution.

  • Why SigNoz for AI Agents?:
    • Native OpenTelemetry (OTel) support: zero vendor lock-in for traces, metrics, and logs.
    • Unified view of agent runs, application backend calls, and database queries in one dashboard.
  • Instrumenting the Agent Harness:
    • Auto-instrumenting LangChain via OpenTelemetry / OpenInference to export spans directly to SigNoz.
    • Visualizing intermediate tool executions, model latency, and token consumption breakdowns.
    • Debugging tool exceptions and trace bottlenecks in the SigNoz trace flamegraph.
  • Setting Triggers & Automation:
    • Moving from interactive chats to automated background agents.
    • Scheduled triggers (running agents on cron intervals for health checks and summaries).
    • Event triggers (invoking agents via incoming webhooks or queue messages).
  • Hands-on Lab: Export live agent execution traces to a SigNoz instance and trigger an automated agent execution with an event payload.

Prerequisites & Requirements

  • Python Knowledge: Comfortable with basic Python functions, decorators, and virtual environments.
  • Environment: Laptop with Python 3.10+, an IDE (VS Code / PyCharm / Cursor), and git.
  • API Key: Access to an OpenAI, Anthropic, or local Ollama LLM endpoint.
  • SigNoz Setup: Local SigNoz (via Docker Compose) or a SigNoz Cloud test account.

What Participants Walk Away With

  • A clean, modern starter repository using the high-level LangChain agent harness.
  • Ready-to-use templates for Python MCP servers and dynamic client bindings.
  • Out-of-the-box OpenTelemetry instrumentation configurations for sending agent traces to SigNoz.
  • Practical blueprints for multi-agent (A2A) delegation and event-driven triggers.