Toepassingen ontwikkelen met modellen en LangChain in Microsoft Foundry (klassiek)

LangChain is een ontwikkelaarsecosysteem waarmee u eenvoudiger redeneringstoepassingen kunt bouwen. Het bevat meerdere componenten, en de meeste daarvan kunnen onafhankelijk worden gebruikt, zodat u de benodigde onderdelen kunt selecteren.

U kunt modellen gebruiken die op twee manieren zijn geïmplementeerd voor Microsoft Foundry met LangChain:

Deze zelfstudie laat zien hoe u het langchain-azure-ai[v1]-pakket met LangChain gebruikt met behulp van Azure AI-modeldeductie-API. Sommige modellen, zoals OpenAI, Cohere of Mistral, bieden hun eigen API's en LangChain-extensies. Deze extensies kunnen modelspecifieke mogelijkheden bevatten en zijn geschikt als u ze wilt gebruiken. Installeer de extensie voor het gekozen model, zoals langchain-openai of langchain-cohere.

Voorwaarden

Als u deze zelfstudie wilt uitvoeren, hebt u het volgende nodig:

• Een Azure-account met een actief abonnement. Als u nog geen account hebt, maakt u een vrij Azure-account, inclusief een gratis proefabonnement.

• Vereiste rol:
  • Eigenaar of bijdrager aan de Foundry-resource of AI Hub om modellen in te zetten
  • Azure AI-gebruiker om het model in een Foundry-project te gebruiken
  • Azure AI Developer om het model te gebruiken in een hubproject

• Een modelimplementatie die ondersteuning biedt voor de ModelDeductie-API. In dit artikel wordt gebruikgemaakt van Mistral-Large-3.

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

• LangChain geïnstalleerd. U kunt deze installeren met behulp van de volgende opdracht:

  pip install langchain
  

• Installeer de Foundry-integratie:

  pip install -U langchain-azure-ai[v1]
  

De omgeving configureren

Als u LLM's wilt gebruiken die zijn geïmplementeerd in Microsoft 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. Meld u aan bij Microsoft Foundry. Zorg ervoor dat de wisselknop New Foundry is ingeschakeld. Deze stappen verwijzen naar Foundry (nieuw).

   

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

3. Kopieer de eindpunt-URL en de sleutel.

In dit scenario stelt u de eindpunt-URL en -sleutel in als omgevingsvariabelen. (Als het eindpunt dat u hebt gekopieerd, extra tekst bevat /models, verwijdert u deze zodat de URL eindigt /models zoals hieronder wordt weergegeven.)

export AZURE_INFERENCE_ENDPOINT="https://<resource>.services.ai.azure.com/models"
export AZURE_INFERENCE_CREDENTIAL="<your-key-goes-here>"

Maak een client om verbinding te maken met het chatmodel met behulp van de AzureAIChatCompletionsModel klasse.

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-3",
)

Wat dit codefragment doet: Hiermee wordt een AzureAIChatCompletionsModel client geïnstitueerd die is geconfigureerd om verbinding te maken met uw geïmplementeerde model met behulp van een API-sleutel voor verificatie. Deze client fungeert als een interface voor de Model Inference API.

Verwijzingen:

• LangChain Azure AI-integratie
• Overzicht van Model Inference API

Als uw eindpunt ondersteuning biedt voor Microsoft Entra ID, gebruikt u de volgende code om de client te maken:

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

model = AzureAIChatCompletionsModel(
    endpoint=os.environ["AZURE_AI_INFERENCE_ENDPOINT"],
    credential=DefaultAzureCredential(),
    model="Mistral-Large-3",
)

Als u asynchrone aanroepen wilt gebruiken, gebruikt u de asynchrone versie van de referenties:

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

model = AzureAIChatCompletionsModel(
    endpoint=os.environ["AZURE_AI_INFERENCE_ENDPOINT"],
    credential=DefaultAzureCredentialAsync(),
    model="Mistral-Large-3",
)

Als uw eindpunt één model gebruikt (bijvoorbeeld serverloze API-implementaties), neemt u de model parameter niet op:

import os
from langchain_azure_ai.chat_models.inference import AzureAIChatCompletionsModel

model = AzureAIChatCompletionsModel(
    endpoint=os.environ["AZURE_AI_INFERENCE_ENDPOINT"],
    credential=os.environ["AZURE_AI_CREDENTIAL"],
)

Uw installatie controleren

Test uw clientverbinding met een eenvoudige aanroep:

response = model.invoke("Say hello")
print(response.content)

