Your Data                 Azure AI Search              Your App
──────────                ───────────────              ────────
Blob Storage  ──────────▶ Index + Embeddings ────────▶ Search Results
SQL Database  (indexing)  Vector Store        (query)  RAG Answers
SharePoint               AI Enrichment                 Recommendations
CosmosDB                 Semantic Ranking              Autocomplete
Custom API               Hybrid Search

┌─────────────────────────────────────────────────────────────┐
│                    AZURE AI SEARCH SERVICE                   │
│                                                              │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────────┐   │
│  │    Index     │  │   Indexer    │  │  Skillset (AI)   │   │
│  │              │  │              │  │                  │   │
│  │ - Fields     │  │ - Pulls from │  │ - OCR            │   │
│  │ - Embeddings │  │   data source│  │ - Entity extract │   │
│  │ - ACL fields │  │ - Schedules  │  │ - Translation    │   │
│  │ - Schema     │  │ - Transforms │  │ - Key phrases    │   │
│  └──────────────┘  └──────────────┘  │ - Custom skills  │   │
│                                      └──────────────────┘   │
│  ┌──────────────────────────────────────────────────────┐   │
│  │                   QUERY ENGINE                        │   │
│  │  Full-text │ Vector │ Hybrid │ Semantic │ Filters    │   │
│  └──────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────┘

Query: "What is our refund policy for international orders?"
Full-text Search        Vector Search           Hybrid Search
────────────────        ─────────────           ─────────────
Keyword matching        Semantic similarity     Full-text + Vector
BM25 algorithm          Embedding comparison    Combined score (RRF)
"refund policy"         Similar meaning docs    Best of both worlds
international           Even if words differ
orders
                                   +
                        Semantic Reranking (L2)
                        Re-orders results using
                        deep language model
                        understanding

POST /indexes/documents/docs/search?api-version=2024-07-01
{
  "search": "refund policy international orders",
  "queryType": "full",
  "searchMode": "all",
  "searchFields": ["content", "title"],
  "select": "id, title, content, source_file",
  "top": 5,
  "count": true
}

Simple query:  "refund policy"
Phrase query:  "\"refund policy\""         exact phrase
Wildcard:      "refund*"                   prefix match
Fuzzy:         "refund~1"                  1 edit distance
Proximity:     "\"refund policy\"~5"       within 5 words
Boolean:       "refund AND (policy OR terms)"
Boosting:      "refund^3 policy"           boost refund term

"How do I get my money back?"
        ↓
Embedding model (text-embedding-3-large)
        ↓
[0.023, -0.412, 0.891, ...]  1536-dimension vector
        ↓
Cosine similarity search in index
        ↓
Finds: "Refund and return policy" (similar meaning)
        even though no words match

POST /indexes/documents/docs/search?api-version=2024-07-01
{
  "vectorQueries": [
    {
      "kind": "vector",
      "vector": [0.023, -0.412, 0.891, ...],
      "fields": "embedding",
      "k": 5,
      "exhaustive": false
    }
  ],
  "select": "id, title, content",
  "top": 5
}

// Index vector field config
{
  "name": "embedding",
  "type": "Collection(Edm.Single)",
  "searchable": true,
  "dimensions": 1536,
  "vectorSearchProfile": "hnsw-profile"
}

Query: "refund policy international"
BM25 Results:              Vector Results:
1. Refund Policy Doc       1. Return & Refund Guide
2. International FAQ       2. Customer Service Policy
3. Terms & Conditions      3. International Orders FAQ
        ↓ RRF merges both ranked lists ↓
Hybrid Results (best quality):
1. Refund Policy Doc       (top in both)
2. Return & Refund Guide   (high vector score)
3. International FAQ       (high BM25 score)

POST /indexes/documents/docs/search?api-version=2024-07-01
{
  "search": "refund policy international orders",
  "vectorQueries": [
    {
      "kind": "vector",
      "vector": [0.023, -0.412, ...],
      "fields": "embedding",
      "k": 50
    }
  ],
  "queryType": "simple",
  "select": "id, title, content, source_file",
  "top": 5
}

Hybrid Search → Top 50 results
                      ↓
              Semantic Ranker
              (reads each result,
               understands meaning,
               compares to query intent)
                      ↓
              Reranked Top 5
              + Semantic captions
              + Semantic answers
              (extracted key passages)

{
  "search": "refund policy international orders",
  "vectorQueries": [...],
  "queryType": "semantic",
  "semanticConfiguration": "my-semantic-config",
  "captions": "extractive",          // extract relevant snippets
  "answers": "extractive|count-3",   // extract direct answers
  "top": 5
}

{
  "value": [
    {
      "@search.rerankerScore": 2.847,
      "@search.captions": [
        {
          "text": "International orders are eligible for refund within 30 days",
          "highlights": "International orders...refund within 30 days"
        }
      ],
      "content": "Full document content...",
      "title": "Refund Policy"
    }
  ],
  "@search.answers": [
    {
      "text": "International orders are eligible for refund within 30 days of purchase",
      "score": 0.94
    }
  ]
}

