AI Security Bootcamp-Guardrails,LLM Gateways,Observability

Discover the latest LangChain updates, covering docs, agents, multi-model integration, tool calls, messages, memory, streaming, middleware, guardrails, and UV package manager setup.

See how LangChain enables autonomous agents to call tools and use context. Build a basic weather tool in a virtual environment and run it with an OpenAI API key.

Learn to integrate LangChain with OpenAI, Google Gemini, and Grok by loading API keys, initializing chat models, and invoking models like GPT-4.1 and Gemini 2.5.

Explore streaming and batch techniques with Langchain to optimize LLM interactions. Experience streaming delivering output as it is generated, and batch enabling parallel processing to boost performance and reduce cost.

Learn to create tools in langchain, define a tool with a decorator and docstring, bind it to an llm, and use a tool execution loop to fetch weather data.

Explore LangChain messages as the core context units for LLMs—system, human, AI, and tool messages with metadata and conversation history, and distinguish text prompts from message prompts.

Learn how to enforce structured output from LLMs with schema-driven prompts, using Pydantic field validation, nested structures, and model with structure techniques.

Apply typedict to generate structured output without runtime validation, contrasting it with pydantic models. Create a movie schema with typing extensions and annotated fields to produce a dict-based result.

Discover how data classes enable structured output through a contact info schema, using Pydantic, typing extensions, and a GPT-5 LangChain agent to produce validated results.

Explore middleware in LangChain, focusing on the summarization middleware that compresses history and preserves recent context. Learn to use hooks and triggers—token, message, or fraction based—and built-in middlewares like logging.

Implement human in the loop middleware to pause autonomous agents for approval and perform interrupt checks in high-stakes tasks such as a financial transaction.

Explore guardrails around AI agents, detailing deterministic and model-based approaches, and learn to implement them with LangChain middleware, including PII detection, human-in-the-loop, before/after agent hooks.

Explore the fundamentals of building agentic AI applications with Langgraph, including chatbots, tool integration, memory, human-in-the-loop, graph concepts, and multi-agent workflows toward deployment.

Set up a Python project workspace with uv, create a virtual environment, install Lang Graph, Lang Chain, and Lang Smith, and build a basic chatbot using Lang Graph APIs.

Build a basic AI chatbot using LangGraph's state graph. Learn edges, nodes, and state, reducer-based message history, and LLM prompts to drive the conversation.

Learn to build a React agent architecture with LangGraph by binding LLMs to tools, enabling tool calls with Tavili search and custom functions for a chatbot.

Explore memory implementation in LangGraph using a memory saver checkpoint for persistent checkpointing across interactions and streaming with update and value modes.

Learn how to implement human in the loop feedback within an AI agent workflow, using an interrupt mechanism to pause tool calls and incorporate human guidance before continuing.

Learn to debug and monitor Langraph workflows with Langsmith and Langraph Studio, explaining observability for Langchain AI apps, including tools, memory, and multi-agent patterns.

Learn to implement multi-agent systems with LangGraph, exploring simple, supervised, and hierarchical architectures using researchers, analysts, and writers, plus grok tools for web search and summary generation.

Learn to build MCP servers and a client within an app using LangChain adapters, enabling tool calls like addition, multiplication, and weather via stdio and streamable http transports.

Master observability for AI systems by tracking logging, tracing, metrics, user feedback, and evaluation signals across the pipeline, turning data into dashboards and alerts that improve latency, cost, and trust.

Explore frameworks for observability in AI security, focusing on LangSmith and Pydentic LogFire. Learn how these tools support logging, tracing, metrics, evaluation signals, and agent performance with multi-language SDKs.

Learn how LangSmith, a LangChain observability framework, traces LLM calls and agentic flows, visualizes runs and traces, and measures cost, latency, and tokens with default and custom tracing.

Learn to enable automatic tracing with LangSmith and LangChain, and to implement manual tracing using the traceable decorator for enriched, metadata-rich traces and observability.

Explore simple rag and agentic rag, including document chunking, vectorization with google embeddings, and a fias vector store, then retrieve, prompt, and orchestrate multi-agent workflows with traces.

Develop an app to observe and trace an agentic workflow in Langrath Studio (Langsmith), exploring a five-node graph: planner, document reader, web in richer, synthesizer, and report writer.

Convert graph logic into a Langgraph Studio app with session IDs, caching, and a Streamlit UI, orchestrating planner, document reader, web enricher, synthesizer, and report writer with observable traces.

Learn to use the pydantic logfire observability framework to trace your entire application, including llm execution. Compare this with llm tracing using langsmith and understand spans, traces, and waterfall concepts.

Set up logfire for AI observability by configuring tokens and API keys, initializing a notebook, and demonstrating logging with configure, info, and spans to build LLM traces.

Learn structured logging for LLM calls using pydantic models with logfire. Capture requests, responses, tokens, latency, and observability spans across grok and Gemini.

Trace a simple rag pipeline from data ingestion to retrieval, embedding documents with Gemini through Lang chain, storing in a FIOS vector store, and logging with log fire for traceability.

Trace a react agent that reasons before acting, using a retriever tool to query a vector database, enforce guardrails, and answer policy and general questions.

