Självstudie: Minimera lagring och kostnader (klassisk RAG i Azure AI Search)

2025-10-14

Azure AI Search erbjuder flera metoder för att minska storleken på vektorindex. Dessa metoder sträcker sig från vektorkomprimering till att vara mer selektiva jämfört med vad du lagrar i din söktjänst.

Anmärkning

Vi rekommenderar nu agentisk hämtning för RAG-arbetsflöden, men klassisk RAG är enklare. Om den uppfyller dina programkrav är det fortfarande ett bra val.

I den här självstudien ändrar du det befintliga sökindexet så att det använder:

Smala datatyper
Skalarkvantisering
Minskad lagring genom att välja bort vektorer i sökresultat

Den här självstudien repriserar sökindexet som skapats av indexeringspipelinen. Alla dessa uppdateringar påverkar det befintliga innehållet, vilket kräver att du kör indexeraren igen. Men i stället för att ta bort sökindexet skapar du ett andra så att du kan jämföra minskningar av vektorindexstorleken när du har lagt till de nya funktionerna.

Helt och hållet kan de tekniker som illustreras i den här självstudien minska vektorlagringen med ungefär hälften.

Följande skärmbild jämför det första indexet från en tidigare självstudiekurs med indexet som skapats i den här.

Prerequisites

Den här självstudien är i princip en omkörning av indexeringspipelinen. Du behöver alla Azure-resurser och behörigheter som beskrivs i den självstudien.

Som jämförelse bör du ha ett befintligt py-rag-tutorial-idx-index på din Azure AI-tjänsten Search. Den bör vara nästan 2 MB stor och vektorindexdelen ska vara 348 KB.

Du bör också ha följande objekt:

py-rag-tutorial-ds (datakälla)
py-rag-tutorial-ss (kompetensuppsättning)

Hämta exemplet

Ladda ned en Jupyter-anteckningsbok från GitHub för att skicka begäranden till Azure AI Search. Mer information finns i Ladda ned filer från GitHub.

Uppdatera indexet för reducerad lagring

Azure AI Search har flera metoder för att minska vektorstorleken, vilket sänker kostnaden för vektorarbetsbelastningar. I det här steget skapar du ett nytt index som använder följande funktioner:

Vektorkomprimering. Scalar-kvantisering ger den här funktionen.
Eliminera valfri lagring. Om du bara behöver vektorer för frågor och inte i en svarsnyttolast kan du släppa vektorkopian som används för sökresultat.
Smala datatyper. Du kan ange Collection(Edm.Half) i fältet text_vector för att lagra inkommande float32-dimensioner som float16, vilket tar mindre utrymme i indexet.

Alla dessa funktioner anges i ett sökindex. När du har läst in indexet jämför du skillnaden mellan det ursprungliga indexet och det nya.

Ge det nya indexet py-rag-tutorial-small-vectors-idxnamnet .

Använd följande definition för det nya indexet. Skillnaden mellan det här schemat och de tidigare schemauppdateringarna i Maximera relevans är nya klasser för skalära kvantiseringar och ett nytt komprimeringsavsnitt, en ny datatyp (Collection(Edm.Half)) för fältet text_vector och en ny egenskap stored inställd på false.

from azure.identity import DefaultAzureCredential
from azure.identity import get_bearer_token_provider
from azure.search.documents.indexes import SearchIndexClient
from azure.search.documents.indexes.models import (
    SearchField,
    SearchFieldDataType,
    VectorSearch,
    HnswAlgorithmConfiguration,
    VectorSearchProfile,
    AzureOpenAIVectorizer,
    AzureOpenAIVectorizerParameters,
    ScalarQuantizationCompression,
    ScalarQuantizationParameters,
    SearchIndex,
    SemanticConfiguration,
    SemanticPrioritizedFields,
    SemanticField,
    SemanticSearch,
    ScoringProfile,
    TagScoringFunction,
    TagScoringParameters
)

credential = DefaultAzureCredential()

index_name = "py-rag-tutorial-small-vectors-idx"
index_client = SearchIndexClient(endpoint=AZURE_SEARCH_SERVICE, credential=credential)  
fields = [
    SearchField(name="parent_id", type=SearchFieldDataType.String),  
    SearchField(name="title", type=SearchFieldDataType.String),
    SearchField(name="locations", type=SearchFieldDataType.Collection(SearchFieldDataType.String), filterable=True),
    SearchField(name="chunk_id", type=SearchFieldDataType.String, key=True, sortable=True, filterable=True, facetable=True, analyzer_name="keyword"),  
    SearchField(name="chunk", type=SearchFieldDataType.String, sortable=False, filterable=False, facetable=False),  
    SearchField(name="text_vector", type="Collection(Edm.Half)", vector_search_dimensions=1024, vector_search_profile_name="myHnswProfile", stored= False)
    ]  

