Nb. days
3
Face-to-face?
Yes
Remote?
Yes
Min. participants
2
Max. participants
8
Place
Toulouse, Paris, etc.
Pricing
2690€ HT
Moving from an appealing multi-agent prototype in a development environment to an application deployed at enterprise scale is a major challenge. While basic graph modeling is now accessible, the transition to production imposes drastic reliability constraints: exploding token costs, latency management, long-term memory persistence, and unprecedented security risks such as prompt injections or behavioral drift.
This intensive 3-day training is the expert extension of our core curriculum. Designed exclusively for intermediate profiles who already master the fundamentals of orchestration, it focuses on the industrialization, securing, and optimization of complex agentic architectures. The goal is no longer to learn how to create a node or an edge, but to structure highly decoupled systems via a component register (Registry) and to implement strict application guardrails.
During this program, you will delve into advanced communication protocols such as Agent-to-Agent (A2A) and Model Context Protocol (MCP), and you will master execution isolation via code sandboxing. A large part of the training will be dedicated to the LangSmith ecosystem to operate a complete AgentOps strategy: from tracing asynchronous graphs to supervising production metrics (costs, latency), up to setting up automated test suites and self-correction loops (self-evaluation).
This intensive 3-day training is the expert extension of our core curriculum. Designed exclusively for intermediate profiles who already master the fundamentals of orchestration, it focuses on the industrialization, securing, and optimization of complex agentic architectures. The goal is no longer to learn how to create a node or an edge, but to structure highly decoupled systems via a component register (Registry) and to implement strict application guardrails.
During this program, you will delve into advanced communication protocols such as Agent-to-Agent (A2A) and Model Context Protocol (MCP), and you will master execution isolation via code sandboxing. A large part of the training will be dedicated to the LangSmith ecosystem to operate a complete AgentOps strategy: from tracing asynchronous graphs to supervising production metrics (costs, latency), up to setting up automated test suites and self-correction loops (self-evaluation).
True to our pedagogical approach, this course dedicates 70% of its time to practice through refactoring workshops, production failure simulations, and execution environment securing, giving you all the keys to deploy robust, cost-effective, and enterprise-grade agents.
Goals
- Industrialize enterprise graph architectures: Design and deploy complex, highly scalable, and decoupled LangGraph topologies, leveraging a component register (Registry) and advanced design patterns.
- Secure agents and end-to-end tool access: Ensure system imperviousness to prompt injections, isolate code execution via sandboxing, and rigorously frame multi-agent communication using A2A and MCP protocols.
- Master latency and financial profitability (TokenOps): Tame token consumption and optimize response times in production by implementing caching strategies, node parallelization, and state streaming.
- Lead a complete AgentOps strategy with LangSmith: Effectively track and diagnose anomalies on complex asynchronous graphs, supervise production metrics, and implement automated self-evaluation and self-correction pipelines.
To know the dates of the next training sessions,
to adapt this program to your needs
or to obtain additional information,
contact us!
to adapt this program to your needs
or to obtain additional information,
contact us!
Teaching method
- This training is 70% practical and uses illustrated and didactic exercises.
- A daily evaluation of the acquisition of the knowledge of the day before is carried out.
- A synthesis is proposed at the end of the training.
- An evaluation will be proposed to the trainee at the end of the course.
- A course support will be given to each participant including slides on the theory and exercises.
- A sign-in sheet for each half-day of attendance is provided at the end of the course as well as a certificate of completion if the trainee has attended the entire session.
- A follow-up and an exchange with the participants will take place a few days after the training.
Prerequisite
- Python proficiency is required.
- Basic knowledge of LLM/RAG/Agents is required.
- Proficiency in the LangChain and LangGraph frameworks is necessary, or having completed the "Beyond RAG: From LLM Foundations to Autonomous Agents" training.
Targets
- Data Engineers
- Data Scientists
- Developers
Evaluation
This training does not require a formal assessment of learningProgram
Advanced Graph Architectures and Memory Management
Architecture Patterns and Deployment
- Advanced design patterns: Complex Supervisor, Agent Network, Plan-and-Execute.
- Typical deployment architecture (Building Blocks) and setup of a component register (Registry) for dynamically loading prompts and tools.
- Lab (Practice): Refactoring an agentic monolith into a modular "Registry" type architecture oriented microservices.
Memory and Knowledge Optimization
- Context management and optimization (short to long term).
- Message truncation strategies, inter-session persistence (Stores).
- Skill management (business knowledge) through dynamic injection based on the active node.
- Context engineering.
- Lab (Practice): Implementing an agent capable of manipulating infinite memory via a vector store, without ever exceeding the LLM context window.
Security, Protocols, and High Performance
Application Security, MCP, and Sandboxing
- Theoretical concepts of Agent Communication: Introduction to emerging protocols A2A and MCP.
- Agent security: Prompt injection, IAM/Rights management, Guardrailing, supply chain control.
- Sandboxing / CLI concepts.
- Lab (Practice): Creating agents that use LangGraph to orchestrate a Sandboxing environment (secure code execution via Docker). Implementing an MCP connector for access to a protected database.
Performance Optimization and TokenOps
- Performance optimization facing response time constraints (parallelization, state streaming).
- Cost and token consumption optimization (TokenOps).
- Lab (Practice): Streaming the state of a LangGraph graph to the front-end in real-time and implementing dynamic cache/routing strategies (small vs large models) to reduce latency by 50%.
AgentOps, Debugging, and Evaluation with LangSmith
Debugging and Production Monitoring
- Expert deep dive into LangSmith.
- Best practices for debugging on asynchronous graphs.
- Tagging, complex trace management, and production monitoring (dashboards for latency, error rate, cost per node).
- Lab (Practice): "Agentic Escape Game": Debugging a severely dysfunctional multi-agent system in production using only LangSmith traces.
Evaluation and Self-Evaluation (Auto-Correction)
- Automated evaluation strategies (LLM-as-a-judge).
- Creation of test datasets from production logs.
- Implementation of Self-evaluation nodes (the graph self-corrects).
- Lab (Practice): Building a complete feedback loop: the agent generates a result, an evaluation node critiques the result via a dataset defined in LangSmith, and forces the agent to re-generate the response if the quality level is not met.