Design a multi-agent workflow led by a planner that routes queries to explain, analyze, creator, or web search agents, with a formatter finalizing the response and log fire tracing.

Explore testing trace and agentic app execution by building a modular graph-enabled Streamlit app that initializes a shared cache, configures a multi-agent workflow, and logs traces with log fire.

Apply guardrails as safety controls and policies that validate, filter, and restrict inputs and outputs of LLMs to ensure safe, reliable, and trustworthy AI.

Nemo guardrails from NVIDIA adds a security layer to large language models, using fast embed similarity with input, output, and custom rails to enable secure, guided RAG chatbots.

Learn to write rails in Nemo Guardrails using Colang, define user, bot, and flow, and combine YAML config with model instructions for secure AI interactions.

Develop Nemo guardrails from scratch by setting up a virtual environment, installing LangChain and dependencies, and implementing guardrails to protect raw LLM interactions.

Implement the first input guardrail to classify queries as on topic or off topic, and respond with guarded replies using colang and yaml configurations.

Explore input rails for guarding against off-topic, jailbreak, sensitive-topic, and dialogue behaviors using Nemo guard and llama guard layers, colang configurations, and conversational flows.

Learn to build custom rails and actions that detect PII and urgency, bridging python logic with colang flows, and apply input and output rails to secure LLM conversations.

Study output rails as the last line of defense between the LLM and the user, using an output sanitizer to remove leaked credentials and other sensitive details from responses.

Learn how to build a secured HR policy assistant bot with grok models, guardrails, and a rag pipeline using FIOS vector store and HR documents.

Test a secured HR assistant by building a streamlit user interface with a sidebar, docs and chat tabs, featuring nemo guardrails and LLM gateway configurations, plus vector store integration.

Explore how AWS guardrails manage input and output in AI systems using topic policy, content policy, word policy, sensitive information policy, and grounding policy within Bedrock.

Learn to create guardrails for a cooking chatbot with AWS bedrock and SDK, configuring topic, content, and word policies, and compare guardrails with and without protection.

Explore guardrail types—inline guards with an LLM (invoke model and converse) and the AWS guardrails API—compare single-shot and multi-turn flows, and understand trace structure and input/output sources.

Block unsafe content with content filters and guardrails across hate, insults, sexual content, violence, and misconduct, while balancing confidence and threshold to prevent false positives and negatives.

Set up AWS Bedrock guardrails with high-threshold filters for hate, insult, misconduct, and prompt attack. Compare high and low thresholds to assess guardrail testing and trace analysis.

Learn to enforce safety in AI chatbots by implementing denied topics, word policy, and PII policy with guardrails, using the Converse API, and understanding block versus anonymize.

Learn to control hallucinations in retrieval augmented generation by applying grounding guardrails that validate llm output against source documents using grounding and relevance scores.

Master versioning and drafts to safely deploy guardrails, monitor performance and costs, and implement automated testing and ci/cd workflows in production.

Explore how AWS guardrails cost compares with open-source options, analyzing policy counts, text units, and API calls, and explain why AWS guardrails can be more cost-efficient and easier to manage.

Explore the guardrails ai framework, why to use it, and components like guardrails hub and validators. Learn to apply guardrails during streaming, integrate with lang chain, and deploy in production.

Guardrails AI aims to make probabilistic LLM outputs strict and predictable using Pydentic style schemas, through guardrails hub validators, open source and enterprise options, and broad ecosystem integrations.

Explain guardrails hub and validators, including input and output validators, on-fail actions, and built-in vs custom validators, with practical demos on PII, toxicity, competitor checks, and topic restrictions.

Explore on fail actions for guardrails in LLM-based refund workflows, using max refund validators to auto-approve under thresholds and route failed outputs to re-ask, fix, filter, refrain, or exception paths.

Understand on fail actions in guardrails, including reask, fix, filter, refrain, and exception, with PII redaction and validator-driven prompts demonstrated through real examples.

implement guardrails hub validators and onfill action in a notebook, installing dependencies, configuring remote inference with an api key, and validating pii, toxicity, and restricted topic.

Delve into implementing guardrails validators, including PII detection, toxic language, competitor checks, and restricted topic, using a guard object for local and remote inference and on-file actions.

Implement on file actions in guardrails by orchestrating validators and actions, such as fix, filter, reframe, and exception, demonstrated with the competitor check validator in a Jupyter notebook.

Demonstrates implementing on-fail actions in guardrails, including filter, refrain, exception, and re-ask, using structured guard objects, parsing, and iterative re-asks with an LLM.

Explore input and output structure validation with Guardrails AI, turning unstructured text into typed structured data using Pydantic schemas, extraction prompts, and optional tool calling.

Explore the guardrails AI guard object and how to apply guardrails during streaming, including LLM call flows, validators, on-file actions, and streaming validation architecture.

Configure guardrails ai as a runnable in the lang chain, convert the guard object for reuse across workflows, and validate outputs with the competitor check validator.

Explore how to deploy guardrails in production and scale with a central guardrails architecture. Learn how central policy, orchestration, and observability enable reusable policies across microservices and multi-language apps.