AI Agents Masterclass MCP Swarms LangChain 21 templates

In this course, students will learn how to create a reactive enterprise workflow engine using  LangGraph, FastAPI for the web interface, and Pydantic for type validation. They will understand how to implement complex decision trees and integrate the Workflow Engine into their own websites or workflows.

In this course, students will learn how to create a reactive enterprise workflow engine using FastAPI for the web interface and Pydantic for type validation. They will understand how to implement complex decision trees and integrate the Workflow Engine into their own websites or workflows.

Learn how to build a Python application that analyzes football player values using the Transfer Market API, CSV files, and OpenAI's GPT for AI estimates. Students will understand how to fetch player data, process statistics, and generate accurate player valuations based on real-time information.

Learn how to integrate AI functionality into your application by communicating with the OpenAI API using JSON data format and Go programming language, including prompt construction, structured data retrieval, value adjustment logic, and performance multipliers.

Learn how to integrate AI functionality into your application by communicating with the OpenAI API using JSON data format and Go programming language, including prompt construction, structured data retrieval, value adjustment logic, and performance multipliers.

In this lecture, students will learn how to build an MLOps pipeline for a Large Enterprise companyutilizing Python, PyTorch, Docker, and CI/CD practices with GitHub Actions. The course will cover essential concepts such as code quality checks, linting, type checking, unit testing, and logging with Python logging, as well as how to handle various data formats effectively.

In this lecture, students will learn how to build an MLOps pipeline utilizing Python, PyTorch, Docker, and CI/CD practices with GitHub Actions. The course will cover essential concepts such as code quality checks, linting, type checking, unit testing, and logging with Python logging, as well as how to handle various data formats effectively.

In this lecture, students will learn how to implement a CI/CD pipeline for MLOps using Docker for containerization, alongside code quality tools such as Black for formatting, Flake8 for comprehensive linting, and MyPy for type checking. The course will also cover the importance of security scanning and full test coverage analysis to ensure robust and secure deployment of machine learning systems.

In this lecture, students will learn how to create a checking agent that ensures project readiness for deployment in an ML Ops environment using GitHub Actions. The course will cover system design principles, the integration of a web front end and CLI, and the implementation of REST APIs to facilitate communication between components while addressing potential security risks associated with the eval function.

In this lecture, students will learn how to integrate OpenAI's GPT for analyzing project dependencies and health, utilizing API prompts to enhance their workflow efficiency. The session covers the implementation of AI analysis techniques, including dependency checks and the creation of a simple API integration program, while preparing for more complex cognitive processing in future lessons.

In this lecture, students will learn how to effectively utilize the PyPDF2 and PDFPlumber libraries for PDF document processing in Python, focusing on text extraction and handling complex PDF structures. The session will cover the challenges of PDF object-based content, error handling strategies, and considerations for multimodal content interpretation.

In this lecture, students will learn how to utilize the Python magic library (version 4.0.4 or higher) for reliable file type detection through content-based analysis, addressing common pitfalls associated with file extensions. We'll also discuss best practices for handling security vulnerabilities during file ingestion, including the importance of multiple validation layers and resource limits for safe processing. 

In this lecture, students will learn how to utilize the Python magic library (version 4.0.4 or higher) for reliable file type detection through content-based analysis, addressing common pitfalls associated with file extensions. We'll also discuss best practices for handling security vulnerabilities during file ingestion, including the importance of multiple validation layers and resource limits for safe processing.     

In this lecture, students will learn how to utilize Retrieval-Augmented Generation (RAGE) to enhance query responses using their own documents stored in a vector database, specifically designed for Large Language Model (LLM) integration. The session will cover the data processing layer, vector database functionalities, and scalability considerations essential for deploying both personal knowledge systems and enterprise-level solutions.

In this lecture, students will learn how to ingest and manage both unstructured data sources such as PDFs, Word documents, and text files, as well as structured data formats like CSVs, JSON, and SQL databases using RAG (Retrieval-Augmented Generation). The session will also cover the impact of embedding models on performance, exploring the differences between general-purpose and specialized models.

In this lecture, students will learn about the functionality of vector databases and how they differ from traditional SQL databases, focusing on the concept of embeddings and dimensionality. We will also explore retrieval-augmented generation (RAG) systems, discussing their implementation complexities and methods for evaluating model accuracy in real-world applications.

