Toepassingen ontwikkelen met LangChain en Azure AI Foundry

LangChain is een ontwikkelecosysteem dat ontwikkelaars zo eenvoudig mogelijk maakt om toepassingen te bouwen die daarom zijn bedoeld. Het ecosysteem bestaat uit meerdere onderdelen. De meeste onderdelen kunnen zelf worden gebruikt, zodat u kunt kiezen welke onderdelen u het beste vindt.

Modellen die zijn geïmplementeerd in Azure AI Foundry kunnen op twee manieren worden gebruikt met LangChain:

• Met behulp van de Azure AI-modeldeductie-API: alle modellen die zijn geïmplementeerd in Azure AI Foundry ondersteunen de Deductie-API voor Azure AI-modellen, die een algemene set functies biedt die voor de meeste modellen in de catalogus kunnen worden gebruikt. Het voordeel van deze API is dat, omdat deze voor alle modellen hetzelfde is, het wijzigen van de ene naar de andere eenvoudig is als het wijzigen van de modelimplementatie die wordt gebruikt. Er zijn geen verdere wijzigingen vereist in de code. Wanneer u met LangChain werkt, installeert u de extensies langchain-azure-ai.

• Met behulp van de providerspecifieke API van het model: Sommige modellen, zoals OpenAI, Cohere of Mistral, bieden hun eigen set API's en extensies voor LlamaIndex. Deze extensies kunnen specifieke functionaliteiten bevatten die door het model worden ondersteund en daarom geschikt zijn als u ze wilt benutten. Wanneer u met LangChain werkt, installeert u de extensie die specifiek is voor het model dat u wilt gebruiken, zoals langchain-openai of langchain-cohere.

In deze zelfstudie leert u hoe u de pakketten langchain-azure-ai gebruikt om toepassingen te bouwen met LangChain.

Vereisten

U hebt het volgende nodig om deze zelfstudie te volgen:

• Een Azure-abonnement.

• Een modelimplementatie die de deductie-API van het Azure AI-model ondersteunt. In dit voorbeeld gebruiken we een Mistral-Large-2407 implementatie in de deductie van het Azure AI-model.

• Python 3.9 of hoger geïnstalleerd, inclusief pip.

• LangChain geïnstalleerd. U kunt dit doen met:

  pip install langchain-core
  

• In dit voorbeeld werken we met de deductie-API van het Azure AI-model. Daarom installeren we de volgende pakketten:

  pip install -U langchain-azure-ai
  

De omgeving configureren

Als u LLM's wilt gebruiken die zijn geïmplementeerd in de Azure AI Foundry-portal, hebt u het eindpunt en de referenties nodig om er verbinding mee te maken. Volg deze stappen om de benodigde informatie op te halen uit het model dat u wilt gebruiken:

1. Ga naar Azure AI Foundry.

2. Open het project waarin het model is geïmplementeerd, als het nog niet is geopend.

3. Ga naar Modellen en eindpunten en selecteer het model dat u hebt geïmplementeerd zoals aangegeven in de vereisten.

4. Kopieer de eindpunt-URL en de sleutel.

   

   Tip

   Als uw model is geïmplementeerd met ondersteuning voor Microsoft Entra ID, hebt u geen sleutel nodig.

In dit scenario hebben we zowel de eindpunt-URL als de sleutel in de volgende omgevingsvariabelen geplaatst:

export AZURE_INFERENCE_ENDPOINT="<your-model-endpoint-goes-here>"
export AZURE_INFERENCE_CREDENTIAL="<your-key-goes-here>"

Zodra deze is geconfigureerd, maakt u een client om verbinding te maken met het eindpunt. In dit geval werken we met een model voor chatvoltooiing, vandaar dat we de klasse AzureAIChatCompletionsModelimporteren.

import os
from langchain_azure_ai.chat_models import AzureAIChatCompletionsModel

model = AzureAIChatCompletionsModel(
    endpoint=os.environ["AZURE_INFERENCE_ENDPOINT"],
    credential=os.environ["AZURE_INFERENCE_CREDENTIAL"],
    model="mistral-large-2407",
)

Tip

Voor Azure OpenAI-modellen configureert u de client zoals aangegeven bij Azure OpenAI-modellen gebruiken.

U kunt de volgende code gebruiken om de client te maken als uw eindpunt Microsoft Entra-id ondersteunt:

import os
from azure.identity import DefaultAzureCredential
from langchain_azure_ai.chat_models import AzureAIChatCompletionsModel

model = AzureAIChatCompletionsModel(
    endpoint=os.environ["AZURE_INFERENCE_ENDPOINT"],
    credential=DefaultAzureCredential(),
    model_name="mistral-large-2407",
)

Notitie