{
  "name": "rag-index",
  "fields": [
    {
      "name": "chunk_id",
      "type": "Edm.String",
      "key": true,
      "searchable": false,
      "filterable": true
    },
    {
      "name": "content",
      "type": "Edm.String",
      "searchable": true,          // full-text search
      "filterable": false,
      "retrievable": true,
      "analyzer": "en.microsoft"   // language analyzer
    },
    {
      "name": "title",
      "type": "Edm.String",
      "searchable": true,
      "filterable": true,
      "retrievable": true
    },
    {
      "name": "source_file",
      "type": "Edm.String",
      "searchable": false,
      "filterable": true,          // filter by document
      "retrievable": true,
      "facetable": true            // faceted navigation
    },
    {
      "name": "sensitivity",
      "type": "Edm.String",
      "filterable": true,          // filter by label
      "facetable": true
    },
    {
      "name": "allowed_groups",
      "type": "Collection(Edm.String)",
      "filterable": true           // document-level security
    },
    {
      "name": "last_modified",
      "type": "Edm.DateTimeOffset",
      "filterable": true,
      "sortable": true
    },
    {
      "name": "embedding",
      "type": "Collection(Edm.Single)",
      "searchable": true,
      "retrievable": false,        // don't return raw vectors
      "dimensions": 3072,          // text-embedding-3-large
      "vectorSearchProfile": "hnsw-profile"
    }
  ],
  "vectorSearch": {
    "algorithms": [
      {
        "name": "hnsw-algo",
        "kind": "hnsw",
        "hnswParameters": {
          "metric": "cosine",
          "m": 4,                  // connections per layer
          "efConstruction": 400,   // build quality
          "efSearch": 500          // query quality
        }
      }
    ],
    "profiles": [
      {
        "name": "hnsw-profile",
        "algorithm": "hnsw-algo",
        "vectorizer": "azure-openai-vectorizer"
      }
    ],
    "vectorizers": [
      {
        "name": "azure-openai-vectorizer",
        "kind": "azureOpenAI",
        "azureOpenAIParameters": {
          "resourceUri": "https://myoai.openai.azure.com",
          "deploymentId": "text-embedding-3-large",
          "modelName": "text-embedding-3-large"
        }
      }
    ]
  },
  "semantic": {
    "configurations": [
      {
        "name": "my-semantic-config",
        "prioritizedFields": {
          "titleField": { "fieldName": "title" },
          "contentFields": [
            { "fieldName": "content" }
          ]
        }
      }
    ]
  }
}

Data Sources supported:
├── Azure Blob Storage      (PDF, Word, Excel, HTML, JSON)
├── Azure Data Lake Gen2
├── Azure SQL Database
├── Azure Cosmos DB
├── Azure Table Storage
├── SharePoint Online
└── OneLake (Fabric)

// Data source connection
{
  "name": "blob-datasource",
  "type": "azureblob",
  "credentials": {
    "connectionString": "ResourceId=/subscriptions/.../storageAccounts/mystg"
  },
  "container": {
    "name": "documents",
    "query": "processed/"    // only index this folder
  },
  "dataDeletionDetectionPolicy": {
    "@odata.type": "#Microsoft.Azure.Search.SoftDeleteColumnDeletionDetectionPolicy",
    "softDeleteColumnName": "IsDeleted",
    "softDeleteMarkerValue": "true"
  }
}
// Indexer — runs on schedule
{
  "name": "blob-indexer",
  "dataSourceName": "blob-datasource",
  "targetIndexName": "rag-index",
  "skillsetName": "ai-enrichment-skillset",
  "schedule": {
    "interval": "PT1H"       // run every hour
  },
  "parameters": {
    "batchSize": 10,
    "configuration": {
      "dataToExtract": "contentAndMetadata",
      "parsingMode": "default"
    }
  },
  "fieldMappings": [
    {
      "sourceFieldName": "metadata_storage_name",
      "targetFieldName": "source_file"
    }
  ],
  "outputFieldMappings": [
    {
      "sourceFieldName": "/document/content/pages/*/embedding",
      "targetFieldName": "embedding"
    }
  ]
}

Raw PDF
   ↓
OCR Skill              → extracts text from scanned images
   ↓
Split Skill            → chunks text into 512-token pieces
   ↓
Entity Recognition     → extracts people, orgs, locations
   ↓
Key Phrase Extraction  → identifies main topics
   ↓
Language Detection     → detects document language
   ↓
Translation Skill      → translates to English if needed
   ↓
Embedding Skill        → generates vectors via Azure OpenAI
   ↓
Index