In this lecture, students will learn how to download and set up a multimodal retrieval augmented generation (RAG) model, which integrates large language models (LLMs) capable of processing both text and images. We will utilize shell scripting for easy deployment, manage a local vector store for document handling, and explore the iterative addition and deletion of documents to optimize performance.

In this lecture, students will learn how to set up and implement a multi-model Retrieval-Augmented Generation (RAG) system using the Llama 3.2 model, including the installation of necessary requirements via pip and the setup of an alarm service and vision model. By following the detailed instructions provided, students will gain hands-on experience in deploying this RAG LLM and understand how to fine-tune parameters for optimal performance.

In this lecture, students will learn how to implement asynchronous programming using Asyncio in Python, focusing on concurrency and event-based loops. We'll explore the limitations of Python's Global Interpreter Lock (GIL) and how Asyncio can enhance performance in network-related tasks while understanding the implications for CPU-bound processes.

In this lecture, students will learn how to effectively use asynchronous programming in Python to optimize file reading and writing tasks, as well as handle networking operations like web scraping with libraries such as asyncio and aiohttp. The course will also cover best practices for managing tasks, including setting limits to avoid memory issues, and the importance of using 'await' to prevent blocking the event loop.

In this lecture, students will learn how to implement asynchronous file operations using the AEO files library in Python to build intelligent agents capable of handling multiple file operations efficiently. The course will cover essential concepts such as agent architecture, error handling, timeouts, and the integration of concurrent I/O operations compatible with async/await patterns.

In this lecture, students will learn performance optimization strategies using Python's aiofiles and asyncio libraries, focusing on buffer size optimization and concurrency control with semaphores. Best practices such as chunk reading will also be covered to avoid memory issues while managing concurrent database operations effectively.

In this lecture, students will learn how to develop backend applications using FastAPI, a modern web framework for building APIs in Python, alongside Uvicorn as the asynchronous server for handling requests. Additionally, we will explore how to use Pydantic for data validation and serialization, ensuring that API responses are formatted correctly without overhead.

In this lecture, students will learn how to implement a multi-parallel system for EEG data ingestion and seizure prediction using FastAPI and Python. The course will also cover the integration of AI tools, Docker usage, and best practices for building robust backend architectures.

In this lecture, students will learn how to manage asynchronous workflows in Python-based AI systems by effectively utilizing the Global Interpreter Lock (GIL) and implementing thread safety in the `inference.py` file. The course will also cover the creation of independent ONNX sessions per patient using the Thread Pool Executor to enhance parallelism and prevent race conditions in multi-patient scenarios.

In this lecture, students will learn how to run applications using Docker and Docker Compose, focusing on building and managing containerized solutions for enterprise deployment. The course will also cover the integration of Apache Pulsar for data handling, the importance of a structured codebase, and the advantages of using Go for simpler project management.

In this lecture, students will learn about MCP (Multi-Channel Protocol) agents, including their concepts, implementations, and how to extend an MC-based system effectively. The course will cover practical applications of agent patterns in real-life scenarios, leveraging AI technologies to enhance productivity and automate tasks.

In this lecture, students will learn how to connect Large Language Models (LLMs) with custom plugins and tools like Zapier using the MCP (Model, Context, Protocol) framework to solve integration challenges. We will also cover advanced functionalities such as calculus and statistics using Python libraries for mathematical operations, including importing math, symbolic differentiation, and CSV data processing for statistical analysis.

In this lecture, students will learn how to create an MCP AI agent application using the Model Context Protocol to standardize connections between AI agents and external tools. The course will cover building three MCP servers (file system, web, and calculator) and interacting with 15 tools, including file operations and statistical analysis using Python.

In this lecture, students will learn how to create an MCP AI agent application using the Model Context Protocol to standardize connections between AI agents and external tools. The course will cover building three MCP servers (file system, web, and calculator) and interacting with 15 tools, including file operations and statistical analysis using Python.

In this lecture, students will learn how to create and implement MCP agents using Python, focusing on the abstract class design pattern to register tools and define agent capabilities. We will explore the structure of the MCP base script, including the init constructor and dictionary management for server capabilities.

In this lecture, students will learn how to implement file operations in the MCPE AI agent using a custom file system server, which includes tools for reading, writing, listing, searching, and deleting files. The course will cover the setup of a secure workspace for AI file interactions and demonstrate how to modify the file system server capabilities for enhanced functionality.

