Mengembangkan aplikasi dengan LangChain dan Azure AI Foundry

LangChain adalah ekosistem pengembangan yang memudahkan pengembang untuk membangun aplikasi dengan alasan tersebut. Ekosistem terdiri dari beberapa komponen. Sebagian besar dapat digunakan sendiri, memungkinkan Anda untuk memilih dan memilih komponen mana pun yang paling Anda sukai.

Model yang disebarkan ke Azure AI Foundry dapat digunakan dengan LangChain dengan dua cara:

• Menggunakan API Inferensi Model Azure AI: Semua model yang disebarkan ke Azure AI Foundry mendukung API Inferensi Model, yang menawarkan serangkaian fungsi umum yang dapat digunakan untuk sebagian besar model dalam katalog. Manfaat dari API ini adalah bahwa, karena sama untuk semua model, mengubah dari satu ke yang lain semahal mengubah penyebaran model yang digunakan. Tidak ada perubahan lebih lanjut yang diperlukan dalam kode. Saat bekerja dengan LangChain, instal ekstensi langchain-azure-ai.

• Menggunakan API khusus penyedia model: Beberapa model, seperti OpenAI, Cohere, atau Mistral, menawarkan serangkaian API dan ekstensi mereka sendiri untuk LangChain. Ekstensi tersebut mungkin mencakup fungsionalitas khusus yang didukung model dan karenanya cocok jika Anda ingin mengeksploitasinya. Saat bekerja dengan LangChain, instal ekstensi khusus untuk model yang ingin Anda gunakan, seperti langchain-openai atau langchain-cohere.

Dalam tutorial ini, Anda mempelajari cara menggunakan paket langchain-azure-ai untuk membangun aplikasi dengan LangChain.

Prasyarat

Untuk menjalankan tutorial ini, Anda perlu:

• Sebuah langganan Azure.

• Penyebaran model yang mendukung API Inferensi Model telah dilakukan. Dalam contoh ini, kami menggunakan Mistral-Large-2411 penerapan di Model Foundry.

• Python 3.9 atau yang lebih baru terinstal, termasuk pip.

• LangChain terinstal. Anda dapat melakukannya dengan:

  pip install langchain
  

• Dalam contoh ini, kami bekerja dengan API Inferensi Model, oleh karena itu kami menginstal paket berikut:

  pip install -U langchain-azure-ai
  

Mengonfigurasi lingkungan

Untuk menggunakan LLM yang disebarkan di portal Azure AI Foundry, Anda memerlukan titik akhir dan kredensial untuk menyambungkannya. Ikuti langkah-langkah ini untuk mendapatkan informasi yang Anda butuhkan dari model yang ingin Anda gunakan:

Petunjuk / Saran

Karena Anda bisa mengkustomisasi panel kiri di portal Azure AI Foundry, Anda mungkin melihat item yang berbeda dari yang diperlihatkan dalam langkah-langkah ini. Jika Anda tidak melihat apa yang Anda cari, pilih ... Lainnya di bagian bawah panel kiri.

1. Pergi ke Azure AI Foundry.

2. Buka proyek tempat model disebarkan, jika belum terbuka.

3. Buka Model + titik akhir dan pilih model yang Anda sebarkan seperti yang ditunjukkan dalam prasyarat.

4. Salin URL titik akhir dan kunci.

   

   Petunjuk / Saran

   Jika model Anda disebarkan dengan dukungan ID Microsoft Entra, Anda tidak memerlukan kunci.

Dalam skenario ini, atur URL titik akhir dan kunci sebagai variabel lingkungan. (Jika titik akhir yang Anda salin menyertakan teks tambahan setelah /models, hapus sehingga URL berakhir seperti yang ditunjukkan di /models bawah ini.)

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

Setelah dikonfigurasi, buat klien untuk terhubung dengan model obrolan dengan menggunakan init_chat_model. Untuk model Azure OpenAI, konfigurasikan klien seperti yang ditunjukkan di Menggunakan model Azure OpenAI.

from langchain.chat_models import init_chat_model

llm = init_chat_model(model="Mistral-Large-2411", model_provider="azure_ai")

