12 WEEKS
INSTRUCTOR-LED
MON–THU
LABS/
CAPSTONE PROJECT
CERTIFICATION
Programme Overview
This practical 12-week programme takes you from Python and API fundamentals to a working, secure AI agent backend. Learners cover tool use, LangGraph workflows, SQL data, MCP integrations, security, testing and observability, then present a capstone project.
Learning outcomes
- Write Python with type hints, connect to AI models over HTTP APIs and manage prompts, tokens, context windows, structured outputs and API-key safety.
- Build FastAPI services with Pydantic v2 validation, async endpoints and dependency injection, and expose safe, typed agent tools through them.
- Orchestrate agents with LangChain 1.0 and LangGraph — explicit state, nodes, branching, checkpoints, streaming and human-in-the-loop approval.
- Persist data and memory with PostgreSQL and SQLAlchemy, ground answers in approved knowledge sources, and apply privacy, consent and retention practices.
- Build MCP servers and integrations, secure routes with JWT and OAuth 2.1, and defend against OWASP agentic risks such as prompt injection and excessive agency.
- Test and evaluate agents with pytest and evaluation datasets, observe them with OpenTelemetry, LangSmith and Langfuse, and present a documented capstone.
Beginner to Junior
Instructor-Led
Guided Labs & Projects
Why Enroll?
AI Agent Engineering is a 12-week programme delivered by Ibadan Digital Academy. You will build a working AI agent backend with Python and FastAPI — connecting models to tools, SQL data, LangGraph workflows, MCP integrations and observability systems — while learning the security and testing practices production agents require. Every session follows explanation, demonstration, guided practice and independent application, and the course ends with a presented, documented capstone agent.
Full Agent Stack:
Python, FastAPI, LangChain 1.0, LangGraph, PostgreSQL, MCP and observability — the complete agent engineering toolkit.
Security-First Design:
JWT and OAuth 2.1, least privilege, the OWASP Top 10 for LLM and Agentic Applications, approvals, rate limits and spending caps.
Production Quality:
pytest, evaluation datasets, prompt-injection regression tests, OpenTelemetry traces, LangSmith and Langfuse monitoring.
Instructor-Led Delivery:
Monday to Thursday, 11:00 a.m. to 2:00 p.m., with Friday optional for project completion, corrections and mentorship.
Capstone You Can Defend:
A secure AI service-desk agent with SQL data, controlled tools, role-based permissions, tests, evaluations and traces.
Delivery & Assessment
Teaching runs Monday to Thursday, 11:00 a.m. to 2:00 p.m.; Friday is optional for project completion, corrections and mentorship. At 12 scheduled hours per week, practical work is distributed across every module, and independent practice is approximately 5 to 7 hours weekly.
- Weekly labs: 25%
- Month 1 agent services build: 15%
- Month 2 workflow, data and security build: 20%
- Testing and evaluation portfolio: 10%
- Month 3 capstone agent: 30%
Evidence includes source files, running FastAPI services, test and evaluation reports, recorded traces, Git history and live demonstrations.
AI Agent Engineering Outline
Month 1 — Foundations: Python, APIs, FastAPI and Tools
Week 1. Introduction to AI agents and Python
- Topics: what AI agents are — models, instructions, tools and memory working in a loop; Python essentials (variables, functions, lists, dictionaries, modules, type hints, virtual environments).
- Practical: set up VS Code, Jupyter Notebook, Git/GitHub and the uv package manager; read, test and understand AI-assisted code.
- Exit: a working Python project environment with version control and a clear understanding of the agent loop.
Week 2. APIs, JSON and working with AI models
- Topics: HTTP APIs and JSON; prompts, system instructions, tokens, context windows and structured outputs; environment variables for keys, cost and rate limits.
- Practical: build a command-line AI assistant that accepts user input and returns structured responses.
- Exit: a model-connected CLI tool with safe key handling and visible cost awareness.
Week 3. FastAPI backend fundamentals
- Topics: request/response cycle, path and query parameters, request bodies; Pydantic v2 validation; async endpoints, dependency injection, settings management; FastAPI CLI and automatic OpenAPI documentation.
- Practical: create validated AI-service routes and explore the generated API docs.
- Exit: a running FastAPI service that validates input and returns reliable responses.
Week 4. Building tools for AI agents
- Topics: function calling; safe, typed Python tools; input validation and error handling; least-privilege design.
- Practical: build calculation, internal-search and user-request tools exposed through FastAPI endpoints.
- Exit: a model that can call validated tools and act on clear results.
Month 1 project: agent services toolkit (15%) — a FastAPI application with validated routes, environment-managed configuration and a set of safe, typed tools the model can call, with tests and Git history.
Month 2 — Agents, Data, Integrations and Security
Week 5. Agent workflows with LangChain and LangGraph
- Topics: LangChain 1.0 create_agent for models, prompts and tools; LangGraph state, nodes, branching, checkpoints and repeatable execution; streaming and human-in-the-loop approval.
- Practical: build a single-agent backend that decides when to answer directly and when to call a tool.
- Exit: a stateful, checkpointed agent workflow with an approval step.
Week 6. Data, SQL and agent memory
- Topics: PostgreSQL tables and queries; FastAPI with SQLAlchemy; retrieval basics (full-text and vector search); short-term conversation state and long-term user memory; privacy, consent, retention and data quality.
- Practical: ground agent answers in an approved knowledge source and persist conversation state.
- Exit: an agent that retrieves approved facts and remembers users within a defined retention policy.
Week 7. Model Context Protocol and external integrations
- Topics: MCP hosts, clients and servers; tools, resources and prompts; stdio vs Streamable HTTP transports and the 2026-07-28 specification; treating tool output as untrusted input.
- Practical: build an MCP server with the Python SDK and connect it to the agent for approved actions in an external system.
- Exit: a working MCP integration with least-privilege actions.
Week 8. Authentication, permissions and secure agent design
- Topics: authentication, authorization, users, roles and permissions; JWT and OAuth 2.1; OWASP Top 10 for LLM Applications 2026 and for Agentic Applications — prompt injection, sensitive data disclosure, excessive agency, tool misuse; least agency, output validation, approvals, rate limits and spending caps.
- Practical: protect FastAPI routes and restrict which tools each user or agent may access.
- Exit: an authenticated agent with per-role tool permissions and safeguards against the core agentic risks.
Month 2 project: workflow, data and security build (20%) — an authenticated agent backend combining a LangGraph workflow, PostgreSQL memory and retrieval, an MCP-connected external system, role-based tool permissions and documented safeguards, with tests and Git history.
Month 3 — Quality, Reliability and Capstone
Week 9. Testing and evaluation of AI agents
- Topics: traditional software tests plus behavioural evaluation; pytest for routes, validation, database functions and tools with mocked model calls; evaluation datasets measuring answer quality, tool selection, format, safety, latency and cost; prompt-injection test cases as regression checks.
- Practical: build an evaluation suite and run it automatically.
- Exit: repeatable tests and evaluations that catch quality and safety regressions.
Week 10. Observability, debugging and reliability
- Topics: traces, logs and metrics across multi-step requests; OpenTelemetry basics; LangSmith and Langfuse inspection of prompts, model calls, tool calls and execution paths; timeouts, retries, structured errors, approvals and fallbacks; cost, latency and failure-pattern monitoring.
- Practical: instrument the agent and diagnose a failing multi-step request from production traces.
- Exit: a traceable agent with documented reliability improvements.
Week 11. Designing and building the capstone agent
- Topics: problem, users, data sources, tools, permissions and success criteria; FastAPI backend combining model, validated tools, SQL data, workflow, authentication and observability; realistic scenarios, evaluation sets, Docker packaging and automated test runs.
- Practical: build the AI service-desk agent and improve accuracy, safety and usability from evaluation results.
- Exit: a containerised capstone passing tests before presentation.
Week 12. Capstone project presentation
- Topics: demonstrate the agent; present architecture, tools, database design, security controls, testing and evaluation results and observed traces; README documentation; peer and instructor feedback.
- Practical: defend design decisions and identify improvements for a future version.
- Exit: a reproducible, documented agent with evidence of security, quality and reliability.
Month 3 project: capstone agent (30%) — a secure AI service-desk and operations agent that answers from an approved knowledge source, looks up customer or ticket data in SQL, creates support requests through a controlled tool, and hands sensitive or uncertain cases to a human — with role-based permissions, tests, evaluations and traces proving it works.
Python, FastAPI, Agents and Production Quality
- Core stack: Python 3, type hints, virtual environments and the uv package manager; VS Code, Jupyter Notebook, Git/GitHub.
- Backend and agents: FastAPI, Pydantic v2, LangChain 1.0, LangGraph, PostgreSQL, SQLAlchemy.
- Integrations and security: Model Context Protocol (Python SDK), JWT, OAuth 2.1, OWASP LLM and Agentic guidance.
- Quality and operations: pytest, evaluation datasets, OpenTelemetry, LangSmith, Langfuse, Docker.
Scope: beginner-friendly AI agent backends with Python and FastAPI. Frontend UI frameworks, model fine-tuning, advanced MLOps and large-scale deployment are outside the core assessment. AI coding assistants are used responsibly — every generated line is read, tested and understood.
Competency Checklist
- Explain the difference between a basic chatbot, a workflow and an AI agent.
- Build a working Python backend and secure FastAPI service.
- Connect a model to validated, typed and least-privilege tools.
- Use Pydantic v2 to validate requests, responses and agent outputs.
- Build a LangGraph workflow with state, nodes, branching, checkpoints, streaming and human approval.
- Persist data and memory with PostgreSQL and retrieval, treating privacy and consent as first-class requirements.
- Build and connect an MCP server and treat its output as untrusted.
- Secure routes with JWT and OAuth 2.1 and defend against the OWASP LLM and Agentic Top 10 risks.
- Test and evaluate agents with pytest, evaluation datasets and prompt-injection regression checks.
- Observe agents with OpenTelemetry, LangSmith and Langfuse, and present a documented capstone agent.
Compact lab sequence: Python environment and Git baseline → model API client with structured outputs and key management → FastAPI service with Pydantic v2 validation and docs → typed tool registry with least-privilege design → LangGraph stateful workflow with checkpointing and approval → PostgreSQL memory with retention policy → retrieval over an approved knowledge source → MCP server with the Python SDK and external integration → JWT and OAuth 2.1 protection with role-based tool permissions → prompt-injection and excessive-agency safeguards → pytest suites with mocked model calls → evaluation datasets for quality, safety, latency and cost → OpenTelemetry traces with LangSmith/Langfuse inspection → timeout, retry, fallback and human-handoff patterns → Docker packaging and automated test runs → capstone integration, presentation and defence.
Start Your AI Agent Engineering Journey
12 weeks to a working, secure AI agent backend you can defend. Ibadan Digital Academy — Iyaganku GRA, Ibadan. Mon–Thu, 11:00 a.m.–2:00 p.m., with optional Friday labs.