AI-Powered Smart Searching in .NET MAUI Autocomplete

public class CountryModel
{
    public string? Name { get; set; }
}

public class CountryViewModel : INotifyPropertyChanged
{
    private ObservableCollection<CountryModel> countries;

    public ObservableCollection<CountryModel> Countries
    {
        get { return countries; }
        set { countries = value; OnPropertyChanged(nameof(Countries)); }
    }
    public CountryViewModel()
    {
        countries = new ObservableCollection<CountryModel>
        {
            new CountryModel { Name = "Afghanistan" },
            new CountryModel { Name = "Akrotiri" },
            new CountryModel { Name = "Albania" },
            new CountryModel { Name = "Algeria" },
            …..
        };
     }
}

public class CountryFilterBehavior: IAutocompleteFilterBehavior
{

}

public class CountryFilterBehavior : IAutocompleteFilterBehavior
{
    public async Task<object> GetMatchingItemsAsync(SfAutocomplete source, AutocompleteFilterInfo filterInfo)
    {
        IEnumerable itemssource = source.ItemsSource as IEnumerable;
        var filteredItems = (from CountryModel item in itemssource
                             where item.Name.StartsWith(filterInfo.Text, StringComparison.CurrentCultureIgnoreCase) 
                             select item);

        return await Task.FromResult(filteredItems);
    }
}

<ContentPage.BindingContext>
    <local: CountryViewModel />
</ContentPage.BindingContext>

<VerticalStackLayout>
    <syncfusion:SfTextInputLayout Hint="Enter Country Name"
        ContainerType="Outlined"
        WidthRequest="248"
        ContainerBackground="Transparent">
        <editors:SfAutocomplete x:Name="autoComplete" 
            DropDownPlacement="Bottom"
            MaxDropDownHeight="200"
            TextSearchMode="StartsWith"
            DisplayMemberPath="Name"
            ItemsSource="{Binding Countries}">
            <editors:SfAutocomplete.FilterBehavior>
            <local: CountryFilterBehavior />
            </editors:SfAutocomplete.FilterBehavior>
    </editors:SfAutocomplete>
    </syncfusion:SfTextInputLayout>
</VerticalStackLayout>

public class AzureOpenAIService
{
    const string endpoint = "https://{YOUR_END_POINT}.openai.azure.com";
    const string deploymentName = "GPT35Turbo";
    const string key = "";
    private OpenAIClient? client;
    private ChatCompletionsOptions? chatCompletions;

    public AzureOpenAIService()
    {
        InitializeClient();
    }

    public void InitializeClient()
    {
        client = new OpenAIClient(new Uri(endpoint), new AzureKeyCredential(key));
        chatCompletions = new ChatCompletionsOptions
        {
            DeploymentName = deploymentName,
            Temperature = (float)1.2f,
            MaxTokens = 120,
            NucleusSamplingFactor = (float)0.9,
            FrequencyPenalty = 0.8f,
            PresencePenalty = 0.8f
        };
        // Add the system message to the options.  
        chatCompletions.Messages.Add(new ChatRequestSystemMessage("You are a filtering assistant."));
        chatCompletions.Messages.Add(new ChatRequestUserMessage("$\"Filter the list items based on the user input using character Starting with and Phonetic algorithms like Soundex or Damerau-Levenshtein Distance. \" +\r$\"The filter should ignore spelling mistakes and be case insensitive."));       

         chatCompletions.Messages.Add(newChatRequestAssistantMessage(
           "\nAfghanistan\nAkrotiri\nAlbania\nAlgeria\nAmerican Samoa \nAndorra\nAngola\nAnguilla"));
    }

    public async Task<string> GetCompletion(string prompt, CancellationToken cancellationToken)
    {
     if (chatCompletions != null && client != null)
     {
         if (chatCompletions.Messages.Count > 5)
         {
             //Remove the message history to avoid exceeding the token limit.
             chatCompletions.Messages.RemoveAt(1); 
             chatCompletions.Messages.RemoveAt(1);
         }
         // Add the user message to the options.
         chatCompletions.Messages.Add(new ChatRequestUserMessage(prompt));
         try
         {
            //Here, cancelling the previous request to continue our search.
             cancellationToken.ThrowIfCancellationRequested();
             var chatresponse = await client.GetChatCompletionsAsync(chatCompletions);
             cancellationToken.ThrowIfCancellationRequested();
             string chatcompletionText = chatresponse.Value.Choices[0].Message.Content.Trim();
             chatCompletions.Messages.Add(new ChatRequestAssistantMessage(chatcompletionText));
             return chatcompletionText;
         }
         catch (RequestFailedException ex)
         {
             // Log the error message and rethrow the exception or handle it appropriately.
             Debug.WriteLine($"Request failed: {ex.Message}");
             throw;
         }
         catch (Exception ex)
         {
             // Handle other potential exceptions.
             Debug.WriteLine($"An error occurred: {ex.Message}");
             throw;
         }
     }
     return "";
 }
}