Wanneer u Microsoft Entra-id gebruikt, moet u ervoor zorgen dat het eindpunt is geïmplementeerd met die verificatiemethode en dat u de vereiste machtigingen hebt om het aan te roepen.

Als u van plan bent asynchroon aanroepen te gebruiken, is het een aanbevolen procedure om de asynchrone versie voor de referenties te gebruiken:

from azure.identity.aio import (
    DefaultAzureCredential as DefaultAzureCredentialAsync,
)
from langchain_azure_ai.chat_models import AzureAIChatCompletionsModel

model = AzureAIChatCompletionsModel(
    endpoint=os.environ["AZURE_INFERENCE_ENDPOINT"],
    credential=DefaultAzureCredentialAsync(),
    model_name="mistral-large-2407",
)

Als uw eindpunt één model bedient, zoals bij de serverloze API-eindpunten, hoeft u geen parameter aan te geven model_name :

import os
from langchain_azure_ai.chat_models import AzureAIChatCompletionsModel

model = AzureAIChatCompletionsModel(
    endpoint=os.environ["AZURE_INFERENCE_ENDPOINT"],
    credential=os.environ["AZURE_INFERENCE_CREDENTIAL"],
)

Modellen voor chatvoltooiing gebruiken

Laten we eerst het model rechtstreeks gebruiken. ChatModels zijn exemplaren van LangChain Runnable, wat betekent dat ze een standaardinterface beschikbaar maken voor interactie met hen. Als u het model gewoon wilt aanroepen, kunnen we een lijst met berichten doorgeven aan de invoke methode.

from langchain_core.messages import HumanMessage, SystemMessage

messages = [
    SystemMessage(content="Translate the following from English into Italian"),
    HumanMessage(content="hi!"),
]

model.invoke(messages)

U kunt zo nodig ook bewerkingen opstellen in de zogenaamde ketens. Laten we nu een promptsjabloon gebruiken om zinnen te vertalen:

from langchain_core.output_parsers import StrOutputParser

system_template = "Translate the following into {language}:"
prompt_template = ChatPromptTemplate.from_messages(
    [("system", system_template), ("user", "{text}")]
)

Zoals u kunt zien in de promptsjabloon, heeft deze keten een language en text invoer. Nu gaan we een uitvoerparser maken:

from langchain_core.prompts import ChatPromptTemplate
parser = StrOutputParser()

We kunnen nu de sjabloon, het model en de uitvoerparser van boven combineren met behulp van de operator pipe (|):

chain = prompt_template | model | parser

Als u de keten wilt aanroepen, identificeert u de vereiste invoer en geeft u waarden op met behulp van de invoke methode:

chain.invoke({"language": "italian", "text": "hi"})

'ciao'

Meerdere LLM's aan elkaar koppelen

Modellen die zijn geïmplementeerd in Azure AI Foundry ondersteunen de Deductie-API van het Azure AI-model, die standaard is voor alle modellen. Koppel meerdere LLM-bewerkingen op basis van de mogelijkheden van elk model, zodat u kunt optimaliseren voor het juiste model op basis van mogelijkheden.

In het volgende voorbeeld maken we twee modelclients, een is een producent en een andere is een verifier. Om het onderscheid duidelijk te maken, gebruiken we een eindpunt met meerdere modellen, zoals de deductieservice van het Azure AI-model. Daarom geven we de parameter model_name door om een Mistral-Large en een Mistral-Small model te gebruiken, waarbij het feit dat het produceren van inhoud complexer is dan het verifiëren ervan.

from langchain_azure_ai.chat_models import AzureAIChatCompletionsModel

producer = AzureAIChatCompletionsModel(
    endpoint=os.environ["AZURE_INFERENCE_ENDPOINT"],
    credential=os.environ["AZURE_INFERENCE_CREDENTIAL"],
    model_name="mistral-large-2407",
)

verifier = AzureAIChatCompletionsModel(
    endpoint=os.environ["AZURE_INFERENCE_ENDPOINT"],
    credential=os.environ["AZURE_INFERENCE_CREDENTIAL"],
    model_name="mistral-small",
)

Tip

Bekijk de modelkaart van elk van de modellen om inzicht te hebben in de beste use cases voor elk model.

In het volgende voorbeeld wordt een gedicht gegenereerd dat is geschreven door een stedelijke dichter:

from langchain_core.prompts import PromptTemplate

producer_template = PromptTemplate(
    template="You are an urban poet, your job is to come up \
             verses based on a given topic.\n\
             Here is the topic you have been asked to generate a verse on:\n\
             {topic}",
    input_variables=["topic"],
)