Wat dit doet: Roept het model aan met een eenvoudige prompt om verificatie en connectiviteit te verifiëren. Verwachte uitvoer: een begroetingsbericht van het model (bijvoorbeeld 'Hallo! Hoe kan ik je vandaag helpen?").

Verwijzingen:

• LangChain Runnable-interface

Modellen voor chattenvoltooiing gebruiken

Gebruik het model rechtstreeks. ChatModels zijn exemplaren van de LangChain-interface Runnable , die een standaardmethode biedt om ermee te communiceren. Als u het model wilt aanroepen, geeft u een lijst met berichten door 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)

Wat dit codefragment doet: Demonstreert hoe u een lijst HumanMessage met objecten SystemMessage doorgeeft aan de methode van invoke() het model om een antwoord te genereren.

Verwijzingen:

• LangChain-berichten
• LangChain Runnable-interface

Stel bewerkingen samen indien nodig in ketens. Gebruik een promptsjabloon om zinnen te vertalen:

from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate

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

Deze keten neemt language en text invoer. Maak nu een uitvoerparser:

from langchain_core.output_parsers import StrOutputParser

parser = StrOutputParser()

Wat dit codefragment doet: Hiermee maakt u een StrOutputParser die de uitvoer van het model converteert naar een tekenreeksindeling, waardoor eventuele extra metagegevens worden verwijderd.

Verwijzingen:

• LangChain-uitvoerparsers

Combineer de sjabloon, het model en de uitvoerparser met behulp van de pijpoperator (|):

chain = prompt_template | model | parser

Roep de keten aan door waarden op te geven language en text te gebruiken met behulp van de invoke methode:

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

Meerdere LLM's aan elkaar koppelen

Omdat modellen in Foundry een algemene ModelDeductie-API beschikbaar maken, kunt u meerdere LLM-bewerkingen koppelen en het model kiezen dat het meest geschikt is voor elke stap.

In het volgende voorbeeld maakt u twee modelclients: één producent en één verifier. Als u het onderscheid duidelijk wilt maken, gebruikt u een eindpunt met meerdere modellen, zoals de Api voor modeldeductie , en geeft u de model parameter door aan een groot model voor generatie en een klein model voor verificatie. Het produceren van inhoud vereist doorgaans een groter model, terwijl verificatie een kleiner model kan gebruiken.

from langchain_azure_ai.chat_models import AzureAIChatCompletionsModel

producer = AzureAIChatCompletionsModel(
    endpoint=os.environ["AZURE_INFERENCE_ENDPOINT"],
    credential=os.environ["AZURE_INFERENCE_CREDENTIAL"],
    model="Mistral-Large-3",
)

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

Wat dit codefragment doet: Instantieert twee afzonderlijke AzureAIChatCompletionsModel clients: één voor Mistral-Large-3 het genereren van inhoud en een ander voor Mistral-Small verificatie, waarmee wordt gedemonstreerd hoe u verschillende modellen voor verschillende taken kiest.

Verwijzingen:

• LangChain Azure AI-integratie

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"],
)

Wat dit codefragment doet: Hiermee maakt u een promptsjabloon en koppelt u deze aan de producer modelclient om creatieve inhoud te genereren (een gedicht in dit geval).

Koppel de stukken aan elkaar:

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

Wat dit codefragment doet: Koppelt het gegenereerde gedicht via het verifier model om de gegenereerde inhoud te valideren of te controleren, waarbij een werkstroom voor producent-verificator wordt gedemonstreerd.

De vorige keten retourneert alleen de uitvoer van de verifier stap. Als u toegang wilt krijgen tot het tussenliggende resultaat dat door de producer wordt gegenereerd, gebruikt u een RunnablePassthrough om die tussenliggende stap uit te voeren.

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)

Roep de keten aan met behulp van de invoke methode:

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

Wat dit codefragment doet: Roept de volledige producer-verifier-keten aan met een onderwerpinvoer, waardoor zowel de gegenereerde inhoud als het verificatieresultaat worden geretourneerd. Verwachte uitvoer: een JSON-object met poem en verification sleutels met het gegenereerde gedicht en verificatieantwoord.

Verwijzingen:

• LangChain Runnables

Insluitmodellen gebruiken

Maak een embeddingsclient op een vergelijkbare manier. Stel de omgevingsvariabelen in om te verwijzen naar een insluitmodel:

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

Maak de client:

import os
from langchain_azure_ai.embeddings import AzureAIEmbeddingsModel

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

Wat dit codefragment doet: Hiermee wordt een insluitingsclient geïnstitueerd die wordt gebruikt AzureAIEmbeddingsModel om tekst te converteren naar vector-insluitingen, die kunnen worden gebruikt voor semantische zoek- en overeenkomstenvergelijkingen.

