Ready-made course · 1 day · Intermediate
From Chatbot to Agent
A one-day workshop that starts with a basic LLM chat application and evolves it, step by step, into a useful agentic system with retrieval, tools, state and production safeguards.
Many teams already have a chatbot. The question is how to grow it without rewriting it every time a new capability appears. This workshop uses that progression as the course: chat, structured output, retrieval, tool use, workflow state, agentic behaviour, evaluation and production safeguards.
Each step is implemented on the same application. You see what breaks when structured output is added, what retrieval changes, and why an agent loop is a different system from a chat with extra prompts. The day is a sequence of working increments, not a set of optional extras.
The teaching is deliberately conservative. Not every chatbot should become an agent. The workshop makes the cost of each step visible so your team can stop at the right layer.
You leave with an evolved application and a map of the increments you would take on your own system.
- Who it is for
- Developers and technical teams who already have, or are about to build, a chat interface and need a controlled path toward retrieval and agents.
- Before you start
- Ability to work in an application codebase. Prior LLM API experience is expected. A simple chat starter is provided if teams do not bring their own.
You will be able to
- Implement structured outputs on top of a basic chat application.
- Add retrieval without turning the chat into an ungrounded knowledge claim.
- Introduce tool use and workflow state as explicit application capabilities.
- Add bounded agentic behaviour only where the task requires it.
- Evaluate the system at each increment and add production safeguards.
- Decide where your own product should stop on the path from chatbot to agent.
Modules
4 quarter-day modules. Each one can go into a custom course on its own.
Working with LLM APIs
- API keys and authentication.
- Sending and receiving requests, structured JSON and streaming.
- Managing context and conversation state.
- Cost and token management.
- Enough Python to understand and change the examples. All code is supplied, with starting points and worked solutions.
RAG and proprietary knowledge
- Using your specifications, documentation and knowledge bases with an LLM.
- Embeddings, vector databases and hybrid search.
- Turning documentation into FAQs to improve retrieval.
- Citations and source grounding.
- Updating knowledge without retraining a model, and reducing hallucination.
Agents and tool calling
- What an agent actually is, and when we need one.
- Function and tool calling.
- Letting an LLM work with your existing APIs and software.
- ReAct and Reflection concepts where useful.
- "Agentic first turns": the assistant opens the conversation with relevant context.
- When a conventional workflow is better than an autonomous agent.
Agent failures, permissions and human approval
- How agents fail: loops, drift and confident wrong actions.
- Permission boundaries and scoped credentials.
- Human approval at the decisions that matter.
- Lab: add approvals and limits to a working agent.
Practical work
One application is evolved through the eight-step progression. You run the same tasks after each increment so the group can see what improved, what became slower, and which safeguards became mandatory.
You take away
- An evolved application from chat through retrieval and tools to a bounded agent
- A step-by-step increment map for the team’s own product
- Evaluation tasks reused across increments
- A production-safeguard checklist for the layer you choose to ship
Combine it with
- RAG in a Day · 1 day
- Build an AI Agent in a Day · 1 day
- AI Architecture Workshop · 1 day