Skapa och använda ett index med hjälp av kod

Viktigt!

Objekt markerade (förhandsversion) i den här artikeln är för närvarande i offentlig förhandsversion. Den här förhandsversionen tillhandahålls utan ett serviceavtal och vi rekommenderar det inte för produktionsarbetsbelastningar. Vissa funktioner kanske inte stöds eller kan vara begränsade. Mer information finns i Kompletterande villkor för användning av Microsoft Azure-förhandsversioner.

I den här artikeln får du lära dig hur du skapar ett index och använder det från kod. För att skapa ett index lokalt använder vi paketet promptflow-rag . För att skapa ett fjärrindex i molnet använder vi paketet azure-ai-ml . Vi använder indexen med .langchain

Förutsättningar

Du måste ha:

• En Azure AI Foundry-hubb och ett projekt.

• En Azure AI-tjänsten Search anslutning för att indexering av exempelprodukt- och kunddata. Om du inte har någon Azure AI-tjänsten Search kan du skapa en från Azure Portal eller se anvisningarna här.

• Modeller för inbäddning:

  • Du kan använda en ada-002-inbäddningsmodell från Azure OpenAI. Instruktionerna för att distribuera finns här.
  • Eller så kan du använda en annan inbäddningsmodell som distribuerats i ditt Azure AI Foundry-projekt. I det här exemplet använder vi samtidig flerspråkig inbäddning. Instruktionerna för att distribuera den här modellen finns här.

Skapa och använda ett index lokalt

Vi kan skapa och använda ett index lokalt.

Nödvändiga paket för lokala indexåtgärder

Installera följande paket som krävs för att skapa lokala index.

pip install promptflow-rag langchain langchain-openai

Konfigurera AI Search för lokal användning

Vi använder Azure AI Search som indexarkiv. För att komma igång kan vi konfigurera Azure AI-tjänsten Search med hjälp av följande kod:

import os
# set credentials to your Azure AI Search instance
os.environ["AZURE_AI_SEARCH_KEY"] = "<your-ai-search-key>"
os.environ["AZURE_AI_SEARCH_ENDPOINT"] = "https://<your-ai-search-service>.search.windows.net"

Skapa ett index lokalt med Azure OpenAI-inbäddningar

För att skapa ett index som använder Azure OpenAI-inbäddningar konfigurerar vi miljövariabler för att ansluta till modellen.

import os
# set credentials to your Azure OpenAI instance
os.environ["OPENAI_API_VERSION"] = "2023-07-01-preview"
os.environ["AZURE_OPENAI_API_KEY"] = "<your-azure-openai-api-key>"
os.environ["AZURE_OPENAI_ENDPOINT"] = "https://<your-azure-openai-service>.openai.azure.com/"

Nu ska vi skapa indexet med hjälp av build_index funktionen .

from promptflow.rag.config import LocalSource, AzureAISearchConfig, EmbeddingsModelConfig
from promptflow.rag import build_index

local_index_aoai=build_index(
    name="<your-index-name>" + "aoai",  # name of your index
    vector_store="azure_ai_search",  # the type of vector store
    embeddings_model_config=EmbeddingsModelConfig(
        model_name="text-embedding-ada-002",
        deployment_name="text-embedding-ada-002", # verify if your deployment name is same as model name
    ),
    input_source=LocalSource(input_data="<path-to-your-local-files>"),  # the location of your file/folders
    index_config=AzureAISearchConfig(
        ai_search_index_name="<your-index-name>" + "-aoai-store", # the name of the index store inside the azure ai search service
    ),
    tokens_per_chunk = 800, # Optional field - Maximum number of tokens per chunk
    token_overlap_across_chunks = 0, # Optional field - Number of tokens to overlap between chunks
)

Koden ovan skapar ett index lokalt. Den använder miljövariabler för att hämta AI-tjänsten Search och även för att ansluta till Inbäddningsmodellen för Azure OpenAI.

