AI-RAG · Path 4: Build and operate
Enterprise RAG Engineering
A RAG demo is an afternoon, a RAG system with permissions and measurable quality is engineering. Here you build the latter.
- Duration
- 3 days
- Group
- up to 12 people
- Format
- In-house · Open enrollment · In the lab
- Language
- German or English
- Price
- €23,700 flat, plus VAT
Who this track is for
Developers, data engineers and architects who build or own a RAG system for enterprise use. Also for teams that want to put an existing prototype on a foundation that holds.
Who it is not for
Not for participants without programming practice, the conceptual entry into sources and permissions is AI-DATA. If your primary concern is quality measurement in operations, AI-EVAL is the better fit.
Starting situation
The first tutorial prototype works in the demo meeting and fails on real documents: tables fall apart during chunking, search misses synonyms, everyone sees every document and nobody can say whether version 2 answers better than version 1. Between tutorial and production lies exactly the engineering this track teaches.
This exists after the track
- A running RAG prototype on the lab environment, built by your own team, with a traceable architecture decision per component
- An ingestion pipeline with documented chunking strategies for prose, tables and structured documents
- Hybrid retrieval combining vector and full-text search with reranking, measured head-to-head against naive vector search
- An evaluation set of 30-50 question-answer pairs and a first measured quality baseline
- An implemented permission model with document-level security and a limits document that honestly states what the prototype cannot do
Prerequisites
Solid programming skills in Python, a basic understanding of APIs and databases. Prior experience with embeddings helps but is not required.
Preparation before the track
You receive lab access with a 30-minute setup check in advance, plus a question catalog: 10 real questions your future system should answer, with the document types that contain the answers. These questions become part of your evaluation set.
What's included
- 3 training days with Dino Bordonaro, on site or in our lab
- A personal environment per participant on our enterprise lab for the training plus 14 days afterwards
- A complete code repository with reference implementation, exercise stages and sample solutions
- Templates for evaluation set, permission model and limits documentation
- Certificates of attendance and training documentation for your compliance archive
- A 90-minute remote office hour 4 weeks after the training for questions from your own implementation
Agenda
Day 1
Why the tutorial RAG fails on your documents
Live findings in the lab: a naive RAG against real document types with tables, scans and versions. Every failure is attributed to a component, which produces the build list for the three days.
Ingestion: turning documents into usable units
Hands-on: parsers for PDF, Office and HTML, handling tables and headers, metadata extraction. Everyone builds the pipeline against a prepared document set with known traps.
Chunking is a decision, not a default
Exercise with measured comparison: fixed windows, structure-based and semantic chunking against the same question catalog. When each strategy holds and how to document the decision.
Embeddings and index in operation
Embedding models compared: dimensions, languages, cost. Building the vector index in your own lab environment, first queries against your own corpus.
Day result: the pipeline runs
Each person demonstrates: document set ingested, chunks inspected, index queryable. The pass criterion is a documented chunking decision with rationale, not just running code.
Day 2
The limits of pure vector search
Measurement exercise on your own index: product numbers, proper names and abbreviations that semantic search misses. The error list motivates the hybrid approach.
Building hybrid retrieval
Hands-on: full-text search next to the vector index, score fusion and weighting. Everyone measures the effect on their own question catalog instead of taking it on faith.
Reranking: precision on the last mile
Adding a reranker to your own pipeline, including latency and cost measurement. Decision by the numbers: when is the extra step worth it and when is it not?
The evaluation set takes shape
The question catalogs you brought become a structured evaluation set with expected answers and source references. An automated run against your own pipeline delivers the first baseline.
Day result: measured quality instead of gut feeling
Each person presents numbers: hit rate and answer quality for naive search, hybrid, and hybrid with reranking side by side. The measurement table is the verifiable result of the day.
Day 3
Permissions: the question that stops projects
Lab demonstration: a RAG without permission checks answers salary questions from an HR document. Then the architectures for document-level security: ACL ingestion, query-time filtering, trusted identity passthrough.
Implementing document-level security
Hands-on: permission metadata in the index, a security filter in the retrieval layer, testing with two user roles against the same corpus. Verification: the restricted role gets neither answer nor citation.
Answer quality: grounding, citations, saying I do not know
Prompting the generation layer: answers with source citations, behavior on missing context, handling contradicting documents. A run against the evaluation set shows the effect of every change.
Limits document and operations handover
Each team writes the honest limits documentation: which question types the prototype answers reliably, which it does not, and what is missing before production. Outlook on observability and release gates as the bridge to AI-EVAL.
Day result: the prototype in review
Final review per person: live query with two roles, evaluation results, limits document. The group checks against a checklist: does it run, does it measure, does it protect, and does it honestly state what is missing?
Exercises and lab share
At least 60 percent of the time is code work in your own environment on the enterprise lab: building the pipeline, filling indexes, measuring retrieval, testing security filters. Every architecture decision is verified against your own measurements.
Platforms
You build on our lab environment with open-source components and locally hosted models, no customer data is used. The patterns transfer to Azure, on-premises and hybrid target environments, platform services in the respective available version. The Sovereign Assistant serves as a reference for a production on-premises RAG.
Transfer evidence
The final review on Day 3 documents each person's running prototype, evaluation results and limits document against a fixed checklist. Attendance and results are documented in an audit-proof way.
Artifacts you take home
- Your own RAG prototype with ingestion, hybrid retrieval and reranking, exportable from the lab environment
- A code repository with reference implementation and sample solutions for further use
- An evaluation set of 30-50 question-answer pairs with a measured baseline
- An implemented permission model with a documented security filter
- A limits document as an honest decision basis for the path to production
Optional extensions
- Evaluation, Observability and Guardrails (AI-EVAL) for the path from prototype to operable system
- LLMOps for connected, disconnected and air-gapped environments (AI-OPS) for sovereign operations
- The Sovereign Assistant as the product path if you want a supported on-premises RAG instead of building your own
Boundaries
This track builds a prototype with your team and teaches the engineering decisions behind it. It is neither a product rollout nor an implementation project in your production environment, for those we talk about a project or the Sovereign Assistant.
Frequently asked questions
We already built a prototype with a framework. What is left to learn?
The difference between running and holding up: hybrid retrieval with measured comparison, reranking decisions by the numbers, document-level security and an evaluation set as a baseline. Exactly the parts missing from framework tutorials that stop projects later.
Do we need our own GPU environment or cloud accounts?
No. Each person works in a dedicated environment on our enterprise lab with 2,516 CPU cores and 24 TB of RAM, including 14 days of continued access. For the transfer to your target environment you take code and architecture decisions with you.
What does it cost if we only want to send 2 developers?
The track runs as an in-house delivery at €23,700 plus VAT with 4 to 12 participants, with question catalogs and document types from your own organization. With fewer than 4 developers of your own, it makes sense to combine with the data or platform team, RAG in particular thrives on that mix.