Ready-made course · 2 days · Intermediate
Building Enterprise AI Assistants
A two-day course for developers and platform teams: build a secure internal assistant that can use organisational knowledge and systems, with identity, permissions, citations and evaluation.
Internal assistants fail when they are treated as a chatbot with a company PDF attached. Enterprises need identity, permissions-aware retrieval, tool access to internal APIs, citations, logging and a deployment path that security will accept. This course is about that system.
You design and build an assistant architecture: enterprise search and RAG, identity and SSO, data access, tool use, workflows, conversational context and memory. Security, privacy, logging, evaluation and deployment are part of the same build, not a later hardening pass.
The practical work is an internal knowledge assistant that can answer from permitted documents, call a constrained internal tool, cite sources, and refuse when it should.
You leave with a working assistant and a clear list of the platform pieces — identity, retrieval ACLs, audit — that a product team should not have to reinvent.
- Who it is for
- Developers and enterprise platform teams building internal assistants, copilots or knowledge systems.
- Before you start
- Professional software development experience and familiarity with authentication concepts. RAG experience is helpful. Access to a representative document set improves the labs.
You will be able to
- Design an assistant architecture that separates conversation, retrieval, tools and identity.
- Implement permissions-aware retrieval so answers cannot cite documents the user cannot access.
- Integrate identity and SSO into assistant sessions, tools and audit logs.
- Connect constrained internal APIs as tools with validation and least privilege.
- Provide citations, conversational context and memory without leaking across users or tenants.
- Evaluate assistant quality, groundedness and unsafe behaviour before deployment.
- Deploy an internal assistant with logging, privacy controls and an operational boundary.
Modules
8 quarter-day modules. Each one can go into a custom course on its own.
Enterprise assistant architecture
- Conversation, knowledge, tools and policy as separate parts.
- Single assistant or several specialised ones.
- Identity and permissions carried through every call.
- Exercise: design an assistant for one department.
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.
Retrieval with permissions
- Document-level access control carried into the index.
- Tenant isolation and per-user filtering.
- Keeping permissions in sync with the source systems.
- Testing that one user cannot see another’s documents.
MCP and integration architecture
- What MCP gives us in practical terms.
- Exposing existing company functionality and tools to an LLM. Example: finding the best-fit test script from a library using set criteria.
- How this could sit alongside your existing APIs and products.
- Lab: build a small MCP server over an existing API.
Designing tools for models
- Tool names, descriptions and schemas a model uses correctly.
- Validating arguments before any side effect.
- Errors the model can recover from.
- Lab: wrap an existing API as a set of tools.
Security and commercial deployment
- Protecting proprietary and customer data.
- Data retention and privacy.
- Authentication, permissions and access control.
- Customer-facing versus internal AI.
- Guardrails and human decision boundaries.
Evaluation and production
- How to test objectively whether an AI solution works, using golden test sets and LLM-assisted scoring.
- Measuring accuracy and reliability.
- Logging, observability and human-in-the-loop.
- Cost and performance monitoring.
- Knowing when something is safe enough for production or customer use.
Assistants in Teams, Slack and the browser
- Meeting people where they already work.
- Bots, extensions and embedded assistants.
- Feedback capture and hand-off to a person.
- Adoption: what makes people come back.
Practical work
You build an internal knowledge assistant over a representative corpus. The system authenticates, retrieves only permitted material, cites sources, can call one internal tool, and is evaluated against realistic internal questions.
You take away
- A working internal knowledge assistant
- Patterns for SSO, retrieval ACLs and tool scopes
- Citation, logging and evaluation templates
- A deployment and security checklist for internal assistants
Combine it with
- Production AI Architecture · 2 days
- Architecting Enterprise Generative AI · 2 days