Skapa ett index lokalt med andra inbäddningsmodeller som distribuerats i ditt Azure AI Foundry-projekt

För att skapa ett index som använder en inbäddningsmodell som distribuerats i ditt Azure AI Foundry-projekt konfigurerar vi anslutningen till modellen med hjälp av en ConnectionConfig som visas nedan. och subscriptionresource_group workspace refererar till projektet där inbäddningsmodellen är installerad. connection_name Refererar till anslutningsnamnet för modellen, som finns på sidan för Azure AI Foundry-projektinställningar.

from promptflow.rag.config import ConnectionConfig

my_connection_config=ConnectionConfig(
    subscription_id="<subscription_id>",
    resource_group_name="<resource_group_name>",
    workspace_name="<ai_studio_project_name>",
    connection_name="<serverless_connection_name>"
    )

Nu ska vi skapa indexet med hjälp av build_index funktionen .

from promptflow.rag.config import LocalSource, AzureAISearchConfig, EmbeddingsModelConfig
from promptflow.rag import build_index

local_index_cohere=build_index(
    name="<your-index-name>" + "cohere",  # name of your index
    vector_store="azure_ai_search",  # the type of vector store
    embeddings_model_config=EmbeddingsModelConfig(
        model_name="cohere-embed-v3-multilingual", # in this example we use cohere multi lingual embedding
        connection_config=my_connection_config # created in previous step
    ),
    input_source=LocalSource(input_data="<path-to-your-local-files>"),  # the location of your file/folders
    index_config=AzureAISearchConfig(
        ai_search_index_name="<your-index-name>" + "cohere-store", # the name of the index store inside the azure ai search service
    ),
    tokens_per_chunk = 800, # Optional field - Maximum number of tokens per chunk
    token_overlap_across_chunks = 0, # Optional field - Number of tokens to overlap between chunks
)

Koden ovan skapar ett index lokalt. Den använder miljövariabler för att hämta AI-tjänsten Search och anslutningskonfigurationen för att ansluta till inbäddningsmodellen.

Använda ett lokalt index

Det lokala index som skapats kan användas som en langchain retriever för att använda det för sökfrågor.

from promptflow.rag import get_langchain_retriever_from_index

# Get the OpenAI embedded Index
retriever=get_langchain_retriever_from_index(local_index_aoai)
retriever.get_relevant_documents("<your search query>")

# Get the Cohere embedded Index
retriever=get_langchain_retriever_from_index(local_index_cohere)
retriever.get_relevant_documents("<your search query>")

Registrera indexet i ditt Azure AI Foundry-projekt (valfritt)

Du kan också registrera indexet i ditt Azure AI Foundry-projekt så att du eller andra som har åtkomst till projektet kan använda det från molnet. Innan du fortsätter installerar du de paket som krävs för fjärråtgärder.

Ansluta till projektet

# connect to the Azure AI Foundry project
from azure.identity import DefaultAzureCredential
from azure.ai.ml import MLClient

client=MLClient(
    DefaultAzureCredential(), 
    subscription_id="<subscription_id>",
    resource_group_name="<resource_group_name>",
    workspace_name="<ai_studio_project_name>"
    )

Koden subscription, resource_group och workspace i ovanstående refererar till det projekt som du vill ansluta till.

Registrera indexet

from azure.ai.ml.entities import Index

# register the index with Azure OpenAI embeddings
client.indexes.create_or_update(
    Index(name="<your-index-name>" + "aoai", 
          path=local_index_aoai, 
          version="1")
          )

# register the index with cohere embeddings
client.indexes.create_or_update(
    Index(name="<your-index-name>" + "cohere", 
          path=local_index_cohere, 
          version="1")
          )

Kommentar

Miljövariabler är avsedda för enkelhetens skull i en lokal miljö. Men om du registrerar ett lokalt index som skapats med hjälp av miljövariabler kanske indexet inte fungerar som förväntat eftersom hemligheter från miljövariabler inte överförs till molnindexet. För att åtgärda det här problemet kan du använda en ConnectionConfig eller connection_id för att skapa ett lokalt index innan du registrerar dig.

