Agents Towards Production
by Nir Diamant
Twenty-three runnable tutorials covering every production layer an agent demo skips.
Overview
Agents Towards Production is an open-source repository by Nir Diamant that treats a GenAI agent as a system to be operated rather than a demo to be run. Under `tutorials/` sit 23 self-contained folders, each with ready-to-run notebooks or code, grouped into roughly eleven production concerns: orchestration (`LangGraph-agent`), tool integration and secure tool calling (`arcade-secure-tool-calling`, `agent-with-mcp`), data acquisition (`agent-with-tavily-web-access`, `agent-with-brightdata`, `agent-file-conversion-with-hushvert`), retrieval (`agent-RAG-with-Contextual`), memory (`agent-memory-with-redis`, `agent-memory-with-mem0`, `ai-memory-with-cognee`), deployment (`docker-intro`, `fastapi-agent`, `aws_agentcore`, `on-prem-llm-ollama`, `runpod-gpu-deploy`), multi-agent interoperability (`a2a`), security (`agent-security-with-llamafirewall`, `agent-security-apex`), model customization (`fine-tuning-agents`), observability (`tracing-with-langsmith`), evaluation (`agent-evaluation-intellagent`), a UI track (`agent-with-streamlit-ui`) and a Kotlin/JVM track (`kotlin-agent-with-koog`). The stack is mostly Python with LangGraph, LangSmith, FastAPI, Docker and MCP, and many folders are contributed by the tool vendors themselves. The repository carries roughly 21.4k stars and 2.8k forks and ships under a custom non-commercial license, so it is free to learn from but not to resell. Diamant also maintains the widely used RAG_Techniques and GenAI_Agents repositories. Its distinguishing choice is horizontal coverage: rather than one more end-to-end use case, each folder isolates a single layer you would otherwise learn about during an outage.
At a Glance
- Topic
- Agentic
- Level
- Intermediate
- Format
- Tutorial
- Cost
- Free
- Duration
- 23 self-paced tutorials, roughly 1-2 hours each (~25-40 hours for the full set)
- Provider
- Nir Diamant
- Hands-on
- Yes — code/exercises
- Certificate
- None
What You’ll Learn
- ✓Wire a stateful LangGraph workflow that survives restarts and retries
- ✓Attach persistent agent memory using Redis, Mem0 or Cognee knowledge graphs
- ✓Expose an agent behind a FastAPI endpoint with synchronous and streaming responses
- ✓Containerize an agent with Docker and deploy GPU inference on RunPod
- ✓Defend against prompt injection using LlamaFirewall input and output guardrails
- ✓Instrument agent runs with LangSmith tracing to debug failing tool calls
- ✓Give agents authorized third-party actions through OAuth-scoped secure tool calling
- ✓Evaluate agent behaviour automatically with IntellAgent instead of manual spot checks
- ✓Run models on-premises with Ollama when data cannot leave your network
Highlights
- •23 self-contained tutorial folders, each runnable alone — no monolithic sample app to reverse-engineer first
- •Horizontal coverage of production layers (memory, deployment, security, observability) rather than another vertical use-case demo
- •Roughly 21.4k stars and 2.8k forks; the author also maintains RAG_Techniques and GenAI_Agents
- •Several tutorials are contributed by the tool owners themselves — Redis, Mem0, Cognee, Tavily, Bright Data, Arcade, RunPod
- •Includes a Kotlin/JVM track via Koog, rare in a Python-dominated agent ecosystem
- •Custom non-commercial license: free to learn from, but check the terms before commercial reuse
Who It’s For
Best For
- ✓Python engineers with a working agent prototype that has never been deployed
- ✓Platform teams choosing memory, tracing and deployment components for agent workloads
- ✓Engineers who need auth, guardrails and GPU scaling documented in one place
- ✓Developers evaluating vendor tooling before committing to an agent stack
Prerequisites
- •Comfortable Python, including virtual environments and running Jupyter notebooks
- •Basic familiarity with LLM APIs and tool/function calling
- •Docker basics help for the deployment tutorials, though the Docker intro covers them
FAQ
What is Agents Towards Production?
An open-source, code-first playbook for taking a GenAI agent from working prototype to something you can actually operate. Each of the 23 tutorial folders isolates one production concern — memory, deployment, tracing, guardrails, evaluation, GPU scaling — with runnable notebooks or scripts. It is aimed at engineers who already have an agent that works on their laptop and now have to ship, monitor and secure it.
Is Agents Towards Production free?
Agents Towards Production is free to access.
What level is Agents Towards Production for?
Agents Towards Production is aimed at a intermediate audience. Recommended background: Comfortable Python, including virtual environments and running Jupyter notebooks, Basic familiarity with LLM APIs and tool/function calling, Docker basics help for the deployment tutorials, though the Docker intro covers them.
How long does Agents Towards Production take?
Expect roughly 23 self-paced tutorials, roughly 1-2 hours each (~25-40 hours for the full set). Most learners work through it at their own pace.
What will I learn from Agents Towards Production?
You'll learn: Wire a stateful LangGraph workflow that survives restarts and retries; Attach persistent agent memory using Redis, Mem0 or Cognee knowledge graphs; Expose an agent behind a FastAPI endpoint with synchronous and streaming responses; Containerize an agent with Docker and deploy GPU inference on RunPod; Defend against prompt injection using LlamaFirewall input and output guardrails; Instrument agent runs with LangSmith tracing to debug failing tool calls; Give agents authorized third-party actions through OAuth-scoped secure tool calling; Evaluate agent behaviour automatically with IntellAgent instead of manual spot checks; Run models on-premises with Ollama when data cannot leave your network.
Topics
Sources
This page was written from 3 sources, 1 on domains other than github.com.