Skip to Content
View all events

Hands-On Agentic GraphRAG

Published by O'Reilly Media, Inc.

Intermediate content levelIntermediate

Build memory-rich AI agents with graph-based retrieval, temporal memory, and tool orchestration

What you’ll learn and how you can apply it

  • Translate an enterprise knowledge domain into entities, relationships, and temporal events that support reasoning
  • Choose appropriate graph representations based on reasoning needs and latency constraints
  • Build and query a GraphRAG pipeline that supports both local lookups and global synthesis
  • Design an agent loop that uses GraphRAG outputs as structured context and logs decisions into memory
  • Add temporal reasoning so the agent can prefer current truth over stale facts
  • Evaluate retrieval and answer quality with a repeatable, automated harness to prevent regressions

Course description

Agentic AI systems do not just answer questions; they pursue goals through observe-think-act loops and must remember what happened yesterday, understand how systems relate, and choose the right tools at the right time. In this hands-on course, Ammar Mohanna guides you through building an “autonomous incident commander” for a fictional microservice platform. You’ll start with a baseline vector RAG chatbot and watch it fail on multihop dependency questions, global “What changed?” questions, and time-sensitive troubleshooting.

Then you’ll upgrade the architecture to agentic GraphRAG and discover how to get those questions resolved. You’ll model the domain as a knowledge graph, build a GraphRAG index, implement graph-guided retrieval, and finally wrap it inside an agent loop with graph-based memory. Throughout the day you’ll produce a working notebook pipeline you can reuse on your own data and compile a checklist for production hardening.

This live event is for you because...

  • You’re building LLM systems in production, and you’re hitting the limits of vector-only RAG.
  • You’re an ML or LLM engineer who’s building RAG or agentic workflows.
  • You’re a data scientist or applied researcher working on enterprise search, copilots, or automation.
  • You’re a software engineer integrating LLMs with tool APIs, catalogs, and operational knowledge.
  • You’re a knowledge graph practitioner who wants a practical GraphRAG and agents workflow.

Prerequisites

  • Python skills (read code, run notebooks, basic data structures)
  • Basic familiarity with LLMs and RAG concepts (helpful but not required)
  • No prior knowledge graph experience is required

Recommended preparation:

Optional local setup (if you want to run everything on your machine)

  • Python 3.10+
  • Ability to run Jupyter notebooks locally
  • Git installed to clone the GitHub repo (link to come)

Note: Labs are designed to run in Colab without paid API keys. Optional cells show how to swap in a hosted LLM if you have credentials.

Recommended follow-up:

Schedule

The time frames are only estimates and may vary according to how the class is progressing.

Baseline vector RAG and the five failure modes (60 minutes)

  • Presentation: Course goals, repository, and notebook orientation; incident story setup; why vector-only RAG breaks down inside agents (context amnesia, relationship blindness, temporal ignorance, reasoning paralysis, tool chaos); local versus global questions
  • Hands-on exercises: Run the starter notebook and confirm the dataset loads; execute three baseline vector RAG queries and inspect retrieved chunks; create a small challenge set for regression testing; share-out on observed failures
  • Q&A
  • Break

Modeling the domain as a knowledge graph (60 minutes)

  • Presentation: Choosing a graph model, and when a hybrid makes sense; schema patterns for agentic systems (identity resolution, provenance, temporal change); designing for retrieval operators (traversal and explainability)
  • Hands-on exercises: Build a graph from preextracted entities and relationships (NetworkX-based) and validate the schema; add temporal fields (valid_from/valid_to) for config changes and incidents; write traversal queries; share one traversal path that answers a multihop question
  • Q&A
  • Break

GraphRAG retrieval in practice (60 minutes)

  • Presentation: Indexing intuition (entity graph plus community summaries for global synthesis); query-time operators (entity linking, constrained traversal, neighborhood expansion, hybrid vector, and graph seeding); context synthesis for traceable answers (evidence paths and compact summaries)
  • Hands-on exercises: Implement a simplified GraphRAG retriever; use community summaries to answer a global question; compare baseline and GraphRAG on the challenge set and record improvements; tune one operator and report the impact on one question
  • Q&A
  • Break

Observe-think-act plus graph-based memory (60 minutes)

  • Presentation: From RAG to agentic workflows—why tool and skill routing must be explicit and auditable; skills integration and protocol standardization covering MCP-style skill manifests (capability discovery, schemas, permissions) and A2A delegation patterns for composing specialist skills; memory types (working, episodic, semantic, procedural) and what each stores; graph memory patterns (temporal awareness, confidence and provenance metadata, hot-warm-cold lifecycle).
  • Hands-on exercises: Wrap GraphRAG in a simple agent loop that routes between skills via a lightweight skill registry plus MCP-style manifests; optionally delegate one subtask to a specialist agent (A2A style) and merge results; log actions, decisions, and outcomes into an episodic memory graph; add a temporal filter; share-out one memory edge (action to outcome) and how it changed a follow-up response
  • Q&A
  • Break

Hardening for production (50 minutes)

  • Presentation: Evaluation—golden questions, a regression harness, and how to detect retrieval drift; operational concerns; governance basics
  • Hands-on exercises: Build an evaluation harness that runs baseline versus GraphRAG versus agent answers on the challenge set; introduce a simulated new incident update and verify the system adapts without regressions; write a personal production checklist; share one change you will make to your RAG or agent system next week
  • Q&A

Wrap-up and Q&A (10 minutes)

Your Instructor

  • Ammar Mohanna

    Ammar Mohanna is a seasoned AI expert, educator, and entrepreneur with extensive experience spanning academia, industry consulting, and technology innovation. He teaches advanced courses in AI and machine learning at the American University of Lebanon, helping shape the next generation of AI professionals. As a consultant, Ammar leads initiatives focused on integrating AI and generative AI into educational technologies, collaborating closely with cloud technologies. Previously, Ammar cofounded and was AI lead at Assentify, a company dedicated to providing specialized AI solutions, training, and consultancy. His professional expertise includes machine learning, MLOps, explainable AI (XAI), Kubernetes, and microservices architecture. He holds a PhD in edge artificial intelligence from the University of Genoa, Italy. Ammar lives in Beirut, Lebanon, and is fluent in Arabic, English, and French, with intermediate proficiency in Italian.

Skill covered

GPT