Hands-On Agentic AI Trading System using MCP & LangChain

In this subsection, we outline all the prerequisites needed to follow along with the hands-on portions of the course. You’ll learn what software, tools, and basic knowledge are required before writing any code, including Python versions, IDE options, and system compatibility for both macOS and Windows. We’ll also clarify optional versus mandatory components, so beginners can get started easily while experienced developers can move faster. By the end of this subsection, you’ll know exactly what needs to be installed and configured before setting up the development environment.

In this subsection, we set up the development environment that will be used throughout the course. You’ll see how to work with Visual Studio Code using the Jupyter Notebook extension, while also learning how the same workflow applies to any IDE of your choice. We’ll walk through creating the project structure, opening notebooks and Python files, and organizing code for MCP servers, clients, and workflows. Although the demos are shown on macOS, equivalent steps and commands for Windows are also covered, ensuring everyone can follow along comfortably.

In this subsection, we configure the required API keys for LangSmith and OpenAI so our agentic system can run securely and be monitored end-to-end. You’ll learn best practices for managing secrets using a .env file instead of hard-coding credentials. We’ll walk through creating the environment file, adding LangSmith and OpenAI keys, and loading them safely in Python. The setup is demonstrated on macOS, with equivalent steps for Windows, ensuring compatibility across platforms. By the end of this section, your environment will be ready for tracing, monitoring, and executing LLM-powered workflows with confidence.

In this subsection, we set up the LLM model endpoints that power our trading agent, focusing on both cloud-based models and local execution using Ollama. You’ll learn how to install and configure Ollama, pull models like Mistral, and verify that your local LLM is running correctly. We’ll also discuss how the same agent architecture can switch between local and hosted LLM endpoints without code changes, reinforcing the cloud-agnostic design of the system. By the end of this section, you’ll have a fully working LLM endpoint ready to plug into LangChain, MCP clients, and agent workflows.

In this subsection, we connect our agent system to real-time and near–real-time financial data sources that power trading analysis. You’ll learn how to integrate market data providers using Python libraries like yfinance, fetch OHLC, volume, and open interest data, and structure this data so it can be consumed by MCP tools and LangChain agents. We’ll also discuss best practices for handling data freshness, API limitations, and error scenarios in production-like environments. By the end of this section, your agent will be able to pull live market data on demand—forming the foundation for technical analysis, workflows, and automated trading insights in later sessions

This subsection introduces practical, real-world use cases where MCP-powered agents add value. You’ll see how agents move beyond simple chat interactions to connect with tools, data sources, and workflows across domains such as trading, enterprise systems, and IoT. This sets the foundation for understanding why MCP is essential for building scalable, production-ready agentic systems.

In this subsection, you’ll learn how to design a trading analysis agent using MCP and agentic LLM principles. We break down the system architecture layer by layer—LLM reasoning, MCP client and server interaction, technical analysis tools, and workflow orchestration. By the end, you’ll understand how real-time market data, indicators like RSI and Bollinger Bands, and decision logic come together in a scalable, cloud-agnostic trading agent.

In this subsection, you’ll explore how MCP-powered agents can be used to design IoT control and monitoring systems. We’ll examine how agents ingest real-time sensor data, detect anomalies, and trigger automated control actions such as adjusting devices or shutting down systems. You’ll learn how MCP enables secure, standardized integration across multiple tools and devices, making IoT systems scalable, responsive, and cloud-agnostic.

In this subsection, we establish the theoretical foundation required to understand workflow orchestration in agentic systems.

You’ll learn what tools are in the context of LLM agents and how they encapsulate real-world actions such as data fetching, analysis, and execution. We then introduce LangGraph, explaining how it enables structured, multi-step workflows where agents can reason, branch, and execute tasks reliably.

Next, we clarify the role of orchestration—how complex agent behavior is managed through controlled execution flows rather than ad-hoc function calls. Finally, we connect these ideas to the MCP Server, showing how standardized tool exposure allows agents and workflows to remain modular, reusable, and cloud-agnostic.

