Chat with Your Own Data

• Oct 10, 2025
• 3 minutes to read

When integrating the AI Chat Control with the OpenAI Assistant API, you can configure it to retain and reference a specific context (for example, a text file or a PDF document). By providing a supplementary document as a context source, the assistant is primed with background information. OpenAI automatically parses the document and searches through it to retrieve relevant content to better respond to user queries.

1. Install the DevExpress.AIIntegration.OpenAI NuGet package.

2. Create an assistant.

   using OpenAI;
   using OpenAI.Assistants;
   using OpenAI.Files;
   using System.IO;
   using System.ClientModel;
   using System.Threading.Tasks;
   using System.Threading;
   using System;
   
   #pragma warning disable OPENAI001
   public class OpenAIAssistantCreator {
       readonly AssistantClient assistantClient;
       readonly OpenAIFileClient fileClient;
       readonly string deployment;
   
       public OpenAIAssistantCreator(OpenAIClient client, string deployment) {
           assistantClient = client.GetAssistantClient();
           fileClient = client.GetOpenAIFileClient();
           this.deployment = deployment;
       }
   
       public async Task<string> CreateAssistantAsync(
               Stream data,
               string fileName,
               string instructions,
               bool useFileSearchTool = true,
               CancellationToken ct = default) {
   
           data.Position = 0;
   
           ClientResult<OpenAIFile> fileResponse = await fileClient.UploadFileAsync(data, fileName, FileUploadPurpose.Assistants, ct);
           OpenAIFile file = fileResponse.Value;
   
           var resources = new ToolResources() {
               CodeInterpreter = new CodeInterpreterToolResources(),
               FileSearch = useFileSearchTool ? new FileSearchToolResources() : null
           };
           resources.FileSearch?.NewVectorStores.Add(new VectorStoreCreationHelper([file.Id]));
           resources.CodeInterpreter.FileIds.Add(file.Id);
   
           AssistantCreationOptions assistantCreationOptions = new AssistantCreationOptions() {
               Name = Guid.NewGuid().ToString(),
               Instructions = instructions,
               ToolResources = resources
           };
   
           assistantCreationOptions.Tools.Add(new CodeInterpreterToolDefinition());
           if (useFileSearchTool) {
               assistantCreationOptions.Tools.Add(new FileSearchToolDefinition());
           }
   
           ClientResult<Assistant> assistantResponse = await assistantClient.CreateAssistantAsync(deployment, assistantCreationOptions, ct);
           Assistant assistant = assistantResponse.Value;
   
           return assistant.Id;
       }
   }
   #pragma warning restore OPENAI001
   

   Warning

   OpenAI.OpenAIClient API is for evaluation purposes only and is subject to change or removal in future updates. The code snippet suppresses the OPENAI001 diagnostic.

3. Register the OpenAI Assistant service in the App.xaml.cs file:

   using DevExpress.AIIntegration;
   using DevExpress.Xpf.Core;
   using Microsoft.Extensions.AI;
   using System.ClientModel;
   using System.Windows;
   using System;
   
   namespace DXChatApplication {
       /// <summary>
       /// Interaction logic for App.xaml
       /// </summary>
       public partial class App : Application {
           static App() {
               CompatibilitySettings.UseLightweightThemes = true;
           }
   
           protected override void OnStartup(StartupEventArgs e) {
               base.OnStartup(e);
               ApplicationThemeHelper.ApplicationThemeName = "Win11Light";
   
               var azureOpenAiClient = new Azure.AI.OpenAI.AzureOpenAIClient(AzureOpenAIEndpoint, AzureOpenAIKey);
   
               var container = AIExtensionsContainerDesktop.Default;
               container.RegisterChatClient(azureOpenAiClient.GetChatClient(ModelId).AsIChatClient());
               container.RegisterOpenAIAssistants(azureOpenAiClient, ModelId); // For example, ModelId = "gpt-4o-mini"
   
               var mainWindow = new MainWindow(new OpenAIAssistantCreator(azureOpenAiClient, ModelId));
               mainWindow.Show();
           }
   
           static string AzureOpenAIEndpoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT");
           static string AzureOpenAIKey = Environment.GetEnvironmentVariable("AZURE_OPENAI_APIKEY");
           static string ModelID = "gpt-4o-mini";
       }
   }
   

   Note

   Availability of Azure Open AI Assistants depends on the region. See the following article for more information: Assistants (Preview).

   4. Handle the Initialized event with an async handler. Call the e.SetupAssistantAsync method to supply Open AI Assistant identifier:

      XAML

      <dx:ThemedWindow 
          x:Class="DXApplication3.MainWindow"
          xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
          xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
          xmlns:dx="http://schemas.devexpress.com/winfx/2008/xaml/core" 
          xmlns:dxaichat="http://schemas.devexpress.com/winfx/2008/xaml/aichat"
          Title="MainWindow" Height="800" Width="1000">
          <Grid>
              <dxaichat:AIChatControl
                  x:Name="aiChatControl"
                  Initialized="AiChatControl_Initialized"
                  ContentFormat="Markdown"
                  MarkdownConvert="aiChatControl_MarkdownConvert"
                  HorizontalAlignment="Stretch" 
                  VerticalAlignment="Stretch" 
                  Margin="10">
              </dxaichat:AIChatControl>
          </Grid>
      </dx:ThemedWindow>
      

      using DevExpress.AIIntegration.Blazor.Chat.WebView;
      using Markdig;
      using Microsoft.AspNetCore.Components;
      using System.IO;
      
      namespace DXChatApplication {
          public partial class MainWindow {
              FileStream dataStream;
              readonly OpenAIAssistantCreator _openAIAssistantCreator;
              public MainWindow(OpenAIAssistantCreator openAIAssistantCreator) {
                  InitializeComponent();
                  _openAIAssistantCreator = openAIAssistantCreator;
                  dataStream = File.OpenRead(@"RestaurantMenu.pdf");
              }
      
              async void aiChatControl_Initialized(object sender, AIChatControlInitializedEventArgs e) {
                  string fileName = "RestaurantMenu.pdf";
                  string prompt = "You are an Analyst Assistant specializing in PDF file analysis. Your role is to assist users by providing accurate answers to their questions about data contained in these files.";
                  string assistantID = await _openAIAssistantCreator.CreateAssistantAsync(dataStream, fileName, prompt);
                  await e.SetupAssistantAsync(assistantID);
              }
      
              void aiChatControl_MarkdownConvert(object sender, AIChatControlMarkdownConvertEventArgs e) {
                  e.HtmlText = (MarkupString)Markdown.ToHtml(e.MarkdownText);
              }
          }
      }
      

The following screenshot shows the result:

Tip

The AI Chat Control does not render citation references as clickable links. These references appear as plain text (for example, [6:2†source]) in the output. To remove citation references from the AI response before display, handle the AI Chat Control’s MarkdownConvert event:

using Markdig;
using System.Text.RegularExpressions;

void AiChatControl1_MarkdownConvert(object sender, AIChatControlMarkdownConvertEventArgs e) {
    string output = ClearCitationReferences(e.MarkdownText);
    e.HtmlText = (MarkupString)Markdown.ToHtml(output);
}

string ClearCitationReferences(string text) {
    return Regex.Replace(text, @"\【.*?】", "");
}