Skapa ett index (via fjärranslutning) i ditt Azure AI Foundry-projekt

Vi skapar ett index i molnet i ditt Azure AI Foundry-projekt.

Nödvändiga paket för fjärrindexåtgärder

Installera följande paket som krävs för att skapa fjärrindex.

pip install azure-ai-ml promptflow-rag langchain langchain-openai

Ansluta till Azure AI Foundry-projektet

För att komma igång ansluter vi till projektet. resource_group workspace Och subscriptioni koden nedan refererar till det projekt som du vill ansluta till.

# connect to the Azure AI Foundry project
from azure.identity import DefaultAzureCredential
from azure.ai.ml import MLClient

client=MLClient(
    DefaultAzureCredential(), 
    subscription_id="<subscription_id>",
    resource_group_name="<resource_group_name>",
    workspace_name="<ai_studio_project_name>"
    )

Hämta AI-tjänsten Search-anslutningen

Det här projektet bör ha en anslutning till AI-tjänsten Search. Vi hämtar informationen från projektet.

ai_search_connection = client.connections.get("<ai_search_connection>")

Ansluta till inbäddningsmodellerna

Du kan ansluta till Azure OpenAI med hjälp av Microsoft Entra-ID-anslutningar eller API-nyckelbaserade anslutningar.

from azure.ai.ml.entities import IndexModelConfiguration
## aoai connections - entra id
aoai_connection = client.connections.get("<your_aoai_entra_id_connection>")
embeddings_model_config = IndexModelConfiguration.from_connection(
    aoai_connection, 
    model_name="text-embedding-ada-002",
    deployment_name="text-embedding-ada-002") # verify if your deployment name is same as model name

## OR you can connect using API Key based connections 
from azure.ai.ml.entities import IndexModelConfiguration
## aoai connections - API Key
aoai_connection = client.connections.get("<your_aoai_connection>", populate_secrets=True)
embeddings_model_config = IndexModelConfiguration.from_connection(
    aoai_connection, 
    model_name="text-embedding-ada-002",
    deployment_name="text-embedding-ada-002")

Du kan ansluta till inbäddningsmodellen som distribuerats i ditt Azure AI Foundry-projekt (inte Azure OpenAI-modeller) med hjälp av den serverlösa anslutningen.

from azure.ai.ml.entities import IndexModelConfiguration
serverless_connection = client.connections.get("<my_embedding_model_severless_connection_name>")
embeddings_model_config = IndexModelConfiguration.from_connection(cohere_serverless_connection)

Välj indata för att skapa indexet

Du kan skapa indexet från följande typer av indata:

• Lokala filer och mappar
• GitHub-lagringsplatser
• Azure Storage

Vi kan använda följande kodexempel för att använda någon av dessa källor och konfigurera vår input_source:

# Local source
from azure.ai.ml.entities import LocalSource

input_source=LocalSource(input_data="<path-to-your-local-files>")

# GitHub repository
from azure.ai.ml.entities import GitSource

input_source=GitSource(
    git_url="https://github.com/rust-lang/book.git", # connecting to the RUST repo as an example
    git_branch_name="main", 
    git_connection_id="")

# Azure Storage
input_source_subscription = "<subscription>"
input_source_resource_group = "<resource_group>"
input_source_workspace = "<workspace>"
input_source_datastore = "<datastore_name>"
input_source_path = "path"

input_source = f"azureml://subscriptions/{input_source_subscription}/resourcegroups/{input_source_resource_group}/workspaces/{input_source_workspace}/datastores/{input_source_datastore}/paths/{input_source_path}"

Skapa indexet i molnet

Nu kan vi skapa indexet med hjälp av ai_search_connection, embeddings_model_config och input_source. Vi använder build_index funktionen. Om du använder en Azure Storage-URL som indatakälla måste du också ange en UserIdentityConfiguration.