# Configure the vector search configuration  
vector_search = VectorSearch(  
    algorithms=[  
        HnswAlgorithmConfiguration(name="myHnsw"),
    ],  
    profiles=[  
        VectorSearchProfile(  
            name="myHnswProfile",  
            algorithm_configuration_name="myHnsw",
            compression_name="myScalarQuantization",
            vectorizer_name="myOpenAI",  
        )
    ],  
    vectorizers=[  
        AzureOpenAIVectorizer(  
            vectorizer_name="myOpenAI",  
            kind="azureOpenAI",  
            parameters=AzureOpenAIVectorizerParameters(  
                resource_url=AZURE_OPENAI_ACCOUNT,  
                deployment_name="text-embedding-3-large",
                model_name="text-embedding-3-large"
            ),
        ),  
    ],
    compressions=[
        ScalarQuantizationCompression(
            compression_name="myScalarQuantization",
            rerank_with_original_vectors=True,
            default_oversampling=10,
            parameters=ScalarQuantizationParameters(quantized_data_type="int8"),
        )
    ]
)

semantic_config = SemanticConfiguration(
    name="my-semantic-config",
    prioritized_fields=SemanticPrioritizedFields(
        title_field=SemanticField(field_name="title"),
        keywords_fields=[SemanticField(field_name="locations")],
        content_fields=[SemanticField(field_name="chunk")]
    )
)

semantic_search = SemanticSearch(configurations=[semantic_config])

scoring_profiles = [  
    ScoringProfile(  
        name="my-scoring-profile",
        functions=[
            TagScoringFunction(  
                field_name="locations",  
                boost=5.0,  
                parameters=TagScoringParameters(  
                    tags_parameter="tags",  
                ),  
            ) 
        ]
    )
]

index = SearchIndex(name=index_name, fields=fields, vector_search=vector_search, semantic_search=semantic_search, scoring_profiles=scoring_profiles)  
result = index_client.create_or_update_index(index)  
print(f"{result.name} created")

Skapa eller återanvända datakällan

Här är definitionen av datakällan från föregående självstudie. Om du redan har den här datakällan i söktjänsten kan du hoppa över att skapa en ny.

from azure.search.documents.indexes import SearchIndexerClient
from azure.search.documents.indexes.models import (
    SearchIndexerDataContainer,
    SearchIndexerDataSourceConnection
)

# Create a data source 
indexer_client = SearchIndexerClient(endpoint=AZURE_SEARCH_SERVICE, credential=credential)
container = SearchIndexerDataContainer(name="nasa-ebooks-pdfs-all")
data_source_connection = SearchIndexerDataSourceConnection(
    name="py-rag-tutorial-ds",
    type="azureblob",
    connection_string=AZURE_STORAGE_CONNECTION,
    container=container
)
data_source = indexer_client.create_or_update_data_source_connection(data_source_connection)

print(f"Data source '{data_source.name}' created or updated")

Skapa eller återanvända kunskapsuppsättningen

Kompetensuppsättningen är också oförändrad från föregående självstudie. Här är det igen så att du kan granska det.

from azure.search.documents.indexes.models import (
    SplitSkill,
    InputFieldMappingEntry,
    OutputFieldMappingEntry,
    AzureOpenAIEmbeddingSkill,
    EntityRecognitionSkill,
    SearchIndexerIndexProjection,
    SearchIndexerIndexProjectionSelector,
    SearchIndexerIndexProjectionsParameters,
    IndexProjectionMode,
    SearchIndexerSkillset,
    CognitiveServicesAccountKey
)

# Create a skillset  
skillset_name = "py-rag-tutorial-ss"

split_skill = SplitSkill(  
    description="Split skill to chunk documents",  
    text_split_mode="pages",  
    context="/document",  
    maximum_page_length=2000,  
    page_overlap_length=500,  
    inputs=[  
        InputFieldMappingEntry(name="text", source="/document/content"),  
    ],  
    outputs=[  
        OutputFieldMappingEntry(name="textItems", target_name="pages")  
    ],  
)  
  
