Model Online / On-Site
Duration
Modules 6 modules

Course Objective & Scope

LangChain makes it easy to connect model providers, data sources and tools through standard interfaces, though outdated patterns or over-abstraction can make code hard to maintain. This course teaches the modern, modular LangChain architecture (`langchain-core`, partner packages, the Runnable interface and LCEL) with a clean, production-friendly approach.

Participants build chains using chat models, prompt templates, `with_structured_output`, `bind_tools`, conversation history and basic retrievers, while tracing every step with LangSmith or open-source alternatives on a scenario tailored to their organisation.

Who Should Attend?

  • Developers looking to build LLM applications quickly and cleanly in Python or TypeScript
  • AI engineers standardising model and vector store integrations across projects
  • Teams preparing a solid foundation before advancing to RAG and LangGraph agent courses
  • Prerequisite: intermediate Python (or TypeScript) programming skills

Key Takeaways

  • Use the modern `langchain-core` package layout and the Runnable (`invoke`, `stream`, `batch`) protocol
  • Build provider-agnostic chains that switch cleanly between LLM vendors
  • Implement structured outputs with Pydantic schemas and tool calling with `@tool`
  • Avoid over-abstraction by knowing when to use raw SDKs, LangChain or LangGraph
  • Debug intermediate chain steps, latency and token usage with tracing tools

Curriculum

Modern LangChain Architecture and the Runnable Protocol
  • `langchain-core`, partner packages and separating modern patterns from legacy APIs
  • The Runnable interface: `invoke`, `stream`, `batch` and async execution
Prompt Templates, ChatModels and LCEL
  • `ChatPromptTemplate`, `MessagesPlaceholder` and multi-provider configuration
  • Readable chain composition, parallel execution and fallbacks with LCEL
Structured Outputs and Data Transformation
  • Type-safe responses using `with_structured_output` and Pydantic models
  • Custom output parsers and handling validation failures
Tool Calling and Conversation History
  • Defining tools with `@tool`, `bind_tools` and the tool execution loop
  • Managing multi-turn chat history with persistent storage
Retriever Integration and Observability
  • Fundamentals of document loading, vector retrieval and grounded answers
  • Tracing and debugging with LangSmith or Langfuse, and when to move to LangGraph
Hands-On: Modular Enterprise Assistant Service
  • Building a tool- and retrieval-enabled chain for an internal scenario
  • Adding provider fallbacks and unit tests

Other Courses in This Category

  • LLM Engineering for Java & .NET (Spring AI, LangChain4j, Semantic Kernel)

    Building type-safe LLM, RAG, tool-calling and MCP integrations directly in enterprise Java (Spring AI, LangChain4j) and .NET (Microsoft.Extensions.AI, Semantic Kernel) stacks without switching to Python.

    LLM Application Engineering Corporate
    Live Course
    6 modules
    View
  • Building Enterprise LLM Applications on Amazon Bedrock

    Hands-on programme for building enterprise generative AI solutions on AWS using the Amazon Bedrock Converse API, Knowledge Bases, Agents, Guardrails, IAM/VPC security and cost controls.

    LLM Application Engineering Corporate
    Live Course
    6 modules
    View
  • Enterprise LLM Development with Azure OpenAI and Azure AI Foundry

    Building enterprise AI applications on Azure AI Foundry and Azure OpenAI Service with GPT and reasoning models, Azure AI Search, Entra ID authentication, Private Endpoints, Content Safety and PTU/quota management.

    LLM Application Engineering Corporate
    Live Course
    6 modules
    View
  • Building Enterprise LLM Applications on Google Cloud Vertex AI

    Hands-on programme for building enterprise AI applications on Google Cloud Vertex AI using Gemini models, the Google Gen AI SDK, Context Caching, Grounding, Vertex AI Search, BigQuery and VPC-SC security.

    LLM Application Engineering Corporate
    Live Course
    6 modules
    View
  • Production Architecture Patterns for Enterprise LLM Systems

    Architectural patterns for turning LLM prototypes into resilient enterprise systems: AI gateways, async queues, circuit breakers, fallback chains, idempotency, guardrails and OpenTelemetry tracing.

    LLM Application Engineering Corporate
    Live Course
    6 modules
    View
  • Large Language Model (LLM) Fundamentals

    How foundation models and LLMs work: tokens, context windows, sampling, hallucination, model families and when to choose prompting, RAG or fine-tuning — a hands-on starting point for technical teams.

    LLM Application Engineering Corporate
    Live Course
    6 modules
    View

Get in touch