In this lecture, students will learn how to create a web server for an AI application that facilitates internet access using the Wikipedia API, incorporating tools like the search tool, summary tool, fetch tool, and news headline tool. We will cover exception handling and disambiguation techniques to effectively manage search queries and results from Wikipedia, ensuring a seamless user experience.

In this lecture, students will learn how to implement a calculator server using the MCP (Multi-Channel Processing) method for building AI agents, leveraging the SimPy library for symbolic mathematics in Python. Additionally, the course covers creating extensible unit conversion functions with lambda expressions and managing feedback for unsupported conversions, ensuring a robust mathematical function implementation outside of GPT models.

In this lecture, students will learn how to integrate the OpenAI API into a Python-based AI agent system using the MCP framework. We will cover essential concepts such as JSON file handling, type checking with Python's typing module, and creating an interactive terminal interface for user interactions.

In this lecture, students will learn how to set up and create an MCP AI agent system, focusing on the crucial steps like generating a .env file and utilizing the OpenAI API for executing functions. The course will cover the iterative workflow of communication between users, administrators, and agents while introducing essential tools and concepts for building reliable AI-driven applications.

In this lecture, students will learn to create a calendar agent using Google's Vertex AI and the Calendar API, enabling seamless interaction between user input and calendar operations. The course will cover the integration of natural language processing in Google Cloud Platform (GCP) to extract structured data from user queries and manage calendar events efficiently.

In this lecture, students will learn how to integrate Google Cloud services, specifically the Calendar API and Vertex AI, to create a calendar vertex agent application. The course will cover setting up authentication using OAuth 2.0, managing API credentials, and utilizing Python for scripting and orchestrating the AI agent functionality.

In this lecture, students will learn how to create a Google Calendar AI Agent using Python with AsyncIO, leveraging the Rich Console for CLI interactions. The course will cover key components such as the Calendar AI Agent, Auth Manager, and techniques for listing events, summarizing with AI, and error checking for correct date and time formats.

In this lecture, students will learn how to utilize the Google Calendar API using Python, focusing on authentication with Google Auth OAuth 2 and managing events through the API client. The course will cover creating, updating, deleting, and searching for events while leveraging environmental variables for configuration and handling application tokens securely.

In this lecture, students will learn how to utilize the Vertex AI client to interact with Google Calendar data, enabling features such as summarizing calendar events and generating smart event descriptions. The session will also cover the importance of using agents in AI applications while addressing the complexities that arise when integrating these technologies.

In this lecture, students will learn how to manage authentication for multiple APIs, specifically focusing on the integration of the Vertex AI client script with the Google Calendar API. We will cover the implementation of security layers using Python, including the use of the Redis library for distributed rate limiting and strategies to enhance API security against common web vulnerabilities.

In this lecture, students will learn the advantages and disadvantages of using GoLang versus Python for building software agents, including the impact of asynchronous operations and startup times. We will explore concepts such as computer vision, large language models (LLM), and how they integrate with agent perception, highlighting key differences in deployment and performance between GoLang and Python.

In this lecture, students will learn the key differences between GoLang and Python when building AI applications, focusing on syntax, typing, and error handling. We will explore the use of FastAPI for creating APIs in Go, including features like automatic validation and API documentation, while also discussing the developer experience of both languages in the context of AI tools and libraries.

In this lecture, students will learn about the differences in building AI agents using Python and GoLang, focusing on Python's extensive ecosystem including tools like LLM Chain, LLM Index, AutoGen from Microsoft, and Haystack. Additionally, we will explore GoLang's native frameworks such as LLM Go and direct API calls using GoL, highlighting the implications of these choices for agent system development.

In this lecture, students will learn the key differences between Go-Lang and Python for building web scraping agents, focusing on the strengths of Python's ecosystem, particularly with libraries like Selenium, and the deployment challenges associated with Python's dependency management. Additionally, we'll explore Go-Lang's advantages in durability and deployment due to its compiled nature, highlighting how these factors influence workflow in production environments.

In this lecture, students will explore the advantages of using Go over Python for deploying multi-agent systems, focusing on compilation, binary execution, and cross-compilation for various operating systems. Additionally, the discussion includes cost implications when deploying on AWS Lambda and the differences in managing dependencies and virtual environments between the two languages.

In this lecture, students will explore the strengths and weaknesses of Go and Python for building scalable applications, including the integration of tools like LlamaIndex and AutoGen. Additionally, we will discuss the use of Python libraries such as NumPy for data-intensive tasks, and the importance of planning for enterprise-quality solutions.