{
  "name": "ai-enrichment-skillset",
  "skills": [
    {
      "@odata.type": "#Microsoft.Skills.Vision.OcrSkill",
      "name": "ocr-skill",
      "inputs": [{ "name": "image", "source": "/document/normalized_images/*" }],
      "outputs": [{ "name": "text", "targetName": "extracted_text" }]
    },
    {
      "@odata.type": "#Microsoft.Skills.Text.SplitSkill",
      "name": "split-skill",
      "textSplitMode": "pages",
      "maximumPageLength": 512,
      "pageOverlapLength": 50,
      "inputs": [{ "name": "text", "source": "/document/content" }],
      "outputs": [{ "name": "textItems", "targetName": "pages" }]
    },
    {
      "@odata.type": "#Microsoft.Skills.Text.AzureOpenAIEmbeddingSkill",
      "name": "embedding-skill",
      "resourceUri": "https://myoai.openai.azure.com",
      "deploymentId": "text-embedding-3-large",
      "modelName": "text-embedding-3-large",
      "inputs": [{ "name": "text", "source": "/document/content/pages/*" }],
      "outputs": [{ "name": "embedding", "targetName": "embedding" }]
    },
    {
      "@odata.type": "#Microsoft.Skills.Text.EntityRecognitionSkill",
      "name": "entity-skill",
      "categories": ["Person", "Organization", "Location"],
      "inputs": [{ "name": "text", "source": "/document/content" }],
      "outputs": [
        { "name": "persons", "targetName": "persons" },
        { "name": "organizations", "targetName": "organizations" }
      ]
    }
  ],
  "knowledgeStore": {
    "storageConnectionString": "...",
    "projections": [
      {
        "tables": [
          {
            "tableName": "enrichedDocuments",
            "source": "/document"
          }
        ]
      }
    ]
  }
}

# Security filter — document-level ACL
security_filter = (
    f"allowed_groups/any(g: search.in(g, '{','.join(user_groups)}'))"
    f" or allowed_users/any(u: u eq '{user_id}')"
)
# Combined search with filters
results = search_client.search(
    search_text=query,
    vector_queries=[vector_query],
    # Filter — applied before scoring (fast)
    filter=f"sensitivity ne 'HighlyConfidential' and ({security_filter})",
    # Facets — for navigation UI
    facets=["sensitivity", "source_file", "last_modified,interval:year"],
    # Ordering
    order_by=["@search.score desc", "last_modified desc"],
    # Pagination
    skip=0,
    top=10,
    # Which fields to return
    select=["id", "title", "content", "source_file", "last_modified"],
    # Highlight matching terms
    highlight_fields="content-3",       # 3 fragments
    highlight_pre_tag="<mark>",
    highlight_post_tag="</mark>"
)
# Facet results for navigation
for facet in results.get_facets().get("sensitivity", []):
    print(f"{facet['value']}: {facet['count']} docs")

# Old way — embed query yourself then search
embedding = openai_client.embeddings.create(
    input=query,
    model="text-embedding-3-large"
).data[0].embedding
results = search_client.search(
    vector_queries=[VectorizedQuery(vector=embedding, ...)]
)
# New way — integrated vectorization
# Search service embeds query automatically
results = search_client.search(
    search_text=query,
    vector_queries=[VectorizableTextQuery(
        text=query,               # ← pass text, not vector
        fields="embedding",
        k_nearest_neighbors=5
    )]
)

{
  "scoringProfiles": [
    {
      "name": "boost-recent-and-title",
      "text": {
        "weights": {
          "title": 5,           // title matches worth 5x
          "content": 1
        }
      },
      "functions": [
        {
          "type": "freshness",
          "fieldName": "last_modified",
          "boost": 3,
          "freshness": {
            "boostingDuration": "P30D"  // boost docs < 30 days old
          }
        },
        {
          "type": "tag",
          "fieldName": "tags",
          "boost": 2,
          "tag": {
            "tagsParameter": "userTags"  // boost matching user tags
          }
        }
      ],
      "functionAggregation": "sum"
    }
  ],
  "defaultScoringProfile": "boost-recent-and-title"
}

from azure.search.documents import SearchClient
from azure.search.documents.models import (
    VectorizedQuery,
    QueryType,
    QueryCaptionType,
    QueryAnswerType
)
from azure.identity import DefaultAzureCredential
from openai import AzureOpenAI
credential = DefaultAzureCredential()
search_client = SearchClient(
    endpoint=SEARCH_ENDPOINT,
    index_name="rag-index",
    credential=credential
)
openai_client = AzureOpenAI(
    azure_endpoint=OPENAI_ENDPOINT,
    azure_ad_token_provider=get_token_provider(credential)
)
def hybrid_search_with_security(
    query: str,
    user_groups: list,
    user_id: str,
    top: int = 5
) -> list:
    # 1. Embed query
    query_embedding = openai_client.embeddings.create(
        input=query,
        model="text-embedding-3-large"
    ).data[0].embedding
    # 2. Build security filter
    group_filter = " or ".join(

Total capacity = replicas × partitions
S1 with 3 replicas + 2 partitions = 6 search units (SU)