embedding_skill = AzureOpenAIEmbeddingSkill(  
    description="Skill to generate embeddings via Azure OpenAI",  
    context="/document/pages/*",  
    resource_url=AZURE_OPENAI_ACCOUNT,  
    deployment_name="text-embedding-3-large",  
    model_name="text-embedding-3-large",
    dimensions=1536,
    inputs=[  
        InputFieldMappingEntry(name="text", source="/document/pages/*"),  
    ],  
    outputs=[  
        OutputFieldMappingEntry(name="embedding", target_name="text_vector")  
    ],  
)

entity_skill = EntityRecognitionSkill(
    description="Skill to recognize entities in text",
    context="/document/pages/*",
    categories=["Location"],
    default_language_code="en",
    inputs=[
        InputFieldMappingEntry(name="text", source="/document/pages/*")
    ],
    outputs=[
        OutputFieldMappingEntry(name="locations", target_name="locations")
    ]
)
  
index_projections = SearchIndexerIndexProjection(  
    selectors=[  
        SearchIndexerIndexProjectionSelector(  
            target_index_name=index_name,  
            parent_key_field_name="parent_id",  
            source_context="/document/pages/*",  
            mappings=[  
                InputFieldMappingEntry(name="chunk", source="/document/pages/*"),  
                InputFieldMappingEntry(name="text_vector", source="/document/pages/*/text_vector"),
                InputFieldMappingEntry(name="locations", source="/document/pages/*/locations"),  
                InputFieldMappingEntry(name="title", source="/document/metadata_storage_name"),  
            ],  
        ),  
    ],  
    parameters=SearchIndexerIndexProjectionsParameters(  
        projection_mode=IndexProjectionMode.SKIP_INDEXING_PARENT_DOCUMENTS  
    ),  
) 

cognitive_services_account = CognitiveServicesAccountKey(key=AZURE_AI_MULTISERVICE_KEY)

skills = [split_skill, embedding_skill, entity_skill]

skillset = SearchIndexerSkillset(  
    name=skillset_name,  
    description="Skillset to chunk documents and generating embeddings",  
    skills=skills,  
    index_projection=index_projections,
    cognitive_services_account=cognitive_services_account
)
  
client = SearchIndexerClient(endpoint=AZURE_SEARCH_SERVICE, credential=credential)  
client.create_or_update_skillset(skillset)  
print(f"{skillset.name} created")

Skapa en ny indexerare och läs in indexet

Även om du kan återställa och köra den befintliga indexeraren igen med det nya indexet är det lika enkelt att skapa en ny indexerare. Att ha två index och indexerare bevarar körningshistoriken och möjliggör närmare jämförelser.

Indexeraren är identisk med den tidigare indexeraren, förutom att den anger det nya indexet från den här självstudien.

from azure.search.documents.indexes.models import (
    SearchIndexer
)

# Create an indexer  
indexer_name = "py-rag-tutorial-small-vectors-idxr" 

indexer_parameters = None

indexer = SearchIndexer(  
    name=indexer_name,  
    description="Indexer to index documents and generate embeddings",
    target_index_name="py-rag-tutorial-small-vectors-idx",
    skillset_name="py-rag-tutorial-ss", 
    data_source_name="py-rag-tutorial-ds",
    parameters=indexer_parameters
)  

# Create and run the indexer  
indexer_client = SearchIndexerClient(endpoint=AZURE_SEARCH_SERVICE, credential=credential)  
indexer_result = indexer_client.create_or_update_indexer(indexer)  

print(f' {indexer_name} is created and running. Give the indexer a few minutes before running a query.')

Som ett sista steg växlar du till Azure Portal för att jämföra vektorlagringskraven för de två indexen. Du bör visa resultat som liknar följande skärmbild.

Indexet som skapades i den här självstudien använder flyttalsnummer med halv precision (float16) för textvektorerna. Detta minskar lagringskraven för vektorerna med hälften jämfört med det tidigare index som använde flyttal med enkel precision (float32). Skalär komprimering och utelämnande av en uppsättning av vektorerna står för de återstående lagringsbesparingarna. Mer information om hur du minskar vektorstorleken finns i Välja en metod för att optimera vektorlagring och bearbetning.

Överväg att gå tillbaka till frågorna från föregående självstudie så att du kan jämföra frågehastighet och verktyg. Du bör förvänta dig en viss variation i LLM-utdata när du upprepar en fråga, men i allmänhet bör de lagringsbesparande tekniker som du implementerade inte försämra kvaliteten på sökresultaten.

Nästa steg

Vi rekommenderar den här acceleratorn för nästa steg:

RAG Experimentaccelerator

Feedback

Var den här sidan till hjälp?