azure-search-documents-dotnet

SEARCH_ENDPOINT=https:// .search.windows.net # Required: search service endpoint
SEARCH_INDEX_NAME= # Required: search index name
AZURE_TOKEN_CREDENTIALS=prod # Required only if DefaultAzureCredential is used in production
SEARCH_API_KEY= # Only required for AzureKeyCredential auth

using Azure.Identity;
using Azure.Search.Documents;

// Local dev: DefaultAzureCredential. Production: set AZURE_TOKEN_CREDENTIALS=prod or AZURE_TOKEN_CREDENTIALS= 
var credential = new DefaultAzureCredential(
 DefaultAzureCredential.DefaultEnvironmentVariableName
);
// Or use a specific credential directly in production:
// See https://learn.microsoft.com/dotnet/api/overview/azure/identity-readme?view=azure-dotnet#credential-classes
// var credential = new ManagedIdentityCredential();
var client = new SearchClient(
 new Uri(Environment.GetEnvironmentVariable("SEARCH_ENDPOINT")),
 Environment.GetEnvironmentVariable("SEARCH_INDEX_NAME"),
 credential);

using Azure;
using Azure.Search.Documents;

var credential = new AzureKeyCredential(
 Environment.GetEnvironmentVariable("SEARCH_API_KEY"));
var client = new SearchClient(
 new Uri(Environment.GetEnvironmentVariable("SEARCH_ENDPOINT")),
 Environment.GetEnvironmentVariable("SEARCH_INDEX_NAME"),
 credential);

using Azure.Search.Documents.Indexes;
using Azure.Search.Documents.Indexes.Models;

// Define model with attributes
public class Hotel
{
 [SimpleField(IsKey = true, IsFilterable = true)]
 public string HotelId { get; set; }

 [SearchableField(IsSortable = true)]
 public string HotelName { get; set; }

 [SearchableField(AnalyzerName = LexicalAnalyzerName.EnLucene)]
 public string Description { get; set; }

 [SimpleField(IsFilterable = true, IsSortable = true, IsFacetable = true)]
 public double? Rating { get; set; }

 [VectorSearchField(VectorSearchDimensions = 1536, VectorSearchProfileName = "vector-profile")]
 public ReadOnlyMemory ? DescriptionVector { get; set; }
}

// Create index
var indexClient = new SearchIndexClient(endpoint, credential);
var fieldBuilder = new FieldBuilder();
var fields = fieldBuilder.Build(typeof(Hotel));

var index = new SearchIndex("hotels")
{
 Fields = fields,
 VectorSearch = new VectorSearch
 {
 Profiles = { new VectorSearchProfile("vector-profile", "hnsw-algo") },
 Algorithms = { new HnswAlgorithmConfiguration("hnsw-algo") }
 }
};

await indexClient.CreateOrUpdateIndexAsync(index);

var index = new SearchIndex("hotels")
{
 Fields =
 {
 new SimpleField("hotelId", SearchFieldDataType.String) { IsKey = true, IsFilterable = true },
 new SearchableField("hotelName") { IsSortable = true },
 new SearchableField("description") { AnalyzerName = LexicalAnalyzerName.EnLucene },
 new SimpleField("rating", SearchFieldDataType.Double) { IsFilterable = true, IsSortable = true },
 new SearchField("descriptionVector", SearchFieldDataType.Collection(SearchFieldDataType.Single))
 {
 VectorSearchDimensions = 1536,
 VectorSearchProfileName = "vector-profile"
 }
 }
};

var searchClient = new SearchClient(endpoint, indexName, credential);

// Upload (add new)
var hotels = new[] { new Hotel { HotelId = "1", HotelName = "Hotel A" } };
await searchClient.UploadDocumentsAsync(hotels);

// Merge (update existing)
await searchClient.MergeDocumentsAsync(hotels);

// Merge or Upload (upsert)
await searchClient.MergeOrUploadDocumentsAsync(hotels);