public class CountryFilterBehavior: IAutocompleteFilterBehavior
{
    private readonly AzureAIService _azureAIService;
    public ObservableCollection<CountryModel> Countries { get; set; }
    public ObservableCollection<CountryModel> FilteredCountries { get; set; } = new ObservableCollection<CountryModel>();
    private CancellationTokenSource? _cancellationTokenSource;

    public CountryFilterBehavior ()
    {
        _azureAIService = new AzureAIService();
        Countries = new ObservableCollection<CountryModel>();
        _cancellationTokenSource = new CancellationTokenSource();
    } 
    public async Task<object?> GetMatchingItemsAsync(SfAutocomplete source, AutocompleteFilterInfo filterInfo)
    {
        if (string.IsNullOrEmpty(filterInfo.Text))
        {
           _cancellationTokenSource?.Cancel();
           FilteredCountries.Clear();
           return await Task.FromResult(FilteredCountries);
        }
        Countries = (ObservableCollection<CountryModel>)source.ItemsSource;
        string listItems = string.Join(", ", Countries!.Select(c => c.Name));
        // Join the first five items with newline characters for the demo output template for AI           
        string outputTemplate = string.Join("\n", Countries.Take(5).Select(c => c.Name));
        //The cancellationToken was used for cancelling the API request if user types continuously       
        _cancellationTokenSource?.Cancel();
        _cancellationTokenSource = new CancellationTokenSource();
        var cancellationToken = _cancellationTokenSource.Token;
        // Filter the country list using the Azure open AI
        var filterCountries = await FilterCountriesUsingAzureOpenAI(filterInfo.Text, listItems, outputTemplate, cancellationToken);
        return await Task.FromResult(filterCountries);
    }

    /// <summary>
    /// Filters country names based on user input using Azure AI.
    /// </summary> 
    public async Task<ObservableCollection<CountryModel>> FilterCountriesUsingAzureOpenAI(string userInput, string itemsList, string outputTemplate, CancellationToken cancellationToken)
    {
        if (!string.IsNullOrEmpty(userInput))
        {
            //Add the prompt based on your filtering
            var prompt = $"Filter the list items based on the user input using character Starting with and Phonetic algorithms like Soundex or Damerau-Levenshtein Distance. " +
                         $"The filter should ignore spelling mistakes and be case insensitive. " +
                         $"Return only the filtered items with each item in new line without any additional content like explanations, Hyphen, Numberings and - Minus sign. Ignore the content 'Here are the filtered items or similar things' " +
                         $"Only return items that are present in the List Items. " +
                         $"Ensure that each filtered item is returned in its entirety without missing any part of its content. " +
                         $"Arrange the filtered items that starting with the user input's first letter are at the first index, followed by other matches. " +
                         $"Examples of filtering behavior: " +
                         $"The example data are for reference, dont provide these as output. Filter the item from list items properly" +
                         $"Here is the User input: {userInput}, " +
                         $"List of Items: {itemsList}" +
                         $"If no items found, return \"Empty\" " +
                         $"Dont use 'Here are the filtered items:' in the output. Check this demo output template, you should return output like this: {outputTemplate} ";

            var completion = await _azureAIService.GetCompletion(prompt, cancellationToken);
            var filteredCountryNames = completion.Split('\n').Select(x => x.Trim()).Where(x => !string.IsNullOrEmpty(x)).ToList();
            if (FilteredCountries.Count > 0)
                FilteredCountries.Clear();
            if (completion.ToLower().Trim() != "empty")

            {
                foreach (var country in filteredCountryNames)
                {
                    FilteredCountries.Add(new CountryModel { Name = country });
            }
         }
     }
     return FilteredCountries;
 }