Module 9: Advanced Querying - Code Samples

This directory contains comprehensive code samples demonstrating advanced querying techniques in Azure AI Search, including complex query patterns, boosting strategies, fuzzy search, wildcard matching, and relevance tuning.

Overview

Advanced querying in Azure AI Search goes beyond basic text search to provide sophisticated relevance control, intelligent matching, and optimized performance. These code samples demonstrate how to implement production-ready advanced search features.

Directory Structure

code-samples/
├── notebooks/                          # Jupyter notebooks for interactive learning
│   ├── 01_advanced_query_syntax.ipynb  # ✅ Complete Interactive Tutorial
│   └── README.md                       # ✅ Notebook Documentation
├── rest/                               # REST API examples (Complete - 6 files)
│   ├── 01_complex_queries.http         # ✅ Advanced query patterns
│   ├── 02_boosting_strategies.http     # ✅ Boosting techniques
│   ├── 03_fuzzy_wildcard_search.http   # ✅ Fuzzy and wildcard examples
│   ├── 04_proximity_search.http        # ✅ Proximity search patterns
│   ├── 05_scoring_profiles.http         # ✅ Scoring profile usage
│   └── 06_suggestions_autocomplete.http # ✅ Suggestions and autocomplete
├── javascript/                         # JavaScript/Node.js SDK examples (Complete - 6 files)
│   ├── 01_complex_queries.js           # ✅ Complex query construction
│   ├── 02_boosting_strategies.js       # ✅ Boosting implementations
│   ├── 03_fuzzy_wildcard_search.js     # ✅ Fuzzy and wildcard search
│   ├── 04_proximity_search.js          # ✅ Proximity search techniques
│   ├── 05_scoring_profiles.js          # ✅ Scoring profile management
│   └── 06_suggestions_autocomplete.js  # ✅ Suggestions and autocomplete
├── csharp/                             # C# SDK examples (Complete - 6 files + README)
│   ├── 01_ComplexQueries.cs            # ✅ Advanced query construction
│   ├── 02_BoostingStrategies.cs        # ✅ Boosting strategy implementations
│   ├── 03_FuzzyWildcardSearch.cs       # ✅ Fuzzy and wildcard search (Simplified)
│   ├── 04_ProximitySearch.cs           # ✅ Proximity search techniques (Simplified)
│   ├── 05_ScoringProfiles.cs           # ✅ Scoring profile management (Simplified)
│   ├── 06_SuggestionsAutocomplete.cs   # ✅ Suggestions and autocomplete (Simplified)
│   └── README.md                       # ✅ C# Implementation Guide
├── python/                             # Python SDK examples (Complete - 6 files)
│   ├── 01_complex_queries.py           # ✅ Advanced query construction
│   ├── 02_boosting_strategies.py       # ✅ Boosting strategy implementations
│   ├── 03_fuzzy_wildcard_search.py     # ✅ Fuzzy and wildcard search
│   ├── 04_proximity_search.py          # ✅ Proximity search techniques
│   ├── 05_scoring_profiles.py          # ✅ Scoring profile management
│   └── 06_suggestions_autocomplete.py  # ✅ Suggestions and autocomplete
└── README.md                           # This file

Status: This module now provides COMPLETE coverage across all major languages and platforms with 25+ working code files.

Prerequisites

Before running these samples, ensure you have:

1. Azure AI Search Service
2. Standard tier or higher (for advanced features)
3. Admin API key for management operations

4. Query API key for search operations

5. Sample Data

6. Rich content index with multiple searchable fields
7. Configured suggesters for autocomplete functionality

8. Scoring profiles defined in index schema

9. Development Environment

10. For notebooks: Jupyter, Python 3.8+, required packages
11. For REST: VS Code with REST Client extension or Postman
12. For C#: .NET 6.0+, Azure.Search.Documents NuGet package
13. For JavaScript: Node.js 14+, @azure/search-documents npm package
14. For Python: Python 3.8+, azure-search-documents package

Configuration

Update the following configuration values in each sample:

SEARCH_SERVICE_NAME = "your-search-service-name"
SEARCH_API_KEY = "your-admin-or-query-api-key"
INDEX_NAME = "your-index-name"
API_VERSION = "2024-07-01"

Sample Categories

1. Complex Queries

Purpose: Demonstrate advanced query construction using full Lucene syntax.