In this lecture, students will learn how to build an agent swarm using the Go programming language and the OpenAI API, focusing on event-driven architecture and real-time event streaming with Go routines. We will explore the implementation of a web interface, message loops, and the structure of worker agents to effectively manage asynchronous tasks.

In this lecture, students will learn how to create and configure GoLang applications using the main package to orchestrate agents, initialize AI-powered personalities, and launch a web dashboard and CLI. The course will also cover managing concurrent tasks with Go routines, utilizing environment variables, and executing a progress callback for real-time updates.

In this lecture, students will learn how to develop specialized research agents using Large Language Models (LLMs) in Python, focusing on the structure and functionality of agents like analysis agent, report agent, and agent go. The course will cover prompt definition, conversational history management, and error handling to enhance the agents' ability to synthesize information and present structured findings.

In this lecture, students will learn about the agent architecture used in Agent Swarm, focusing on the interaction between the CLI, orchestration layer, swarm coordinator, and research agents. Additionally, the course will cover how to utilize the Mermaid diagram viewer to visualize agent interactions and the role of the LLM client in processing private data for research and report generation.

In this lecture, students will learn about the foundational role of the base agent in swarm systems, including its message queue management, thread-safe state management, and customizable parallel message handlers. We will also explore the architecture patterns of specialized agents, such as the analysis agent, report agent, and research agent, and how they interact within the overall system.

In this lecture, students will learn about the concepts of agent swarms and event-driven architecture, focusing on the implementation of AI agents in both Python and GoLang. The session will cover the roles of decision-making capabilities, communication protocols, and event buses, providing a comprehensive understanding of how these components interact within a system.

In this lecture, students will learn about the event bus as a publish and subscribe messaging system, enabling decoupled communication between components in an agent swarm architecture. We will also explore Go's concurrency model using GoRoutines, highlighting how it allows for efficient management of thousands of concurrent agents compared to traditional scripting in Python.

In this lecture, students will learn how to implement the handler registration pattern in Go, enabling agents to dynamically associate handler functions with specific message types for flexible message processing. Key concepts covered include concurrency, message-driven architecture, and the creation of a registry to decouple message handling logic from core agent structures.

In this lecture, students will learn about the Model Context Protocol (MCP), an open-source standard introduced by Anthropic for connecting large AI models like CLAWD to external data and tools. We will also explore the structure and functionality of agent swarms in GoLang, focusing on how to effectively orchestrate multiple agents to enhance productivity and reduce integration challenges.

In this lecture, students will learn about the differences between the MCP (Main Control Point) architecture and swarm-based agent coordination in the context of integrating large language models (LLMs) with databases and data processing tools. The session will cover concepts such as agent orchestration, data analysis agents, and report writing agents, emphasizing the strengths of direct database access and data integration within these frameworks.

In this lecture, students will learn the differences between using Python and Go for building AI agents, focusing on performance, deployment, and system requirements. We will explore the benefits of Go's static compilation for production deployment and high throughput, while discussing Python's dynamic nature and its suitability for MVPs and POCs in various development scenarios.

In this lecture, students will learn how to effectively scale agent swarms using the MCP server, with a focus on horizontal scaling strategies across multiple machines. We will explore prompt engineering techniques, caching responses, and batching requests to optimize costs and improve output quality when working with large language models (LLMs) in agent-based systems.

In this lecture, students will learn how to implement unit and integration testing for agents using debugging tools in Python, such as cProfile, PySpy, and PDB. The session will cover concepts like distributed tracing with trace IDs, error handling in workflows, and best practices for logging agent activities to ensure functionality and performance validation.

In this lecture, students will learn about advanced patterns in agent-based systems, focusing on agent hierarchies and rule-based orchestration using techniques like sequential orchestrators and event buses. The course will also cover practical implementations of machine learning models for data classification and moderation, including tiered approaches to filtering and decision-making with large language models (LLMs).

In this lecture, students will learn about optimizing performance in agent swarm architectures by implementing batching techniques to reduce API calls to LLM services. We will explore tools and frameworks including LangChain for prototyping, the Go programming language for agent implementation, and the concepts of event-driven messaging for enhanced control and efficiency.

In this lecture, students will learn how to effectively implement agent swarms in Python for handling multi-step workflows that require tailored AI configurations for different tasks. We will explore the advantages of using agent swarms over single-step AI tasks and discuss their applications in high-volume scenarios, equipping students with the foundational knowledge to build autonomous agents using cutting-edge AI technology.