Most important take away

Rolling your own Retrieval-Augmented Generation (RAG) system is the modern equivalent of rolling your own auth: it demos well on a weekend but collapses under real-world scale, data variety, and evaluation requirements. Progress Agentic RAG (built on the acquired NucliaDB) bundles ingestion, hybrid search, knowledge-graph-based named entity recognition, citations, quality evaluators, and a new V1 .NET SDK so teams can ship intelligent search, product recommendation, and research workflows in minutes rather than engineering every moving piece themselves.

Summary

Actionable insights

• Treat RAG like auth: unless you have a data scientist or two, buy rather than build. The moving pieces (embedding model, vector DB, ingestion pipelines for PDFs/Word/MP3/MP4, chunking, evaluation, monitoring) each hide real complexity, and scale problems show up the moment upper management asks you to ingest a new file type.
• Do not rely on plain vector similarity alone. Phrase-sensitive semantic search misses answers; combine vector search with keyword search plus Named Entity Recognition that builds a knowledge graph so relationships (company sells product, person works at place) can be reversed and reasoned over. This is what makes queries like “what competes with X” actually work.
• Invest heavily in ingestion-time agents. Running agents during ingestion to summarize, tag, categorize, or extract structured JSON (e.g., turning unstructured Fortune 500 PDFs into chartable data) means you pay the LLM cost once and every downstream query is cheap and consistent.
• Always demand citations and resources in your RAG output. Distinguish between “resources” (hit the search) and “citations” (actually used in the answer), and surface the exact source paragraph so users can trust and verify. A definitive answer without traceability is worse than no answer.
• Use guardrails in the default prompts to prevent LLM training data from overriding retrieved context. If the vector store has nothing, the system should say so rather than hallucinate from pre-training.
• Reframe “hallucination” by use case: creative writing wants it, factual grounding punishes it. Pick the model temperature and prompt strategy to match.
• Stand up a continuous evaluation layer (groundedness, context relevance, answer relevance). Progress ships this as “Remy” with dashboards; if you build your own RAG, plan to build this too because ingesting conflicting sources is inevitable.
• For on-prem / regulated data, use hybrid mode: keep the vector database local, call hosted or local models (Ollama is viable) via custom endpoints. The back office lets you swap between Azure, AWS, Gemini, or custom endpoints as plug-and-play.
• When scraping for ingestion, feed a sitemap plus CSS/XML selectors so you index only meaningful content and avoid polluting vectors with menus and footers.
• Think beyond search as the RAG “hello world”. Higher-value use cases: product recommendation (“I’m a .NET dev, what do you have for this?”), competitive battle cards generated in real time from competitor + internal data, and multimodal R&D flows (photograph a food prototype, analyze color/sheen, then search your additives catalog and return datasheets with follow-up Q&A).

Software architecture patterns mentioned

• Rag-as-a-service architecture: commercial product (Progress Agentic RAG) sitting on an open-source vector DB (NucliaDB). Platform is written in Python but exposes REST APIs, with SDKs per language including a new .NET SDK.
• Ingestion pipeline: documents are chunked, sent through an embedding model, stored as vectors; multi-source providers handle PDF, Word, text, MP3, MP4, and web (sitemap + selectors).
• Hybrid retrieval: vector (cosine similarity) + keyword + Named Entity Recognition building a knowledge graph. Inverted cosine similarity (“opposite of dairy -> capsaicin”) is a legitimate query mode.
• Agentic layer at ingestion time: task runners that summarize, tag, categorize, or extract structured JSON from unstructured content (e.g., annual report PDFs -> chartable data) and persist metadata back into the DB.
• Evaluation agents (“Remy”) continuously scoring groundedness, context relevance, and answer relevance with a dashboard.
• .NET SDK patterns familiar to the ecosystem: NuGet package, dependency injection (UseNucliaDB with keys/endpoint), strongly typed responses, similar shape to Microsoft.Extensions.AI. Three or four lines of code to get from DI registration to an intelligent search call.
• Pluggable model layer with a back-office UI: choose among Azure, AWS, Gemini, or custom endpoints; fully on-prem is available only at the enterprise tier.
• UI pattern shift noted by the hosts: modern AI apps are “a box to describe what you want” plus most of the screen dedicated to visualization, pairing well with Telerik/Kendo/Blazor/MAUI components.

Career advice

