IBM RAG and Agentic AI

A model alone cannot answer from your documents. You load and split text, retrieve relevant passages, hand them to a model, and put a Gradio interface on the result so others can try it.

• Why retrieval beats pasting documents into a prompt
• Loading documents and splitting them into chunks
• Embedding chunks and storing them
• Retrieving passages for a question
• Building the answer prompt from retrieved context
• A Gradio interface for the question-answering app

You build A document question-answering app with a web interface.

Retrieval quality starts in the store. You turn text into embeddings, search by similarity in Chroma and FAISS, and understand the differences between them well enough to choose one.

• What an embedding vector represents
• Distance and similarity measures
• Indexing and querying in Chroma
• Indexing and querying in FAISS
• Metadata filters and persistence
• Choosing a store for a given workload

You build The same corpus indexed in two vector stores, with their results compared.

Plain similarity search misses things. You improve recall and precision with richer retrievers, rewrite queries, rebalance results to avoid repetition, and bring in LlamaIndex as another way to build the index.

• Where plain similarity search fails
• Multi-query and rewritten queries
• Maximal marginal relevance for diverse results
• Parent-document and contextual compression retrievers
• Combining keyword and vector search
• Building an index and query engine with LlamaIndex
• Judging retrieval on a labeled question set

You build A retriever pipeline that beats plain similarity search on a labeled question set.

Real inputs are not only text. You build applications that read and describe images, generate pictures and handle speech with pretrained models from Hugging Face, and expose them through a simple interface.

• What multimodal models take in and produce
• Image captioning and visual question answering
• Generating images from text
• Speech to text and text to speech
• Loading pretrained models from Hugging Face
• Combining modalities in one Gradio app

You build A Gradio app that accepts an image and a spoken question and returns an answer.

An agent is a model that decides, acts and looks at the result. You learn how function calling works, write tools a model can use correctly, and build the loop that lets an agent pick its next step.

• From a chain to an agent
• Function calling and tool schemas
• Writing tool descriptions that guide the model
• The reason-act loop
• Short-term memory and context
• Stopping conditions and failure handling

You build A hand-built tool-calling agent with two tools and clear stopping rules.

Plain agent loops are hard to control. LangGraph represents the workflow as a graph of steps with shared state, so you can branch, loop, pause for a person and resume exactly where you stopped.

• State, nodes and edges
• Conditional routing between nodes
• Tools and retrieval as graph nodes
• Persisting state with checkpoints
• Pausing for human approval
• Streaming and inspecting a run

You build A LangGraph agent with retrieval, tools and a human approval step.

Some tasks split naturally among specialists. You build teams of agents in CrewAI, AG2 and BeeAI, then compare how each framework models roles, conversation and control so you can pick one on purpose.

• Roles, goals and delegation in CrewAI
• Conversation-driven agents in AG2
• Building agents with BeeAI
• Sequential, hierarchical and conversational patterns
• Shared state and handoffs
• Comparing frameworks on the same task
• Where multi-agent designs add cost without value

You build One task solved by a team of agents in two frameworks, with a written comparison.

Hard-wiring tools into every agent does not scale. MCP gives agents a standard way to discover tools and data. You build a server, connect a client, and think through what an agent should be allowed to reach.

• The problem MCP solves
• Tools, resources and prompts as server primitives
• Building an MCP server in Python
• Connecting an agent as an MCP client
• Local and remote transports
• Permissions and trust for connected tools

You build An MCP server exposing a data source, used by an agent.

Demos hide fragility. You build test sets for retrieval and agent behavior, trace runs to see why they went wrong, and put limits on cost, steps and what tools may do.

• Evaluation sets for retrieval and answers
• Measuring faithfulness to sources
• Tracing an agent run step by step
• Testing tool selection and arguments
• Limits on steps, tokens and spending
• Defending against injected instructions

You build An evaluation harness and tracing setup for one agent application.

Combine retrieval, agents and MCP into one system for a real scenario. You design the architecture, build it, evaluate it and write down the trade-offs you made and the ones you would revisit.

• Choosing the scenario and architecture
• Building the retrieval layer
• Building the agent layer and its tools
• Connecting through MCP
• Evaluating and presenting the system

You build A complete system combining retrieval, tool-using agents and an MCP connection.