Features Demonstrated: - Field-specific searches with boolean logic - Nested query expressions with proper precedence - Multi-field queries with different importance levels - Query validation and error handling

Files: - notebooks/01_advanced_query_syntax.ipynb ✅ - rest/01_complex_queries.http ✅ - javascript/01_complex_queries.js ✅ - csharp/01_ComplexQueries.cs ✅ - python/01_complex_queries.py ✅

2. Boosting Strategies

Purpose: Implement various boosting techniques for relevance improvement.

Features Demonstrated: - Term and phrase boosting with appropriate weights - Field-specific boosting strategies - Dynamic boost calculation based on content analysis - A/B testing framework for boost optimization

Files: - rest/02_boosting_strategies.http ✅ - javascript/02_boosting_strategies.js ✅ - csharp/02_BoostingStrategies.cs ✅ - python/02_boosting_strategies.py ✅

3. Fuzzy and Wildcard Search

Purpose: Handle approximate matching and pattern-based searches.

Features Demonstrated: - Fuzzy search with intelligent edit distance selection - Wildcard patterns for prefix and suffix matching - Hybrid exact and fuzzy search strategies - Performance optimization for wildcard queries

Files: - rest/03_fuzzy_wildcard_search.http ✅ - javascript/03_fuzzy_wildcard_search.js ✅ - csharp/03_FuzzyWildcardSearch.cs ✅ - python/03_fuzzy_wildcard_search.py ✅

4. Proximity Search

Purpose: Find related terms within specified distances.

Features Demonstrated: - Proximity search with variable distances - Combining exact phrases with proximity matching - Context-aware proximity distance selection - Performance analysis of proximity queries

Files: - rest/04_proximity_search.http ✅ - javascript/04_proximity_search.js ✅ - csharp/04_ProximitySearch.cs ✅ - python/04_proximity_search.py ✅

5. Scoring Profiles

Purpose: Implement custom relevance algorithms with scoring profiles.

Features Demonstrated: - Field weight configuration and optimization - Freshness functions for time-based boosting - Magnitude functions for popularity boosting - Combined scoring strategies for complex scenarios

Files: - rest/05_scoring_profiles.http ✅ - javascript/05_scoring_profiles.js ✅ - csharp/05_ScoringProfiles.cs ✅ - python/05_scoring_profiles.py ✅

6. Suggestions and Autocomplete

Purpose: Build intelligent suggestion and autocomplete systems.

Features Demonstrated: - Suggester configuration and optimization - Real-time autocomplete with fallback mechanisms - Suggestion ranking and filtering - Performance optimization for suggestion queries

Files: - rest/06_suggestions_autocomplete.http ✅ - javascript/06_suggestions_autocomplete.js ✅ - csharp/06_SuggestionsAutocomplete.cs ✅ - python/06_suggestions_autocomplete.py ✅

Quick Start Guide

1. Using Jupyter Notebooks (Recommended for Learning)

# Install required packages
pip install azure-search-documents pandas matplotlib jupyter

# Start Jupyter
jupyter notebook

# Open and run the available notebook:
# 1. 01_advanced_query_syntax.ipynb - Comprehensive interactive tutorial

2. Using REST API

# Install VS Code REST Client extension
# Open .http files in VS Code
# Update configuration variables
# Execute requests using Ctrl+Alt+R (or Cmd+Alt+R on Mac)

3. Using C# SDK

# Create new console application
dotnet new console -n AdvancedQueryingSamples
cd AdvancedQueryingSamples

# Add required packages
dotnet add package Azure.Search.Documents

# Copy sample code and update configuration
# Run the application
dotnet run

4. Using JavaScript SDK

# Initialize Node.js project
npm init -y

# Install required packages
npm install @azure/search-documents

# Copy sample code and update configuration
# Run the application
node 01_complex_queries.js

5. Using Python SDK (Complete Implementation)

# Install required packages
pip install azure-search-documents

# Run individual samples:
python 01_complex_queries.py --demo
python 02_boosting_strategies.py --demo
python 03_fuzzy_wildcard_search.py --demo
python 04_proximity_search.py --demo
python 05_scoring_profiles.py --demo
python 06_suggestions_autocomplete.py --demo

# Or run with specific parameters:
python 01_complex_queries.py --query "machine learning" --validate
python 02_boosting_strategies.py --search "AI" --compare

Key Features by Sample

Complete Feature Coverage Matrix

