Skip to content
Linear Horizon Training

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.

  1. 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.
  2. 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.
  3. 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.
  4. 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.
  5. 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.
  6. 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.
  7. 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.
  8. 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

Contact