In this subsection, we move from theory to practice by building a fully functional MCP Server from scratch.

You’ll implement real financial tools such as fetching market data, calculating technical indicators like RSI and Bollinger Bands, and exposing them through standardized MCP endpoints. Step by step, we’ll write the server code, define tool interfaces, and connect real-time data sources to make the tools usable by intelligent agents.

This lesson focuses on clean tool design, modular coding practices, and how MCP enables consistent tool discovery and execution across different clients. By the end, you’ll have a working MCP Server that serves as the backbone for trading analysis workflows used in later sessions.

n this subsection, this is continuation of section 4.2 where we move from theory to practice by building a fully functional MCP Server from scratch.

You’ll implement real financial tools such as fetching market data, calculating technical indicators like RSI and Bollinger Bands, and exposing them through standardized MCP endpoints. Step by step, we’ll write the server code, define tool interfaces, and connect real-time data sources to make the tools usable by intelligent agents.

This lesson focuses on clean tool design, modular coding practices, and how MCP enables consistent tool discovery and execution across different clients. By the end, you’ll have a working MCP Server that serves as the backbone for trading analysis workflows used in later sessions.

This subsection is continuation of previuos two subsections, we move from theory to practice by building a fully functional MCP Server from scratch.

You’ll implement real financial tools such as fetching market data, calculating technical indicators like RSI and Bollinger Bands, and exposing them through standardized MCP endpoints. Step by step, we’ll write the server code, define tool interfaces, and connect real-time data sources to make the tools usable by intelligent agents.

This lesson focuses on clean tool design, modular coding practices, and how MCP enables consistent tool discovery and execution across different clients. By the end, you’ll have a working MCP Server that serves as the backbone for trading analysis workflows used in later sessions.

In this section, we focus on orchestrating intelligent workflows using LangGraph through a fully hands-on coding session.

You’ll learn how to design and implement multi-step agent workflows where tools are executed in a structured, reliable sequence instead of ad-hoc calls. Using LangGraph, we’ll define states, transitions, and execution paths that allow agents to fetch market data, compute indicators, analyze results, and generate trading insights in a controlled flow.

This session demonstrates how LangGraph complements MCP by adding determinism, conditional logic, and fault tolerance to agent systems. By the end of this section, you’ll have a working orchestration pipeline that transforms individual tools into a production-ready trading workflow.

In this section, we integrate LangGraph-based workflow orchestration directly into the MCP Server, transforming it from a collection of standalone tools into a cohesive, intelligent service.

You’ll learn how to expose orchestrated workflows as first-class MCP endpoints, allowing agents to trigger complex, multi-step executions through a single standardized interface. We’ll connect LangGraph workflows with MCP server routes, enabling end-to-end analysis pipelines such as fetching market data, computing indicators, and generating insights in one controlled execution.

This section bridges tool development and system-level design, demonstrating how MCP and LangGraph work together to support scalable, modular, and production-ready agent systems.

In this session, we explore the MCP Client as the core component responsible for tool integration, tool discovery, and secure execution in agentic AI systems. You’ll understand how the MCP client bridges large language models with MCP servers, enabling agents to dynamically discover available tools and invoke them in a structured, reliable way.

We break down how the MCP client:

• Discovers tools exposed by MCP servers

• Integrates those tools into agent frameworks like LangChain

• Translates LLM intent into executable tool calls

This hands-on session focuses on executing an MCP client in practice, bringing together tool discovery, intent detection, and real tool execution. Learners will implement and run an MCP client that interprets user queries, detects intent using a system prompt, dynamically discovers available tools from the MCP server, and invokes the correct tool at runtime.

We walk through coding the intent detection logic, demonstrating how carefully designed system prompts guide the LLM to select the appropriate tool and extract parameters reliably. The session highlights how MCP clients convert natural language requests into structured actions, making AI agents deterministic and production-friendly.