// Delete
await searchClient.DeleteDocumentsAsync("hotelId", new[] { "1", "2" });

// Batch operations
var batch = IndexDocumentsBatch.Create(
 IndexDocumentsAction.Upload(hotel1),
 IndexDocumentsAction.Merge(hotel2),
 IndexDocumentsAction.Delete(hotel3));
await searchClient.IndexDocumentsAsync(batch);

var options = new SearchOptions
{
 Filter = "rating ge 4",
 OrderBy = { "rating desc" },
 Select = { "hotelId", "hotelName", "rating" },
 Size = 10,
 Skip = 0,
 IncludeTotalCount = true
};

SearchResults results = await searchClient.SearchAsync ("luxury", options);

Console.WriteLine($"Total: {results.TotalCount}");
await foreach (SearchResult result in results.GetResultsAsync())
{
 Console.WriteLine($"{result.Document.HotelName} (Score: {result.Score})");
}

var options = new SearchOptions
{
 Facets = { "rating,count:5", "category" }
};

var results = await searchClient.SearchAsync ("*", options);

foreach (var facet in results.Value.Facets["rating"])
{
 Console.WriteLine($"Rating {facet.Value}: {facet.Count}");
}

// Autocomplete
var autocompleteOptions = new AutocompleteOptions { Mode = AutocompleteMode.OneTermWithContext };
var autocomplete = await searchClient.AutocompleteAsync("lux", "suggester-name", autocompleteOptions);

// Suggestions
var suggestOptions = new SuggestOptions { UseFuzzyMatching = true };
var suggestions = await searchClient.SuggestAsync ("lux", "suggester-name", suggestOptions);

using Azure.Search.Documents.Models;

// Pure vector search
var vectorQuery = new VectorizedQuery(embedding)
{
 KNearestNeighborsCount = 5,
 Fields = { "descriptionVector" }
};

var options = new SearchOptions
{
 VectorSearch = new VectorSearchOptions
 {
 Queries = { vectorQuery }
 }
};

var results = await searchClient.SearchAsync (null, options);

var options = new SearchOptions
{
 QueryType = SearchQueryType.Semantic,
 SemanticSearch = new SemanticSearchOptions
 {
 SemanticConfigurationName = "my-semantic-config",
 QueryCaption = new QueryCaption(QueryCaptionType.Extractive),
 QueryAnswer = new QueryAnswer(QueryAnswerType.Extractive)
 }
};

var results = await searchClient.SearchAsync ("best hotel for families", options);

// Access semantic answers
foreach (var answer in results.Value.SemanticSearch.Answers)
{
 Console.WriteLine($"Answer: {answer.Text} (Score: {answer.Score})");
}

// Access captions
await foreach (var result in results.Value.GetResultsAsync())
{
 var caption = result.SemanticSearch?.Captions?.FirstOrDefault();
 Console.WriteLine($"Caption: {caption?.Text}");
}

var vectorQuery = new VectorizedQuery(embedding)
{
 KNearestNeighborsCount = 5,
 Fields = { "descriptionVector" }
};

var options = new SearchOptions
{
 QueryType = SearchQueryType.Semantic,
 SemanticSearch = new SemanticSearchOptions
 {
 SemanticConfigurationName = "my-semantic-config"
 },
 VectorSearch = new VectorSearchOptions
 {
 Queries = { vectorQuery }
 }
};

// Combines keyword search, vector search, and semantic ranking
var results = await searchClient.SearchAsync ("luxury beachfront", options);

using Azure;

try
{
 var results = await searchClient.SearchAsync ("query");
}
catch (RequestFailedException ex) when (ex.Status == 404)
{
 Console.WriteLine("Index not found");
}
catch (RequestFailedException ex)
{
 Console.WriteLine($"Search error: {ex.Status} - {ex.ErrorCode}: {ex.Message}");
}