Feature Category	Notebook	REST	JavaScript	C#	Python	Status
Complex Queries	✅	✅	✅	✅	✅	Complete
Boosting Strategies	✅	✅	✅	✅	✅	Complete
Fuzzy & Wildcard Search	✅	✅	✅	✅	✅	Complete
Proximity Search	✅	✅	✅	✅	✅	Complete
Scoring Profiles	✅	✅	✅	✅	✅	Complete
Suggestions & Autocomplete	✅	✅	✅	✅	✅	Complete

Detailed Feature Implementation

Core Features (All Languages)

• Field-Specific Search - Target specific fields with strategic boosting
• Boolean Logic - Complex AND/OR/NOT expressions with proper precedence
• Query Validation - Syntax validation and error handling
• Performance Analysis - Query timing and optimization tools

Advanced Features (All Languages)

• Term & Phrase Boosting - Individual term and phrase weight adjustment
• Field Boosting - Different weights for different fields
• Dynamic Boosting - Runtime boost calculation based on content analysis
• Fuzzy Search - Approximate string matching with intelligent edit distance
• Wildcard Patterns - Prefix/suffix matching with performance optimization
• Proximity Search - Context-aware term distance matching
• Scoring Profiles - Custom relevance algorithms with field weights and functions
• Suggestions & Autocomplete - Intelligent suggestion systems with caching and ranking

Best Practices

1. Query Construction

1. Start Simple - Begin with basic queries and add complexity gradually
2. Use Field Targeting - Limit searches to relevant fields for better performance
3. Apply Appropriate Boosting - Use moderate boost values (1.5-3.0) for most cases
4. Test Query Performance - Monitor execution times and optimize as needed
5. Validate Syntax - Implement proper error handling for query syntax issues

2. Fuzzy and Wildcard Usage

1. Limit Edit Distance - Use edit distance 1-2 for fuzzy search
2. Prefer Suffix Wildcards - Trailing wildcards (*term) are more efficient
3. Combine Strategies - Use exact matches with fuzzy fallbacks
4. Monitor Performance - Wildcard queries can be resource-intensive
5. Field Restrictions - Limit wildcard searches to specific fields

3. Scoring and Relevance

1. Balance Field Weights - Avoid extreme weight differences
2. Test Scoring Profiles - Use A/B testing to validate improvements
3. Monitor User Behavior - Track click-through rates and user satisfaction
4. Iterate and Optimize - Continuously refine based on usage patterns
5. Document Decisions - Keep records of scoring profile changes

4. Performance Optimization

1. Cache Common Queries - Implement intelligent caching strategies
2. Limit Result Sets - Use appropriate top values and field selection
3. Monitor Query Times - Set up alerting for slow queries
4. Optimize Index Design - Ensure proper field configuration
5. Use Connection Pooling - Reuse connections for better performance

Troubleshooting

Common Issues

1. Query Syntax Errors
2. Verify Lucene syntax for full query type
3. Escape special characters properly

4. Check field names and types

5. Poor Relevance

6. Review scoring profiles and field weights
7. Test different boosting strategies

8. Analyze user behavior and feedback

9. Performance Issues

10. Monitor query complexity and execution times
11. Optimize wildcard and fuzzy search usage

12. Implement appropriate caching

13. Suggestion Problems

14. Verify suggester configuration
15. Check source field quality
16. Implement fallback mechanisms

Getting Help

1. Azure Documentation: Azure AI Search Documentation
2. Query Syntax Reference: Lucene Query Syntax
3. Scoring Profiles Guide: Scoring Profiles Documentation
4. Community Support: Microsoft Q&A

Contributing

To contribute to these samples:

1. Fork the repository
2. Create a feature branch
3. Add or improve samples
4. Test thoroughly with different scenarios
5. Update documentation
6. Submit a pull request

License

These samples are provided under the MIT License. See LICENSE file for details.

Related Resources

Module Documentation

• Prerequisites - Required setup and knowledge
• Main Documentation - Complete module overview
• Best Practices - Guidelines for effective implementation
• Troubleshooting - Common issues and solutions

Other Modules

• Module 6: Filters & Sorting - Foundation filtering concepts
• Module 8: Search Explorer - Portal-based query testing
• Module 10: Analyzers & Scoring - Advanced text analysis

External Resources

• Azure AI Search Samples
• Lucene Documentation
• Search Best Practices

By using these code samples, you can implement sophisticated advanced querying features that provide highly relevant, intelligent search experiences for your users.