Anda juga dapat menggunakan kelas AzureAIChatCompletionsModel secara langsung.

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

Perhatian

Perubahan menerobos: Parameter model_name diganti model namanya dalam versi 0.1.3.

Anda dapat menggunakan kode berikut untuk membuat klien jika titik akhir Anda mendukung ID Microsoft Entra:

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="Mistral-Large-2411",
)

Nota

Saat menggunakan ID Microsoft Entra, pastikan titik akhir disebarkan dengan metode autentikasi tersebut dan Anda memiliki izin yang diperlukan untuk memanggilnya.

Jika Anda berencana menggunakan panggilan asinkron, ini adalah praktik terbaik untuk menggunakan versi asinkron untuk kredensial:

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="Mistral-Large-2411",
)

Jika titik akhir Anda melayani satu model, seperti penyebaran API tanpa server, Anda tidak perlu menunjukkan model parameter:

import os
from langchain_azure_ai.chat_models import AzureAIChatCompletionsModel

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

Menggunakan model penyelesaian obrolan

Mari kita pertama-tama gunakan model secara langsung. ChatModels adalah instans LangChain Runnable, yang berarti mereka mengekspos antarmuka standar untuk berinteraksi dengan mereka. Untuk memanggil model, kita dapat meneruskan daftar pesan ke invoke metode .

from langchain_core.messages import HumanMessage, SystemMessage

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

model.invoke(messages)

Anda juga dapat menyusun operasi sesuai kebutuhan dalam rantai. Sekarang mari kita gunakan templat perintah untuk menerjemahkan kalimat:

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

Seperti yang Anda lihat dari templat prompt, rantai ini memiliki language input dan text . Sekarang, mari kita buat pengurai output:

from langchain_core.output_parsers import StrOutputParser

parser = StrOutputParser()

Kita sekarang dapat menggabungkan templat, model, dan pengurai output dari atas menggunakan operator pipa (|):

chain = prompt_template | model | parser

Untuk memanggil rantai, identifikasi input yang diperlukan dan berikan nilai menggunakan invoke metode :

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

Menautkan beberapa LLM bersama-sama

Model yang disebarkan ke Azure AI Foundry mendukung API Inferensi Model, yang merupakan standar di semua model. Rantai beberapa operasi LLM berdasarkan kemampuan setiap model sehingga Anda dapat mengoptimalkan model yang tepat berdasarkan kemampuan.

Dalam contoh berikut, kami membuat dua klien model. Satu adalah produser dan satu lagi adalah pemverifikasi. Untuk memperjelas perbedaan, kami menggunakan titik akhir multi-model seperti Foundry Models API dan karenanya kami meneruskan parameter model untuk menggunakan Mistral-Large model dan Mistral-Small , mengutip fakta bahwa memproduksi konten lebih kompleks daripada memverifikasinya.

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

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

Petunjuk / Saran

Jelajahi kartu model dari setiap model untuk memahami kasus penggunaan terbaik untuk setiap model.

Contoh berikut menghasilkan puisi yang ditulis oleh penyair perkotaan:

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

Sekarang mari kita rantai potongan-potongan:

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

Rantai sebelumnya mengembalikan output dari langkah verifier saja. Karena kami ingin mengakses hasil perantara yang dihasilkan oleh producer, di LangChain, Anda perlu menggunakan RunnablePassthrough objek untuk juga menghasilkan langkah perantara tersebut.

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)

Untuk memanggil rantai, identifikasi input yang diperlukan dan berikan nilai menggunakan invoke metode :

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

Menggunakan model penyematan

Dengan cara yang sama, Anda membuat klien LLM, Anda dapat terhubung ke model penyematan. Dalam contoh berikut, kita mengatur variabel lingkungan agar sekarang menunjuk ke model embedding:

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

Kemudian buat klien:

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

Contoh berikut menunjukkan contoh sederhana menggunakan penyimpanan vektor dalam memori:

from langchain_core.vectorstores import InMemoryVectorStore

vector_store = InMemoryVectorStore(embed_model)

Mari kita tambahkan beberapa dokumen:

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)

