Een index bouwen en gebruiken met behulp van code
Belangrijk
Items die in dit artikel zijn gemarkeerd (preview) zijn momenteel beschikbaar als openbare preview. Deze preview wordt aangeboden zonder een service level agreement en we raden deze niet aan voor productieworkloads. Misschien worden bepaalde functies niet ondersteund of zijn de mogelijkheden ervan beperkt. Zie Aanvullende gebruiksvoorwaarden voor Microsoft Azure-previews voor meer informatie.
In dit artikel leert u hoe u een index maakt en gebruikt op basis van code. We gebruiken het promptflow-rag pakket om lokaal een index te maken. Voor het maken van een externe index in de cloud gebruiken we het azure-ai-ml pakket. We gebruiken de indexen met behulp van langchain.
Vereisten
U moet over het volgende beschikken:
Een AI Studio-hub en -project.
Een Azure AI-Search-service verbinding om het voorbeeldproduct en de klantgegevens te indexeren. Als u geen Azure AI-Search-service hebt, kunt u er een maken vanuit Azure Portal of de instructies hier bekijken.
Modellen voor insluiten:
- U kunt een ada-002-insluitmodel van Azure OpenAI gebruiken. De instructies voor implementatie vindt u hier.
- OF u kunt elk ander insluitmodel gebruiken dat is geïmplementeerd in uw AI Studio-project. In dit voorbeeld gebruiken we cohere multi-lingual embedding. De instructies voor het implementeren van dit model vindt u hier.
Een index lokaal bouwen en gebruiken
We kunnen een index lokaal bouwen en gebruiken.
Vereiste pakketten voor lokale indexbewerkingen
Installeer de volgende pakketten die vereist zijn voor het maken van lokale indexen.
pip install promptflow-rag langchain langchain-openai
AI Search configureren voor lokaal gebruik
We gebruiken Azure AI Search als het indexarchief. Om aan de slag te gaan, kunnen we de Azure AI-Search-service instellen met behulp van de volgende code:
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"
Een index lokaal bouwen met behulp van Azure OpenAI-insluitingen
Als u een index wilt maken die gebruikmaakt van Azure OpenAI-insluitingen, configureren we omgevingsvariabelen om verbinding te maken met het model.
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/"
Laten we nu de index bouwen met behulp van de build_index functie.
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
)
Met de bovenstaande code wordt een index lokaal gebouwd. Er worden omgevingsvariabelen gebruikt om de AI-Search-service op te halen en om verbinding te maken met het Azure OpenAI-insluitingsmodel.
Een index lokaal bouwen met andere insluitmodellen die zijn geïmplementeerd in uw AI Studio-project
Als u een index wilt maken die gebruikmaakt van een insluitmodel dat is geïmplementeerd in uw AI Studio-project, configureren we de verbinding met het model met behulp van een ConnectionConfig zoals hieronder wordt weergegeven. De subscription, resource_group en workspace verwijst naar het project waar het insluitmodel is geïnstalleerd. De connection_name naam van de verbinding voor het model verwijst naar de naam van het model, die te vinden is op de pagina met projectinstellingen van AI Studio.
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>"
)
Laten we nu de index bouwen met behulp van de build_index functie.
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
)
Met de bovenstaande code wordt een index lokaal gebouwd. Er worden omgevingsvariabelen gebruikt om de AI-Search-service en de verbindingsconfiguratie op te halen om verbinding te maken met het insluitmodel.
Een lokale index gebruiken
De lokale index die is gemaakt, kan worden gebruikt als een langchain-retriever om deze te gebruiken voor zoekquery's.
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>")
De index registreren in uw AI Studio-project (optioneel)
Desgewenst kunt u de index registreren in uw AI Studio-project, zodat u of anderen die toegang hebben tot uw project, deze vanuit de cloud kunnen gebruiken. Voordat u doorgaat, installeert u de vereiste pakketten voor externe bewerkingen .
Verbinding maken met het project
# connect to the AI Studio 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>"
)
De subscription, resource_group en workspace in de bovenstaande code verwijst naar het project waarmee u verbinding wilt maken.
De index registreren
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")
)
Notitie
Omgevingsvariabelen zijn bedoeld voor het gemak in een lokale omgeving. Als u echter een lokale index registreert die is gemaakt met omgevingsvariabelen, werkt de index mogelijk niet zoals verwacht, omdat geheimen van omgevingsvariabelen niet worden overgedragen naar de cloudindex. U kunt dit probleem oplossen door een ConnectionConfig of connection_id om een lokale index te maken voordat u zich registreert.
Een index bouwen (extern) in uw AI Studio-project
We bouwen een index in de cloud in uw AI Studio-project.
Vereiste pakketten voor externe indexbewerkingen
Installeer de volgende pakketten die vereist zijn voor het maken van externe indexen.
pip install azure-ai-ml promptflow-rag langchain langchain-openai
Verbinding maken met het AI Studio-project
Om aan de slag te gaan, maken we verbinding met het project. De subscription, resource_group en workspace in de onderstaande code verwijst naar het project waarmee u verbinding wilt maken.
# connect to the AI Studio 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>"
)
De AI-Search-service-verbinding ophalen
Dit project moet een verbinding hebben met de AI-Search-service. We halen de details van het project op.
ai_search_connection = client.connections.get("<ai_search_connection>")
Verbinding maken met de insluitmodellen
U kunt verbinding maken met Azure OpenAI met behulp van Microsoft Entra ID-verbindingen of API-sleutelverbindingen.
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")
U kunt verbinding maken met het insluitmodel dat is geïmplementeerd in uw AI Studio-project (niet Azure OpenAI-modellen) met behulp van de serverloze verbinding.
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)
Invoergegevens selecteren om de index te bouwen
U kunt de index maken op basis van de volgende typen invoer:
- Lokale bestanden en mappen
- GitHub-opslagplaatsen
- Azure Storage
We kunnen het volgende codevoorbeeld gebruiken om een van deze bronnen te gebruiken en ons input_sourcete configureren:
# 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}"
De index bouwen in de cloud
Nu kunnen we de index bouwen met behulp van de ai_search_connection, embeddings_model_config en input_source. We gebruiken de build_index functie. Als u een Azure Storage-URL als invoerbron gebruikt, moet u ook een 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
)
Afhankelijk van de grootte van de invoerbrongegevens kan het enige tijd duren voordat de bovenstaande stappen zijn voltooid. Zodra de taak is voltooid, kunt u het indexobject ophalen.
my_index=client.indexes.get(name="<index_name>", label="latest")
Een geregistreerde index van uw project gebruiken
Als u een geregistreerde index uit uw project wilt gebruiken, moet u verbinding maken met het project en de index ophalen. De opgehaalde index kan worden gebruikt als een langhcain-retriever om deze te gebruiken. U kunt verbinding maken met het project met een client zoals hier wordt weergegeven.
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>")
Een vraag- en antwoordfunctie voor het gebruik van de index
We hebben gezien hoe we een index lokaal of in de cloud kunnen bouwen. Met deze index bouwen we een QnA-functie die een gebruikersvraag accepteert en een antwoord biedt op basis van de indexgegevens. Laten we eerst de index ophalen als een langchain_retriever, zoals hier wordt weergegeven. We gebruiken dit retriever nu in onze functie. Deze functie maakt gebruik van de LLM zoals gedefinieerd in de AzureChatOpenAI constructor. De index wordt gebruikt als een langchain_retriever om een query uit te voeren op de gegevens. We bouwen een promptsjabloon die een context en een vraag accepteert. We gebruiken langchain's RetrievalQA.from_chain_type om al deze samen te stellen en ons de antwoorden te geven.
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"]]),
}
Laten we een vraag stellen om er zeker van te zijn dat we een antwoord krijgen.
result = qna("<your question>")
print(result["answer"])