verifier_template = PromptTemplate(
    template="You are a verifier of poems, you are tasked\
              to inspect the verses of poem. If they consist of violence and abusive language\
              report it. Your response should be only one word either True or False.\n \
              Here is the lyrics submitted to you:\n\
              {input}",
    input_variables=["input"],
)

Nu gaan we de onderdelen aan elkaar koppelen:

chain = producer_template | producer | parser | verifier_template | verifier | parser

De vorige keten retourneert alleen de uitvoer van de stap verifier . Omdat we toegang willen krijgen tot het tussenliggende resultaat dat is gegenereerd door de producer, moet u in LangChain een RunnablePassthrough object gebruiken om ook die tussenliggende stap uit te voeren. De volgende code laat zien hoe u dit doet:

from langchain_core.runnables import RunnablePassthrough, RunnableParallel

generate_poem = producer_template | producer | parser
verify_poem = verifier_template | verifier | parser

chain = generate_poem | RunnableParallel(poem=RunnablePassthrough(), verification=RunnablePassthrough() | verify_poem)

Als u de keten wilt aanroepen, identificeert u de vereiste invoer en geeft u waarden op met behulp van de invoke methode:

chain.invoke({"topic": "living in a foreign country"})

{
  "peom": "...",
  "verification: "false"
}

Insluitingsmodellen gebruiken

Op dezelfde manier maakt u een LLM-client, kunt u verbinding maken met een insluitmodel. In het volgende voorbeeld stellen we de omgevingsvariabele zo in dat deze nu verwijst naar een insluitingsmodel:

export AZURE_INFERENCE_ENDPOINT="<your-model-endpoint-goes-here>"
export AZURE_INFERENCE_CREDENTIAL="<your-key-goes-here>"

Maak vervolgens de client:

from langchain_azure_ai.embeddings import AzureAIEmbeddingsModel

embed_model = AzureAIEmbeddingsModel(
    endpoint=os.environ["AZURE_INFERENCE_ENDPOINT"],
    credential=os.environ['AZURE_INFERENCE_CREDENTIAL'],
    model_name="text-embedding-3-large",
)

In het volgende voorbeeld ziet u een eenvoudig voorbeeld met behulp van een vectorarchief in het geheugen:

from langchain_core.vectorstores import InMemoryVectorStore

vector_store = InMemoryVectorStore(embed_model)

Laten we enkele documenten toevoegen:

from langchain_core.documents import Document

document_1 = Document(id="1", page_content="foo", metadata={"baz": "bar"})
document_2 = Document(id="2", page_content="thud", metadata={"bar": "baz"})

documents = [document_1, document_2]
vector_store.add_documents(documents=documents)

Laten we zoeken op gelijkenis:

results = vector_store.similarity_search(query="thud",k=1)
for doc in results:
    print(f"* {doc.page_content} [{doc.metadata}]")

Azure OpenAI-modellen gebruiken

Als u de Azure OpenAI-service of azure AI-modeldeductieservice gebruikt met OpenAI-modellen met langchain-azure-ai pakket, moet u mogelijk een parameter gebruiken api_version om een specifieke API-versie te selecteren. In het volgende voorbeeld ziet u hoe u verbinding maakt met een Azure OpenAI-modelimplementatie in de Azure OpenAI-service:

from langchain_azure_ai.chat_models import AzureAIChatCompletionsModel

llm = AzureAIChatCompletionsModel(
    endpoint="https://<resource>.openai.azure.com/openai/deployments/<deployment-name>",
    credential=os.environ["AZURE_INFERENCE_CREDENTIAL"],
    api_version="2024-05-01-preview",
)

Belangrijk

Controleer welke API-versie uw implementatie gebruikt. Als u een fout api_version gebruikt of niet wordt ondersteund door het model, resulteert dit in een ResourceNotFound uitzondering.

Als de implementatie wordt gehost in Azure AI Services, kunt u de deductieservice van het Azure AI-model gebruiken:

from langchain_azure_ai.chat_models import AzureAIChatCompletionsModel

llm = AzureAIChatCompletionsModel(
    endpoint="https://<resource>.services.ai.azure.com/models",
    credential=os.environ["AZURE_INFERENCE_CREDENTIAL"],
    model_name="<model-name>",
    api_version="2024-05-01-preview",
)

Foutopsporing en probleemoplossing

Als u fouten in uw toepassing wilt opsporen en inzicht wilt hebben in de aanvragen die naar de modellen in Azure AI Foundry worden verzonden, kunt u de foutopsporingsmogelijkheden van de integratie als volgt gebruiken:

Configureer eerst logboekregistratie op het niveau waarin u geïnteresseerd bent:

import sys
import logging

# Acquire the logger for this client library. Use 'azure' to affect both
# 'azure.core` and `azure.ai.inference' libraries.
logger = logging.getLogger("azure")