This hands-on part 2 session focuses on executing an MCP client in practice, bringing together tool discovery, intent detection, and real tool execution. Learners will implement and run an MCP client that interprets user queries, detects intent using a system prompt, dynamically discovers available tools from the MCP server, and invokes the correct tool at runtime.

We walk through coding the intent detection logic, demonstrating how carefully designed system prompts guide the LLM to select the appropriate tool and extract parameters reliably. The session highlights how MCP clients convert natural language requests into structured actions, making AI agents deterministic and production-friendly.

In this session, we bring everything together by integrating the MCP client with the MCP server to enable full end-to-end execution of agent workflows. Learners will connect the client’s intent detection and tool discovery logic with the server-hosted trading tools, demonstrating how natural language queries are transformed into real tool executions.

We explore how the MCP client authenticates, routes requests, and invokes server-side tools, while the MCP server responds with structured outputs. This session emphasizes modular architecture, showing how clients and servers can evolve independently while remaining loosely coupled through MCP.

Using a trading analysis use case, you’ll observe the complete lifecycle—from user query, intent detection, and tool selection to server execution and response handling—laying the foundation for scalable, production-grade agent systems.

In this session, we implement a production-style MCP client using LangChain, demonstrating how LangChain agents can seamlessly interact with MCP servers and tools. Learners will see how LangChain abstracts prompt handling, tool execution, and agent reasoning while still leveraging MCP’s standardized tool interface.

Using a trading analysis use case, we demonstrate how natural language queries flow through a LangChain agent, trigger MCP tool execution, and return actionable results—setting the stage for monitoring and observability with LangSmith in the next session.

In this session, we build a conceptual understanding of monitoring and observability in agentic AI systems using LangSmith. Before diving into dashboards and code, learners explore why monitoring is essential for modern AI agents that rely on LLM reasoning, tool execution, and multi-step workflows.

We discuss how LangSmith tracks agent decisions, tool invocations, workflow paths, latency, and failures, and why traditional logging is insufficient for agent-based architectures. Using examples from our trading agent and MCP-based workflows, we explain how LangSmith enables traceability, debugging, performance optimization, and compliance auditing.

In this session, we move from theory to implementation by adding LangSmith tracing to the MCP-based trading agent we have built so far. Learners will make minimal but powerful code changes to enable full observability across agents, tools, and workflows.

We demonstrate how to instrument LangChain agents, MCP clients, MCP server tools, and LangGraph workflows using LangSmith decorators and environment configuration. You’ll see how traces are automatically captured without changing business logic, making it easy to monitor agent reasoning, tool execution, and workflow paths.

By the end of this session, learners will be able to confidently trace agent behavior in the LangSmith cloud dashboard and understand exactly how each user query flows through the system.

In this session, we explore the LangSmith dashboard to understand how agent behavior is monitored, visualized, and debugged in real time. Learners will see how traces generated from the previous session appear in the LangSmith UI and how to interpret them to gain deep insights into agent reasoning and execution flow.

We walk through the Tracing Projects, Monitoring views, and execution traces, showing how LangSmith captures LLM calls, tool invocations, MCP client–server interactions, and LangGraph workflow steps. This session focuses on helping learners read and reason about traces, not just generate them.

By the end of the session, learners will be able to confidently use the LangSmith dashboard to debug agent behavior, analyze performance, and support compliance and auditing requirements.

In this subsection, we build and execute a complete MCP-powered trading agent that integrates reasoning, tooling, workflows, and monitoring into one unified system.

Learners will see how:

• A user query is interpreted by an LLM

• The MCP Client detects intent and discovers tools

• The MCP Server executes financial analysis tools

• LangGraph orchestrates multi-step workflows

• LangSmith captures traces, logs, and performance metrics

In this subsection, we explore how agentic AI systems are evolving beyond single agents into modular, interoperable, and collaborative ecosystems.

Topics include:

• Open standards and why MCP matters long-term

• Multi-agent systems and federated agents

• Privacy-aware and distributed AI architectures

• Edge AI and on-device reasoning

The focus is on helping learners understand where the industry is heading, not just where it is today.