Verwijzingen:

• LangChain Embeddings

Gebruik een vectorarchief in het geheugen:

from langchain_core.vectorstores import InMemoryVectorStore

vector_store = InMemoryVectorStore(embed_model)

Wat dit codefragment doet: Het creëert een in-memory vectoropslag (InMemoryVectorStore) waarin embeddings worden opgeslagen voor snelle similariteitszoekoperaties.

Verwijzingen:

• LangChain Vector Stores

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)

Wat dit codefragment doet: Converteert documenten naar insluitingen met behulp van de client voor insluitingen en voegt deze toe aan het vectorarchief voor later ophalen.

Verwijzingen:

• LangChain Vector Stores

Zoeken op gelijkenis:

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

Wat dit codefragment doet: Voert een semantische zoekopdracht uit op het vectorarchief en retourneert documenten die het meest lijken op de query op basis van het insluiten van overeenkomsten. Verwachte uitvoer: Lijst met relevante documenten gerangschikt op overeenkomstenscore.

Azure OpenAI-modellen gebruiken

Wanneer u Azure OpenAI-modellen gebruikt met het pakket langchain-azure-ai, gebruikt u de volgende eindpuntindeling:

import os
from langchain_azure_ai.chat_models.inference import AzureAIChatCompletionsModel

llm = AzureAIChatCompletionsModel(
    endpoint="https://<resource>.openai.azure.com/openai/v1",
    credential=os.environ["AZURE_INFERENCE_CREDENTIAL"],
    model="gpt-4o"
)

Wat dit codefragment doet: Instantieert een client die specifiek is geconfigureerd voor Azure OpenAI-modellen met behulp van het Azure OpenAI-eindpuntformaat. De parameter endpoint verwijst naar uw Azure OpenAI-resource en de credential maakt gebruik van de API-sleutel die is opgeslagen in de omgevingsvariabele.

Verwijzingen:

• LangChain Azure AI-integratie

Foutopsporing en probleemoplossing

Als u fouten in uw toepassing wilt opsporen en inzicht wilt hebben in de aanvragen die naar modellen in Foundry worden verzonden, gebruikt u de mogelijkheden voor foutopsporing van de integratie:

Configureer eerst logboekregistratie op het gewenste niveau:

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)

Wat dit codefragment doet: stelt Python logboekregistratie in op foutopsporingsniveau om gedetailleerde informatie over HTTP-aanvragen en -antwoorden tussen LangChain en de Modeldeductie-API vast te leggen.

Verwijzingen:

• Python logboekregistratiemodule

Als u verzoekpayloads wilt bekijken, geef dan logging_enable=True in client_kwargs door bij het instantiëren van de client:

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-3",
    client_kwargs={"logging_enable": True},
)

Wat dit codefragment doet: Hiermee maakt u een client waarvoor logboekregistratie is ingeschakeld om gedetailleerde nettoladingen voor aanvragen/antwoorden vast te leggen en weer te geven, handig voor het opsporen van fouten in API-interacties.

Gebruik de client zoals gebruikelijk in uw code.

Tracering

Gebruik maken van traceren in Foundry door een tracer te creëren. Logboeken worden opgeslagen in Azure-toepassing Insights en kunnen op elk gewenst moment worden opgevraagd met behulp van Azure Monitor of de Foundry-portal. Elke AI-hub heeft een gekoppeld Azure-toepassing Insights-exemplaar.

Haal uw instrumentatie-verbindingsreeks op.

U kunt uw toepassing configureren om telemetrie te verzenden naar Azure-toepassing Insights met behulp van een van de volgende methoden:

1. Gebruik de verbindingsreeks om rechtstreeks toegang te krijgen tot Azure-toepassing Insights.

   1. Ga naar de 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 Microsoft Foundry SDK en het Foundry Project-eindpunt:

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

   2. Ga naar de Foundry-portal.

   3. Kopieer de eindpunt-URL van het Foundry-project en stel deze in de volgende code in:

      from azure.ai.projects import AIProjectClient
      from azure.identity import DefaultAzureCredential
      
      project_client = AIProjectClient(
          credential=DefaultAzureCredential(),
          endpoint="<your-foundry-project-endpoint-url>",
      )
      
      application_insights_connection_string = project_client.telemetry.get_application_insights_connection_string()
      

Meer informatie over het visualiseren en beheren van traceringen.

Volgende stappen

• Toepassingen ontwikkelen met LlamaIndex
• Traceringen visualiseren en beheren in Foundry
• Foundry-modellen gebruiken
• Referentie: Modelinferentie-API