Mari kita cari dengan kesamaan:

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

Menggunakan model Azure OpenAI

Jika Anda menggunakan model Azure OpenAI dengan langchain-azure-ai paket, gunakan URL berikut:

from langchain_azure_ai.chat_models import AzureAIChatCompletionsModel

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

Debugging dan pemecahan masalah

Jika Anda perlu men-debug aplikasi dan memahami permintaan yang dikirim ke model di Azure AI Foundry, Anda dapat menggunakan kemampuan debug integrasi sebagai berikut:

Pertama, konfigurasikan pengelogan ke tingkat yang Anda minati:

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)

Untuk melihat payload permintaan, saat membuat instans klien, teruskan argumen logging_enable=True ke :client_kwargs

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

Gunakan klien seperti biasa dalam kode Anda.

Memetakan

Anda dapat menggunakan kemampuan pelacakan di Azure AI Foundry dengan membuat pelacak. Log disimpan di Azure Application Insights dan dapat dikueri kapan saja menggunakan Azure Monitor atau portal Azure AI Foundry. Setiap AI Hub memiliki Azure Application Insights yang terkait dengannya.

Dapatkan string koneksi instrumentasi Anda

Petunjuk / Saran

Karena Anda bisa mengkustomisasi panel kiri di portal Azure AI Foundry, Anda mungkin melihat item yang berbeda dari yang diperlihatkan dalam langkah-langkah ini. Jika Anda tidak melihat apa yang Anda cari, pilih ... Lainnya di bagian bawah panel kiri.

Anda dapat mengonfigurasi aplikasi untuk mengirim telemetri ke Azure Application Insights baik dengan:

1. Menggunakan string koneksi ke Azure Application Insights secara langsung:

   1. Buka portal Azure AI Foundry dan pilih Pelacakan.

   2. Pilih Kelola sumber data. Di layar ini Anda dapat melihat instans yang terkait dengan proyek.

   3. Salin nilai di String koneksi dan atur ke variabel berikut:

      import os
      
      application_insights_connection_string = "instrumentation...."
      

2. Menggunakan Azure AI Foundry SDK dan string koneksi proyek (hanya proyek berbasis hub).

   1. Pastikan Anda memiliki paket azure-ai-projects yang terinstal di lingkungan Anda.

   2. Pergi ke portal Azure AI Foundry.

   3. Salin string koneksi proyek Anda dan atur kode berikut:

      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()
      

Mengonfigurasi pelacakan untuk Azure AI Foundry

Kode berikut membuat pelacak yang tersambung ke Azure Application Insights di belakang proyek di Azure AI Foundry. Perhatikan bahwa parameter enable_content_recording diatur ke True. Ini memungkinkan pengambilan input dan output dari seluruh aplikasi serta langkah-langkah perantara. Hal ini sangat membantu saat men-debug dan membangun aplikasi, tetapi Anda mungkin ingin menonaktifkannya di lingkungan produksi. Ini default ke variabel AZURE_TRACING_GEN_AI_CONTENT_RECORDING_ENABLEDlingkungan :

from langchain_azure_ai.callbacks.tracers import AzureAIInferenceTracer

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

Untuk mengonfigurasi pelacakan dengan rantai Anda, tunjukkan konfigurasi nilai dalam invoke operasi sebagai panggilan balik:

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

Untuk mengonfigurasi rantai itu sendiri untuk pelacakan, gunakan .with_config() metode :

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

Kemudian gunakan invoke() metode seperti biasa:

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

Melihat jejak

Untuk melihat jejak:

1. Pergi ke portal Azure AI Foundry.

2. Navigasi ke bagian Pelacakan .

3. Identifikasi jejak yang telah Anda buat. Mungkin perlu beberapa detik agar jejak ditampilkan.

   

Pelajari selengkapnya tentang cara memvisualisasikan dan mengelola jejak.

Langkah selanjutnya

• Mengembangkan aplikasi dengan LlamaIndex
• Memvisualisasikan dan mengelola jejak di Azure AI Foundry
• Menggunakan Model Azure AI Foundry
• Referensi: API Inferensi Model