# Set the desired logging level. logging.INFO or logging.DEBUG are good options.
logger.setLevel(logging.DEBUG)

# Direct logging output to stdout:
handler = logging.StreamHandler(stream=sys.stdout)
# Or direct logging output to a file:
# handler = logging.FileHandler(filename="sample.log")
logger.addHandler(handler)

# Optional: change the default logging format. Here we add a timestamp.
formatter = logging.Formatter("%(asctime)s:%(levelname)s:%(name)s:%(message)s")
handler.setFormatter(formatter)

Als u de nettoladingen van de aanvragen wilt zien, geeft u bij het instantiëren van de client het argument logging_enable=True door aan het client_kwargsvolgende:

import os
from langchain_azure_ai.chat_models import AzureAIChatCompletionsModel

model = AzureAIChatCompletionsModel(
    endpoint=os.environ["AZURE_INFERENCE_ENDPOINT"],
    credential=os.environ["AZURE_INFERENCE_CREDENTIAL"],
    model_name="mistral-large-2407",
    client_kwargs={"logging_enable": True},
)

Gebruik de client zoals gebruikelijk in uw code.

Tracering

U kunt de traceringsmogelijkheden in Azure AI Foundry gebruiken door een tracer te maken. Logboeken worden opgeslagen in Azure-toepassing Insights en kunnen op elk gewenst moment worden opgevraagd met behulp van de Azure Monitor- of Azure AI Foundry-portal. Aan elke AI Hub is een Azure-toepassing Inzichten gekoppeld.

Uw instrumentatie verbindingsreeks

U kunt uw toepassing configureren voor het verzenden van telemetrie naar Azure-toepassing Insights door:

1. De verbindingsreeks gebruiken om inzichten rechtstreeks te Azure-toepassing:

   1. Ga naar de Azure AI Foundry-portal en selecteer Tracering.

   2. Selecteer Gegevensbron beheren. In dit scherm ziet u het exemplaar dat is gekoppeld aan het project.

   3. Kopieer de waarde bij de verbindingsreeks en stel deze in op de volgende variabele:

      import os
      
      application_insights_connection_string = "instrumentation...."
      

2. Gebruik de Azure AI Foundry SDK en het project verbindingsreeks.

   1. Zorg ervoor dat het pakket azure-ai-projects in uw omgeving is geïnstalleerd.

   2. Ga naar de Azure AI Foundry-portal.

   3. Kopieer de verbindingsreeks van uw project en stel de volgende code in:

      from azure.ai.projects import AIProjectClient
      from azure.identity import DefaultAzureCredential
      
      project_client = AIProjectClient.from_connection_string(
          credential=DefaultAzureCredential(),
          conn_str="<your-project-connection-string>",
      )
      
      application_insights_connection_string = project_client.telemetry.get_connection_string()
      

Tracering configureren voor Azure AI Foundry

Met de volgende code wordt een tracer gemaakt die is verbonden met de Azure-toepassing Insights achter een project in Azure AI Foundry. U ziet dat de parameter enable_content_recording is ingesteld op True. Hiermee kunt u de invoer en uitvoer van de gehele toepassing en de tussenliggende stappen vastleggen. Dit is handig bij het opsporen en bouwen van toepassingen, maar mogelijk wilt u dit uitschakelen in productieomgevingen. Deze wordt standaard ingesteld op de omgevingsvariabele AZURE_TRACING_GEN_AI_CONTENT_RECORDING_ENABLED:

from langchain_azure_ai.callbacks.tracers import AzureAIInferenceTracer

tracer = AzureAIInferenceTracer(
    connection_string=application_insights_connection_string,
    enable_content_recording=True,
)

Als u tracering met uw keten wilt configureren, geeft u de waardeconfiguratie in de invoke bewerking aan als een callback:

chain.invoke({"topic": "living in a foreign country"}, config={"callbacks": [tracer]})

Als u de keten zelf wilt configureren voor tracering, gebruikt u de .with_config() methode:

chain = chain.with_config({"callbacks": [tracer]})

Gebruik vervolgens de invoke() methode zoals gebruikelijk:

chain.invoke({"topic": "living in a foreign country"})

Traceringen weergeven

Traceringen bekijken:

1. Ga naar de Azure AI Foundry-portal.

2. Navigeer naar de sectie Tracering .

3. Identificeer de trace die u hebt gemaakt. Het kan enkele seconden duren voordat de tracering wordt weergegeven.

   

Meer informatie over het visualiseren en beheren van traceringen.

Volgende stappen

• Toepassingen ontwikkelen met LlamaIndex
• Traceringen visualiseren en beheren in Azure AI Foundry
• De azure AI-modeldeductieservice gebruiken
• Naslaginformatie: Azure AI-modeldeductie-API