Like your organization’s databases, you should regard your AI resources as strategic, organizational resources. And, like the data in your organization’s databases, you need to manage the content used by your AI resources to enable those resources give you reliable, grounded answers. Telerik Agent Tools API lets gives you the tools for automating the process of creating and maintaining the content in your AI resources.

In an earlier post, I showed how to use Progress Telerik Document Processing Libraries (DPL) to create an AI resource with content from existing documents and then tie that resource to a Large Language Model (LLM) that your users could query.

Tying an LLM to your content creates a Resource Augmented Generation (RAG) resource that helps get your users grounded answers driven by the content you load into your resource. And using the DPL toolset is a great solution when you’re building an application that creates a RAG resource “as needed.”

But if you want to reliably create/update a RAG resource that will be used (and reused) by multiple applications and multiple users, then you need the Telerik Agent Tools API. Once you have a reliable process for creating your RAG resource, the Agent Tools API also lets you then use that resource to support your users by integrating with Microsoft’s latest toolset for responding to your user’s prompts.

In this post, I’m going to cover how to construct an automated workflow for creating a RAG resource that can be used across applications and users. In my next post, I’ll cover how to use that resource with the LLM of your choice.

Building a RAG Resource Workflow

You can use the Tools API to create an interactive application that lets you manage the documents that make up your resource’s content. However, for this post, I’m going to assume a simpler process than that (though I’ll cover all the tools you’d need for an interactive solution).

For this post, I’m going to assume there’s a folder that holds all the documents with the content that should be in my RAG resource (which might be Word documents, spreadsheets, PDF, text files—basically, all the content that you can load with Telerik DPL tools). Users control what goes into my resource by adding and removing documents from that folder.

In this case study, then, I build my RAG resource by running a batch program that reads all the documents in the folder, adds them all to a RAG resource in memory, and then saves the new resource, replacing any existing version with a new, updated version.

Configuring Your Project

To start building an application to manage your RAG resource, you must first add the Telerik.Documents.AI.Tools.Core NuGet package to your project. After that, you need the specific Telerik packages that support the document types that you’ll add to your RAG resource.

For my case study, I’m just going to use PDF documents, so I just need the “Fixed” packages:

- Telerik.Documents.AI.Tools.Fixed.Core
- Telerik.Documents.AI.AgentTools.Fixed 

If you’re working with spreadsheets, you’ll want to add the equivalent Spreadsheet packages:
- Telerik.Documents.AI.Tools.Spreadsheet.Core
-Telerik.Documents.AI.AgentTools.Spreadsheet)

To support Microsoft Word, HTML and text documents, you also need to add the Telerik.Documents.AI.Tools.Flow.Core package.

And, of course, there’s no reason you couldn’t make your life simpler by adding all the Telerik.Documents.AI.* libraries to your application, even if you don’t need to use them all right now. In this case study, I also didn’t take advantage of the some of the other packages available—the Telerik.Documents.AI.AgentTools.Conversion package that handles conversions between document types, for example.

Building Your RAG Resource

The process for creating a RAG resource begins with creating an in-memory repository which holds your documents. A repository can hold one of three categories of documents: spreadsheets, PDF documents or Word and Word-related documents.

In my case study, I’m only going to work with PDF documents (which Progress Telerik classifies as “Fixed” documents), so I created an inMemoryFixedDocumentRepository object and then stored a reference to that repository in an IFixedDocumentRepository variable.

The code to do that looks like this:

IFixedDocumentRepository pdfRepo = 
          new InMemoryFixedDocumentRepository( new TimeSpan(0, 2, 0) );

All of the three types of repositories look very much alike though (they all share a common IDocumentRepository interface, for example). As a result, working with other document types is similar.

If, for example, you were loading spreadsheet files (“Workbook” documents), you’d use the InMemoryWorkbookRepository object and the IWorkbookRepository interface. For Word and Word-related documents (“Flow” documents), you’d use the InMemoryFlowDocumentRepository object and the IFlowDocumentRepository interface.

Repositories have some built-in functionality (they all include a ListDocuments method that returns a list of documents in the repository, for example). You will, however, want to extend your repository by attaching one or more toolsets containing tools that add additional functionality to your repository.

For my case study, I just needed to be able to import documents into an empty repository so the only toolset I attached was the FixedFileManagementAgentTools toolset that supports working with a PDF repository and has import (and export) methods for individual documents. To that toolset looks like this, I pass a reference to my repository, I pass a reference to my repository and the path to the folder containing the documents that the tools will work with:

FixedFileManagementAgentTools pdfFileTools = 
            new FixedFileManagementAgentTools(pdfRepo, repoFolderPath);

You can add additional toolsets if you need additional functionality or need to work with more folders. If, for example, I wanted to work with PDF forms, I could add the FixedDocumentFormAgentTools toolset to my repository. When creating a toolset, you’ll always need to pass a reference to the repository the toolset will be attached to, but other parameters (if any) will vary from one toolset to another.

Managing Repositories with Registries

If you’re going to be working with multiple repositories in your workflow, you might want to create a registry to simplify managing your repositories. In my case study, for example, where I’m potentially loading several different kinds of files, I could end up supporting all three types of repositories (PDF files, spreadsheets, Word and Word-related documents)—creating a registry simplifies switching between the different types of repositories.

Registries are created using the DocumentRepositoryRegistry object and support registering one repository of each document category using their RegisterRespository method.

You can then retrieve the repository you want from a registry by using the registry’s TryGetRepository method, passing two parameters: the document type of the repository you want and an out parameter of type IDocumentRepository. Like other TryGet* methods, the TryGetRepository method returns return true if the method finds the repository you want and false if the method does not (the actual repository, if found, is loaded into the method’s second, out parameter).

The following code creates a registry, registers my PDF repository using the RegisterRepository method and then immediately retrieves the repository using the registry’s TryGetRepository method. Because the repository is returned using the common IDocumentRepository interface type, I cast the returned reference to the IFixedDocumentRepository type before working with it:

DocumentRepositoryRegistry registry = new();

registry.RegisterRepository(DocumentType.FixedDocument, pdfRepo);

if (registry.TryGetRepository(DocumentType.FixedDocument, 
                                                           out IDocumentRepository? repo) )
{
     IFixedDocumentRepository fixedRepo = (IFixedDocumentRepository) repo;
    //…work with the fixedRepo repository
}

You’ll also want to create a registry if, as part of your workflow, you want to support converting documents between formats or merging multiple documents. The toolsets that support that are ConvertDocumentsAgentTool and MergeDocumentsAgentTool toolsets and they attach to registries rather than repositories.

Loading, Saving and Retrieving Your Repository

Adding a document to a repository is easy: Just call the appropriate import method on the appropriate toolset that’s tied to the repository you want to update.

To add a PDF document to my repository, for example, I’d use the ImportFixedDocument method on my FixedFileManagementAgentTools toolset, tied to my PDF repository. To use the ImportFixedDocument method, I pass the path to the document I want to load and its document format (e.g., PDF, XLSX, etc.). Optionally, I can pass a name for the document which will be returned as part of the ListDocuments method.

Which means that importing a PDF document into my repository would look like this:

CallToolResponse res =
          pdfRepoTools.ImportFixedDocument(documentPath, 
                                                                                         DocumentFormat.PDF,
                                                                                          Path.GetFileNameWithoutExtension(documentPath)
                                                                                        );

The CallToolResponse object’s IsError property will be set to true if your import succeeds (and the Message property will contain additional information regardless of whether the call succeeds or fails).

Once I’ve added all the documents from my folder to my repository, I can save my repository with all of its content to a single file using my repository’s MergeAndExport method. The MergeAndExport method requires three parameters:

• An array of the id property for each of the documents in the repository. You can use that array both to control which documents are exported and the merge order of the documents. I didn’t bother and just used a LINQ Select method to retrieve all the id property values.
• A FileStream object that points to your repository file (I set this up to overwrite my repository every time).
• The document type for the file (PDF, in my case).

You must close your FileStream after you finish exporting your documents. As a result, the code to export my repository of PDF documents would look like this:

string[] ids = pdfRepo.ListDocuments().Select( doc => doc.Id ).ToArray();
FileStream fs =  new FileStream(repoFilePath, FileMode.CreateNew),
                                 
repo.MergeAndExport(ids,
                                                fs,  
                                                DocumentFormat.PDF);
fs.Close()

You can now tie that file to an LLM using Microsoft ChatClientAgent object to let your users query your RAG resource. I’ll walk through how to do that in my next post.

By themselves, AI agents can be useful. Integrated into an application, however, a custom AI agent can provide users with the ability to navigate the application and to better understand the business area that the application is part of.

Progress provides multiple tools for embedding AI agents into your application’s UI. In previous posts, for example, I’ve looked at Progress Telerik and Kendo UI AI Prompt components in JavaScript [in post 5](Creating a Custom AI Agent with Telerik Tools: Creating an Interactive UI in JavaScript) and Blazor [in post 4](Creating a Custom AI Agent with Telerik Tools: Crafting an Interactive Blazor UI). In this post, I’m going to address two different UI scenarios where the AI Prompt might not be your best choice.

The first scenario is when your AI agent isn’t the point of your application—it’s just a useful tool that your users can invoke when they need it. The AI Prompt component isn’t necessarily your best choice there because, by default, the AI Prompt takes over a significant portion of your application’s UI (though you can customize that using the AI Prompt’s various templates). Out of the box, however, the Inline AIPrompt provides a compact interface that users can bring up when they need your agent and, equally important, dismiss it when they don’t need your agent.

The AI Prompt component also assumes a specific workflow, with the user alternatively entering a prompt and viewing the current output from your agent (along with a history of responses to previous prompts). But when the interaction with your AI agent is the point of your application, you might want to create more natural back-and-forth conversational interaction between your user and the agent. The Telerik Chat component will let you do that, again, out of the box.

I’m going to show how to use both in this post.

By the way (which means you can skip this paragraph—it’s all background): In this post, I’m assuming the existence of a custom AI agent that provides application-specific support to your users. That means that you’ve [selected a Large Language Model](reference to Creating a Custom AI Agent with Telerik Tools: Configuring an LLM for Azure or Ollama) (LLM) for processing your user’s input, loaded your own content into your [custom AI agent](reference to Creating a Custom AI Agent with Telerik Tools: Loading and Accessing Your Agent’s Content) (about 10 lines of code) and written another 10 lines of code to tie your agent into your application. For a JavaScript application, you’ll need to wrap that code in a web service (I covered the, literally, two lines of code to make that happen at the start of a [post on using the AI Prompt component from JavaScript](reference to Creating a Custom AI Agent with Telerik Tools: Creating an Interactive UI in JavaScript)) and write the five lines of JavaScript code to all your agent. That probably sounds like a lot. It is, however, only about two dozen lines of code to give you an AI-enabled application with domain-specific knowledge.

Letting the User Access Your AI Agent When They Want It

I’m going to start with the scenario where you want to enable your user to invoke your AI agent when they need it and ignore the agent the rest of the time. The Inline AIPrompt lets you do that: implement a minimal user interface that pops up when the user needs to send a prompt to your agent and then review your agent’s response:

I’m going to use the Kendo UI for jQuery Inline AIPrompt in this case study, but there are also versions of the component for React, Angular, ASP.NET Core, ASP.NET MVC and Blazor.

Configuring the Inline AI Prompt

Your first step is to add the Inline AIPrompt to your webpage with a <div> element that has its id attribute set to some name (I used customAgent):

<div id="customAgent" />

You can place that <div> element wherever you want in your page’s body (I put it near the top of my application’s HTML, but it really doesn’t matter).

Next, you need to configure your Inline AIPrompt component. You do that by writing a jQuery command to find your <div> element, passing the name you put in the <div> element’s id attribute.

You then call the kendoInlineAIPrompt function from the retrieved element, passing a configuration object. The kendoInlineAIPrompt function returns an object and you then call that object’s data function, passing the string kendoInlineAIPrompt. That, in turn, will return an object you can use to manage the component.

You only want to do this configuration once, so you should tuck that code into jQuery’s ready function. That means you’ll end up with code like this to set up your component:

$( () =>
{
  $("#customAgent").kendoInlineAIPrompt(
    {
      //…configuration object
     }).data("kendoInlineAIPrompt");
}

In the customization object that you pass to the kendoInlineAIPrompt function, you need to set two properties on the object:

• isStreaming: Set this to true to let you update the component’s UI with the output from your custom AI agent
• promptRequest: Set this to a function to be called when your user enters a prompt and clicks the “go” button in the Inline AIPrompt’s UI

By the way, you don’t have to put a function in the promptRequest property. You can configure the Inline AIPrompt to call an LLM directly by setting your configuration object’s service and systemPrompt properties. Using the promptRequest function, however, simplifies calling a custom AI agent.

A minimal implementation might look like this:

let ca = $("#customAgent").kendoInlineAIPrompt(
 {
   isStreaming: true,
   promptRequest: async function (req) {
     //…function code           
   }
 }).data("kendoInlineAIPrompt");         

Your promptRequest function will be passed a parameter. From that parameter, you can retrieve the user’s prompt by reading a property cleverly called prompt. Once you have the user’s prompt, you can pass it to your agent and catch your agent’s response. In my case, that means passing the prompt to my JavaScript function that calls my AI agent’s web service.

Once you get a response from your agent, you need to add it to the Inline AIPrompt’s UI. To do that, you just need call the component’s updatePromptOutputContent function, passing the output from your agent.

Since the JavaScript function that calls my agent is called asyncAppAgent and returns the agent’s response as a string ready to add to the Inline AIPrompt’s UI, my promptResult function is a single line of code (my web service function is asynchronous so I have to use the await keyword when calling it and flag the function as async):

ca = $("#customAgent").kendoInlineAIPrompt(
  {
    isStreaming: true,
    promptRequest: async function(req) 
      {
        this.updatePromptOutputContent(                                                       
          await asyncAppAgent(req.prompt));
      }
  }).data("kendoInlineAIPrompt"); 

There’s more you can do with the component (for example, as with the AI Prompt component, you can give the user some predefined commands to use with the component). But before you can do any of that—because, by default, the component isn’t visible—you need give your users a way to display the Inline AIPrompt when they want it.

Opening the Prompt

Since I’m trying to minimize the UI footprint for my agent’s interface, I decided to use the Kendo UI for jQuery Context Menu to let the user invoke my prompt (you could just have a button on your page that opens Inline AIPrompt).

Since I was using the context menu (which implies giving the user choices), I also decided to give the user the ability to choose between two custom agents:

• One agent would be loaded with content about using the application (e.g., the application’s user guide, enhanced with a download of questions and responses from the application’s end user forum)
• The other agent would be loaded with content about the application’s topic area (in my case, that topic area is creating an asynchronous application and the content is from another series of posts on Coding Azure I wrote).

The first step in using the context menu is to add a <ul> element anywhere on your page and set its id attribute to some name (in this case, I picked selectAgentMenu).

Within that <ul> element, you use <li> elements to define your popup menu’s choices. I also (for reasons that will become obvious), assigned values to the <li> elements’ name attributes:

<ul id="selectAgentMenu">
  <li name="Ask">Ask about asynchronouse processing</li>
  <li name="Help">Ask about using this application</li>
</ul>

Next, you need to configure your content menu, this time by calling the kendoContextMenu function on the <ul> element that defines your menu. In the configuration object you pass to this function, you must set its select property to a function that will be called when a user clicks a choice in the menu. That function is passed a parameter with an item property that holds the <li> element that defined the menu choice the user selected.

In this code, I use the element’s attr function to retrieve the element’s name attribute and use that value to set a variable I called mode. Later on, I’ll use that mode variable in my Inline AIPrompt’s promptRequest function to call the right AI agent. I then use the variable created when I configured my Inline AI Prompt component to display the component by calling the its open method:

let mode = "";
$(function () 
{
  $("#selectAgentMenu").kendoContextMenu(
    {
      select: function (e) {
        mode = $(e.item).attr("name");                                                
        ca.open();           
      }
});

With my context menu in place, I can enhance my promptRequest function to pick the AI agent, based on the user’s menu choice:

promptRequest: async function(req) {
  switch (mode)
  {
    case "Ask":
    this.updatePromptOutputContent(                                                       
    await asyncInfoAgent(req.prompt));      
    break;
    case "Help":
    this.updatePromptOutputContent(                                                       
    await appHelpAgent(req.prompt));      
    break;
  }
}

The user can dismiss the component by clicking anywhere on the webpage, so using the resulting interface looks like this:

At this point you have an interface to your AI agent that appears and disappears as the user needs it.

Conversational AI

Sometimes, however, you want a UI that allows your user to have a conversation with your agent. You can enable Kendo UI for jQuery Chat component for that (and, again, versions of the Chat component exist for multiple other platforms). The component creates a chat UI familiar to your user, with a textbox at the bottom for your user to enter their prompt and a chat history above that to display the user’s prompts and the agent’s responses:

Your first step is to decide where on your page you want your chat dialog to appear and to add a <div> element there, with the <div> element’s id attribute set to some name (I used dialogAgent):

<div id="dialogAgent" />

After that, you need to configure your chat dialog by using a jQuery query to find your <div> element and call the kendoChat function from it, passing a configuration object. In the configuration object, you need to set its sendMessage property to a function to be called when your user enters a prompt. In that function, you’ll call your agent and update the chat with your agent’s response.

You only want to configure your chat once, so you should wrap that code in jQuery’s ready function, like this:

$(function () 
{
  $("#dialogAgent").kendoChat({
    sendMessage: (e) => {
  //…function
  }
  });
});

Rather than using a function in the sendMessage property, you can configure your chat component to call an LLM directly by setting the configuration object’s aiServiceUrl property. Using a function in the sendMessage property, however, simplifies calling a custom agent.

Now you need to write the sendMessage function that will send a message to your agent. You function will be passed a parameter that has two useful properties:

• message: You use this property both to retrieve the user’s prompt and to manage the display of the user’s prompt in the chat history pane
• sender: Use this to add the response from your agent to the chat history (your user’s prompt will be added to the chat history automatically)

In your sendMessage function, you need to set the authorName property on the parameter’s message property. That controls the label displayed in the chat history window with your user’s prompts. I picked Me:

$("#dialogAgent").kendoChat({
  sendMessage: (c) => {
  c.message.authorName = "Me";
  //…more
}

You can retrieve the user’s prompt from the text property on the object in the parameter’s message property. You then pass that prompt to your agent (I used the JavaScript function I wrote to call my agent’s web service) and catch your agent’s response.

To add the agent’s response to the chat history, you call the postMessage of the object in the sender property of the parameter passed to your function. You pass the postMessage property an object with three properties set:

• authorId: A unique identifier to distinguish your user’s prompt from your agent’s responses
• authorName: The name that will be displayed with the agent’s response in the chat history
• text: The response from your agent

That code is also pretty short:

sendMessage: async (e) => {
  e.message.authorName = "Me";
  e.sender.postMessage(
  {
    authorId: "Agent",
    authorName: "Agent",
    text: await asyncInfoAgent(e.message.text)}
});

Your user can now interactively query your AI agent to extract whatever information you need.

There’s more you can do here (creating a context-aware conversation by using state management to store message history and including that in your user’s requests, for example). But, even with this simple implementation, you’re ready to let your user have a conversation with your agent.

There are, at least, three scenarios when you’ll want to integrate an AI-enabled component into your application’s UI: when the interaction with your agent is the primary point of your application, when your AI agent is not the primary part by “just another part” of your application, and when your users will only occasionally need to access your agent (and these are just points on a continuum).

All three of the Progress Telerik and Kendo UI “UI for AI” components—Chat, AIPrompt and Inline AIPrompt—support those three scenarios (and all the points in between). Picking the right component, however, will simplify your code and let you get your application up and running faster.

Testing a web API involves much more than simply checking whether methods return or send data correctly. It requires validating real-world behaviors like pagination, unique keys, data persistence and other database rules. Anticipating and reproducing these scenarios can be challenging, especially when they depend on specific query behaviors or stored data.

To address this, the .NET ecosystem provides powerful tools for unit testing. In this post, we explore how in-memory SQLite serves as an effective solution for testing ASP.NET Core APIs, enabling developers to simulate common scenarios without deploying a real database. Additionally, we demonstrate how tools like Progress Telerik JustMock can streamline test implementation and help validate business rules efficiently.

The Importance of Testing in Real-World Environments

A common example of functionality in web APIs is paginated search, which at first glance is quite simple. We receive parameters such as page and pageSize, apply a Skip and a Take, return the data and move on. In a controlled scenario, with few records, it’s difficult for something to go wrong.

The problem begins when this code reaches production or even test environments, without having been validated with a real database. Consider a common scenario: in a paginated search, sorting is essential for it to function correctly. Without an explicit OrderBy, the database does not guarantee the order of the returned records.

In in-memory lists, the result usually appears stable, which completely masks the problem. Without tests running this query on a relational database, the error goes unnoticed, resulting in inconsistent pagination with duplicate records between pages, items “disappearing” when navigating between pages or different results for the same request. This type of bug is especially difficult to reproduce locally when not using a real database or even a simulation of one.

This is where the in-memory database plays a very important role. It allows the query to be executed exactly as it will be executed in production, revealing flaws that only appear when pagination, sorting and the database work together.

Understanding In-Memory SQLite

In-memory SQLite is a way to use the SQLite database entirely in memory. Instead of saving data to a .db file, SQLite creates the database only while the application or connection is active. When the connection is closed, all data is discarded.

In-memory SQLite is widely used in automated testing, especially in ASP.NET Core applications in conjunction with Entity Framework Core, as it has advanced features such as simulating a real database and executing real SQL (constraints, indexes, unique keys, FK and others).

Testing with SQLite in Memory

Next, we’ll look at some examples of unit tests in common web API scenarios where in-memory SQLite excels. But first, let’s create the basic application and then add the tests.

You can access all the code discussed in this post in this GitHub repository: Memo Order source code.

To create the application you can use the command below:

dotnet new web -o MemoOrder

To add the NuGet packages you can use the following commands:

dotnet add package Microsoft.EntityFrameworkCore --version 10.0.1
dotnet add package Microsoft.EntityFrameworkCore.Sqlite --version 10.0.1

Then, open the application and create the following classes:

namespace MemoOrder;

public class Order
{
    public int Id { get; set; }
    public string Number { get; set; } = string.Empty;
    public decimal TotalAmount { get; set; }
    public DateTime CreatedAt { get; set; }
    public bool IsDeleted { get; set; }
}

namespace MemoOrder;

public class OrderSummaryDto
{
    public string Number { get; set; }
    public decimal Total { get; set; }
}

using Microsoft.EntityFrameworkCore;

namespace MemoOrder;

public class AppDbContext : DbContext
{
    public AppDbContext(DbContextOptions<AppDbContext> options)
        : base(options) { }

    public DbSet<Order> Orders => Set<Order>();

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Order>(entity =>
        {
            entity.HasKey(o => o.Id);
            entity.Property(o => o.Number).IsRequired();
            entity.HasIndex(o => o.Number).IsUnique();
entity.HasQueryFilter(o => !o.IsDeleted);
        });
    }
}

using Microsoft.EntityFrameworkCore;

namespace MemoOrder;

public class OrderRepository
{
    private readonly AppDbContext _context;

    public OrderRepository(AppDbContext context)
    {
        _context = context;
    }

    public async Task AddAsync(Order order)
    {
        _context.Orders.Add(order);
        await _context.SaveChangesAsync();
    }

    public async Task<List<Order>> Pagination(AppDbContext context, int skip, int take)
    {
        return await context.Orders
                    .OrderBy(o => o.Id)
                    .Skip(skip)
                    .Take(take)
                    .ToListAsync();
    }
}

Now let’s create a special factory class that will be used in the tests to create the in-memory database and keep the connection open while the tests are running. Create the following class in the application:

namespace MemoOrder;

using Microsoft.Data.Sqlite;
using Microsoft.EntityFrameworkCore;

public static class SqliteInMemoryFactory
{
    public static AppDbContext Create()
    {
        var connection = new SqliteConnection("DataSource=:memory:");
        connection.Open();

        var options = new DbContextOptionsBuilder<AppDbContext>()
            .UseSqlite(connection)
            .Options;

        var context = new AppDbContext(options);
        context.Database.EnsureCreated();

        return context;
    }
}

Note that to tell SQLite to use an in-memory database, we use DataSource=:memory: in the connection string.

Creating the Test Project

All the code needed to implement the unit tests is ready, so let’s create the test project and download the NuGet packages for it. To do this, you can use the following commands, simply run them in a terminal in the application’s root directory:

dotnet new xunit -n MemoOrder.Tests
cd MemoOrder.Tests
dotnet add package Microsoft.NET.Test.Sdk --version 18.0.1
dotnet add package xunit --version 2.9.3
dotnet add package xunit.runner.visualstudio --version 3.1.5
dotnet add package coverlet.collector --version 6.0.4
dotnet add reference ../MemoOrder/MemoOrder.csproj

Next, inside the project MemoOrder.Tests, create a new class called OrderRepositoryTests and let’s add tests to it.

Testing Persistence

The first test will be used to validate persistence—that is, to insert data into the database (which in this case will be the in-memory database). To do this, simply add the following test method to the OrderRepositoryTests class:

[Fact]
public async Task AddAsync_ShouldPersistOrder()
{
    // Arrange
    using var context = SqliteInMemoryFactory.Create();
    var repository = new OrderRepository(context);

    var order = new Order
    {
        Number = "ORD-2026-0001",
        TotalAmount = 200m,
        CreatedAt = DateTime.UtcNow
    };

    // Act
    await repository.AddAsync(order);

    // Assert
    var savedOrder = await context.Orders.FirstAsync();

    Assert.Equal("ORD-2026-0001", savedOrder.Number);
    Assert.Equal(200m, savedOrder.TotalAmount);
}

Note that we use var context = SqliteInMemoryFactory.Create(); to create and represent the database in memory. It works exactly like the EF Core context that maps database tables to class entities.

Testing Constraint UNIQUE

Another common mistake is allowing duplicate records to reach the production environment, which in many cases can have catastrophic impacts. With in-memory testing, we can anticipate problems like this. Simply create a test that verifies inserting a duplicate record will generate an exception. In this case, we could do the following:

[Fact]
public async Task Should_Throw_When_Duplicated_Order_Number()
{
    using var context = SqliteInMemoryFactory.Create();

    context.Orders.Add(new Order
    {
        Number = "ORD-001",
        TotalAmount = 100,
        CreatedAt = DateTime.UtcNow
    });

    await context.SaveChangesAsync();

    context.Orders.Add(new Order
    {
        Number = "ORD-001",
        TotalAmount = 200,
        CreatedAt = DateTime.UtcNow
    });

    await Assert.ThrowsAsync<DbUpdateException>(() => context.SaveChangesAsync());
}

In this test, we created an instance of the database in memory, added an item to the table and saved it.

Then, we tried to add the same item, which generates an exception because, in the dbContext configuration, we declared the Number property of the Order entity as Unique: entity.HasIndex(o => o.Number).IsUnique();.

Thus, we have a real-world scenario, demonstrating that duplicate records will not reach the production environment, as the unit test is able to reproduce exactly the same result.

Testing Pagination

To test pagination using an in-memory database, we could do the following:

[Fact]
public async Task Should_Return_Paginated_Orders()
{
    using var context = SqliteInMemoryFactory.Create();
    var repository = new OrderRepository(context);

    for (int i = 1; i <= 10; i++)
    {
        context.Orders.Add(new Order
        {
            Number = $"ORD-{i}",
            TotalAmount = i * 10,
            CreatedAt = DateTime.UtcNow
        });
    }

    await context.SaveChangesAsync();

    List<Order> page = await repository.Pagination(context, 5, 5);

    Assert.Equal(5, page.Count);
    Assert.Equal("ORD-6", page.First().Number);
}

Note that here we create 10 items and insert them into the in-memory database. Then, we use the Pagination(context, 5, 5) method to perform the pagination and finally verify if the expected quantity and item are correct.

An in-memory database wouldn’t be mandatory to test pagination. This could be done using only regular in-memory lists. However, in this way, we can reproduce the same production scenario.

Testing Soft Delete

Soft-delete is a technique where data is not physically removed from the database, but rather marked as inactive through a flag, such as an isDeleted or deleted_at column. This allows you to keep the entire transaction history in the database.

The problem is that in some cases soft delete can leak unwanted data into reports, new endpoints or even refactored queries. To prevent this from happening, we can use the in-memory database and simulate a search with and without soft-delete:

[Fact]
 public async Task SoftDeleted_Orders_Should_Not_Appear_In_Default_Queries()
 {
     using var context = SqliteInMemoryFactory.Create();

     context.Orders.AddRange(
         new Order
         {
             Number = "ORD-001",
             TotalAmount = 100,
             CreatedAt = DateTime.UtcNow,
             IsDeleted = false
         },
         new Order
         {
             Number = "ORD-002",
             TotalAmount = 200,
             CreatedAt = DateTime.UtcNow,
             IsDeleted = true
         }
     );

     await context.SaveChangesAsync();

     var orders = await context.Orders.ToListAsync();

     Assert.Single(orders);
     Assert.Equal("ORD-001", orders.First().Number);
 }

In this test, the list returns only one item because the second one is marked as deleted. This happens because we declared the query filter entity.HasQueryFilter(o => !o.IsDeleted); when the database is created. By using an in-memory database, we can verify this mechanism works.

It’s also possible to ignore the query filter and still verify it works:

[Fact]
public async Task Admin_Query_Should_See_SoftDeleted_Orders()
{
    using var context = SqliteInMemoryFactory.Create();

    context.Orders.AddRange(
        new Order
        {
            Number = "ORD-001",
            TotalAmount = 100,
            CreatedAt = DateTime.UtcNow,
            IsDeleted = false
        },
        new Order
        {
            Number = "ORD-002",
            TotalAmount = 200,
            CreatedAt = DateTime.UtcNow,
            IsDeleted = true
        }
    );

    await context.SaveChangesAsync();

    var orders = await context.Orders.IgnoreQueryFilters().ToListAsync();

    Assert.Equal(2, orders.Count);
}

Testing Rollback

When performing multiple operations, we run the risk of something failing during the process and the data becoming inconsistent. To keep this from happening, we can use the in-memory database to test if the rollback operation solves this problem.

[Fact]
public async Task Transaction_Should_Rollback_When_Error_Occurs()
{
    using var context = SqliteInMemoryFactory.Create();

    using var transaction = await context.Database.BeginTransactionAsync();

    context.Orders.Add(new Order
    {
        Number = "ORD-NMBR-1",
        TotalAmount = 100,
        CreatedAt = DateTime.UtcNow
    });

    await context.SaveChangesAsync();

    await transaction.RollbackAsync();

    var count = await context.Orders.CountAsync();

    Assert.Equal(0, count);
}

In this test, we added an item to the order list, saved it and then performed a rollback. Finally, we verified that the list was empty, checking that the operation was undone.

Testing Query Refactoring

Refactoring queries is often necessary, whether to improve performance or simply to make the code cleaner. The problem is that this can break queries that previously worked.

To see that both the old and new queries have the same result, we can use an in-memory database as demonstrated in the example below:

   [Fact]
    public async Task Refactored_Query_Should_Return_Same_Result()
    {
        using var context = SqliteInMemoryFactory.Create();

        var oldResult = await context.Orders
            .Where(o => o.TotalAmount > 100)
            .Select(o => o.Id)
            .ToListAsync();

        var newResult = await context.Orders
            .Select(o => new { o.Id, o.TotalAmount })
            .Where(o => o.TotalAmount > 100)
            .Select(o => o.Id)
            .ToListAsync();

        Assert.Equal(oldResult, newResult);
    }

In this example, we verify that both queries have the same result, so even after refactoring, the old logic will continue to work.

Query Test with Projection to DTO

When using Data Transfer Objects (DTOs) for data transport, we are subject to errors that can silently break our queries. Again, with an in-memory database, we can simulate a query using a DTO.

   [Fact]
    public async Task Projection_To_Dto_Should_Work()
    {
        using var context = SqliteInMemoryFactory.Create();

        var result = await context.Orders
            .Select(o => new OrderSummaryDto
            {
                Number = o.Number,
                Total = o.TotalAmount
            })
            .ToListAsync();

        Assert.NotNull(result);
    }

Note that through this test, we can be sure that our DTOs will function correctly.

Not All Tests Need a Database

Until now, we’ve used in-memory SQLite to validate constraints (UNIQUE), global filters (Soft Delete), real pagination, GroupBy, Sum, transactions and rollback.

Tests like these depend on database behavior, but it’s common to encounter scenarios where the database isn’t present, and only business rules are involved. In this case, to facilitate our work and validate our tests, we can use tools like JustMock and simulate a production-facing environment.

Next, we’ll look at some examples of business rule tests where we can use JustMock to easily create mocks for our tests.

Verifying the Repository Will Be Called

[Fact]
public async Task CreateAsync_Should_Call_Repository_AddAsync()
{
    // Arrange
    var repository = Mock.Create<IOrderRepository>();

    var order = new Order
    {
        Id = 1,
        Number = "ORD-001"
    };

    Mock.Arrange(() => repository.AddAsync(order))
        .Returns(Task.CompletedTask)
        .MustBeCalled();

    var service = new OrderService(repository);

    // Act
    await service.CreateAsync(order);

    // Assert
    Mock.Assert(repository);
}

Verifying the GetHighValueOrders Method Returns Only Orders Above the Minimum Value

[Fact]
public void GetHighValueOrders_Should_Return_Only_Orders_Above_MinValue()
{
    // Arrange
    var repository = Mock.Create<IOrderRepository>();

    var orders = FakeOrders()
        .Where(o => o.TotalAmount >= 150 && !o.IsDeleted)
        .ToList();

    Mock.Arrange(() => repository.GetHighValueOrders(150))
        .Returns(orders);

    var service = new OrderService(repository);

    // Act
    var result = service.GetHighValueOrders(150);

    // Assert
    Assert.AreEqual(1, result.Count);
    Assert.IsTrue(result.First().TotalAmount >= 150);
}

Verifying the Service Forwards Exactly the Filter Received

       [Fact]
        public void GetHighValueOrders_Should_Call_Repository_With_Same_MinValue()
        {
            // Arrange
            var repository = Mock.Create<IOrderRepository>();

            Mock.Arrange(() => repository.GetHighValueOrders(500))
                .Returns(new List<Order>())
                .MustBeCalled();

            var service = new OrderService(repository);

            // Act
            service.GetHighValueOrders(500);

            // Assert
            Mock.Assert(repository);
        }

If you run all the tests, you can verify that they all passed:

Conclusion

Testing web applications is common in software development, but these tests don’t always guarantee that errors won’t occur in the production environment. Using in-memory databases, such as in-memory SQLite, allows you to reproduce scenarios closer to reality.

In this post, we saw how this approach helps identify common errors, such as persistence, pagination and projection issues. Furthermore, we explored how JustMock can help save time when validating business rules. I hope the content covered here helps you further improve your applications, making them more reliable through even more realistic testing.

Try JustMock free for 30 days, or try out the whole Telerik DevCraft suite for access to the ASP.NET Core component library and lots more (also a free 30-day trial).

Right now, using Progress Telerik and Kendo UI tools you can create your own custom AI agent. (I’ve covered those tools in earlier posts, beginning with configuring a Large Language Model (LLM) in Azure or Ollama, loading content with Telerik Document Processing Library, linking your content to your LLM and summarizing/querying your content. But that backend isn’t much use without a frontend your users can interact with.

Your users have expectations around what the UI for an AI agent look like and how that UI should behave—expectations that are set by tools like OpenAI’s ChatGPT and Microsoft’s Copilot clients. Specifically, your users are looking for an interactive flow that enables them to evolve (through a set of prompts) from some initial response to a response that meets their needs. The Progress AIPrompt provides that UI as a single component.

This post is about how to create that UI with the JavaScript Kendo UI for jQuery version.

In an earlier post (Creating a Custom AI Agent with Telerik Tools 4: Crafting an Interactive Blazor UI), I walked through implementing a UI with the Blazor version of the AIPrompt component. And, in addition to the JavaScript for Kendo UI and Blazor versions of the AIPrompt, there are also versions for ASP.NET Ajax, WinForms and MAUI.

Background: The Custom Agent Backend as a Web Service

If you just want to know how to use AIPrompt (and aren’t interested in the AI-enabled backend I’ll be using), you can skip this whole section.

To implement a JavaScript frontend, I had to wrap my custom AI agent in a web service that could be called from my JavaScript code. My processor expects two parameters: the user’s prompt, of course (which I pass as a parameter to the single method that my AI agent class exposes), but also a processing option that lets the user choose between two modes: asking questions or summarizing selected content (that’s controlled through a property on the class that implements my AI agent). Fundamentally, that processing mode chooses between two Telerik AI connectors: CompleteContextQuestionProcessor or SummarizationProcessor.

I decided that, since my prompt could be a relatively wordy string, I’d pass those two parameters as a JSON document in the body of a request to my web service. So, as part of creating my web service I defined this Data Transfer Object (DTO) class to hold those two pieces of information:

public class CustomAgentRequest
{
   public string Prompt { get; set; } = string.Empty;
   public string Mode { get; set; } = string.Empty;
}

I then created a web service wrapper as an ASP.NET Core WebAPI project that instantiates my AI agent’s class and accepts my DTO class as part of an HttpPut method. (Since I was passing data in the body of the request, I had to use either a PUT or a POST request. I flipped a coin and settled on PUT.) In that HttpPut method, my service sets the processor’s mode property and calls the single method on my AI agent class, passing the prompt and returning the text generated by my selected mode.

My web service wrapper looked something like this:

public class CustomAgentAPI : ControllerBase
{
    CustomAgent? proc;

    public CustomAgentAPI()
    {
        proc = new();
    }
    
    [HttpPut]
    public async Task<IActionResult> Put(CustomAgentRequest req)
    {
       proc.Mode = req.Mode; 
       return Ok(await proc.ProcessRequest(req.Prompt));
    }
}

I then added this JavaScript function to my frontend’s webpage that accepts a prompt and a mode option, and then uses JavaScript’s Fetch API functionality to call my web service:

const putAgentPrompt = async (requestPrompt, requestProcess) =>
{
   const resp = await fetch(
               "<URL for my Web service>",
               {
                method: "PUT",
                headers: 
                {
                   "Content-Type": "application/json"
                },
                body: JSON.stringify(
                {
                   Prompt: requestPrompt,
                   Mode: requestProcess
                }
   ) });
   return await resp.text();
}

Since JavaScript’s Fetch API is asynchronous, I had to use the await keyword when calling the fetch function and mark my putAgentPrompt function as async.

My JavaScript function extracts the text property of the response object returned from my web service and then returns that to the JavaScript application that called my function.

Processing Requests

Assuming you’ve created a project with the necessary Progress Kendo UI support, the markup for using the AIPrompt component is very simple—a div element with its id attribute set to some name of your choice:

<div id="customAgent" />

To load that div element with the Progress AIPrompt component, you use jQuery to find that element and then call the Kendo UI for jQuery kendoAIPrompt extension from the found element. The resulting UI looks like this, with a textbox for the user to enter their prompt and a button to trigger sending the prompt to my backend:

To enable the UI to process your user’s prompts, you must pass the kendoAIPrompt extension a single parameter, an object literal. To process the user prompts when the user clicks the Generate button, you must set that object literal’s promptRequest property to a function that, in turn, accepts a single parameter.

That means that, initially, the code to process a user’s prompt looks something like this:

$("#customAgent").kendoAIPrompt(        
      {
   promptRequest: async function(e) 
   {

         }
     }
);    

If you’re tempted to write the function set in the promptRequest property as an arrow function, don’t give into the temptation. Your function in the promptRequest property must accept the this reference set in the kendoAIPrompt function, which is only possible if you use a traditional JavaScript function.

The parameter passed to your promptRequest has two properties that you’re interested in:

• prompt: The text the user entered in the AIPrompt’s prompt view
• isRetry: Set to false unless the user clicks the Retry button displayed when AIPrompt shows the result of your processing in AIPrompt’s output view

Within your promptRequest function, you need to call your custom AI agent (in my case, the web service that wraps my AI agent class). I used the putAgentPrompt function from earlier in this post which returns a single text result.

After that, you need to provide the information that the AIPrompt’s output view requires and then switch to that output view. Building the output view consists of loading an object literal with four properties (all required):

• id: A unique identifier
• output: The response from your backend
• prompt: The user’s prompt
• isRetry: The isRetry setting

Once you’ve built that object, you just pass it to the kendoAIPrompt’s addPromptOutput function to have your response added to kendoAIPrompt’s output view.

Finally, to actually display the AIPrompt’s output view, you call the kendoAIPrompt’s activeView function, passing the name of the view you want (“output”, in this case).

Putting that all together, a typical version of the promptRequest function would look like this:

$("#customAgent").kendoAIPrompt( 
    {
        promptRequest: async function(e) 
         { 
             this.addPromptOutput(
                         {
                 id: kendo.guid(),
                output: await putAgentPrompt(e.prompt, "summarize"),
                prompt: e.prompt,
                 isRetry: false
                        }
             );
             this.activeView("output");
         }
   }
);

A typical response might look like this, showing the user’s response and the output from my custom AI agent:

However, as you can see, the result isn’t necessarily very pretty because, as responses get more interesting, my custom agent produces output that uses Markdown for formatting. However, AIPrompt’s default output page just displays all that text “as is.”

Taking Control of the Output

You can, however, replace AIPrompt’s default output view with your own custom view and, in that custom, convert the output to HTML.

You do that by setting the outputTemplate property of the parameter passed to the kendoAIPrompt function to yet another function. That outputTemplate function will be passed a parameter that has a content property, which holds the response you put in the output property back in your promptRequest function.

To support a better display, I added the markdown-it JavaScript library to my page with this script tag and CDN URL:

<script src="https://cdnjs.cloudflare.com/ajax/libs/markdown-it/13.0.1/markdown-it.min.js" 
              integrity="sha512-SYfDUYPg5xspsG6OOpXU366G8SZsdHOhqk/icdrYJ2E/WKZxPxze7d2HD3AyXpT7U22PZ5y74xRpqZ6A2bJ+kQ==" 
              crossorigin="anonymous" 
              referrerpolicy="no-referrer"></script>

In my custom output template, I could then use the library’s markdownit function that returns an object with a render function that converts Markdown to HTML. All I had to do was pass the content property of the parameter passed to my outputTemplate to that render function.

This means that extending the kendoAIPrompt function with a custom function that converts my output to HTML looks like this:

$("#customAgent").kendoAIPrompt(        {
            promptRequest: async function(e) 
            { 
                …previous code…
            },

            outputTemplate: output   => {
                    return markdownit().render(output.content);
                }
         }
);

The enhanced output looks like this:

Allowing the User to Customize Their Prompts

Your agent probably supports some customization options that your users will want to take advantage of (for example, my agent supports two modes: summarizing and querying). You have two options for letting your users customize how your backend responds to your users’ prompts:

• Set options on your backend. My custom agent, for example, operates in two modes, depending on which of the Telerik AI connectors my code invokes.
• Tweak the prompts being sent to your backend in order to trigger specific behavior

In AIPrompt, I can support the user selecting my backend’s mode by having AIPrompt display a commands menu which I’ll use to let the user choose which mode (summarize or query) they want. To trigger that commands menu, I need to add a commands view to the kendoAIPrompt’s views collection and load that view with an array of the menu items to be displayed in the component’s command menu.

However, if you add a custom view to AIPrompt’s views then you have to add implementations for AIPrompt’s existing, predefined prompt view and output view. You add those default views to the views property of the parameter object passed to kendoAIPrompt, like this:

$("#customAgent").kendoAIPrompt(        {
        promptRequest: async function(e) 
        { 
   …existing code…
        },
        views: [ 
            {
               type: 'prompt',
            },
            {
               type: 'output',
            }
        ]
} 

To add a command menu, you tack another view definition on to the end of your new default views, setting its type property to “commands”. In addition, you set this view’s promptCommands property to an array of objects with these properties:

• id: A unique value within the array
• text: The text that will be displayed to the user in AIPrompt’s commands menu
• prompt: Associated text (probably text you will send to your agent backend—optional)
• icon: An SVG graphic (you can draw from the Progress store of icons—also, optional)

Here, I’ve set up four options for the user to select from:

views: [ 
    {
       type: 'prompt',
    },
    {
       type: 'output',
    },
    {
       type: 'commands', 
       promptCommands: [
           { id: "Summarize", text: "Summarize", prompt: "in 100 words", 
        icon: "info-circle" },
           { id: "SummarizeTerse", text: "Summarize: Terse", prompt: "in 50 words, ", 
             icon: "min-width" },
           { id: "SummarizeVerbose", text: "Summarize: Verbose", prompt: "in 200 words", 
        icon: "max-width" },
           { id: "Ask", text: "Ask a question", 
             icon: "question-circle" },
        ]
    }
],

The result is that the AIPrompt gets a new overflow menu icon in its command bar, just to the right of the existing “Ask AI” and “Output” buttons. When your user clicks on the overflow menu icon, they get your list of commands:

To respond to the user clicking on one of the command menu options, you need to load a function into the commandExecute property in the object passed to the kendoAIPrompt function. That commandExecute function will be passed a parameter that has an item property holding the object from the promptCommands array that the user selected.

You can decide what to do in the commandExecute function. You could, for example, just save the user’s choice and use it later when the user clicks AIPrompt’s Generate button.

I’ll go a little further: In my commandExecute method, I’ll submit the command to my custom agent and display the results, leveraging the user’s last prompt.

To support that, in my promptRequest function, I save the user’s last prompt in a variable called, cleverly, lastPrompt. I also create a variable called mode to hold which mode (“Ask” or “Summarize”) the user wants to operate in.

My revised promptRequest function that saves the user’s prompt and uses my new mode variable looks like this:

let lastPrompt = "";
let mode = "Ask";
    
$("#customAgent").kendoAIPrompt(
    {
        promptRequest: async function(e) 
        {         
            this.addPromptOutput({
                id: kendo.guid(),
                output: await putAgentPrompt(e.prompt, mode),
                prompt: e.prompt,
                isRetry: e.isRetry
        });  
        lastPrompt = e.prompt;
        …  

Then, in my commandExecute function, I check which command the user picked from my commands menu. If the user selected the menu option that switches to “Ask” mode, I set my mode variable to “Ask.” If the user selected one of the summarization menu choices, I set the mode to “Summarize” and then modify the user’s last prompt to include the prompt property from the selected menu choice.

Either way, I re-submit the user’s last prompt, with the new settings, and display the result in AIPrompt’s output view:

$("#customAgent").kendoAIPrompt(
    {
        promptRequest: async function(e) 
        { 
           …previous code…
        },
        promptCommands: {
…command prompt menu choices…
        },
        commandExecute: async function(c) 
       {
            let newPrompt = "";

            if (c.item.id.startsWith("Summarize"))
            {
                mode = "Summarize";
                newPrompt = lastPrompt + c.item.prompt;
            }
            else
            {
                mode = c.item.id;
                newPrompt = lastPrompt;
            }                

            this.addPromptOutput({
                id: kendo.guid(),
                output: await putAgentPrompt(newPrompt, mode),
                prompt: lastPrompt
             });
            this.activeView("output");
        },    

The result looks like this, with the result of executing the menu choice added to the output from the user’s previous requests:

Providing Sample Prompts

One last thing: It’s not unusual for an AI agent’s UI to include sample prompts to help users see what they can do with your application. Progress AIPrompt will let you do that, too, just by adding the promptSuggestions property to the object passed to kendoAIPrompt and setting it to an array of strings. This example loads three suggested prompts to AIPrompt:

$("#customAgent").kendoAIPrompt(
    {
        promptRequest: async function(e) 
        { 
           …previous code…
        },
        promptSuggestions: 
       [
         "Summarize, targeting project leads",             
        "What are the key features",
         "What are the critical steps"
     ],
     {

The result looks like this:

Now, when the user clicks on one of your suggested prompts, that prompt will be automatically copied into the prompt textbox where the user can modify the suggestion before clicking the Generate button. This can also simplify testing—instead of typing in a test prompt, you can just pick one of your suggestions.

Combining Telerik Document Processing Library and the library’s AI Connectors lets you create your own custom AI Agent. And the AIPrompt, in any of its implementations, lets you create a front end that enables your users take advantage of your backend (and meets your users’ expectations). You’re ready to give your users a whole new level of support.

Remember, you can get access to all of the Kendo UI and Telerik components in this series with a free 30-day trial of the Telerik DevCraft bundle.

Try Now

If you’re creating an AI-enabled application, you can, of course, create any frontend for that application that makes sense to your users. But that “makes sense” must take into account your user’s expectations around the kind of user interface that an AI-enabled application should provide—expectations that are set by tools like OpenAI’s ChatGPT client.

Typically, that means supporting an interactive flow that allows the user to evolve through a set of prompts to move from an initial response from your AI-enabled application to a response that better meets the user’s needs. The Progress Telerik AIPrompt component creates that UI in a single component.

In previous posts, I walked through configuring an LLM in Azure or Ollama, creating content with Telerik Document Processing Library, tying that content to my LLM and leveraging the Telerik DPL AI connectors.

For this post, I’m going to create UI with Telerik AI Prompt for Blazor to let users interact with my custom agent.

My next post will use the JavaScript for Kendo UI version. And, while I won’t be covering them, there are also versions of the AI Prompt component for ASP.NET AJAX, WinForms and .NET MAUI).

Creating the Initial Display

To get started, you’ll need to create a Telerik-enabled application (e.g., for Blazor), adding the Telerik.UI.for.Blazor and Telerik.AI.SmartComponents.Extensions NuGet packages to your application (in addition to the AI and document processing packages I described in my previous posts).

With those in place, you can then add your AIPrompt to your user interface, which can be as simple as this:

<TelerikAIPrompt OnPromptRequest="@HandlePromptRequest">
</TelerikAIPrompt>

Your next step is to write the method in the OnPromptRequest that will be called whenever the user clicks the AIPrompt Generate button (I’ll call this the “prompt method”).

Your prompt method will be passed an AIPromptPromptRequestEventArgs parameter whose Prompt property will contain whatever prompt the user has typed into the AIPrompt textbox.

All you have to do is call your custom agent (I’ve assumed that’s a class called CustomAgent), pass the user’s prompt to whatever method it exposes (I’ve assumed a method called ProcessRequest), and then update the prompt method parameter’s Output property with the result of that processing.

That code could be as simple as this:

private async Task HandlePromptRequest(AIPromptPromptRequestEventArgs args)
{
   private CustomAgent proc = new ();
   args.Output = await proc.ProcessRequest(args.Prompt);
}

And with that in place, your UI looks like this:

My CustomAgent object’s ProcessRequest method does three things:

1. Accesses a Large Language Model (LLM) and creates a chat client to work with it
2. Loads some content using tools from Progress Telerik Document Processing Libraries (DPL) to create the agent’s content
3. Passes the chat client and content to the Telerik SummarizationProcessor AI connector and returns the result

That code looks like this (I’ve covered it in more detail in my earlier posts):

public async Task<string> ProcessRequest(string prompt)
{
      aiclt = new(new Uri("<LLM deployment name>"),
                             new AzureKeyCredential("<Access Key>");
      chatClt = aiclt.GetChatClient("<LLM deployment name>").AsIChatClient();

     RadFlowDocument rdoc;
     RtfFormatProvider rprov = new();
     using (Stream str = System.IO.File.OpenRead("<path to document>"))
     {
        rdoc = rprov.Import(str, TimeSpan.FromSeconds(10));
     }
     SummarizationProcessorSettings spOpts = new (3500, prompt);
    using (SummarizationProcessor sp = new (chatClt, spOpts))
    {
       return await sp.Summarize(std);
    }

As the user modifies their prompt and generates new responses, AIPrompt automatically provides a history of those responses in its output view. The user can switch between entering a new prompt and reviewing previous responses by clicking on the Ask AI and Output icons at the top of AIPrompt:

Enhancing the Response

The default UI for your AI processor’s response is probably fine if your LLM is only returning plain text. If, however, your LLM is returning anything that requires formatting (e.g., a bulleted text or, as in my example, code), then you’ll probably want to enhance your display to take advantage of any formatting in your processor’s response.

That requires three steps: Add a custom view to the AIPrompt AIPromptViews, add some Razor markup to that view and convert the output of your LLM to HTML.

AIPrompt has two main views: AIPromptPromptView (where the user types in their prompts) and AIOutputPromptView where AIPrompt displays the history of the user’s interactions. If you want to replace either one of those views, you have to replace both. To modify a view, you just put your own Razor markup inside a ViewTemplateinside the view you want to modify.

For example, to maintain the existing prompt view while customizing the output view, you’d add this markup inside the TelerikAIPrompt component:

<TelerikAIPrompt OnPromptRequest="@HandlePromptRequest">
   <AIPromptViews>

      <AIPromptPromptView ButtonText="Ask AI" 
                                                        ButtonIcon="@SvgIcon.Sparkles" />

      <AIPromptOutputView ButtonText=”Output”
                                                      ButtonIcon="@SvgIcon.Comment">
         <ViewTemplate>
    …new Razor markup
</ViewTemplate>
      </AIPromptOutputView>

   </AIPromptViews> 
</TelerikAIPrompt>

If all you want to do is display text in your output view, all you need to do is declare a string field in your code to hold your text and display that field in your template. To get an HTML-formatted display of your text, you’ll need to either, in Blazor, cast the field to MarkupString or pass, in ASP.NET, pass the field to the @Html.Raw method.

My case study is in Blazor so my new output view looks like this:

<AIPromptOutputView  ButtonText=”Output”
                                                   ButtonIcon="@SvgIcon.Comment">

   <ViewTemplate>
      @( (MarkupString) output )
   </ViewTemplate>

</AIPromptOutputView>

In Blazor, to get something that Razor’s MarkupString would be happy with, I added the Markdlg NuGet package to my project and used its Markdown class’s ToHtml method to convert my output to HTML. That means that my updated method for handling the user’s prompts looks like this:

string output = string.Empty;

private async Task HandlePromptRequest(AIPromptPromptRequestEventArgs args)
{
   output = string.Empty;
   output = Markdown.ToHtml( await proc.ProcessDocument(prompt) );
}

And the result is, in fact, easier for my users to read:

Letting the User Customize Processing

You can also give your user more control over your AI processing either by:

• Setting options on your processor
• Modifying your users’ prompts before turning them over for processing

AIPrompt commands collection lets you use both options.

Defining Commands

For example, in my AI processor, I can let the user:

• Choose between two of the Telerik AI connectors: CompleteContextQuestionProcessor to ask questions about my agent’s content, or SummarizationProcessor to summarize my agent’s content
• When summarizing, specify how much content is returned: terse (under 20 words), normal (under 100 words) and verbose (no limit)

The first step in letting the user customize your processing is to create a List of AIPromptCommandDescriptor objects in a property in your application. For any AIPromptCommandDescriptor, you can set up to five properties (they’re all optional):

• Id: Uniquely identifies a command
• Title: Displayed in AIPrompt UI
• Prompt: Useful when modifying the user’s prompt
• Icon: Displayed in AIPrompt UI
• Children: Subcommands

In the following code, I’ve created a property called Commands and loaded it with two command objects to allow the user to select between asking questions and summarizing content (I added the Telerik SvgIcons NuGet package to my application so that I could use its icons when defining my commands):

private List<AIPromptCommandDescriptor> Commands { get; set; } = 
    new List<AIPromptCommandDescriptor>
{
   new AIPromptCommandDescriptor() { 
                                         Id = "Ask", 
                                         Title = "Ask a question", 
                                          Icon = SvgIcon.ZoomIn },
   new AIPromptCommandDescriptor() { 
                                          Id = "Summarize", 
                                          Title = "Summarize", 
                                          Icon = SvgIcon.FontShrink}
};

To let the user select a command, you just need to set two properties on the TelerikAIPrompt:

• Commands to the name of the property you created that holds your array of commands
• OnCommandExecute to the name of a method that will do any processing when a user selects a command (I’ll call it the “command method”)

The result will look something like this:

<TelerikAIPrompt OnPromptRequest="@HandlePromptRequest"
                                     Commands="@Commands"
                                     OnCommandExecute="@HandleCommandExecute">

The default UI for AIPrompt provides an overflow menu icon that the user can click to pick one of your commands, so you may not need to do anything more to let users select from your commands.

However, if you’ve customized the AIPrompt views then, to let the user select from your commands, you’ll also need to add an AIPromptCommandViewto the AIPromptViews list, like this one:

<AIPromptViews>
<AIPromptCommandView ButtonIcon="@SvgIcon.MoreVertical" />

When the user does click on the AIPrompt overflow icon, they’ll get a list of your commands:

Now it’s just a matter of doing the right thing for each command.

Setting Processor Options

When the user clicks on one of your commands, your command method will be called and be passed an AIPromptCommandExecuteEventArgs parameter. That parameter has a Command property that holds whichever command the user selected.

For my application, I can let the user choose between querying the document and summarizing the document just by setting my processor’s Process property.

Cleverly, the two options that my Process property expects match the values I used in the Id properties of my two commands (it’s like I planned it). As a result, my command method just looks like this:

private async void HandleCommandExecute(AIPromptCommandExecuteEventArgs args)
{
   proc.Process = args.Command.Id;
}

Adding Subcommands

But I might also want to give the user who selects the “summarize” option the ability to select how big a summary they will get. I can incorporate that choice into my commands by setting the command objects’ Children property to a new list of AIPromptCommandDescriptor objects.

To implement that, I add three subcommands to my summarize command: Terse (less than 20 words), Normal (less than 100 words) and Verbose (no word count).

My code looks like this:

private List<AIPromptCommandDescriptor> PromptCommands { get; set; } = 
                                                  new List<AIPromptCommandDescriptor>
{
new AIPromptCommandDescriptor() { 
                                 Id = "Ask", 
                                 Title = "Ask questions", 
                                 Icon = SvgIcon.ZoomIn },
new AIPromptCommandDescriptor() { 
                                 Id = "Summarize", 
                                 Title = "Summarize", 
                                 Icon = SvgIcon.FontShrink,
                  Children = new List<AIPromptCommandDescriptor>
   {
       new AIPromptCommandDescriptor() { 
                                                          Id = "SummarizeTerse", 
                                                          Title = "Terse", 
                                                          Prompt=" in less than 20 words"},
        new AIPromptCommandDescriptor() { 
                                                          Id = "SummarizeNormal", 
                                                          Title = "Normal", 
                                                          Prompt=" in less than 100 words"},
new AIPromptCommandDescriptor() { 
                                                           Id = "SummarizeVerbose", 
                                                           Title = "Verbose", 
                                                           Prompt="" }
}
}
};

I’ll handle these subcommands by modifying the user’s prompts.

Modifying Prompt

Not surprisingly, handling these subcommands means my command method gets more complicated. I still want to set the Process option on my processor object but I also want to:

• When the user selects one of the “summarize” subcommands, save the Prompt property on the command that specifies the word count for a summary. After saving that choice, I can add it to any subsequent prompts the user submits (I created a field summarizeLimit to hold the command’s Prompt property)
• Clear the summarizeLimit when the user selects the Ask option

That new version of the method looks like this:

private string summarizeList = string.Empty;

private async void HandleCommandExecute(AIPromptCommandExecuteEventArgs args)
{
   if (args.Command.Id.StartsWith( "Summarize"))
   {
      proc.Process = "Summarize";
      summarizeLimit = args.Command.Prompt;    
   }
   else
   {
      proc.Process = args.Command.Id;
      summarizeLimit = string.Empty;   
   }
}

I also need to update my prompt command to see if my summarizeList field has anything in it. If the field does, I’ll add the field’s text to whatever the user has entered as their prompt:

private string prevPrompt = string.Empty;
private async Task HandlePromptRequest(AIPromptPromptRequestEventArgs args)
{
   string innertPrompt = string.Empty;
   if (!string.IsNullOrEmpty(summarizeLimit))
   {
      prevPrompt = args.Prompt;
      innerPrompt += summarizeLimit + ", " + args.Prompt
   }
   else
   {
      innerPrompt = args.Prompt;
   }
   args.Output = Markdown.ToHtml(await proc.ProcessDocument(innerPrompt));
}

As you can see in this code, I’m also hanging onto the user’s initial prompt whenever they’re summarizing content. I’m doing this so that, in the next section, I can demonstrate how to add your own custom output views to the AIPrompt output history.

Displaying Custom Output

AIPrompt also lets me create custom output from anywhere in my code and add that output to the AIPrompt default output view.

I can, in my command method, call my AI processor. However, by default, output created in my command method won’t update the AIPrompt default output view. What I can do in my command view, however, is create some custom output and add that to the AIPrompt default output view.

That can be useful because, if a user selects one of my summarize subcommands, my user might reasonably expect to see their previous prompt re-executed with the new summarize subcommand applied to it.

To do that, I first need to declare a field to reference my AIPrompt:

private TelerikAIPrompt? aiprompt = null;

And then tie that field to my AIPrompt:

<TelerikAIPrompt @ref="aiprompt"
                                     OnPromptRequest="@HandlePromptRequest"
                                     …

Now, in my command method, I can call my processor, pass it my user’s previous prompt (which I saved in my prompt method), apply whatever command the user selected and catch the new result:

proc.Process = "Summarize";
summarizeLimit = args.Command.Prompt;
string result = await proc.ProcessDocument(summarizeLimit + ", " + prevPrompt);

With that new result in hand, I can use my reference to the TelerikAIPrompt component to call the AIPrompt AddOutput method, passing the parameters to generate a new AIPrompt output view.

The AddOutput method accepts up to six parameters, but the primary ones are:

• output: The result of your processing
• title: The large text displayed above your result
• subtitle: Some smaller text displayed below the title
• prompt: The prompt used to generate the result

After adding my custom output, I then also call the AIPrompt Refresh method to have AIPrompt update its output view with my new result.

Altogether, the code looks like this:

aiprompt.AddOutput(
output: result,
title: "Summarize: " + args.Command.Prompt,
subtitle: string.Empty,
prompt: prevPrompt,
commandId: null,
openOutputView: true);
aiprompt.Refresh();

Providing Suggested Prompts

One last thing: It’s possible that your users may not realize the variety of prompts they can provide to your application. Alternatively, you might want to guide users away from entering some prompts by providing your users with some “approved prompts.” To support either of those goals, AIPrompt lets you provide a list of suggested prompts.

First, you need to create an array of strings with some suggested prompts:

private List<string> Suggestions { get; set; } = 
    new List<string>()
   {
      "Summarize in under 100 words, targeting developers",
      "Summarize in under 100 words, targeting project leads",
      "What are the key features",
      "What are the critical steps"
};

To integrate that list of suggested prompts, you just need to set the TelerikAIPrompt component’s PromptSuggestions property to the name of your array of strings:

<TelerikAIPrompt @ref="aiprompt"
 OnPromptRequest="@HandlePromptRequest"
 PromptSuggestions="@Suggestions"
…

The result looks like this:

The user can then click on any of these suggestions to add them to the AIPrompt textbox where the user can then edit or modify the suggestion before submitting it as their next prompt. This can also simplify testing—instead of typing in a test prompt, you can just pick one of your suggestions.

You now have all the tools you need to create an application that lets your users leverage your custom AI agent to provide a quick source of information from any content you might want to provide … in Blazor, at least.

In my next post, I’ll move my processor into a web service and access it from the JavaScript version of the AIPrompt component.

Remember, you can get access to all of the Kendo UI and Telerik components in this series with a free 30-day trial of the Telerik DevCraft bundle.

Try Now

In this series of posts, I’ve been creating a custom AI Agent using Telerik tools. That’s included accessing an Azure Large Language Model (LLM) and loading my own content and creating a client to access the LLM.

The last step is to pass my content to my LLM using one of the Progress Telerik AI processors (part of the Document Processor Libraries), which is what this post is about.

The Telerik AI processors support two scenarios for your users: summarizing your agent’s content and querying your agent’s content.

To summarize your content, you’ll use the Telerik SummarizationProcess processor. For querying content, on the other hand, you have a choice between two processors:

• CompleteContextQuestionProcessor which loads all of your content before querying it
• PartialContentQuestionProcessor which loads just part of your content as a series of fragments—a good choice when your content is large and you don’t want to allocate (i.e., “pay for”) enough tokens to load all of it at once

A token, by the way, represents a word, part of a word or a punctuation mark. The sample document I’ll be using to demonstrate the summarization process contains roughly 1,500 words (a relatively small document). So, when summarizing that document, I’ll set my token count to 3,500 (I figured doubling the word count to include punctuation marks and adding a 33% buffer would work).

On the other hand, to demonstrate querying, I’ll be loading three documents as my agent’s content, totaling about 8,000 words. That’s going to require either a larger token count or fragmenting my document.

Summarizing Documents

Before you can do any summarizing or querying, you’ll need to add the Telerik.Documents.AIConnector NuGet package to your project. With that package added, to summarize your agent’s content you’ll use the Telerik SummarizationProcessor processor. Your first step is to create a settings object the model that defines the context window for the model by specifying:

• The maximum of number of tokens you’re willing to have used in processing the document
• Any text describing how you want to customize the summarization process (e.g., “under 100 words,” “target project managers”)

Once you’ve created the settings object, you create a SummarizationProcessor object, passing a chat client (discussed in my last post) and your settings object. Once you’ve created the processor, you pass its Summarize method your content and catch the result as a string.

In the following code, I’ve assumed that you’ve used Telerik Document Processing Libraries to load a SimpleTextDocument into a variable called std (again, see my previous posts). The code then:

1. Creates a chat client tied to an LLM deployed in Azure
2. Creates a settings object that tells the summarization processor to
   • Accept up to 3,500 tokens
   • Asks the processor to summarize the document in less than 100 words
3. Creates the SummarizationProcessor from the chat client and the settings object
4. Passes my content document to the SummarizationProcessor’s Summarize method
5. Catches the result as a string

And it’s only four lines of code:

AzureOpenAIClient aiclt = new(
                new Uri("<deployment URL>"),
                new AzureKeyCredential("<access key>"));
IChatClient chatClt = aiclt.GetChatClient("<Deployment Name>").AsIChatClient();

SummarizationProcessorSettings spOpts = new (3500, "Summarize in 100 words");
using (SummarizationProcessor sp = new (chatClt, spOpts))
{
   string summary = await sp.Summarize(std);
}

Summarization Results

As an example of what you can expect, I fed my custom agent [a post I wrote on how to use the scrollToItemmethod]() in the Kendo Grid. You can compare the output to the post to decide how good a job the LLMs did.

For my first try, I used Azure’s gpt-5.2-chat LLM and asked for a summary in 100 words or less. That gave me these 94 words (I’ve stripped out the HTML formatting):

This article explains how to ensure the right row is visible in a Kendo Grid without forcing users to scroll. It focuses on the `scrollToItem` method, which scrolls directly to a row based on a data item’s unique ID. The method works in Angular, ASP.NET MVC, and jQuery grids, with alternatives for React and Blazor. The article walks through configuring an ASP.NET Core project, setting up the grid and data source, enabling scrolling, and invoking `scrollToItem` via JavaScript. It also covers handling invalid selections and loading rows not on the current page using callbacks.

I tried the same content using the gpt-oss LLM running in Ollama and got these 114 words:

This article explains Kendo Grid’s `scrollToItem` method, which brings a specified row into view without manual scrolling. It works across Angular, ASP .NET MVC, and jQuery grids (React and Blazor can use DOM’s `scrollIntoView`). The method requires the grid’s data model to have a unique `id` field (e.g., `ProductID`) and virtual or endless scrolling enabled. The author demonstrates setting up an ASP .NET Core Razor Page, configuring the grid with a datasource, model, and columns, and creating a textbox/dropdown that triggers `MoveToItem`. The method accepts a callback for invalid IDs or to fetch non‑paged items by calling the callback’s `success` with the row index. The result is a row positioned at the top of the grid.

I also tried passing just “summarize” to both LLMs without specifying a word count. The gpt-5.2-chat LLM on Azure gave me back just under 300 words with a pretty good breakdown of the main points in the article. The same prompt with Ollama and gpt-oss gave me just over 400 words but also threw in some of the sample code.

Finally, I passed “provide a title” as my requested processing to both LLMs. From gpt-5.2-chat, I got back “Using Kendo Grid’s scrollToItem to Instantly Bring Data Into View” and from gpt-oss, I got “Kendo Grid’s scrollToItem: A Practical Guide to Quick Row Navigation.” I have to admit, I think both of those proposed titles are better than the one I used (feel free to disagree). Not surprisingly, given that I was using the Telerik summarization processor, both engines threw in a summary of the post along with their new title.

Complete Document Queries

If you want to let your user ask queries that require looking at your complete document, you can use the Telerik CompleteContextQuestionProcessor processor(which is also the easiest of the two query processors to use).

To query your agent’s content, you just need to:

1. Create a CompleteContextProcessorSettings object, passing a maximum token count
2. Create a new CompleteContextQuestionProcessor object, passing a chat client and the settings object
3. Pass your content and the user’s question to the CompleteContextQuestionProcessor object’s AnswerQuestion method
4. Catch the result as a string

Typical code will look like this (I’ve omitted the code to create the chat client because it’s identical to my previous example). Note the larger token count:

CompleteContextProcessorSettings caOpts = new(9000);
using (CompleteContextQuestionProcessor ca = new(chatClient, caOpts))
{
       string answer = await ca.AnswerQuestion(sampleDocument, prompt);
}

Complete Query Results

For this example, I loaded three of my posts on how to create asynchronous applications using Azure storage queues (starting with this Coding Azure 18 post. With that content loaded, I tried asking “How do I create a storage queue?” using the gpt-5.2-chat LLM and got back this result:

You create a storage queue in two main steps:
1. Create a storage account
     In the Azure Portal, go to Storage Accounts and select Create.
     Give the storage account a URL friendly name (lowercase, no special characters).
     Choose settings appropriate for queues (Primary service set to Other).
     Complete the wizard and create the storage account.

2. Create the queue inside the storage account
         Open the storage account you just created.
          From the left menu, select Data Storage, then Queues.
          Click + Queue.
           Enter a lowercase, UL friendly queue name.
           Click OK to create the queue.

At that point, the storage queue exists and is ready to be secured and used by applications.

Which isn’t, I thought, a bad response (though I question the need for the last sentence). I then tried asking “What’s the minimum code required” and the answer I got back began with this text:

The minimum code required depends on what you are trying to do. The simplest meaningful scenario covered is adding a message to an Azure Storage Queue from a server-side app using a Managed Identity (the recommended production approach).

Assumptions (already configured in Azure):
- The queue already exists
- The App Service has a User Assigned Managed Identity
- That identity has the Storage Queue Data Message Sender role on the queue 

That was followed by the code to write out a message to a storage queue (about another 200 words). What I especially liked about response is that the opening cued me (pun intended) to ask follow-up questions. For example, my next prompts would probably be “How do I create a User-Assigned Managed Identity?” and/or “How do I read a message from the queue?”

Partial Document Queries

However, if you have a very large document (and your LLM is charging you by your token count), you might want to use the Telerik PartialContextQuestionProcessor processor. Using this processor does make an assumption: that you don’t need the whole document to answer any one question. And, for a large document that, presumably covers multiple topics, that may be a reasonable assumption.

Using the PartialContextQuestionProcessor is more complicated than using a CompleteContextQuestionProcessor. First, you’ll need to pick an LLM that supports embeddings (I used Azure’s text-embedding-3-large LLM). Second, you’ll need to provide a custom “embedding” class that will segment your content into fragments to be processed individually.

I’ve provided a version of the default Telerik “embedding” class at the end of this post. When you instantiate this class, you’ll need to pass:

• The security key for your deployment
• The first segment of the URL for your LLM’s deployment (i.e., everything up to the first single forward slash)
• Your deployment’s name
• The version of your LLM

With your “embedding” class available, to use the PartialContextQuestionProcessor you need to:

1. Use the EmbeddingSettingsFactoryobject’s static CreateSettingsForTextDocuments method to create an IEmbeddingSettings object, passing a token count and the name of your deployment
2. Create your “embedding” object
3. Create a PartialContextQuestionProcessor, passing a chat client, your embedding object, your settings object and your content
4. Pass your query to the PartialContextQuestionProcessor object’s Answer method
5. Catch the result in a string

Typical code looks like this (note the lower token count) and is still only four lines of code:

IEmbeddingSettings paOpts =
       EmbeddingSettingsFactory.CreateSettingsForTextDocuments(3500, 
                                                                                                                                          “<deployment name>”);
DefaultAIEmbedder embedder =
    new DefaultAIEmbedder(
        "<key>",
        "<deployment URL>",
        "<deployment name>",
        "<deployment version>"
        );
using (PartialContextQuestionProcessor pa =
           new PartialContextQuestionProcessor(chatClt, embedder, paOpts, std))
{
    string answer = await pa.AnswerQuestion(prompt);
}

Partial Query Results

I then retried the “How do I create a storage queue” question with the same content I used for the CompleteContextQuestionProcessor. Here’s the result I got, which, you’ll notice, omits the material on creating the Storage Account that the CompleteContextQuestionProcessor answer included:

Here is how you create a storage queue in the Azure Portal. First, make sure you already have a Storage Account created that is dedicated to queues.
Then do the following:
1.Go to the Azure Portal.
2. Open your Storage Account.
3. From the menu on the left, select Data Storage, then Queues.
4. On the Queues page, click the + Queue button at the top.
5. Enter a queue name. The name must be lowercase, contain no spaces, and have no special characters. Example: updateproductinventory
6. Click OK.
That’s it. The queue is created immediately.

In answer to my “What is the minimal code” question, I got identical code, but the introduction wasn’t as comprehensive as with the CompleteContextQuestionProcessor (the prerequisites/assumptions section is terser, for example):

From the context, the smallest useful interpretation of “minimal code” is: The minimal code required to add a message to an Azure Storage Queue, assuming the queue already exists and security is already configured.
Below are the minimal working examples for both scenarios described in the context.

Still, I thought, a pretty good answer.

With those three processors (and an LLM and your content) you have all you need to create an AI-enabled backend. The next step is to create a frontend that supports your users interacting with your backend and meets their expectations for an AI-enabled application. That’s my next two posts: Crafting an Interactive Blazor UI and Creating an Interactive UI in JavaScript.

And here’s that default embedder I promised:

    internal class DefaultAIEmbedder : IEmbedder
    {
        internal readonly HttpClient httpClient;
        internal readonly string deploymentName;
        internal readonly string apiVersion;
        internal DefaultAIEmbedder(string apiKey, string url, string deploymentName, string apiVersion,)
        {
            this.deploymentName = deploymentName;
            this.apiVersion = apiVersion;

            this.httpClient = new HttpClient();
            this.httpClient.Timeout = TimeSpan.FromMinutes(10);
            this.httpClient.DefaultRequestHeaders.Add("api-key", apiKey);
            this.httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));            
            this.httpClient.BaseAddress = new Uri(Path.TrimEndingDirectorySeparator(url));
        }

        public async Task<IList<Telerik.Documents.AI.Core.Embedding>> EmbedAsync(IList<IFragment> fragments)
        {
            AzureEmbeddingsRequest requestBody = new AzureEmbeddingsRequest
            {
                Input = fragments.Select(p => p.ToEmbeddingText()).ToArray(),
                Dimensions = 3072
            };

            string json = JsonSerializer.Serialize(requestBody);
            StringContent content = new StringContent(json, Encoding.UTF8, "application/json");

            using HttpResponseMessage response = await this.httpClient.PostAsync(
                "openai/deployments/" + this.deploymentName + "/embeddings?api-version=" + this.apiVersion,
                content,
                CancellationToken.None);

            Telerik.Documents.AI.Core.Embedding[] embeddings = new Telerik.Documents.AI.Core.Embedding[fragments.Count];

            string responseJson = await response.Content.ReadAsStringAsync(CancellationToken.None);
            AzureEmbeddingsResponse? responseObj = JsonSerializer.Deserialize<AzureEmbeddingsResponse>(responseJson);

            List<EmbeddingData> sorted = responseObj!.Data.OrderBy(d => d.Index).ToList();
            List<float[]> result = new List<float[]>(sorted.Count);

            for (int i = 0; i < sorted.Count; i++)
            {
                EmbeddingData item = sorted[i];
                embeddings[i] = new Telerik.Documents.AI.Core.Embedding(fragments[i], item.Embedding);
            }

            return embeddings;
        }

        private sealed class AzureEmbeddingsRequest
        {
            [System.Text.Json.Serialization.JsonPropertyName("input")]
            public string[] Input { get; set; } = Array.Empty<string>();

            [System.Text.Json.Serialization.JsonPropertyName("dimensions")]
            public int? Dimensions { get; set; }
        }

        private sealed class AzureEmbeddingsResponse
        {
            [System.Text.Json.Serialization.JsonPropertyName("data")]
            public EmbeddingData[] Data { get; set; } = Array.Empty<EmbeddingData>();

            [System.Text.Json.Serialization.JsonPropertyName("model")]
            public string? Model { get; set; }

            [System.Text.Json.Serialization.JsonPropertyName("usage")]
            public UsageInfo? Usage { get; set; }
        }

        private sealed class UsageInfo
        {
            [System.Text.Json.Serialization.JsonPropertyName("prompt_tokens")]
            public int PromptTokens { get; set; }

            [System.Text.Json.Serialization.JsonPropertyName("total_tokens")]
            public int TotalTokens { get; set; }
        }

        private sealed class EmbeddingData
        {
            [System.Text.Json.Serialization.JsonPropertyName("embedding")]
            public float[] Embedding { get; set; } = Array.Empty<float>();

            [System.Text.Json.Serialization.JsonPropertyName("index")]
            public int Index { get; set; }
        }
    }
}   

Let me paint you a picture.

You are sitting at your desk. Your app loads in the browser. The page renders. The buttons work. The data shows up. Everything looks fine.

Except it is not fine. Somewhere underneath that perfectly rendered page, a request is taking 3 seconds when it should take 200 milliseconds. Another endpoint is returning a 200 but leaking an auth token in a query parameter. A third one is completely missing its Cache-Control header, so every single page refresh costs your users the full round-trip all over again.

But hey—the page loads. So it is fine, right?

Image Credit: KC Green
Your browser: “Everything rendered successfully!” Your network traffic: literal dumpster fire.

This was the old debugging workflow for years: You open DevTools. You scroll through 47 network requests. You squint at the Timing column. You click into a request, copy the headers, paste them into a notepad, try to figure out if X-Content-Type-Options is set or not. By request number six, you have forgotten what you found in request number two. You do that for 12 more requests.

Then you switch back to your editor, ask your coding assistant for help, and it says something like: “You might want to check if your caching headers are configured properly.”

Might. Want. To check.

It does not know. It cannot know. It is reading your Express routes and giving you its best guess based on what the code probably does. It has never seen the actual traffic.

Now Imagine This Instead

You open your editor. You type:

#fiddler Start capturing HTTP traffic in Fiddler using Chrome

A Chrome window opens with the Fiddler proxy already configured. You click around your app for thirty seconds. Then you type:

#fiddler Identify the slowest API endpoints in the captured traffic

And your coding assistant—which can now actually see the captured sessions—comes back with:

GET /api/products/featured — average 2,847ms across 4 requests, 52KB response body, no Cache-Control header. This is your primary bottleneck.

No guessing. No “you might want to.” Just facts, pulled from real HTTPS sessions.

This is what the Progress Telerik Fiddler Everywhere MCP server does. It gives your coding assistant network vision. MCP—Model Context Protocol—is the open standard that lets your editor’s assistant call external tools during a conversation. The Fiddler MCP server exposes captured traffic data through those tools: session lists, request and response details, headers, bodies, timing, TLS info—the whole picture.

The setup? A JSON config file in your workspace:

{  
  "servers": {  
    "fiddler": {  
      "type": "http",  
      "url": "http://localhost:8868/mcp",  
      "headers": {  
        "Authorization": "ApiKey YOUR_API_KEY_HERE"  
      }  
    }  
  }  
}  

Generate the key in Fiddler Everywhere, drop the config and you are connected. Works with VS Code, Cursor, Claude Code, Windsurf, Copilot CLI—the full lineup.

The Prompts That Make You Feel Like a Wizard

Once Fiddler MCP is connected, the things you can ask your assistant become genuinely fun:

• #fiddler Show me all failed requests (status codes 4xx and 5xx)
• #fiddler Identify sessions with weak or missing security headers
• #fiddler Create a comprehensive report covering security highlights and performance optimizations
• #fiddler Analyze caching efficiency for the captured sessions

Each of these triggers real tool calls. The assistant reads actual captured sessions, not your imagination of what the sessions might look like. That means the security audit it produces is based on the headers your server actually sent, not the headers it assumes you configured.

The Fiddler Prompt Library has dozens more if you want to explore.

Skip the Setup: Fiddler Agent Skills

If even the two-minute config feels like too much (I get it, we are all busy), the official Fiddler agent skills do it for you. Clone the repo, drop the skills into your project, and tell your assistant:

Set up Fiddler MCP

Done. Port discovery, API key retrieval, config file, .gitignore update—all handled. There is also a skill that analyzes captured traffic after you run a feature and gives you a structured pass/fail report. Honestly, it is the kind of thing that makes you wonder why you were ever doing it manually.

Build Your Own Debugging Agents (This Is Where It Gets Good)

Here is where things get spicy. The built-in skills are great, but you can write your own. A skill is just a Markdown file—a SKILL.md—that tells your assistant which Fiddler tools to call, in what order, and how to format the output.

Some agents I think every team should consider building:

• traffic-security-auditor – Scans every session for missing security headers, tokens exposed in URLs, insecure connections. Produces a prioritized report. Basically your own automated pen-test lite that runs from a chat prompt.

• api-performance-watchdog – Flags slow endpoints, checks caching headers, reports payload bloat. Think of it as a performance review for your API—except this one is actually useful. (Sorry, managers.)

• checkout-flow-verifier – Replays a captured e-commerce checkout flow and verifies each step hit the right status codes and redirects. Because nobody wants to find out the payment confirmation page is broken from an angry customer email.

The Creating Custom Skills guide has the full format and a working example.

You Never Have to Leave Your Editor

Here is the part that really lands once you try it: you do not need to switch to Fiddler Everywhere. You do not need to open a separate desktop application. You do not need to context-switch at all.

Everything happens inside the tool you are already using—VS Code with Copilot, Claude Code in the terminal, Cursor, Windsurf, whatever your setup is. Capture traffic, filter sessions, inspect headers, create rules, run a full security audit, all from the same chat window where you write code.

That is the whole point. The MCP server brings Fiddler network inspection capabilities directly into your coding workflow. Filters? Ask for them in a prompt. Rules? Create them with a sentence. Session details? One tool call away. You get the full power of a professional traffic inspector without ever breaking your flow.

When your entire debugging workflow fits inside one chat window and zero browser tabs.

Try It

Seriously—if you are already using a coding assistant while you code, giving it access to your network traffic is one of the highest-leverage things you can do. The guessing stops. The analysis gets real. And you might actually enjoy debugging for once.

Try Fiddler Everywhere

Seriously Though, Tell Us What You Think

We are building this as fast as we can, and your feedback is what steers the ship. Tried a prompt that did not work well? Built a custom skill that saved your team hours? Found a bug? We want all of it.

• Email: fiddler-support@progress.com
• GitHub issues: github.com/telerik/fiddler-everywhere/issues

With your LLM set up with a custom AI agent, let’s connect our content via Telerik Document Processing Libraries AI processor—resulting in a RAG-enhanced app!

In my previous post, I covered how to set up a Large Language Model (LLM) either in the cloud using Azure AI or on your desktop/server using Ollama. This post walks through the code you need to load your own content into a custom AI agent based on that LLM.

That will let you create a Retrieval-Augmented Generation–enhanced application that provides grounded answers on the content that matters to your users. You could use this code to, for example, create a custom AI assistant for any part of your organization.

There are four steps to creating that application:

1. Configure your application
2. Create a chat client to work with your LLM
3. Convert your content into a format that your chat client will accept using Progress Telerik Document Processing Libraries
4. Pass the chat client, your content and a prompt to the appropriate Telerik AI processor

Configuring the Application

I’m going to demonstrate the code for loading your content using a Blazor application (Blazor simplifies creating an interactive application that integrates server and client-side processing). However, the code in this post will be very similar in any C# application and, in a later post, I’ll wrap my agent in a web service and access it from client-side JavaScript code.

Once your project is created, your next step is to add the necessary NuGet packages. The best advice I can give you around picking the right NuGet package is to a) include prerelease versions and b) always take the most recent package available.

The packages you’ll need are:

• For OpenAI LLMs (like the LLMs I picked in my previous post):
  • Azure.AI.OpenAI
  • Microsoft.Extensions.AI.OpenAI
  • OpenAI (probably already installed with the previous packages)
• For Ollama:
  • OllamaSharp
• For Telerik document processing:
  • Telerik.Documents.AIConnector
  • Telerik.Documents.Core
  • Telerik.Documents.Flow (to work with DOCX, HTML, and RTF files)
  • Telerik.Documents.Fixed (to work with PDF files)

Accessing the LLM

Connecting to your LLM depends on whether you’re using Azure or Ollama to host your LLM. (And, if you just created your LLM deployment, it can take up to 15 minutes before your LLM is ready to be used.)

Azure-hosted LLM

If you’re using an Azure LLM then you need to create an AzureOpenAIClient, passing the URL and key from your deployment’s information page in the ai.azure.com portal (see my previous post).

Once you’ve created your AzureOpenAIClient, you can use its GetChatClient method to retrieve a ChatClient. But, rather than access that ChatClient directly, you should use the AsIChatClient method to, effectively, cast the ChatClient to the more general purpose IChatClient interface. All that just requires just these two lines of code:

AzureOpenAIClient aiclt = new(
                new Uri("<deployment URL>"),
                new AzureKeyCredential("<access key>"));
IChatClient chatClt = aiclt.GetChatClient("<Deployment Name>").AsIChatClient();

Ollama-hosted LLM

If you’re working with Ollama, you create a chat client with the IChatClient interface by creating an OllamaApiClient object, passing the URL for your local Ollama server and the LLM that you want to use. That looks like this:

IChatClient chatClt =
    new OllamaApiClient(new Uri("<address for Ollama>"), 
                                                   "<LLM name>");

Do be aware: For a typical development machine, processing documents using Ollama is not going to be as responsive as using an LLM on Azure. For example, the document I used in this case study contains about 1,500 words and took a few seconds to summarize using one of the Azure LLMs. Using Ollama, that process sometimes took over a minute. In some cases, your application may time out waiting for Ollama to respond.

You can deal with that issue in Ollama by creating a customHttpClient object and passing it to your OllamaApiClient when you create it.

Here’s some sample code that creates an HttpClient that is a) tied to the Ollama client’s URL (probably http://localhost:11434) and b) sets a five-minute timeout. The code then uses that custom HttpClient to create an Ollama client:

HttpClient httpClt = new()
{
    BaseAddress = new Uri("<address for Ollama>"),
    Timeout = new TimeSpan(0, 5, 0)
};

IChatClient chatClt =
          new OllamaApiClient(httpClt, "<model name>");

Loading Content

The Telerik Document Processing Libraries (DPL) provide multiple AI processors for analyzing documents.

In this post, I’m going to focus on the summarization processor (I’ll look at other processors in my next post). Since all the processors expect to be passed a DPL SimpleTextDocument, switching between processors is simple.

As an example, here’s the code to convert a DOCX file into a SimpleTextDocument using Telerik WordsProcessing library (the Flow library also handles RTF and HTML files; for PDF files, you would use Telerik PdfProcessing library):

RadFlowDocument dDoc;
DocxFormatProvider dProv = new();
using (Stream str = System.IO.File.OpenRead(@"wwwroot/documents/scrolltoitem.docx"))
            {
                dDoc = dProv.Import(str, TimeSpan.FromSeconds(10));
            }
SimpleTextDocument std = dDoc.ToSimpleTextDocument(TimeSpan.FromSeconds(10));

Now that you have a SimpleTextDocument, your next step is to configure one of the Telerik AI processors to work with it.

In terms of AI processing, this document represents the content (or corpus) to be used by your LLM … but it’s a very small corpus that consists of only a single document. While I’m going to stick with a single document for this case study, you can use the Merge method on both Flow and Fixed documents to load multiple documents into a single document object before creating your SimpleTextDocument from that single document.

This code, for example, loads one DOCX file and then merges a second one into it, before creating a SimpleTextDocument from the result:

RadFlowDocument ddocMaster;
RadFlowDocument ddocTemp;
DocxFormatProvider dprov = new();
using (Stream str = System.IO.File.OpenRead(@"wwwroot/documents/InitialDoc.docx"))
{
    ddocMaster = dprov.Import(str, TimeSpan.FromSeconds(10));
}

using (Stream str = System.IO.File.OpenRead(@"wwwroot/documents/SecondDoc.docx"))
{
    ddocTemp = dprov.Import(str, TimeSpan.FromSeconds(10));
}
ddocMaster.Merge(ddocTemp);

Generating Summaries in Your Agent

The next step is to use one of the Telerik AI Connectors to enable your content for use by the LLM. To support this processing, you’ll need to add the Telerik.Documents.AIConnector NuGet package to your project.

In this example, I’m using the Telerik summarization processor to generate a summary of my custom content (more on the summarization processor and the other two Telerik AI processors in my next post):

SummarizationProcessorSettings spOpts = new (3500, "Summarize in 100 words");
using (SummarizationProcessor sp = new (chatClt, spOpts))
{
   string summary = await sp.Summarize(std);
}

Don’t expect a fast response when testing—it takes some time to absorb a complete document. The Azure-based LLMs I used would pause for three or four seconds to absorb each document, while the Ollama LLM took about 90 seconds on my laptop.

Which raises an important point: The summarization processor passes the whole document to your LLM—that can be both time consuming and expensive. You might want to catch the SummaryResourceCalculated event that the processor raises. The EventArgs parameter passed to that event includes two properties (EstimatedCallsRequired and EstimatedTokensRequired) that you can check to see if the request is larger than you want to handle. If the request is “too big,” you can set the EventArgs parameter’s ShouldContinueExecutionproperty to false to stop processing.

And there you have your own, custom AI agent which you can load with whatever content you want to create. You can do more than just summarize document content, though, as I’ll cover in my next post.

But, looking ahead to providing a frontend for users to access my custom AI agent, I have two UI issues that I should be thinking about to create a genuinely useful agent:

• Users will probably want to be able to enter an initial prompt and then refine it to get a better version of my custom agent’s response.
• Telerik has two other AI processors that support other types of AI processing. I want to give my user the chance to pick one of those other processors.

And that’s ignoring the reality that, thanks to the existing AI-enabled UIs my users are already using (looking at you, ChatGPT), my users have expectations about what an AI-enabled UI should look like. All that suggests that my application will need an interactive UI. So, after my next post, I’m going to use the Telerik AI Prompt component to create a UI that provides my user with that interactivity.

Explore Telerik Document Processing Libraries, plus component libraries, reporting and more with a free trial of the Telerik DevCraft bundle:

Try DevCraft

The problem with general-purpose AI agents is that they are subject to “hallucinations” (these days, we say that those agents produce answers that aren’t “grounded”).

One solution to that problem is to create a custom AI agent with your own content and have your agent use that content to generate grounded answers (this is referred to as Retrieval Augmented Generation or RAG). Effectively, you can create a dedicated, reliable AI assistant for your users for any aspect of your organization.

Progress Telerik Document Processing Libraries (DPL) include a set of AI connectors that support creating those custom RAG-enabled AI agents of your own using any of the existing Large Language Models (LLMs) available to you in Azure or on your own computer/server using Ollama. And, once that agent is created, Telerik UI tools will let you integrate it into any application.

So, this post kicks off a series of posts where I’m going to walk you through all of the steps you need to create a custom AI agent by using Telerik DPL (and related AI tools), integrated with an LLM available on Azure or in Ollama. Once you’ve created an agent, I’ll show you how to add that custom agent into your application’s UI using AI-enabled Telerik UI components in either JavaScript or Blazor (though you could also create your frontend in ASP.NET, Windows Forms or .NET MAUI).

But … having said that, if all you want to do is add an AI prompt to your application, then, thanks to Telerik tools, this post might be the only one you need. At the end of this post, I’ll show you how to create a simple frontend for your application to use your LLM. In fact, if you’ve already got an LLM deployed (which is what this post is about), you might want to skip the rest of this post and go directly to that last section.

Picking Your LLM Provider

If you stick with Microsoft’s offerings, you actually have three options for creating the LLM your application will use. The good news here is that, thanks to Microsoft and Telerik tools, it doesn’t make much difference to your code which of those three options you use.

Your three choices are:

• Microsoft Foundry: This gives you access to a wide variety of LLMs from multiple providers (including the OpenAI LLMs), while giving you integration with Azure security. Microsoft Foundry also gives you extensive monitoring for your LLM, enables data privacy and supports integration with other Azure services. This is Microsoft’s recommended option. I’ll call this the “Foundry option.”

• Azure OpenAI: This is the easiest option to set up but also provides the least access to Azure functionality. The Azure OpenAI option gives you access only to OpenAI’s LLMs and only limited integration with other Azure resources (principally, security). With this choice you do, however, get access to the latest OpenAI LLMs, potentially before they show up in Microsoft Foundry. I’ll call this the “OpenAI-only option.”

• Ollama: Unlike OpenAI or Microsoft Foundry, Ollama runs on your local computer, rather than in the cloud. Since there are no API fees, that makes Ollama an attractive choice for cheaper solutions (provided you have a powerful enough development computer). I’ll call this the “Client-side option.”

Setting Up OpenAI/Microsoft Foundry

While I’m treating the OpenAI-only option as a separate case from the Foundry option, the OpenAI-only option is actually hosted in Microsoft Foundry. As a result, the processes for setting up the OpenAI-only or the Foundry option are very similar:

1. In the Azure portal at portal.azure.com, create an Azure resource.
2. In the Microsoft Foundry portal at ai.azure.com, add an LLM—a “deployment”—to that resource.

Creating the Resource

To start, surf to the Azure Portal and search for Microsoft Foundry. On the Microsoft Foundry page, in the menu on the left, expand the Use with Foundry node and click on either:

• The Foundry node for the Foundry option
• The Azure OpenAI node for the OpenAI-only options

Either choice will open a page on the right. On that new page, click on the +Create menu choice at the left end of the menu running across the top of the page. That will start the wizard that will create your Azure resource.

If you opened this page from the Foundry node, you’ll start the wizard for creating your Foundry resource.

If you opened this page from the OpenAI node, you’ll get a dropdown list with two choices: OpenAI and Microsoft Foundry. This is, effectively, your last chance to switch to the Foundry option instead of OpenAI-only. Pick the OpenAI choice to open the wizard for creating an OpenAI-only resource.

Regardless of which wizard you’ve invoked, on the wizard’s first page you’ll need to provide a resource group, a name for your resource and a region for your LLM to run in. In addition, on the first page:

• For a Foundry resource, you’ll need to provide a default project name
• For an Azure OpenAI resource, you’ll need to select a pricing tier

After that, it’s just a matter of “Next”ing your way through the rest of the wizard’s tabs.

Setting Network Access

Both the Foundry and OpenAI-only wizards include a Network tab to control access to your resource. You have three choices on the Network tab:

• All networks: Gives access to your resource from anywhere
• Selected networks: Limits access to a subnet on a specific Azure virtual network, plus a list of IP addresses (e.g., your development computer)
• Disabled: Allows access only through a private endpoint on an Azure virtual network

You would use the last two options if you were going to run your application on a VM on a virtual network or in an App Service. You don’t need to use the network choices to control access to your resource. You could control access to your LLM just through the resource’s Access Control/IAM roles, for example, or your application’s built-in security. However, for a production application, you should always lean toward more control rather than less and pick whichever of these options that makes sense for limiting network access to your resource.

Setting Foundry Option

The Foundry wizard includes three additional tabs that the OpenAI wizard does not:

• Storage: This tab provides access to multiple additional Azure resources. You can:
      » Tie your resource to an Azure Key Vault where you can store passwords or other credentials that agents in your resource will need
      » Turn on Application Insights to log activities in your resource
      » Tie in an AI Search agent that your resource can access when processing requests
      » Add a Storage account to hold uploaded files
      » Integrate a CosmosDB account to hold conversation history.
• Identity: Assign a Managed Identity to your resource to support agents that access other Azure resources
• Encryption: Use your own encryption keys for any data stored by your resource

For a proof-of-concept project, you can take the defaults on all these tabs.

Both wizards finish with the standard Tags tab and Review-and-create tab. When you get to that last tab, click the Create button to create your resource.

Selecting an LLM

Your application interacts with a deployed instance of some LLM so your next step is to create a deployment that uses one of the LLMs available to your resource.

To do that, navigate to your resource and, on the Overview page, click on the Go to Foundry portal link at the top of the page. This will open a new tab in your browser displaying the ai.azure.com portal. This is where you will select the LLM you’ll use in your deployment.

To create a deployment, on the Microsoft Foundry page for your resource, in the menu on the left, click on the Model catalog node. That will take you to a page where you can select your LLM.

A warning: Over and above whatever criteria you have for getting the right model for your application, selecting a model may require some trial-and-error poking around. That’s because:

• Some models are deprecated or may not be available for your resource (e.g., selecting a non-OpenAI LLM for an OpenAI-only resource).
• You may not be eligible for some models.
• Your subscription may not have the necessary resources to support a model.
• The model you select may not support the processing you want to implement.

Once you open the page listing available LLMs, if you got to the page from a:

• Foundry resource: You can browse the lists of LLMs from a variety of providers or you can search for an LLM using the search box just below those lists
• OpenAI resource: You can browse the list of OpenAI LLMs

When you select an LLM, Azure will display a page with high-level information about your LLM. For my case study, I created three deployments, one each for these three LLMs:

• gpt-5.2-chat LLM as an example of a Foundry resource
• gpt-5-chat LLM as an example of an Azure OpenAI-only resource
• text-embedding-3-large as an example of an LLM with specific features (I’ll use it in a later post on querying with Telerik AI connectors).

Creating a Deployment

To create your deployment, at the top of the page, click the button labeled “Use this model.” That will display a dialog where you can customize the LLM you’ve chosen, including giving your deployment a name (your deployment’s name will default to the name of your LLM). Click on the button at the bottom of the page labeled “Create resource and deploy” … and then be patient because this can take a moment.

After your deployment is created with your selected LLM:

• In a Foundry resource, you’ll be taken to the page describing your deployment.
• In an OpenAI-only resource, you’ll be taken to an Overview page. In the menu on the left, click on the Models + endpoints node to open a list of your deployments. Select the deployment you just created to be taken to the page describing your deployment.

Once you’re on your deployment’s page, you need three required pieces of information from the page to use in your application and one optional piece:

• Name: Displayed at the top of the page.
• Authentication information: Your deployment will default to Key authentication, which is fine for a proof-of-concept application (you can switch to Entra Id authentication for production, but the code to access your resource will get more complicated). Assuming that you stick with Key Authentication, copy the Key provided on this page.
• URL: At the top of your deployment’s page, find the Target Uri and copy the first segment of the URL provided (i.e., everything from the “https://” and up to, but not including, the first forward slash in the URL).
• Version: Depending on how you intend to use your LLM, you may not need this, but it does no harm to grab it now. Again, the easiest place to get this is from the sample code. Look for the string put in the variable called api-version (it will look like a date, e.g., “2025-12-01”).

Returning to Your Deployment

To return to your resource or your model, first surf to ai.azure.com and sign in. This portal is, currently, in the process of migrating to a new UI, so:

• If you get the “old” UI then, you may get a list of Foundry and Open AI resources. If so, pick the resource you want to go to the resource’s page. On the other hand, you may just be taken directly to one of your resources. Either way, in the menu on the left, select the Models + endpoints node to see a list of your deployments.
• If you don’t get that list of your resources … well, then you’re probably in the new UI and, at this point, I’d recommend using the toggle at the top of the page to return to the old UI so you can follow along.

You have more to do to create your own custom RAG-enabled AI agent (load your own content, for example). But if all you want is an application that integrates an AI prompt, you’ve done everything you need to support that. You just need to create a frontend that lets the user query your LLM’s deployment. The Telerik AI Prompt will let you do that with minimum effort. I’ll cover that after showing how to set up the client-side option with Ollama.

Setting Up Ollama

To implement the client-side option, you first need to download Ollama and install it. To confirm that Ollama installed successfully, open a command window and enter ollama. You should get back a list of Ollama commands.

You next need to add the LLM you want to use to Ollama. To do that, open a command window and use Ollama’s pull command to install one of the LLMs from the Ollama registry. This command installs OpenAI’s gpt-oss LLM:

ollama pull gpt-oss

After using the pull command, you can use Ollama’s list command (which displays the installed LLMs) to confirm your installation.

The Ollama server should start automatically after installation (and after every reboot) and should be listening on port 11434 on localhost. You can confirm that by using Ollama’s serve command. If server isn’t running, it will start and report the address the server is listening on. If the server is already running, you’ll get an error message that includes address that Ollama is listening on.

Make a note of the address (probably http://localhost:11434) and the name of the LLM you installed—you’ll need both in your code.

I’m building up to a creating a custom AI agent over this series of posts. But, at this point, you’ve done everything you need to create an application with an AI prompt—it’s just a matter of adding a frontend to your LLM.

Adding a Front End

In my next posts, I’ll use Telerik Document Processing Library tools to create applications that allow users to apply AI to documents. However, once you’ve created an LLM deployment, you can tie that deployment into your application’s UI with a few lines of code in your application’s Program.cs file and then query your LLM through the Telerik AI Prompt component in your application’s UI.

To do that in a .NET 8 or later application, you first need to add the Microsoft.Extensions.AI.OpenAI NuGet package to your application. After that, you need to tie your model into your application by adding the following code to your application’s Program.cs file, inserting the information about your LLM that you gathered from your deployment’s information page.

For either of my Foundry or OpenAI-only options that code looks like this:

builder.Services.AddSingleton(new AzureOpenAIClient(
     new Uri(“<url>”),
     new AzureKeyCredential(“<key>”)
 ));
builder.Services.AddChatClient(services => 
         services.GetRequiredService<AzureOpenAIClient>()
            .GetChatClient(<deployment name>).AsIChatClient());

For Ollama, in addition to adding the Microsoft.Extensions.AI.OpenAI NuGet package, you’ll also need to add the OllamaSharp and Microsoft.SemanticKernel.Connectors.Ollama packages. After that, this single line of code will integrate Ollama into your application:

builder.Services.AddSingleton<IChatClient>(
    sp => new OllamaApiClient("<Ollama address>", "<model name>")
);

Your last step is to add the Telerik AIPrompt to your application’s UI (available in JavaScript for Kendo UI, Blazor, ASP.NET AJAX, WinForms and .NET MAUI). That can be as simple as this in an application that supports Razor (e.g., ASP.NET or Blazor):

<TelerikAIPrompt/>

And that would give you this UI:

In a JavaScript application, you’ll need to add a <div> element, set the element’s id attribute, and write a couple lines of JavaScript code. I’ll cover that in a later post in this series.

You can now start your application, enter a prompt into the AIPrompt component (e.g., “Tell me about RAG-enabled AI applications”) and get a response.

There’s obviously far more that you can do with the AI Prompt … and I’ll return to that after my next post. Before that, however, I’m going to roll in Telerik Document Processing Library to let you load the content for your custom AI agent. Read Part 2!

Explore Telerik Document Processing Libraries, plus component libraries, reporting and more with a free trial of the Telerik DevCraft bundle:

Try DevCraft

Progress Telerik Document Processing Libraries, in addition to letting you work with a variety of document formats (PDF, DOCX, RTF, HTML, XLSX and more), are an example of the reason you buy into a suite of tools: All the tools bear a “family resemblance.”

The ideal scenario, of course, would be for a single tool that made all these document formats look the same. Given the differences in format and functionality between, for example, a PDF, a Microsoft Word (or RTF or HTML) document and an Excel spreadsheet, that’s not reasonable (though Progress Telerik has achieved that with DOCX, RTF and HTML documents).

The good news here is that, with Telerik Document Processing Libraries (DPL), the family resemblance is strong enough that, for all of the document types the library supports, I can show you how to load documents, start the editing process, convert between various document types and save a document in this one post.

Configuring Your Project

The sample code in this post was all written using the DPL for Windows libraries (even though I was working in ASP.NET Core—the more technical name for the version I used is “.NET(Target OS: Windows).” The suite is also available for the .NET Framework.

To create an ASP.NET Core project that would work with “all the documents,” I added these NuGet packages to my project:

• To work with PDF files: Telerik.Windows.Documents.Fixed
• To work with DOCX, HTML and RTF files: Telerik.Windows.Documents.Flow
• To work with Excel spreadsheets: Telerik.Windows.Documents.Spreadsheet

For the Excel spreadsheets, I’m only going to work with XLSX files, so I added the Telerik.Windows.Documents.Spreadsheet.FormatProviders.OpenXml package to my project. (If I was going to work with, for example, XLS spreadsheet, then I would have added the Telerik.Documents.Spreadsheet.FormatProviders.Xls package.)

Loading Your Document

The code to load a document from a file into any of these libraries is very similar:

1. Create the appropriate provider.
2. Use the .NETFile object’s OpenRead to create a Stream that points to the file.
3. Use the provider’s Import method to load the stream into the document object.

Here, for example, is the code to load a PDF file into a RadFixedDocument object (I used this code in an ASP.NET Core application with documents in my project’s wwwroot folder):

RadFixedDocument doc;
PdfFormatProvider prov = new();

using (Stream str = File.OpenRead(@"wwwroot/documents/Priorities.pdf"))
{
    doc = prov.Import(str, TimeSpan.FromSeconds(10));
}

And here’s the code to load a DOCX file into a RadFlowDocument:

RadFlowDocument doc;
DocxFormatProvider prov = new();

using (Stream str = File.OpenRead(@"wwwroot/documents/Priorities.docx"))
{
    doc = prov.Import(str, TimeSpan.FromSeconds(10));
}

As you can see, the code is identical except for the provider (PdfFormatProvider vs. DocxFormatProvider) and document objects (RadFlowDocument vs. RadFixedDocument).

Because both RTF and HTML documents load into the same RadFlowDocument object as a DOCX document, only the provider object changes (HtmlFormatProvider or RtfFormatProdiver instead of DocxFormatProvider) when working with those file formats. Here’s the code to load an RTF document:

RadFlowDocument doc;
RtfFormatProvider prov = new();

using (Stream str = File.OpenRead(@"wwwroot/documents/Priorities.rtf"))
{
    doc = prov.Import(str, TimeSpan.FromSeconds(10));
}

And here’s the almost identical code to load an HTML file:

RadFlowDocument doc;
HtmlFormatProvider prov = new();

using (Stream str = File.OpenRead(@"wwwroot/documents/Priorities.html"))
{
    doc = prov.Import(str, TimeSpan.FromSeconds(10));
}

The code to load an Excel workbook is also similar to what you’ve seen before, just swapping in a new document object (Workbook) and provider (XlsxFormatProvider):

Workbook doc;
XlsxFormatProvider prov = new();
using (Stream str = File.OpenRead(@"wwwroot/documents/priority.xlsx"))
{
    doc = prov.Import(str, TimeSpan.FromSeconds(10));
}

A note: The Workbook object assumes that you’re going to load the whole Excel workbook into memory. For very large workbooks, that may not make sense. For that scenario, you should look at the SpreadStreamProcessing Library.

Modifying the Documents

Once you’ve loaded the documents, you can start working with them. You can often simplify your code by using the RadFixedDocumentEditor with PDF documents or the RadFlowDocumentEditorwith Word/RTF/HTML documents. Not surprisingly, the code for creating an editor is almost identical for these two document types: create an editor object and pass the document you want loaded into the editor.

The code to create an editor for a PDF document looks like this:

RadFixedDocumentEditor editor = new RadFixedDocumentEditor(doc);

The code for Word/RTF/HTML documents looks like this:

RadFlowDocumentEditor editor = new RadFlowDocumentEditor(doc);

That’s not to say that, as you start working with those documents, there aren’t going to be differences. These are, after all, very different kinds of documents. Having said that, some functionality does work in a similar way across all the document types.

If, for example, I want to search a PDF document for the text “ASP.NET,” I create a TextSearch instance from my document object. I then use the TextSearch object’s FindAll method to search for text in my PDF document, passing two things: my search text and a TextSearchOptions object that specifies how I want my search conducted. That FindAll object returns a collection of SearchResult objects that I can loop through.

Typical code, then, looks like this:

TextSearch search = new TextSearch(doc);
TextSearchOptions opts = new() {
CaseSensitive = false,
WholeWordsOnly = true,
UseRegularExpression = true
                                                              };

IEnumerable<SearchResult> items = search.FindAll("ASP.NET", opts);

Debug.Print($"Found {items.Count()} items.");
foreach (SearchResult item in items)
{
    Debug.Print($"Found at {item.Range.StartPosition} ");
    Debug.Print($"Found: {item.Result}");
}

The process is almost identical for the RadFlowDocument object, except:

• You call the FindAllmethod directly from the RadFlowDocumentEditor.
• There isn’t a separate options object (though all the search options from the TextSearch object are still available).
• The FindAll method on the editor returns FindResult objects instead of SearchResult objects.

As a result, the equivalent search code for a DOCX, RTF or HTML document looks like this:

RadFlowDocumentEditor editor = new RadFlowDocumentEditor(doc);

IEnumerable<FindResult> items = editor.FindAll("ASP.NET");

Debug.Print($"Found {items.Count()} items.");
foreach (FindResult item in items)
{
    Debug.Print($"Found at {item.RelativeStartIndex} ");
    Debug.Print($"Found: {item.FullMatchText}");
}

Searching a spreadsheet works similarly. The differences:

• The FindAll method is built right into the Workbook object.
• You have more search options available with the spreadsheet object.
• You pass your search string as part of the options object.

My find code with a workbook would look like this:

FindOptions opts = new() {
FindWhat = "ASP.NET",
MatchCase = false,
MatchEntireCellContents = true,
                                                };

IEnumerable<FindResult> items = doc.FindAll(opts);

Debug.Print($"Found {items.Count()} items.");
foreach(FindResult item in items)
{
    Debug.Print($"Found at {item.FoundCell.CellIndex} ");
    Debug.Print($"Found: {item.ResultValue}");
}

One note: It is certainly convenient when objects from the different libraries share the same name (like the FindResult object that’s defined in both the RadFlowDocument and Workbook libraries). However, if you try to use both FindResult objects in the same code file, the compiler will get confused because the two objects are in different namespaces. In the unlikely case that you’re working with both Excel and Word documents in the same code file, you’ll have to fully qualify the object names—something I haven’t done in this post.

Saving Your Documents

To save your modified documents back to disk, you just need to use the provider’s Export method. The code for all the document types is identical:

using (Stream str = File.Create(@"wwwroot/documents/Prioritiesnew.<filetype>"))
{
    prov.Export(doc,str, TimeSpan.FromSeconds(10));
}

Converting Documents

You can convert from one type in the suite to other types and, not surprisingly, the conversion processes look very much alike. As you’ve seen before, it often comes down to using the right provider.

If, for example, you want plain text version of your PDF file, you use the TextFormatProvider object’s Export method:

TextFormatProvider prov = new();
string text = prov.Export(doc, TimeSpan.FromSeconds(10));

For Word/HTML/RTF document types, the code is almost identical except it uses the TxtFormatProvider object:

TxtFormatProvider txProv = new();
string text = prov.Export(doc, TimeSpan.FromSeconds(10));            

One note: There is a downside to having the classes that do similar things to different document types have the same name. If you are mixing document types and, as a result, using the Fixed, Flow and spreadsheet libraries in the same application, the compiler can get confused about which class from which library you’re using. If so, you’ll have to fully qualify your class names by including their namespaces in the class names. That makes for hard-to-read code, so I haven’t done that here.

But, as an example of how different documents require different functionality, you probably wouldn’t ever want to convert an Excel workbook to a string … but you might want to save your workbook as a CSV file. As you might expect by now, the code to save your imported workbook into a CSV file just means using the Export method on the appropriate provider—the CsvFormatProvider object in this case.

Typical code would look like this:

CsvFormatProvider prov = new();

using (Stream str = File.Create("Priority.csv"))
{
    prov.Export(doc, str, TimeSpan.FromSeconds(10));
}

Converting any of these document types (Excel, Word, HTML, etc.) to PDF is equally straightforward. Because all the libraries look very much alike, it’s really just a matter of adding the library with the provider you need.

But you can also convert your Workbook object into a RadFixedDocument if you wanted to manipulate your spreadsheet as a PDF object. That conversion is handled by the PdfFormatProvider from the Telerik.Windows.Documents.Spreadsheet.Formatproviders.Pdf package and using its ExportToFixedDocumentmethod:

PdfFormatProvider prov = new();

RadFixedDocument fixedDoc = 
        prov.ExportToFixedDocument(doc, TimeSpan.FromSeconds(10));

The code is identical if you want to convert a Word/RTF/HTML document to a RadFixedDocument to work with it as a PDF file. That conversion also uses a PdfFormatProvider object but, this time, from the Telerik.Windows.Documents.Flow.FormatProviders.Pdf namespace.

But, because the providers from the two libraries have the same name, if you’re using both libraries in the same code file, you will need to fully qualify your provider names to make sure you’re getting the appropriate PdfFormatProvider.

Of course, once you start using these tools to create or modify the documents you’ve loaded, you’ll find more differences—the functionality in a spreadsheet is very different from the functionality in an HTML document. But, while the family resemblances among this suite won’t eliminate those differences, it does cut those differences down to what matters: how those documents differ in their functionality. Which is, after all, what you want.

Explore Telerik Document Processing Libraries, plus component libraries, reporting and more with a free trial of the Telerik DevCraft bundle:

Try DevCraft

If you have ever built a model-powered agent, you know the development loop. Write some code, fire it at the endpoint, check the response, tweak the parsing, fire it again. Repeat until the output looks right. It is a perfectly normal workflow—and it quietly drains your token budget with every single iteration.

The new Progress Telerik Fiddler Everywhere Agent Cache feature is designed to break that cycle. Once you capture a response from a model-provider endpoint, you can flip a single switch and have Fiddler software replay that response for every subsequent matching call—without the request ever leaving your machine. Same output, zero additional tokens consumed on the provider side.

This post walks through exactly how that works, using a small open-source demo project to make everything concrete.

The Hidden Cost of Agent Development

Building an agent that calls a completion endpoint involves a lot of repetition that has nothing to do with the model itself. You are iterating on:

• How you construct the prompt
• How you parse and validate the structured response
• How you surface the result to the rest of your system
• How your error handling behaves when the response is malformed

None of those iterations require a new, unique response from the model. You already have a good one from the first call. But unless you manually save the raw response and mock it yourself, every invocation sends a fresh request, and the provider charges for it.

Once agents move beyond demos, three pressures show up together and stay for the duration of development:

• Cost – Repeated runs during development burn budget. For a simple agent that exchanges a few hundred tokens per call, this might feel negligible. But development sessions involve dozens of sequential runs, teams have multiple developers iterating in parallel, and the costs compound quickly.
• Latency – Every round trip to the provider stretches the feedback loop. When you are tweaking prompt construction or adjusting response parsing, waiting on a live call each time slows everything down.
• Determinism – The same input does not always produce the same output. That variability makes it harder to isolate whether a difference in behavior came from your code change or from the model.

This is especially visible in teams that build many small, task-specific agents rather than one large agent. Even small per-run costs compound when iteration is constant—and none of that spend actually improves the agent.

What Teams Already Do

Most teams already compensate for this manually. Common patterns include separating development runs from real execution, validating agent wiring before triggering model calls, reusing mocked or previously captured responses, and avoiding live execution early to keep iteration fast.

These approaches work, but they are fragmented. Provider-level caching helps in some cases but is limited. Custom mocks and fixtures are costly to maintain. Replay logic often lives outside the main development flow, and different teams end up solving the same problem with different local tooling.

The problem is not a lack of solutions. It is the lack of a low-friction one that fits naturally into everyday iteration.

What Agent Cache Does

Fiddler Everywhere acts as a proxy that sits between your agent and the remote endpoint. When your agent makes an HTTPS call to, say, api.anthropic.com, Fiddler software intercepts it, forwards it and logs the full request-response pair in the Traffic pane.

The new Agent Calls tab is a focused view inside that pane. It automatically filters and displays HTTPS sessions that target supported model-provider endpoints—such as OpenAI, Anthropic and Gemini—so you are not wading through noise from other traffic. Every captured call gets a Caching toggle.

Enable the toggle, and Fiddler software starts intercepting any outbound call that matches that session’s request. Instead of forwarding the request, it immediately returns the cached response. The endpoint never receives the duplicate call. Your agent sees the exact same payload it would have received from a live call. Token count: zero.

Disable the toggle at any time and live traffic resumes, no restarts required.

How Agent Calls and Caching Behave

A few details that matter when you start using it:

• Deterministic filtering: Sessions appear in Agent Calls automatically when Fiddler software detects traffic to a supported agentic endpoint. You do not need to configure which endpoints to watch.
• First-match caching: If two or more sessions target the same endpoint (for example, https://api.anthropic.com/v1/messages) and both are cached, Fiddler software returns the response from the first cached session.
• No rule interference: Fiddler rules are executed only for non-cached sessions. Cached responses are returned as-is, without rule evaluation.
• Visibility split: After a session is cached, subsequent matching requests appear only in Live Traffic. The Agent Calls tab continues to show the original non-cached captures.

Why It Matters During Development

Agent Cache is built around three practical benefits that matter most during active development.

1. Faster iterations: Replaying a cached response is instant. Instead of waiting on a round trip to the provider on every run, you get a result back immediately—shortening the feedback loop so you can move through prompt and code changes without unnecessary delays.
2. Lower execution costs: Each cached run consumes zero tokens on the provider side. During active development, where the same request may be triggered dozens of times, this directly reduces the token spend that accumulates before a feature is even complete.
3. More predictable behavior: A cached response is fixed and repeatable. Running the same agent logic against the same response on every iteration makes it straightforward to verify that a code change had the intended effect, without having to account for variability in live model output.

Demo: Bug Report Analyzer

To make this tangible, walk through the agent-cache-demo—a minimal Python agent that takes a fixed bug report and returns a structured analysis (severity, category, a plain-English summary and a suggested next step).

The input never changes between runs, which makes it a perfect showcase for Agent Cache: the model’s answer to an identical prompt is always reusable, so there is genuinely no reason to pay for it more than once.

What the Agent Does

The core of agent.py is straightforward:

message = client.messages.create(  
model=MODEL,  
max_tokens=256,  
system=SYSTEM_PROMPT,  
messages=[  
{"role": "user", "content": f"Analyze this bug report:\n\n{report}"}  
],  
)  

It sends the bug report to the Claude API and expects a JSON response like this:

{  
"severity": "high",  
"category": "crash",  
"summary": "App crashes with a NullPointerException when attempting to log in under no network connectivity.",  
"suggested_next_step": "Add a null or connectivity check in NetworkManager.checkConnectivity() before network calls."  
}  

That response is then formatted and printed to the terminal:

── Bug Report Analysis ─────────────────────────────────────  
Severity  : HIGH  
Category  : crash  
Summary  : App crashes with a NullPointerException when attempting to  
log in under no network connectivity.  
Next step : Add a null or connectivity check in  
NetworkManager.checkConnectivity() before network calls.  
─────────────────────────────────────  

Setup

Clone the repository and install dependencies:

git clone [https://github.com/NickIliev/agent-cache-demo](https://github.com/NickIliev/agent-cache-demo)  
cd agent-cache-demo  
  
python -m venv .venv  
source .venv/bin/activate  # macOS / Linux  
.venv\Scripts\activate  # Windows  
  
pip install -r requirements.txt  
export ANTHROPIC_API_KEY=sk-ant-... # macOS / Linux (Git Bash)  
set ANTHROPIC_API_KEY=sk-ant-... # Windows (CMD)  

The demo supports routing traffic through the Fiddler proxy or running directly against the provider. It also covers SSL/TLS trust configuration for HTTPS interception. See the repository README for full details on proxy setup, environment variables and certificate options.

Step 1: The First Live Call

Start Fiddler Everywhere and run the agent:

python agent.py  

The terminal shows the result and, crucially, the token consumption:

[tokens] Input: 312  |  Output: 68  |  Total: 380  

Switch to Fiddler Everywhere and open Traffic > Agent Calls. You will see the captured call to api.anthropic.com with the full request and response visible.

This is your baseline. You paid for 380 tokens. That is fair—you needed the live call to validate the end-to-end flow.

Step 2: Enable the Cache

In the Agent Calls grid, find the captured session and flip its Caching switch to on. That is the entire configuration step.

Step 3: All Subsequent Runs Are Free

Run the agent again:

python agent.py  

The output in the terminal is byte-for-byte identical to the first run, including the token count display. Because the Caching switch was on, Fiddler software served the stored response immediately and never forwarded the request to the provider. The endpoint never saw the call.

You can now iterate on agent.py as many times as you need—refactor the display logic, adjust the JSON parsing, add logging—and none of those runs cost a single token.

When to Use Agent Cache

Agent Cache is a development-stage tool. It is particularly valuable when:

• Iterating on response handling: Your agent already returns a correct response from the model. You are now working on how your code handles that response—formatting, validation, error recovery. None of that work requires fresh model calls.
• Sharing a working state with teammates: Cache a known-good response and share the Fiddler session. Everyone on the team can iterate against the same replay without burning tokens or depending on network access to the provider.
• Working offline or in restricted environments: Once the cache is populated, your agent keeps working even without connectivity to the provider.

Things to Keep in Mind

• Cache matching is request-based. If your agent changes the prompt, the model or any request headers, the cached session will no longer match. Capture and cache the updated variant separately.
• The cache lives in the current Fiddler session. Closing and reopening Fiddler clears the cache state, so the next run after a restart will make a live call. Review cached sessions periodically to keep stored responses aligned with your current workflow.
• Cache is for development, not production. Agent Cache is designed for development workflows where deterministic, repeatable responses are the goal. When you are ready to validate against a live endpoint, disable the cache and resume live calls.

Availability

Agent Cache is available on Fiddler Everywhere Trial, Pro and Enterprise tiers. The feature is not included in Lite licenses.

Try It Yourself

The full demo is on GitHub: github.com/NickIliev/agent-cache-demo. Clone it, set your Anthropic API key, and you can see the before-and-after token counts yourself in under five minutes.

The point is not really the 380 tokens saved in a single run. It is the dozens of runs you make in a typical development session, the parallel runs across a team—all of which can stop paying for answers they already have.

Agent Cache does not change how you build agents. It just removes the tax on iterating.

If you aren’t already using Fiddler Everywhere, it does come with a free trial:

Try Fiddler Everywhere

Leave Feedback

Agent development workflows are still evolving quickly, and your feedback shapes what comes next. If you try Agent Cache during development—or if there is something you wish it did differently—we want to hear about it.

• Email: fiddler-support@progress.com
• GitHub issues: github.com/telerik/fiddler-everywhere/issues
• Demo repository: github.com/NickIliev/agent-cache-demo

Modern applications rely on automation and intelligent processing to handle large volumes of data, and spreadsheets are no exception. With the 2026 Q1 release, Progress introduced Agentic Tools (in Preview) for Telerik Document Processing Libraries (DPL).

These tools are purpose‑built .NET APIs for agentic document workflows, enabling AI agents to analyze, extract, edit and generate Excel and PDF files; run aggregates; transform content; and convert formats directly inside your app. The new Agentic Tools cover both PdfProcessing and SpreadProcessing libraries and are available with a Subscription license.

In this post, we’ll walk you through how to use the SpreadProcessing Agentic Tools to analyze an existing spreadsheet.

Importing the Workbook

Let’s create a simple .NET console app. Our first step is to import the Workbook. I am going to add the necessary DPL dependencies, in this case:

and then use this code:

Workbook workbook = null;

using (Stream input = File.OpenRead("Electric_Vehicle_Population_Data.xlsx"))
{
    XlsxFormatProvider formatProvider = new();
    workbook = formatProvider.Import(input, null);
}

In case you are wondering, this file contains 17 columns and 75,331 rows of data.

An agent using the DPL tools can work with multiple files at the same time by importing and exporting them via the SpreadProcessingFileManagementAgentTools and managing them with the InMemoryWorkbookRepository. However, in this example we are going to concentrate on analyzing one workbook, so we are going to use the SingleWorkbookRepository, a class which gives an agent a single file to work with in memory.

IWorkbookRepository repository = new SingleWorkbookRepository(workbook);

For this code, we need to reference the Telerik.Documents.AI.AgentTools.Spreadsheet package.

Initializing the DPL Agentic Tools

Initializing the Agentic Tools is very simple. For this example, we will use an Azure Open AI deployment, so first we are going to add the Microsoft.Agents.AI.OpenAI and Azure.AI.OpenAI packages. Then we are going to collect the Read and Formula tools in one collection:

List<AITool> tools = new SpreadProcessingReadAgentTools(repository).GetTools().ToList();
tools.AddRange(new SpreadProcessingFormulaAgentTools(repository).GetTools());

And then we can initialize our agent. We are going to need an Azure Open AI endpoint and key and are going to use gpt-4.1-mini.

OpenAI.Chat.ChatClient chatClient = new AzureOpenAIClient(
    new Uri(endpoint),
    new ApiKeyCredential(key))
    .GetChatClient(model);

AIAgent agent = chatClient.AsIChatClient().AsAIAgent(
    instructions: "",
    name: "SpreadsheetAnalyzer",
    tools: tools);

At this point, we can already ask a simple question to check our progress:

AgentResponse response = await agent.RunAsync("What is the value on cell A4?");
Console.WriteLine(response.ToString());

Here is the result:

If you examine the response of the agent more closely, you will notice that it contains three messages. The first is the function call the agent made to the document processing tool GetCellValues and with what parameters. The second is the response. And the third is what the LLM has reasoned and has decided to give us.

Giving It UI

A console app is good for a proof of concept, but it would be nice to give our functionality a more finished look. One of the ways to do this is by using some Progress Telerik for WPF controls. The RadSpreadsheet control can show the content of our file, and we can leverage RadChat for the conversation with the agent.

We can give the repository the Workbook object of the RadSpreadsheet like this when initializing the chat:

IWorkbookRepository repository = new SingleWorkbookRepository(this.radSpreadsheet.Workbook);

Then we are going to subscribe to the SendMessage event, which is where our logic for running the agent is going to go:

this.radChat.SendMessage += this.RadChat_SendMessage;

After a few more tweaks, this is the result:

The full code of the demo can be found on this link: AgentToolsAnalyzeSpreadsheet on GitHub

Conclusion

Agentic workflows introduce a powerful new way to interact with documents, moving beyond static reading and writing to dynamic, intelligent analysis. As you’ve seen, the setup integrates seamlessly with .NET, and, once the agent is initialized, it can leverage the full capabilities of the Document Processing Libraries.

This example is just the beginning! The same approach can be extended to multi-document scenarios, automated reporting, data validation or even generating new spreadsheets from scratch.

The future of document processing is agentic, and it’s already here.

Try out the Telerik Document Processing Libraries, which are included in the Telerik DevCraft bundles to pair perfectly with your favorite component libraries.

Try Telerik DevCraft

Offloading document generation, conversion or manipulation to cloud services allows you to handle large workloads without overloading on-prem resources. Azure Functions and AWS Lambda scale automatically based on demand, so whether you need to generate 10 or 10,000 documents, the infrastructure adjusts dynamically. Serverless models charge per execution time and resources consumed, eliminating the need for dedicated servers for document processing. Thus, you pay only for what you use.

This blog post introduces comprehensive cloud integration demonstrations for Azure and AWS, showcasing PDF processing capabilities using Progress Telerik Document Processing in serverless environments. The examples demonstrate two main integration patterns: PDF merging and external digital signing, implemented for both Azure Functions and AWS Lambda. The complete code projects are available in our SDK repository: Cloud Integration Demos.

Integrate RadPdfProcessing with Azure Functions

First, you’ll need: an active Azure subscription, Azure functions tools installed and the Telerik NuGet feed set up.

1. Create an Azure Functions App

2. Select Anonymous authorization level:

3. Install the following NuGet packages:

• Install the Telerik.Documents.Fixed NuGet package.
• Install the HttpMultipartParser NuGet package:

4. Rename the Functiona1.cs file to “MergeFunction” and introduce your custom implementation in the Run method:

using HttpMultipartParser;
using Microsoft.Azure.Functions.Worker;
using Microsoft.Azure.Functions.Worker.Http;
using System.Net;
using Telerik.Windows.Documents.Fixed.FormatProviders.Pdf;
using Telerik.Windows.Documents.Fixed.Model;
 
namespace MyAzureFunctionApp;
 
public class MergeFunction
{
    [Function("MergeFunction")]
    public async Task<HttpResponseData> Run([HttpTrigger(AuthorizationLevel.Anonymous, "get", "post")] HttpRequestData req)
    {
        Task<MultipartFormDataParser> parsedFormBody = MultipartFormDataParser.ParseAsync(req.Body);
 
        PdfFormatProvider provider = new PdfFormatProvider();
        RadFixedDocument result = MergePdfs(provider, parsedFormBody.Result.Files);
 
        using (MemoryStream outputStream = new MemoryStream())
        {
            provider.Export(result, outputStream, TimeSpan.FromSeconds(20));
            outputStream.Seek(0, SeekOrigin.Begin);
 
            HttpResponseData httpResponseData = req.CreateResponse(HttpStatusCode.OK);
            httpResponseData.Headers.Add("Content-Type", "application/pdf");
            await outputStream.CopyToAsync(httpResponseData.Body);
 
            return httpResponseData;
        }
    }
 
    static RadFixedDocument MergePdfs(PdfFormatProvider pdfFormatProvider, IReadOnlyList<FilePart> files)
    {
        RadFixedDocument mergedDocument = new RadFixedDocument();
        foreach (FilePart file in files)
        {
            RadFixedDocument documentToMerge = pdfFormatProvider.Import(file.Data, TimeSpan.FromSeconds(20));
            mergedDocument.Merge(documentToMerge);
        }
 
        return mergedDocument;
    }
} 

This Azure Function, named MergeFunction, handles HTTP GET and POST requests to merge multiple PDF files into a single document. It uses:

• HttpMultipartParser to parse multipart form data and extract uploaded files.
• Telerik PdfFormatProvider and RadFixedDocument to import and merge PDF documents.
• The merged PDF is exported to a memory stream and returned as an HTTP response with the application/pdf content type.

The function supports anonymous access and processes uploaded files efficiently, so that the merged PDF is delivered in the response. Since the function is implemented with anonymous access for demo purposes, consider adding authentication as needed for your scenario.

5. Run the project and copy the URL from the window that pops up:

6. Create a .NET Console App (e.g., MyMergeApp) that acts as a client for the Azure Function PDF Merge service.

using System.Diagnostics;
using System.Net.Http.Headers;
 
namespace MyMergeApp
{
    internal class Program
    {
        static void Main(string[] args)
        {
            string functionUrl = "http://localhost:7163/api/MergeFunction";
 
            // Specify PDF files to merge from the Resources directory
            string[] pdfFilePaths = { "../../../Resources/file1.pdf", "../../../Resources/file2.pdf" };
 
            // Create multipart form data content for file upload
            using MultipartFormDataContent content = new();
 
            // Add each PDF file to the form data
            foreach (string filePath in pdfFilePaths)
            {
                byte[] fileBytes = File.ReadAllBytes(filePath);
                ByteArrayContent fileContent = new(fileBytes);
                fileContent.Headers.ContentType = new MediaTypeHeaderValue("application/pdf");
                content.Add(fileContent, "files", Path.GetFileName(filePath));
            }
 
            // Send the merge request to the Azure Function
            HttpResponseMessage response = PostAsync(functionUrl, content).Result;
            response.EnsureSuccessStatusCode();
 
            // Read the merged PDF from the response
            byte[] result = response.Content.ReadAsByteArrayAsync().Result;
 
            // Save the merged PDF to disk
            string outputPath = "merged_output.pdf";
            if (File.Exists(outputPath))
            {
                File.Delete(outputPath);
            }
            File.WriteAllBytes(outputPath, result);
 
            // Open the merged PDF in the default viewer
            Process.Start(new ProcessStartInfo(outputPath) { UseShellExecute = true });
        }
        static async Task<HttpResponseMessage> PostAsync(string url, MultipartFormDataContent content)
        {
            using HttpClient httpClient = new HttpClient();
            httpClient.Timeout = TimeSpan.FromMinutes(2); // Allow sufficient time for large files
 
            return await httpClient.PostAsync(url, content);
        }
    }
}

It demonstrates how to send multiple PDF files to the MergeFunction endpoint and handle the merged result. The workflow includes:

• Loading PDF files from a local Resources directory.
• Packaging the files as multipart form data for upload.
• Sending an HTTP POST request to the Azure Function endpoint.
• Receiving the merged PDF in the response and saving it to disk.
• Automatically opening the merged PDF in the system’s default viewer.
  The application uses HttpClient for communication, enables proper content type headers and includes a helper method PostAsync for sending requests with a configurable timeout.

7. Run the Azure Functions .NET Worker (e.g., MyAzureFunctionApp.csproj):

8. While the service is running, run the Console App (e.g., MyMergeApp).

As a result, a merged PDF document will be produced:

Integrate RadPdfProcessing with AWS Lambda

Using an AWS Lambda function for signing PDF documents offers a more secure, scalable and cost-effective approach to digital signature workflows. By offloading the signing process to a serverless environment, sensitive private keys remain isolated in the cloud, reducing the risk of exposure on client machines.

The following tutorial defines the steps for creating an AWS Lambda function that performs digital signature operations for PDF documents using a private key stored in a certificate file. The AWS Lambda function is purposed to act as a more secure service that remotely signs PDF documents, and the private key is never exposed to the client.

Before starting, you’ll need valid AWS Credentials and the Telerik NuGet Feed properly set up.

1. Create AWS Lambda Project (e.g., MyAWSLambda):

2. From the Select Blueprint wizard, select “.NET 8 (Container Image)”:

3. Open the Function.cs file and implement the custom logic for signing PDF documents in the FunctionHandler:

The method receives data to be signed, signs it using a private key certificate, and returns the Base64-encoded signature. The .pfx certificate is stored independently from the project used for processing documents.

NOTE: Do not forget that sensitive data should be stored properly and that this implementation is for demo purposes.

using Amazon.Lambda.Core;
using System.Security.Cryptography;
using System.Security.Cryptography.X509Certificates;
 
// Assembly attribute to enable the Lambda function's JSON input to be converted into a .NET class.
[assembly: LambdaSerializer(typeof(Amazon.Lambda.Serialization.SystemTextJson.DefaultLambdaJsonSerializer))]
 
namespace MyAWSLambda;
 
public class Function
{
    public async Task<string> FunctionHandler(Input input, ILambdaContext context)
    {
        byte[] dataToSign = Convert.FromBase64String(input.DataToSign);
 
        byte[]? result = SignData(dataToSign, input.DigestAlgorithm);
 
        if (result != null)
        {
            return Convert.ToBase64String(result);
        }
        else
        {
            throw new InvalidOperationException("Signing operation failed");
        }
    }
    static byte[]? SignData(byte[] dataToSign, string? digestAlgorithm)
    {
        string certificateFilePassword = "johndoe";
        string certificateFilePath = "Resources/JohnDoe.pfx";
 
        using (Stream stream = File.OpenRead(certificateFilePath))
        {
            byte[] certRawData = new byte[stream.Length];
            stream.ReadExactly(certRawData, 0, (int)stream.Length);
 
            using (X509Certificate2 fullCert = new X509Certificate2(certRawData, certificateFilePassword))
            {
                using (RSA? rsa = fullCert.GetRSAPrivateKey())
                {
                    if (rsa == null)
                    {
                        throw new InvalidOperationException("Certificate does not contain an RSA private key");
                    }
 
                    // Map the digest algorithm string to HashAlgorithmName
                    HashAlgorithmName algorithmName = HashAlgorithmName.SHA256;
                    algorithmName = digestAlgorithm switch
                    {
                        "Sha384" => HashAlgorithmName.SHA384,
                        "Sha512" => HashAlgorithmName.SHA512,
                        _ => HashAlgorithmName.SHA256,
                    };
 
                    byte[]? bytes = rsa.SignData(dataToSign, algorithmName, RSASignaturePadding.Pkcs1);
                    return bytes;
                }
            }
        }
    }
 
    public class Input
    {
        public string DataToSign { get; set; } = string.Empty;
 
        public string? DigestAlgorithm { get; set; }
    }
}

4. Modify the aws-lambda-tools-defaults.json file and specify the function-name for the AWS Lambda function (e.g., ExternalSignPdfAWSFunction):

{
  "Information": [
    "This file provides default values for the deployment wizard inside Visual Studio and the AWS Lambda commands added to the .NET Core CLI.",
    "To learn more about the Lambda commands with the .NET Core CLI execute the following command at the command line in the project root directory.",
    "dotnet lambda help",
    "All the command line options for the Lambda command can be specified in this file."
  ],
  "profile": "telerik-dpl",
  "region": "eu-north-1",
  "configuration": "Release",
  "package-type": "image",
  "function-memory-size": 512,
  "function-timeout": 30,
  "image-command": "MyAWSLambda::MyAWSLambda.Function::FunctionHandler",
  "docker-host-build-output-dir": "./bin/Release/lambda-publish",
  "function-name": "ExternalSignPdfAWSFunction"
}

5. Create a Console App (e.g., MySigningApp.csproj) that will consume the AWS Lambda function.

6. Install the following NuGet packages:

• AWSSDK.Lambda
• Telerik.Documents.Fixed

The Resources folder stores the unsigned PDF document together with the public .crt certificate.

7. Modify the Program.cs file to demonstrate how to apply a digital signature to a PDF document using the Telerik PdfProcessinglibrary and an external AWS Lambda signer. The workflow includes importing a PDF, creating a signature field with a visual representation, configuring signature settings and exporting the signed document.

Note: We will use the specified function-name in the previous step when creating the LambdaFunctionSigner object:

using System.Diagnostics;
using Telerik.Documents.Fixed.Model.DigitalSignatures;
using Telerik.Documents.Primitives;
using Telerik.Windows.Documents.Fixed.FormatProviders.Pdf;
using Telerik.Windows.Documents.Fixed.Model;
using Telerik.Windows.Documents.Fixed.Model.Annotations;
using Telerik.Windows.Documents.Fixed.Model.DigitalSignatures;
using Telerik.Windows.Documents.Fixed.Model.Editing;
using Telerik.Windows.Documents.Fixed.Model.InteractiveForms;
using Telerik.Windows.Documents.Fixed.Model.Objects;
using Telerik.Windows.Documents.Fixed.Model.Resources;
 
namespace MySigningApp
{
    internal class Program
    {
        static void Main(string[] args)
        {
            PdfFormatProvider provider = new PdfFormatProvider();
            RadFixedDocument document = ImportDocument(provider);
 
            string signatureName = "SampleSignature";
 
            Form form = new Form();
            form.FormSource = new FormSource();
            form.FormSource.Size = new Size(120, 120);
 
            // We will use the editor to fill the Form XObject.  
            FixedContentEditor formEditor = new FixedContentEditor(form.FormSource);
            formEditor.DrawCircle(new Point(50, 50), 20);
            formEditor.DrawText(signatureName);
 
            // The Signature object is added to a signature field, so we can add a visualization to it.  
            SignatureField signatureField = new SignatureField(signatureName);
 
            // Create the external signer that will call AWS Lambda to perform the actual signing
            ExternalSignerBase externalSigner = new LambdaFunctionSigner("ExternalSignPdfAWSFunction", "eu-north-1");
 
            // Configure the signature with digest algorithm and timestamp server
            Signature signature = new Signature(externalSigner);
            signature.Settings.DigestAlgorithm = DigestAlgorithmType.Sha512;
            signature.Settings.TimeStampServer = new TimeStampServer("http://timestamp.digicert.com", TimeSpan.FromSeconds(10));
            signatureField.Signature = signature;
 
            // The widget contains the Form XObject and defines the appearance of the signature field.  
            SignatureWidget widget = signatureField.Widgets.AddWidget();
            widget.Rect = new Rect(200, 600, 100, 100);
            widget.Border = new AnnotationBorder(100, AnnotationBorderStyle.Solid, null);
            widget.Content.NormalContentSource = form.FormSource;
 
            // The Widget class inherits from Annotation. And, as any other annotation, must be added to the respective collection of the page.  
            RadFixedPage page = document.Pages.AddPage();
            page.Annotations.Add(widget);
            document.AcroForm.FormFields.Add(signatureField);
 
            document.AcroForm.SignatureFlags = SignatureFlags.AppendOnly;
 
            ExportDocument(provider, document);
 
        }
 
        static RadFixedDocument ImportDocument(PdfFormatProvider provider)
        {
            using (FileStream stream = File.OpenRead("Resources/SampleDocument.pdf"))
            {
                return provider.Import(stream, TimeSpan.FromSeconds(20));
            }
        }
 
        static void ExportDocument(PdfFormatProvider provider, RadFixedDocument document)
        {
            string outputPath = "ExternallySignedDocument.pdf";
            File.Delete(outputPath);
 
            using (FileStream stream = File.Create(outputPath))
            {
                provider.Export(document, stream, TimeSpan.FromSeconds(60));
            }
 
            Process.Start(new ProcessStartInfo(outputPath) { UseShellExecute = true });
        }
    }
}

8. Implement the External Signer.

The LambdaFunctionSigner class is a custom implementation of an external signer that delegates digital signing operations to an AWS Lambda function. It inherits from ExternalSignerBaseand is designed for scenarios where the private key is securely stored in AWS Lambda, while the public certificate resides locally.

using Amazon.Lambda;
using Amazon.Lambda.Model;
using Amazon.Runtime; 
using System.Security.Cryptography.X509Certificates;
using System.Text;
using System.Text.Json;
using Telerik.Documents.Fixed.Model.DigitalSignatures;
 
namespace MySigningApp
{
    public class LambdaFunctionSigner : ExternalSignerBase
 
    {
        private readonly string functionName;
        private readonly AmazonLambdaClient lambdaClient;
 
        /// <summary>
        /// Creates a new instance of LambdaFunctionSigner.
        /// </summary>
        /// <param name="functionName">The AWS Lambda function name or ARN (e.g., "MyAWSLambda" or "arn:aws:lambda:region:account:function:name")</param>
        /// <param name="region">The AWS region where the Lambda function is deployed (e.g., "us-east-1", "eu-north-1")</param>
        public LambdaFunctionSigner(string functionName, string region)
        {
            this.functionName = functionName;
            var credentials = new BasicAWSCredentials("your-access-key", "your-secret-key");
            this.lambdaClient = new AmazonLambdaClient(credentials, Amazon.RegionEndpoint.GetBySystemName(region));
        }
 
        /// <summary>
        /// Gets the certificate chain used for signing.
        /// </summary>
        /// <returns>An array of X509Certificate2 objects representing the certificate chain.</returns>
        /// <remarks>
        /// The public certificate is loaded from the Resources folder and should match
        /// the private key certificate stored in the AWS Lambda function.
        /// </remarks>
        protected override X509Certificate2[] GetCertificateChain()
        {
            string publicKey = "Resources/JohnDoe.crt";
            return [new X509Certificate2(publicKey)];
        }
 
        /// <summary>
        /// Signs the provided data by invoking the AWS Lambda function.
        /// </summary>
        /// <param name="dataToSign">The byte array containing the data to be signed.</param>
        /// <param name="settings">The signature settings containing digest algorithm and other configuration.</param>
        /// <returns>A byte array containing the digital signature.</returns>
        /// <exception cref="InvalidOperationException">Thrown when the Lambda invocation fails or returns an error.</exception>
        /// <remarks>
        /// This method:
        /// 1. Serializes the data and settings to JSON
        /// 2. Invokes the Lambda function synchronously
        /// 3. Validates the response
        /// 4. Returns the decoded signature bytes
        /// </remarks>
        protected override byte[] SignData(byte[] dataToSign, SignatureSettings settings)
        {
            var requestData = new
            {
                DataToSign = Convert.ToBase64String(dataToSign),
                DigestAlgorithm = settings.DigestAlgorithm.ToString()
            };
 
            string jsonRequest = JsonSerializer.Serialize(requestData, new JsonSerializerOptions
            {
                WriteIndented = true
            });
 
            var invokeRequest = new InvokeRequest
            {
                FunctionName = this.functionName,
                InvocationType = InvocationType.RequestResponse, // synchronous
                Payload = jsonRequest
            };
 
            InvokeResponse invokeResponse = lambdaClient.InvokeAsync(invokeRequest).Result;
 
            if (invokeResponse.StatusCode != 200)
            {
                throw new InvalidOperationException($"Lambda invocation failed with status code: {invokeResponse.StatusCode}");
            }
 
            if (!string.IsNullOrEmpty(invokeResponse.FunctionError))
            {
                string errorMessage = Encoding.UTF8.GetString(invokeResponse.Payload.ToArray());
                throw new InvalidOperationException($"Lambda function error: {invokeResponse.FunctionError}. Details: {errorMessage}");
            }
 
            string jsonResponse = Encoding.UTF8.GetString(invokeResponse.Payload.ToArray());
            string? base64Signature = JsonSerializer.Deserialize<string>(jsonResponse);
 
            if (string.IsNullOrEmpty(base64Signature))
            {
                throw new InvalidOperationException("Invalid response from Lambda function");
            }
 
            return Convert.FromBase64String(base64Signature);
        }
    }
}

9. Run the project.

As a result, the unsigned PDF document is successfully signed:

Wrapping Up

Integrating Telerik Document Processing with Azure Functions and AWS Lambda demonstrates how serverless architectures can transform document workflows. By leveraging cloud scalability and pay-per-use models, organizations can efficiently handle tasks like PDF merging and secure digital signing without maintaining dedicated infrastructure. These approaches not only reduce operational overhead but also enhance security by isolating sensitive keys in the cloud.

As businesses continue to adopt remote and distributed solutions, similar patterns can be extended to other workflows such as document conversion, watermarking and batch processing, unlocking even greater flexibility and cost efficiency. The examples provided serve as a foundation for building robust, cloud-powered document services that scale seamlessly with demand.

Try out the Telerik Document Processing Libraries, which are included in the Telerik DevCraft bundles to pair perfectly with your favorite component libraries.

At its core, the Telerik and Kendo UI 2025 Q4 release is about giving developers, team leads and enterprises a partner they can trust: AI tools that understand the Telerik and Kendo UI libraries inside-out, adapt to their technology stack and meet the standards of enterprise-ready UI application development. These tools don’t ask teams to start from scratch. They’re simply designed to accelerate what you’re already building.

The spotlight of this 2025 Q4 release is the Telerik Agentic UI Generator—a new way to build UI with speed and confidence. Developers can now prompt their way into fully functional pages—complete with layouts, styling, accessibility, needed components and data bindings. It does this from an MCP server that works in any AI-enabled IDE.

The Telerik Agentic UI Generator debuts in Telerik UI for Blazor, KendoReact and Kendo UI for Angular as part of DevCraft Complete or Ultimate subscriptions. The Agentic UI Generator is an evolution of the AI Coding Assistants currently available across all major Telerik and Kendo UI libraries, reporting and document processing tools, giving developers a full productivity stack.

Beyond development acceleration, the 2025 Q4 release empowers teams to continue embedding AI directly into their applications. New and enhanced AI components like the Inline AI Prompt, AI-optimized Chat UI and prompt-driven Data Grid bring natural language control to everyday user scenarios.

AI-driven innovation only delivers value when it’s matched with stability and long-term platform confidence. That’s why Progress continues the tradition of day-zero compatibility with Microsoft’s latest technologies with .NET 10 fully supported at launch.

The 2025 Q4 release introduces AI-driven debugging capabilities in Fiddler Everywhere, too, expanding Progress’ MCP ecosystem beyond UI development. With Fiddler MCP integration, network traffic analysis and debugging data are available directly inside your IDE. Combined with the new Debugging Assistant, Fiddler transforms the debugging journey into a guided, conversational experience that helps resolve issues faster and earlier in the development cycle.

To see the new updates firsthand, don’t forget to sign up for the release webinars:

• Telerik 2025 Q4 Release Webinar: Web, Desktop and Mobile on Dec 3
• Kendo UI 2025 Q4 Release Webinaron Dec 4
• Telerik Reporting and Fiddler 2025 Q4 Release Webinar on Dec 5

Let’s Dive into the 2025 Q4 Highlights

Build and Deliver Faster with Context-Aware AI

• Telerik Agentic UI Generator: Generate pages as quickly as possible with Telerik Agentic UI Generator. Use prompts to assemble layouts, grids, forms and styles based on Telerik and Kendo UI components. Keep your IDE and workflow and code at least 30% faster.
• IDE-integrated AI Coding Assistants: Combined with the Agentic UI Generator, the AI Coding Assistants, currently available across all major Telerik and Kendo UI libraries, deliver context-aware, specialized code so teams can ship faster and do more.
• Prompt-controlled Data Grid: Empower users to effortlessly interact with the Data Grids using natural language, whether through the built-in prompt interface or a unified, app-wide chat experience.
• New Inline AI Prompt: Ideal for enabling in-context interactions such as rewriting content, fixing errors and generating alternatives.
• AI-enhanced Chat UI: This component is redesigned to enable smarter, more natural interactions through streaming responses, text-to-speech, flexible response formats and built-in token tracking.
• Redesigned AI Prompt: All key web UI libraries feature an enhanced AI Prompt that supports a new message template, speech-to-text and streaming buttons, improved accessibility and more.
• Enhanced GenAI-powered report insights: Local embeddings for more conscious, controlled spending and tighter data privacy. Plus, broader viewer support, including WPF Viewer (remote engine), Native Blazor Viewer and Native Angular Viewer now fully supporting GenAI insights.
• Conversational prompts in Progress ThemeBuilder: Refine the AI-generated theme through natural, conversational feedback. Adjust colors, spacing, typography and accessibility in plain language, and see instant updates.
• MCP debugging: With Fiddler MCP integration, network traffic analysis and debugging data are available directly inside your IDE, enabling developers to quickly pinpoint performance bottlenecks, security issues or failed sessions.
• AI demo hub: The new dedicated AI demo hub, showcasing AI-enhanced components and features is available across Telerik and Kendo UI web products.

Embrace Next-Gen Frameworks

• Day-zero support for .NET 10: Continuing day-zero support for Microsoft’s newest frameworks, all Telerik products now feature compatibility with .NET 10.

Streamline Development with New, Interactive Components

• Diagram in Telerik UI for Blazor and Kendo UI for Angular: Map relationships, workflows and structures with customizable shapes, flexible connections and built-in layouts with the new Diagram.
• Chat UI in Telerik UI for Blazor: Elevate user engagement with modern, real-time conversations, connecting people or enabling intelligent interactions through AI-powered chatbots.
• Kendo UI for Angular Form: Easily build and organize complex forms with a structured, configurable layout. Group inputs, dropdowns, labels, hints, error messages and more to deliver clear, consistent and user-friendly forms.
• Speech-To-Text Button: Empower users to convert speech into text with a single click, making it easy to add voice input to forms, search bars, chat interfaces and other interactive scenarios.
• Bottom Sheet and Skeleton controls in Telerik UI for .NET MAUI: Slide up additional content from the bottom of the screen to enhance your app experience with the BottomSheet control. Create a preview of how content is going to be displayed before it is loaded with the Skeleton component.

Unlock Robust Features in Your Favorite Components and Tools

• Stacked data layout mode in Data Grids: Deliver a consistent, user-friendly experience across devices with an adaptive, card-like display optimized for both desktop and mobile.
• Workflow diagram in Telerik UI for ASP.NET Core/MVC and Kendo UI for jQuery: Specialized shape types allow you to represent algorithms, tasks and events. While these shapes are tailored for workflows, they’re versatile enough for any diagram scenario.
• PDF Viewer enhancements: Text highlight, free text annotations and form filling for completing PDF forms directly within your app are added to Kendo UI for Angular. Form filling is also available in Telerik UI for Blazor. AI-powered PDF querying and summarization are now present in Telerik UI for WPF and UI for WinForms.
• Responsive Form layout in Angular and React: Build forms that automatically adapt their columns, spacing and field arrangements across breakpoints to deliver a seamless user experience on any screen size.
• Dark mode in Progress ThemeBuilder: Switch to the new dark mode for a more comfortable experience in lowlight setups.
• Document Processing Libraries (DPL) improvements: DPL continues to expand its AI and file-processing capabilities, giving developers more flexibility and smarter ways to work with documents.
• Debugging Assistant: Fiddler transforms the debugging journey into a guided, conversational experience that helps resolve issues faster and earlier in the development cycle.

What’s New & Release History

To see everything that is new in 2025 Q4, visit the What’s New in Telerik and Kendo UI page. For a deeper dive into each product, follow the links below.

With the recent releases, Progress is helping to shape a new era of developer productivity: AI that behaves less like a tool and more like a teammate. Instead of forcing developers to change their flow to match an AI system, Telerik, Kendo UI and Fiddler delivered AI tools that bring intelligence directly into your environment, components and patterns.

Whether generating full UI layouts, refining code in the moment, debugging network traffic or enabling end users to trigger smart actions through prompt-driven interfaces, these products move beyond traditional AI integration into the realm of agentic, embedded collaboration.

At its core, the 2025 Q4 release on November 19 is about giving developers, team leads and enterprises a partner they can trust: AI tools that understand Telerik and Kendo UI inside-out, adapt to their technology stack and meet the standards of enterprise-ready UI application development. These tools don’t ask teams to start from scratch. They’re simply designed to accelerate what you’re already building.

The flagship innovation of this 2025 Q4 release is the Telerik Agentic UI Generator*—a new way to build UI with speed and confidence. Developers can now prompt their way into fully functional pages—complete with layouts, styling, accessibility, needed components and data bindings. It does this from an MCP server that works in any AI-enabled IDE.

* The Telerik Agentic UI Generator debuts in Telerik UI for Blazor, KendoReact and Kendo UI for Angular as part of DevCraft Complete or Ultimate subscriptions.

The Agentic UI Generator is an evolution of the AI Coding Assistants currently available across all major Telerik and Kendo UI libraries, reporting and document processing tools, giving developers a full productivity stack. Developers using the early versions of the AI Coding Assistants have reported an average of 30% time savings, and this innovation should go even further.

Beyond development acceleration, the 2025 Q4 release empowers teams to continue embedding AI directly into their applications. New and enhanced AI components like the Inline AI Prompt, AI-optimized Chat UI and prompt-driven Data Grid bring natural language control to everyday user scenarios. Instead of clicking through multiple panels or configuring complex filters manually, users can simply ask: “Show me all orders processed last month” or “Highlight anything above threshold.” This is not AI for novelty; it’s AI applied with purpose, enhancing the way both developers and end users interact with applications built on Telerik and Kendo UI.

AI-driven innovation only delivers value when it’s matched with stability and long-term platform confidence. That’s why Progress continues the tradition of day-zero compatibility with Microsoft’s latest technologies with .NET 10 fully supported at launch.

Rounding out the productivity story, the 2025 Q4 release introduces AI-driven debugging capabilities in Fiddler Everywhere, expanding Progress’ MCP ecosystem beyond UI development. With Fiddler MCP integration, network traffic analysis and debugging data are available directly inside your IDE, enabling developers to quickly pinpoint performance bottlenecks, security issues or failed sessions. Combined with the new Debugging Assistant, Fiddler transforms the debugging journey into a guided, conversational experience that helps resolve issues faster and earlier in the development cycle.

Save Your Seat for the Webinars!

Find out what’s new in your favorite UI component libraries, reporting and debugging tools by joining our webinars!

Find the details and specific per product highlights in the webinar pages linked below. You can register for more than one webinar.

Progress Telerik .NET Web, Desktop and Mobile 2025 Q4 Release Webinar | December 3

Discover all updates across Telerik UI for Blazor, UI for ASP.NET Core, UI for ASP.NET MVC, UI for ASP.NET AJAX, UI for WPF, UI for WinForms, UI for .NET MAUI and ThemeBuilder. Tune in 11:00 a.m.–1:00 p.m. ET on Wednesday, June 3.

Save Your Seat

Progress Kendo UI 2025 Q4 Release Webinar | December 4

Discover all updates across KendoReact and Kendo UI for Angular, Vue and jQuery, as well as ThemeBuilder. Tune in 11:00 a.m.–1:00 p.m. ET on Thursday, December 4.

Save Your Seat

Progress Telerik Reporting and Fiddler 2025 Q4 Release Webinar | December 5

Discover all updates across Telerik Reporting, Report Server and Fiddler Everywhere. Tune in 11:00 a.m.–1:00 p.m. ET Friday, December 5.

Save Your Seat

And the Best Part About the Release Webinars?

The live webinars are a great opportunity for you to ask questions of the team. We’ll be waiting to hear from you on X—just use the #heyTelerik and #heyKendoUI hashtags before and during the webinars.

Sign up today to make sure you don’t miss these great events with our experienced developer advocates and experts:

• Ed Charbeneau, Microsoft MVP, international speaker, writer, online influencer, Developer Advocate with a passion for .NET
• Alyssa Nicoll, Google Developer Expert and Angular Developer Advocate
• Kathryn Grayson Nanz, Developer Advocate with a passion for React, UI and design
• Rick Hellwege, Principal Sales Engineer, reporting guru and innovator with a passion for experimenting with the latest technologies and frameworks

Can’t wait to see you soon!