• Ed’s guiding principle (quoting H.G. Wells on “infinite complacency”): always ask what technology is coming to “take your food away.” Don’t put your head in the sand during comfortable patterns.
• Get ahead of platform shifts before your sector does. Ed did this with responsive web at an industrial manufacturer and earned outsized attention because competitors ignored the trend.
• Even as a UI-focused developer advocate, stay full stack. Ed keeps his hand in backend topics like EF Core internals so he can own whole problems.
• Build the thing you wish existed. Ed was not tasked with writing the .NET SDK for the acquired product; he saw the gap, built it himself, and shipped V1 because he knew it would matter to .NET devs.
• The broader industry discussion (via Carl and Richard responding to a listener comment): the developer’s job was never just to write code, it was to deliver solutions. AI tooling drives demand rather than eliminating it, following the radiologist pattern where FDA-approved image models expanded rather than contracted the profession. Be skeptical of doom predictions made on a five-year horizon.

Pricing and practical notes

• 14-day free trial (hosts felt this is short for serious RAG work).
• Starter: ~$700/month, text files only, 750-file cap, 5 GB index or 15,000 resources.
• Pro: ~$1,925/month, all file types, 25 GB index or 80,000 resources.
• Enterprise: custom quote, only tier with on-prem option.
• NuGet package: progress.nuclia. Demos for Blazor, MAUI, and Kendo live in the Telerik GitHub; business logic is minimal, mostly markup.

Chapter Summaries

• Opening and 1997 retrospective: Episode 1997 kicks off with Y2K/2000 Vox Pop calls, then a long look at 1997 world events (Hong Kong handover, Kyoto Protocol, Asian financial crisis) and tech/science highlights (eight shuttle launches, Mir fire and Spektr collision, Mars Pathfinder and Sojourner, Cassini launch, comet Hale-Bopp, Google domain registered, HTTP 1.1, 802.11, Winamp, Deep Blue beats Kasparov, Visual Studio 1.0, Microsoft’s $150M Apple investment).
• Better Know a Framework: Robust Toolbox, a C# game engine built for Space Station 14, now released as a standalone project.
• Listener comment: Adam Wright’s concern about AI hype, RAM shortages, and “training your own replacement”; Carl and Richard reframe demand expansion via the radiologist analogy.
• Guest intro: Ed Charbeneau, principal developer advocate at Progress, 10x MVP, Dometrain author, helped launch Telerik Free UI for Blazor, now focused on AI and agentic RAG tooling for .NET.
• Ed’s philosophy: the H.G. Wells “infinite complacency” quote drives his career habit of watching for the next disruptive shift (responsive web, mobile, now AI).
• RAG primer: what retrieval augmented generation actually is chunking, embedding, vector search, context augmentation, and prompt reshaping.
• NucliaDB and Progress Agentic RAG: Nuclia acquisition, open-source core, rag-as-a-service commercial offering, scale to millions of documents, multi-format ingestion including MP3/MP4 and sitemap scraping with selectors.
• Hybrid deployment: full cloud, full on-prem, or hybrid (local DB + cloud models or vice versa); pluggable models across Azure, AWS, Gemini, custom endpoints, and Ollama.
• Agentic ingestion: ingestion-time agents that tag, summarize, and extract structured JSON from PDFs; Fortune 500 annual-report-to-chart demo.
• What goes wrong: phrasing-sensitive semantic search misses answers; the fix is hybrid search with keyword and NER-driven knowledge graphs to connect companies, products, and people.
• Guardrails and hallucinations: default prompts prevent training data from overriding retrieved context; the system says “no context” rather than fabricating; citations and source-paragraph tracing are built in.
• Remy evaluation system: continuous groundedness, context relevance, and answer relevance scoring on a dashboard, something teams would otherwise have to build from scratch.
• Pricing tiers and trial length (14 days), with Ed arguing turnaround is fast enough to matter.
• .NET SDK: V1 shipped last week, full REST coverage, DI-based, Microsoft.Extensions.AI-style patterns, Telerik/Kendo/Blazor/MAUI demo apps with minimal business logic.
• Beyond search: product recommendation, competitive battle cards, and the food lab R&D demo (photograph a prototype, analyze attributes, retrieve additive datasheets, ask follow-ups).
• Wrap-up: Ed’s upcoming events (Star Trek [likely Stir Trek], CodeStock, MVP Summit); progress.com home page dogfoods the product in its own search box; NuGet package is progress.nuclia.