# from azure.ai.ml.entities.credentials import UserIdentityConfiguration # user specified identity used to access the data. Required when using an azure storage URL
from azure.ai.ml.entities import AzureAISearchConfig

client.indexes.build_index(
    name="<index_name>", # name of your index
    embeddings_model_config=embeddings_model_config, 
    input_source=input_source, 
    # input_source_credential=UserIdentityConfiguration(), # user specified identity used to access the data. Required when using an azure storage URL
    index_config=AzureAISearchConfig(
        ai_search_index_name="<index_name>",  # the name of the index store in AI search service
        ai_search_connection_id=ai_search_connection.id, 
    ),
    tokens_per_chunk = 800, # Optional field - Maximum number of tokens per chunk
    token_overlap_across_chunks = 0, # Optional field - Number of tokens to overlap between chunks
)

Beroende på storleken på dina indatakälldata kan ovanstående steg ta lite tid att slutföra. När jobbet är klart kan du hämta indexobjektet.

my_index=client.indexes.get(name="<index_name>", label="latest")

Använda ett registrerat index från projektet

Om du vill använda ett registrerat index från projektet måste du ansluta till projektet och hämta indexet. Det hämtade indexet kan användas som en langhcain retriever för att använda det. Du kan ansluta till projektet med en client som visas här.

from promptflow.rag import get_langchain_retriever_from_index

my_index=client.indexes.get(
    name="<registered_index_name>", 
    label="latest")

index_langchain_retriever=get_langchain_retriever_from_index(my_index.path)
index_langchain_retriever.get_relevant_documents("<your search query>")

En fråge- och svarsfunktion för att använda indexet

Vi har sett hur du skapar ett index lokalt eller i molnet. Med det här indexet skapar vi en QnA-funktion som accepterar en användarfråga och ger ett svar från indexdata. Låt oss först hämta indexet som en langchain_retriever som visas här. Nu använder vi detta retriever i vår funktion. Den här funktionen använder LLM enligt definitionen i AzureChatOpenAI konstruktorn. Det använder indexet som en langchain_retriever för att köra frågor mot data. Vi skapar en promptmall som accepterar en kontext och en fråga. Vi använder langchain's RetrievalQA.from_chain_type för att sätta ihop alla dessa och ge oss svaren.

def qna(question: str, temperature: float = 0.0, prompt_template: object = None) -> str:
    from langchain import PromptTemplate
    from langchain.chains import RetrievalQA
    from langchain_openai import AzureChatOpenAI

    llm = AzureChatOpenAI(
        openai_api_version="2023-06-01-preview",
        api_key="<your-azure-openai-api-key>",
        azure_endpoint="https://<your-azure-openai-service>.openai.azure.com/",
        azure_deployment="<your-chat-model-deployment>", # verify the model name and deployment name
        temperature=temperature,
    )

    template = """
    System:
    You are an AI assistant helping users answer questions given a specific context.
    Use the following pieces of context to answer the questions as completely, 
    correctly, and concisely as possible.
    Your answer should only come from the context. Don't try to make up an answer.
    Do not add documentation reference in the response.

    {context}

    ---

    Question: {question}

    Answer:"
    """
    prompt_template = PromptTemplate(template=template, input_variables=["context", "question"])

    qa = RetrievalQA.from_chain_type(
        llm=llm,
        chain_type="stuff",
        retriever=index_langchain_retriever,
        return_source_documents=True,
        chain_type_kwargs={
            "prompt": prompt_template,
        },
    )

    response = qa(question)

    return {
        "question": response["query"],
        "answer": response["result"],
        "context": "\n\n".join([doc.page_content for doc in response["source_documents"]]),
    }

Låt oss ställa en fråga för att se till att vi får ett svar.

result = qna("<your question>")
print(result["answer"])

Relaterat innehåll

• Skapa och använda ett index från Azure AI Foundry-portalens användargränssnitt
• Kom igång att skapa en chattapp med hjälp av promptflödes-SDK:n
• Arbeta med projekt i VS Code