Ever wanted to build an advanced project to level up in building production-grade systems powered by AI agents, and didn’t know where to start?
If so, Decoding ML’s philosophy is to learn by doing. No procrastination, no useless “research,” just jump straight into it and learn along the way. Suppose that’s how you like to learn, then we have the perfect free learning roadmap to get into building real-world AI agents: from theory to APIs and LLMOps.
Packaged as a fun project. So…
For the builders from the AI community, we created thePhiloAgents open-source course, where you will learn to architect and build an AI-powered game simulation engine to impersonate popular philosophers.
→ An end-to-end AI product, powered by AI agents, from ReAct agents, to agentic RAG, to real-time deployments and LLMOps.
This course is a gift to the AI community. Thus, it’s 100% free, with no hidden costs or registration required. You just need our GitHub, Substack, and YouTube lessons.
(and some sweat and perseverance to make the whole AI system work)
This course will teach you the core concepts required to build industry-level AI applications while implementing a fun project: a game where you can talk with historical geniuses, such as Aristotle, Turing or Socrates.
While learning how to impersonate these characters and expose them in a fun 2D game, you will learn how to:
Building AI agents with LangGraph using Python best practices.
Creating production-grade RAG systems to feed facts into the philosophers.
Implement short-term and long-term memory layers.
Engineering the system architecture (UI → Backend → Agent → Monitoring).
Expose the agent as an API deployment with FastAPI, Docker, and WebSockets.
Mastering industry tools: Groq, MongoDB, Opik, Python tooling (uv, ruff).
Applying LLMOps best practices: prompt monitoring and versioning, evaluation.
🥷 By the end, you'll be a ninja in production-ready AI agent development!
More details, such as who should join this course and the technical and hardware prerequisites, can be found in the GitHub repository.
Here is a quick demo of the PhiloAgents game you will learn to build by the end of the free series, from agents in Notebooks to real-world infrastructure:
Now, let’s move on to the fun part, where we zoom in on each lesson to understand better what it takes to build our PhiloAgent simulation.
Trying to get into AI Engineering, but don’t know where to start?
When learning something new, to avoid wasting time, we need structure. That’s why if you consider a career in AI Engineering, we heartily recommend The Full Stack AI Engineering Course from the Towards AI Academy.
It’s full-stack. Therefore, it covers everything you need from LLMs, prompting, RAG, fine-tuning and agents.
Similar to what I preach through Decoding ML and my LLM Engineer’s Handbook, the course is project-focused. Made for active builders who, through a bit of sweat, want to build awesome stuff!
Instead of focusing on dozens of mini-projects that don’t reflect the real world. During the course, you will design, implement and deploy an AI Tutor as your capstone project, reflecting an end-to-end workflow similar to what you would do at your job.
You can find more details by clicking the button below. They offer a free preview of the course and a 30-Day Money-Back Guarantee.
Use codePaul_15 for 15% off and to keep Decoding ML free.
💭 As I am developing my Agentic AI Engineering course together with the Towards AI team, I am confident that we are 100% on the same page. A massive passion for AI and the will to put in hard work for something worth your time.
↓ Now, back to our lesson.
1. Build your gaming simulation AI agent
First, we will explore the system architecture of the PhiloAgents philosophers’ simulation, illustrated in the figure below. We will explain each component's role, what it is, what algorithms and tools we used, and, most importantly, why we used them.
By the end of this lesson, you will have a strong intuition of what it takes to architect a production-ready backend-frontend architecture, coupled with an RAG layer, that serves AI agents as real-time APIs. Plus, all the LLMOps goodies on top of the system that make it robust, observable and traceable.
Building AI agents can become complex relatively quickly. When implementing more advanced applications, you must orchestrate multiple LLM API calls, prompt templates, states, and tools within a single request.
That’s why you need specialized tools, such as LangGraph, which can help you orchestrate all these components, making the agent easier to implement, deploy, monitor, and debug.
In this lesson, we will start by going through the fundamentals of how agents work (the ReAct pattern) and how to build a simple ChatBot using LangGraph. Then, we will add more complexity and learn how to develop our PhiloAgent by:
Building an advanced agentic RAG system using LangGraph.
Leveraging Groq API’s as our LLM provider for low-latency inference speeds.
Prompt engineering a character card used to impersonate our philosophers (which can be adapted to other characters).
Manage multiple personas and inject them into our character card prompt template.
Designing a robust memory layer for your agents is one of the most underrated aspects of building AI applications. Memory sits at the core of any AI project, guiding how you implement your RAG (or agentic RAG) algorithm, how you access external information used as context, manage multiple conversation threads, and handle multiple users. All critical aspects of any successful agentic application.
Every agent has short-term memory and some level of long-term memory. Understanding the difference between the two and what types of long-term memory exist is essential to knowing what to adopt in your toolbelt and how to design your AI application system and business logic.
With that in mind, in this lesson, we will explore short-term and long-term memory, what subtypes of long-term memory we can adopt, and how to implement them in our PhiloAgent use cases using MongoDB as the backbone of our memory layer.
As a minor spoiler, long-term memory implies building an agentic RAG system!
Until now, we’ve been focused on making our agents think—designing personalities, reasoning systems, and behaviors rooted in philosophical worldviews.
But what good is a brilliant philosopher if they’re locked in a basement with no way to speak to the world?
In real-world applications, intelligence alone isn’t enough. If we want our agents to be more than local experiments, they need to be accessible, interactive, and production-ready. It’s time to give your agents a voice—and more importantly, an interface.
In this lesson, we’ll take your PhiloAgent from a local prototype to a live, interactive character on the web. You’ll learn how to build a web API using FastAPI and add WebSocket support so your agent can respond in real time.
Here’s what we’ll dive into:
Understand the difference between REST APIs and WebSockets.
Build and test a REST API to serve your agent.
Stream live, token-by-token responses using WebSockets.
Design a clean backend–frontend architecture with FastAPI and Phaser.
5. Observability for RAG Agents: Monitoring & Evaluation
Until now, we’ve focused on making our agents intelligent and interactive—shaping their personalities, wiring them to tools, and deploying them through real-time APIs.
But being smart doesn’t guarantee being reliable—especially in production.
Once your agents are live, the real questions begin: Are they reasoning effectively? Are their responses actually helpful—or drifting off course? Are your prompt changes improving performance or breaking things silently? And most importantly—how would you even know?
That’s where observability steps in. In Lesson 5, we shift from building agents to measuring them.
In this lesson, we’ll take your PhiloAgent from a black-box experiment to a transparent, measurable system. You’ll learn how to monitor your agent’s behavior, track prompt versions, and evaluate performance—core skills for deploying and improving agents in the real world.
Here are the LLMOps concepts we’ll dive into:
Understand what observability means in the context of LLMs and agents.
Learn to monitor complex prompt traces using open-source tools, like Opik.
Implement prompt versioning to track changes and ensure reproducibility.
Generate evaluation datasets and run structured assessments on your agents.
Explore how LLM offline and online evaluation pipelines fit into your architecture.
During the first five lessons, we discussed in depth what it takes to build a production-ready AI agent, from creating the agent itself to wrapping it up in a backend and frontend architecture to serve it as a game and implement the LLMOps layer.
Still, in the world of AI, we are bombarded with the latest models, tools, and algorithms, but often forget what matters: building software that works.
Thus, we aim to conclude this series by returning to the fundamentals. To understand how to structure a Python project and use the right development tools (e.g., uv, ruff, Make) like a senior software engineer would. Additionally, we will explore how to containerize the project using Docker, as a senior DevOps engineer would.
These are all essential skills you will need in any software project, whether you're building AI applications around LLMs, Agents, RAG, or any other type of AI models. Thus, these are crucial skills for:
development speed and experience;
ease of deploying your app to the cloud;
making your project future-proof;
moving away from “it works on my machine” to “it works everywhere”.
Open the Substack and YouTube lessons found in the repository’s GitHub docs.
Set up the code using the documentation from the repository.
Start going through the lessons and running the code.
The best part? We encourage you to reuse our code for your open-source projects! If you do, DM us on Substack, and we’ll share your project on our socials.
More details, such as who should join this course and the technical and hardware prerequisites, can be found in the GitHub repository.
Enjoy!
Go Deeper
Everything you learned in this article, from building evals datasets to evaluators, comes from the AI Evals & Observability module of our Agentic AI Engineering self-paced course.
Your path to agentic AI for production. Built in partnership with Towards AI.
Across 34 lessons (articles, videos, and a lot of code), you’ll design, build, evaluate, and deploy production-grade AI agents end to end. By the final lesson, you’ll have built a multi-agent system that orchestrates Nova (a deep research agent) and Brown (a full writing workflow), plus a capstone project where you apply everything on your own.
Three portfolio projects and a certificate to show off in interviews. Plus a Discord community where you have direct access to other industry experts and me.
Rated 4.9/5 ⭐️ by 190+ early students — “Every AI Engineer needs a course like this.”
Not ready to commit? We also prepared a free 6-day email course to reveal the 6 critical mistakes that silently destroy agentic systems. Get the free email course.
Images
If not otherwise stated, all images are created by the author.
Awesome
Such a great Course, thank you for always sharing such a high-valuable content