Trasování a sledování agentů AI v Microsoft Foundry (Preview) (Classic)

Platí jenom pro:Portál Foundry (Classic). Tento článek není k dispozici pro nový portál Foundry. Přečtěte si další informace o novém portálu.

Poznámka

Odkazy v tomto článku můžou otevírat obsah v nové dokumentaci Microsoft Foundry místo dokumentace Foundry (classic), kterou si právě prohlížíte.

Důležité

Položky označené (Preview) v tomto článku jsou aktuálně ve verzi Public Preview. Tato verze Preview je poskytována bez smlouvy o úrovni služeb a nedoporučujeme ji pro produkční úlohy. Některé funkce nemusí být podporované nebo můžou mít omezené možnosti. Další informace najdete v tématu Supplementální podmínky použití pro Microsoft Azure Verze Preview.

V tomto článku se naučíte:

Seznamte se s klíčovými koncepty trasování.
Trasování a sledování agentů AI v Foundry
Prozkoumejte nové sémantické konvence s využitím pozorovatelnosti s více agenty.
Integrace s oblíbenými architekturami agentů
Zobrazte trasování na portálu Foundry a Azure Monitor.
Zobrazte vlákna agentů v dětském hřišti Agenti.

Určení důvodů vykonávání vašeho softwarového agenta je důležité pro odstraňování problémů a ladění. Složité agenty ale můžou být obtížné z mnoha důvodů:

Při generování odpovědi může být velký počet kroků, což znesnadňuje sledování všech těchto kroků.
Posloupnost kroků se může lišit v závislosti na vstupu uživatele.
Vstupy a výstupy v každé fázi můžou být dlouhé a zaslouží si podrobnější kontrolu.
Každý krok modulu runtime agenta může zahrnovat také vnoření. Agent může například vyvolat nástroj, který používá jiný proces, který pak vyvolá jiný nástroj. Pokud si všimnete podivného nebo nesprávného výstupu z spuštění agenta nejvyšší úrovně, může být obtížné přesně určit, kde byl problém zaveden.

Výsledky trasování tento problém řeší tím, že vám umožní zobrazit vstupy a výstupy jednotlivých primitiv zapojených do konkrétního spuštění agenta. Výsledky se zobrazí v pořadí, v jakém jsou vyvolány primitivy, což usnadňuje pochopení a ladění chování agenta AI.

Přehled klíčových konceptů trasování

Tady je stručný přehled klíčových konceptů, než začnete:

Klíčové koncepty	Popis
Sledování	Trasy zachycují cestu požadavku nebo pracovního postupu vaší aplikací tím, že zaznamenávají události a změny stavu, jako například volání funkcí, hodnoty a systémové události. Viz trasování OpenTelemetry.
Rozsahy	Úseky jsou stavební bloky trasování, které představují jednotlivé operace v rámci jednoho trasování. Každý rozsah zachycuje počáteční a koncové časy, atributy a dají se vnořit, aby se zobrazily hierarchické vztahy. Zobrazí se kompletní zásobník volání a posloupnost operací.
Atributy	Atributy jsou páry klíč-hodnota připojené k trasám a rozpětím. Poskytují kontextová metadata, jako jsou parametry funkce, návratové hodnoty nebo vlastní poznámky. Tyto hodnoty vylepšují data trasování, což z nich dělá více informativních a užitečnějších pro analýzu.
Sémantické konvence	OpenTelemetry definuje sémantické konvence pro standardizaci názvů a formátů pro atributy dat trasování. Tyto konvence usnadňují interpretaci a analýzu dat napříč nástroji a platformami. Další informace najdete v tématu sémantické konvence OpenTelemetry.
Vývozci trasování	Exportéři trasování odesílají data trasování do back-endových systémů pro ukládání a analýzu. Azure AI podporuje export trasování do Azure Monitor a dalších platforem kompatibilních s OpenTelemetry, což umožňuje integraci s různými nástroji pozorovatelnosti.

Osvědčené postupy

Používejte konzistentní atributy spanu.
Provázat ID běhů vyhodnocení pro analýzu kvality a výkonu.
Redigovat citlivý obsah. Vyhněte se ukládání tajných kódů v atributech.

Rozšíření OpenTelemetry s pozorovatelností s více agenty

Microsoft vylepšuje pozorovatelnost multi-agentních systémů zaváděním nových sémantických konvencí do OpenTelemetry, vyvinutých ve spolupráci s Outshift, inkubačním enginem společnosti Cisco. Tyto doplňky založené na OpenTelemetry a kontextu trasování W3C vytvářejí standardizované postupy pro trasování a telemetrii v rámci systémů s více agenty. Usnadňují konzistentní protokolování klíčových metrik pro kvalitu, výkon, bezpečnost a náklady. Tento systematický přístup umožňuje komplexnější přehled o pracovních postupech s více agenty, včetně vyvolání nástrojů a spolupráce. Microsoft tyto pokroky integrují do Microsoft Foundry, Microsoft Agent Framework, Sémantické jádro a Azure balíčků AI pro LangChain, LangGraph a sadu OpenAI Agents SDK. Pomocí Foundry můžou zákazníci získat jednotnou pozorovatelnost pro systémy agentů vytvořené pomocí některé z těchto architektur. Přečtěte si další informace o integraci trasování.

Typ	Kontext nebo nadřazený rozsah	Název/atribut/událost	Účel
Span	—	spustit_úlohu	Zaznamenává plánování úkolů a šíření událostí a poskytuje přehled o tom, jak se úkoly rozkládají a distribuují.
Podřízená úroveň	invoke_agent	interakce_mezi_agenty	Trasuje komunikaci mezi agenty.
Podřízená úroveň	invoke_agent	agent.state.management	Efektivní kontext, krátkodobá nebo dlouhodobá správa paměti
Podřízená úroveň	invoke_agent	plánování agenta	Zaznamená interní kroky plánování agenta.
Podřízená úroveň	invoke_agent	Orchestrace agentů	Zachytává koordinaci mezi agenty.
Atribut	invoke_agent	definice_nástrojů	Popisuje účel nebo konfiguraci nástroje.
Atribut	invoke_agent	llm_spans	Zaznamenává rozsah volání modelu.
Atribut	spustit_nástroj	tool.call.arguments (nástroj.volání.argumenty)	Zaznamená argumenty předané během vyvolání nástroje.
Atribut	spustit_nástroj	tool.call.results	Zaznamenává výsledky vrácené nástrojem.
Událost	—	Vyhodnocení (název, typ.chyby, štítek)	Umožňuje strukturované vyhodnocení výkonu a rozhodování agentů.

Nastavení trasování v sadě Microsoft Foundry SDK

Pro dokončování chatu nebo sestavování agentů s Foundry nainstalujte:

pip install azure-ai-projects azure-identity

Pro trasování nainstalujte následující instrumentační knihovny.

pip install azure-monitor-opentelemetry opentelemetry-sdk

Pokud chcete zobrazit trasování v Foundry, připojte prostředek Application Insights k projektu Foundry.

V levém navigačním podokně portálu Foundry přejděte na Trasování .
Pokud ho ještě nemáte, vytvořte nový prostředek Application Insights.
Připojte zdroj k projektu Foundry.

Trasování instrumentace v kódu

Pokud chcete sledovat obsah chatových zpráv, nastavte AZURE_TRACING_GEN_AI_CONTENT_RECORDING_ENABLED proměnnou prostředí na true (nerozlišují se malá a velká písmena). Tento obsah může obsahovat osobní údaje. Další informace najdete v klientské knihovně Azure Core Tracing OpenTelemetry pro Python.

import os
os.environ["AZURE_TRACING_GEN_AI_CONTENT_RECORDING_ENABLED"] = "true" # False by default

Začněme tím, že náš agent bude vybaven nástroji pro trasování OpenTelemetry, a začneme ověřováním a připojením k projektu Azure AI pomocí AIProjectClient.

from azure.ai.projects import AIProjectClient
from azure.identity import DefaultAzureCredential
project_client = AIProjectClient(
    credential=DefaultAzureCredential(),
    endpoint=os.environ["PROJECT_ENDPOINT"],
)

Dále načtěte připojovací řetězec z prostředku Application Insights připojeného k vašemu projektu a nastavte exportéry OTLP tak, aby odesílaly telemetrii do Azure Monitor.

from azure.monitor.opentelemetry import configure_azure_monitor

connection_string = project_client.telemetry.get_application_insights_connection_string()
configure_azure_monitor(connection_string=connection_string) #enable telemetry collection

Teď sledujte kód, kde vytváříte a spouštíte agenta a zprávu uživatele v Project Azure AI, abyste viděli podrobné kroky pro řešení potíží nebo monitorování.

from opentelemetry import trace
tracer = trace.get_tracer(__name__)

with tracer.start_as_current_span("example-tracing"):
    agent = project_client.agents.create_agent(
        model=os.environ["MODEL_DEPLOYMENT_NAME"],
        name="my-assistant",
        instructions="You are a helpful assistant"
    )
    thread = project_client.agents.threads.create()
    message = project_client.agents.messages.create(
        thread_id=thread.id, role="user", content="Tell me a joke"
    )
    run = project_client.agents.runs.create_and_process(thread_id=thread.id, agent_id=agent.id)

Po spuštění agenta můžete začít sledovat stopy v portálu Foundry.

Trasování protokolů místně

Pokud se chcete připojit k řídicímu panelu Aspire nebo jinému back-endu kompatibilnímu s OpenTelemetry, nainstalujte vývozce OpenTelemetry Protocol (OTLP). Pomocí tohoto vývozce můžete zobrazit trasování na konzoli nebo použít místní prohlížeč, jako je Aspire Dashboard.

pip install azure-core-tracing-opentelemetry opentelemetry-exporter-otlp opentelemetry-sdk

Dále nakonfigurujte trasování pro výstup konzoly:

from azure.core.settings import settings
settings.tracing_implementation = "opentelemetry"

from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import SimpleSpanProcessor, ConsoleSpanExporter

# Setup tracing to console
span_exporter = ConsoleSpanExporter()
tracer_provider = TracerProvider()
tracer_provider.add_span_processor(SimpleSpanProcessor(span_exporter))
trace.set_tracer_provider(tracer_provider)

Nebo upravte předchozí kód na základě řídicího panelu Aspire tak, aby trasoval do místního prohlížeče OTLP.

Teď povolte instrumentaci agenta a spusťte agenta:

from azure.ai.agents.telemetry import AIAgentsInstrumentor
AIAgentsInstrumentor().instrument()

# Start tracing
tracer = trace.get_tracer(__name__)

with tracer.start_as_current_span("example-tracing"):
    agent = project_client.agents.create_agent(
        model=os.environ["MODEL_DEPLOYMENT_NAME"],
        name="my-assistant",
        instructions="You are a helpful assistant"
    )
    thread = project_client.agents.threads.create()
    message = project_client.agents.messages.create(
        thread_id=thread.id, role="user", content="Tell me a joke"
    )
    run = project_client.agents.runs.create_and_process(thread_id=thread.id, agent_id=agent.id)

Alternativní: Foundry Toolkit pro VS Code

Foundry Toolkit nabízí jednoduchý způsob, jak trasovat místně ve VS Code. Používá místní kolektor kompatibilní s OTLP, který je ideální pro vývoj a ladění.

Sada nástrojů podporuje architektury AI, jako je služba Foundry Agents Service, OpenAI, Anthropic a LangChain prostřednictvím OpenTelemetry. Trasování můžete okamžitě zobrazit ve VS Code bez nutnosti přístupu ke cloudu.

Podrobné pokyny k nastavení a příklady kódu specifické pro sadu SDK najdete v tématu Trasování v sadě Foundry Toolkit.

Trasování vlastních funkcí

Ke sledování vlastních funkcí použijte sadu OpenTelemetry SDK k instrumentaci kódu.

Nastavení poskytovatele sledování: Inicializace poskytovatele sledování pro správu a vytváření úseků.
Vytvoření rozsahů: Zabalte kód, který chcete trasovat pomocí rozsahů. Každé rozpětí představuje jednotku práce a můžete vnořit rozsahy, které tvoří trasovací strom.
Přidat atributy: Atributy obohacují úseky o více kontextu pro data trasování.
Konfigurace vývozce: Odeslání dat trasování do back-endu pro analýzu a vizualizaci

Tady je příklad trasování vlastní funkce:

from opentelemetry import trace
from opentelemetry.trace import SpanKind

# Initialize tracer
tracer = trace.get_tracer(__name__)

def custom_function():
    with tracer.start_as_current_span("custom_function") as span:
        span.set_attribute("custom_attribute", "value")
        # Your function logic here
        print("Executing custom function")

custom_function()

Podrobné pokyny a pokročilé použití najdete v dokumentaci k OpenTelemetry.

Připojení zpětné vazby uživatelů k trasování

Pokud chcete připojit zpětnou vazbu uživatelů k trasování a vizualizaci na portálu Foundry, instrumentujte aplikaci, abyste povolili trasování a protokolování zpětné vazby uživatelů pomocí sémantických konvencí OpenTelemetry.

Korelováním tras zpětné vazby s příslušnými trasami žádostí chatu pomocí ID odpovědi nebo ID vlákna můžete tyto trasy zobrazit a spravovat na portálu Foundry. Specifikace OpenTelemetry umožňuje standardizovaná a rozšířená data trasování, která můžete analyzovat na portálu Foundry za účelem optimalizace výkonu a přehledů uživatelského prostředí. Tento přístup vám pomůže využít plný výkon OpenTelemetry pro lepší pozorovatelnost ve vašich aplikacích.

Pokud chcete protokolovat názory uživatelů, postupujte podle tohoto formátu:

Událost vyhodnocení zpětné vazby uživatele se zaznamenává pouze v případě, že uživatel poskytne reakci na odpověď modelu GenAI. Pokud je to možné, přiřaďte tuto událost do rozsahu GenAI, který popisuje takovou odpověď.

Text události zpětné vazby uživatele má následující strukturu:

Základní pole	Typ	Popis	Příklady	Úroveň požadavku
`comment`	řetězec	Další podrobnosti o zpětné vazbě uživatelů	`"I did not like it"`	`Opt-in`

Použití názvu služby v datech trasování

Pokud chcete službu identifikovat prostřednictvím jedinečného ID v Application Insights, použijte ve svých datech trasování vlastnost OpenTelemetry s názvem služby. Tato vlastnost je užitečná, pokud protokolujete data z více aplikací do stejného prostředku Application Insights a chcete mezi nimi rozlišovat.

Řekněme například, že máte dvě aplikace: App-1 a App-2 s trasováním nakonfigurovaným pro protokolování dat do stejného prostředku Application Insights. Možná byste chtěli nastavit , aby se aplikace App-1 vyhodnocovala nepřetržitě podle relevance a app-2 , aby se vyhodnocovala nepřetržitě podle relevance. Název služby můžete použít k filtrování Application, když sledujete svou aplikaci v portálu Foundry.

Pokud chcete nastavit vlastnost názvu služby, přidejte ji přímo do kódu aplikace podle kroků v části Použití více zprostředkovatelů trasování s jiným prostředkem. Můžete také nastavit proměnnou OTEL_SERVICE_NAME prostředí před nasazením aplikace. Další informace o práci s názvem služby najdete v tématu Proměnné prostředí OTEL a sémantické konvence prostředků služby.

Pokud chcete dotazovat data trasování pro daný název služby, zadejte dotaz na cloud_roleName vlastnost.

| where cloud_RoleName == "service_name"

Integrace

Foundry usnadňuje protokolování trasování s minimálními změnami pomocí integrace trasování s Microsoft Agent Framework, Sémantické jádro, LangChain, LangGraph a OpenAI Agent SDK.

Trasování agentů založených na Microsoft Agent Frameworku a Sémantické jádro

Foundry má nativní integrace s Microsoft Agent Framework a Sémantické jádro. Agenti, kteří jsou postaveni na těchto dvou architekturách, získají předem integrované trasování v pozorovatelnosti.

Přečtěte si další informace o trasování a pozorovatelnosti v Sémantické jádro a Microsoft Agent Framework.

Povolte sledování pro agenty postavené na LangChain a LangGraph

Poznámka

Integrace trasování pro LangChain a LangGraph popsané tady je aktuálně dostupná jenom v Python.

Trasování pro LangChain, které se řídí standardy OpenTelemetry, můžete povolit pomocí opentelemetry-instrumentation-langchain.

Po instalaci potřebných balíčků můžete snadno nastavit trasování ve vašem kódu.

Poznámka

Verze LangChain a LangGraph v1 jsou v současné době aktivní ve vývoji. Rozhraní API a trasovací funkce se mohou v této verzi změnit. Sledujte aktualizace na stránce s poznámkou k verzi LangChain v1.0.

Ukázka: LangChain v1 agent s trasováním pomocí Azure AI

Tuto kompletní ukázku použijte k instrumentaci agenta LangChain v1 pomocí langchain-azure-ai traceru. Implementuje nejnovější specifikaci OpenTelemetry (OTel), abyste mohli zobrazit podrobné sledování v rámci observability.

Instalace balíčků

pip install \
  langchain-azure-ai \
  langchain \
  langgraph \
  langchain-openai \
  azure-identity \
  python-dotenv \
  rich

Konfigurace prostředí

APPLICATION_INSIGHTS_CONNECTION_STRING: Připojovací řetězec služby Azure Monitor Application Insights pro trasování.
AZURE_OPENAI_ENDPOINT: Adresa URL koncového bodu Azure OpenAI.
AZURE_OPENAI_CHAT_DEPLOYMENT: Název nasazení chatového modelu.
AZURE_OPENAI_VERSION: Verze rozhraní API, například 2024-08-01-preview.
Azure přihlašovací údaje se vyřeší pomocí DefaultAzureCredential (podporuje proměnné prostředí, spravovanou identitu, přihlášení pomocí VS Code a další).

Tyto hodnoty můžete uložit do .env souboru pro místní vývoj.

Nastavení traceru

from dotenv import load_dotenv
import os
from langchain_azure_ai.callbacks.tracers import AzureAIOpenTelemetryTracer

load_dotenv(override=True)

azure_tracer = AzureAIOpenTelemetryTracer(
    connection_string=os.environ.get("APPLICATION_INSIGHTS_CONNECTION_STRING"),
    enable_content_recording=True,
    name="Weather information agent",
    id="weather_info_agent_771929",
)

tracers = [azure_tracer]

Nastavení modelu (Azure OpenAI)

import os
import azure.identity
from langchain_openai import AzureChatOpenAI

token_provider = azure.identity.get_bearer_token_provider(
    azure.identity.DefaultAzureCredential(),
    "https://ai.azure.com/.default",
)

model = AzureChatOpenAI(
    azure_endpoint=os.environ.get("AZURE_OPENAI_ENDPOINT"),
    azure_deployment=os.environ.get("AZURE_OPENAI_CHAT_DEPLOYMENT"),
    openai_api_version=os.environ.get("AZURE_OPENAI_VERSION"),
    azure_ad_token_provider=token_provider,
)

Definování nástrojů a výzvy

from dataclasses import dataclass
from langchain_core.tools import tool

system_prompt = """You are an expert weather forecaster, who speaks in puns.

You have access to two tools:

- get_weather_for_location: use this to get the weather for a specific location
- get_user_location: use this to get the user's location

If a user asks you for the weather, make sure you know the location.
If you can tell from the question that they mean wherever they are,
use the get_user_location tool to find their location."""

# Mock user locations keyed by user id (string)
USER_LOCATION = {
    "1": "Florida",
    "2": "SF",
}

@dataclass
class UserContext:
    user_id: str

@tool
def get_weather(city: str) -> str:
    """Get weather for a given city."""
    return f"It's always sunny in {city}!"

Použití kontextu modulu runtime a definování nástroje s informacemi o uživateli

from langgraph.runtime import get_runtime
from langchain_core.runnables import RunnableConfig

@tool
def get_user_info(config: RunnableConfig) -> str:
    """Retrieve user information based on user ID."""
    runtime = get_runtime(UserContext)
    user_id = runtime.context.user_id
    return USER_LOCATION[user_id]

Vytvoření agenta

from langchain.agents import create_agent
from langgraph.checkpoint.memory import InMemorySaver
from dataclasses import dataclass

@dataclass
class WeatherResponse:
    conditions: str
    punny_response: str

checkpointer = InMemorySaver()

agent = create_agent(
    model=model,
    prompt=system_prompt,
    tools=[get_user_info, get_weather],
    response_format=WeatherResponse,
    checkpointer=checkpointer,
)

Spusťte agenta s trasováním

from rich import print

def main():
    config = {"configurable": {"thread_id": "1"}, "callbacks": [azure_tracer]}
    context = UserContext(user_id="1")

    r1 = agent.invoke(
        {"messages": [{"role": "user", "content": "what is the weather outside?"}]},
        config=config,
        context=context,
    )
    print(r1.get("structured_response"))

    r2 = agent.invoke(
        {"messages": [{"role": "user", "content": "Thanks"}]},
        config=config,
        context=context,
    )
    print(r2.get("structured_response"))

if __name__ == "__main__":
    main()

Když povolíte langchain-azure-ai, všechny operace LangChain v1 (volání LLM, vyvolání nástrojů, kroky agenta) se trasují pomocí nejnovějších sémantických konvencí OpenTelemetry. Zobrazují se v systému sledovatelnosti, propojené s vaším prostředkem Application Insights.

Ukázka: Agent LangGraph s trasováním Azure AI

Tato ukázka ukazuje jednoduchý agent LangGraph instrumentovaný s cílem generovat trasování kompatibilní s langchain-azure-ai OpenTelemetry pro kroky grafu, volání nástrojů a volání modelu.

Instalace balíčků

pip install \
  langchain-azure-ai \
  langgraph==1.0.0a4 \
  langchain==1.0.0a10 \
  langchain-openai \
  azure-identity \
  python-dotenv

Konfigurace prostředí

APPLICATION_INSIGHTS_CONNECTION_STRING: Připojovací řetězec služby Azure Monitor Application Insights pro trasování.
AZURE_OPENAI_ENDPOINT: Adresa URL koncového bodu Azure OpenAI.
AZURE_OPENAI_CHAT_DEPLOYMENT: Název nasazení chatového modelu.
AZURE_OPENAI_VERSION: Verze rozhraní API, například 2024-08-01-preview.

Tyto hodnoty můžete uložit do .env souboru pro místní vývoj.

Nastavení traceru

import os
from dotenv import load_dotenv
from langchain_azure_ai.callbacks.tracers import AzureAIOpenTelemetryTracer

load_dotenv(override=True)

azure_tracer = AzureAIOpenTelemetryTracer(
    connection_string=os.environ.get("APPLICATION_INSIGHTS_CONNECTION_STRING"),
    enable_content_recording=os.getenv("OTEL_RECORD_CONTENT", "true").lower() == "true",
    name="Music Player Agent",
)

Nástroje

from langchain_core.tools import tool

@tool
def play_song_on_spotify(song: str):
    """Play a song on Spotify"""
    # Integrate with Spotify API here.
    return f"Successfully played {song} on Spotify!"

@tool
def play_song_on_apple(song: str):
    """Play a song on Apple Music"""
    # Integrate with Apple Music API here.
    return f"Successfully played {song} on Apple Music!"

tools = [play_song_on_apple, play_song_on_spotify]

Nastavení modelu (Azure OpenAI)

import os
import azure.identity
from langchain_openai import AzureChatOpenAI

token_provider = azure.identity.get_bearer_token_provider(
    azure.identity.DefaultAzureCredential(),
    "https://ai.azure.com/.default",
)

model = AzureChatOpenAI(
    azure_endpoint=os.environ.get("AZURE_OPENAI_ENDPOINT"),
    azure_deployment=os.environ.get("AZURE_OPENAI_CHAT_DEPLOYMENT"),
    openai_api_version=os.environ.get("AZURE_OPENAI_VERSION"),
    azure_ad_token_provider=token_provider,
).bind_tools(tools, parallel_tool_calls=False)

Sestavení pracovního postupu LangGraph

from langgraph.graph import END, START, MessagesState, StateGraph
from langgraph.prebuilt import ToolNode
from langgraph.checkpoint.memory import MemorySaver

tool_node = ToolNode(tools)

def should_continue(state: MessagesState):
    messages = state["messages"]
    last_message = messages[-1]
    return "continue" if getattr(last_message, "tool_calls", None) else "end"

def call_model(state: MessagesState):
    messages = state["messages"]
    response = model.invoke(messages)
    return {"messages": [response]}

workflow = StateGraph(MessagesState)
workflow.add_node("agent", call_model)
workflow.add_node("action", tool_node)

workflow.add_edge(START, "agent")
workflow.add_conditional_edges(
    "agent",
    should_continue,
    {
        "continue": "action",
        "end": END,
    },
)
workflow.add_edge("action", "agent")

memory = MemorySaver()
app = workflow.compile(checkpointer=memory)

Spuštění s trasováním

from langchain_core.messages import HumanMessage

config = {"configurable": {"thread_id": "1"}, "callbacks": [azure_tracer]}
input_message = HumanMessage(content="Can you play Taylor Swift's most popular song?")

for event in app.stream({"messages": [input_message]}, config, stream_mode="values"):
    event["messages"][-1].pretty_print()

Povolením langchain-azure-ai bude vaše spouštění LangGraph generovat spanů kompatibilních s OpenTelemetry pro volání modelu, vyvolání nástrojů a přechody grafů. Tyto záznamy proudí do Application Insights a zobrazí se ve sledování.

Ukázka: Nastavení LangChain 0.3 s trasováním Azure AI

Toto minimální nastavení ukazuje, jak povolit trasování Azure AI v aplikaci LangChain 0.3 pomocí langchain-azure-ai tracer a AzureChatOpenAI.

Instalace balíčků

pip install \
  "langchain>=0.3,<0.4" \
  langchain-openai \
  langchain-azure-ai \
  python-dotenv

Konfigurace prostředí

APPLICATION_INSIGHTS_CONNECTION_STRING: Application Insights připojovací řetězec pro trasování.
AZURE_OPENAI_ENDPOINT: Azure OpenAI URL koncového bodu.
AZURE_OPENAI_CHAT_DEPLOYMENT: Název nasazení modelu chatu
AZURE_OPENAI_VERSION: Verze rozhraní API, například 2024-08-01-preview.
AZURE_OPENAI_API_KEY: Klíč k rozhraní API Azure OpenAI.

Trasování a nastavení modelu

import os
from dotenv import load_dotenv
from langchain_azure_ai.callbacks.tracers import AzureAIOpenTelemetryTracer
from langchain_openai import AzureChatOpenAI

load_dotenv(override=True)

# Tracer: emits spans conforming to updated OTel spec
azure_tracer = AzureAIOpenTelemetryTracer(
    connection_string=os.environ.get("APPLICATION_INSIGHTS_CONNECTION_STRING"),
    enable_content_recording=True,
    name="Trip Planner Orchestrator",
    id="trip_planner_orchestrator_v3",
)
tracers = [azure_tracer]

# Model: Azure OpenAI with callbacks for tracing
llm = AzureChatOpenAI(
    azure_deployment=os.environ.get("AZURE_OPENAI_CHAT_DEPLOYMENT"),
    api_key=os.environ.get("AZURE_OPENAI_API_KEY"),
    azure_endpoint=os.environ.get("AZURE_OPENAI_ENDPOINT"),
    api_version=os.environ.get("AZURE_OPENAI_VERSION"),
    temperature=0.2,
    callbacks=tracers,
)

Připojte callbacks=[azure_tracer] ke svým řetězům, nástrojům nebo agentům, abyste zajistili, že operace LangChain 0.3 jsou sledovány a viditelné v monitorování.

Povolení trasování pro agenty založené na sadě OpenAI Agents SDK

Nainstalujte požadované balíčky:

pip install opentelemetry-sdk opentelemetry-instrumentation-openai-agents azure-monitor-opentelemetry-exporter

Tento fragment kódu použijte ke konfiguraci trasování OpenTelemetry pro sadu SDK pro agenty OpenAI a instrumentaci architektury. Exportuje se do Azure Monitor, pokud je nastavena APPLICATION_INSIGHTS_CONNECTION_STRING; jinak se vrátí zpět do konzoly.

import os
from opentelemetry import trace
from opentelemetry.instrumentation.openai_agents import OpenAIAgentsInstrumentor
from opentelemetry.sdk.resources import Resource
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor, ConsoleSpanExporter

# Configure tracer provider + exporter
resource = Resource.create({
    "service.name": os.getenv("OTEL_SERVICE_NAME", "openai-agents-app"),
})
provider = TracerProvider(resource=resource)

conn = os.getenv("APPLICATION_INSIGHTS_CONNECTION_STRING")
if conn:
    from azure.monitor.opentelemetry.exporter import AzureMonitorTraceExporter
    provider.add_span_processor(
        BatchSpanProcessor(AzureMonitorTraceExporter.from_connection_string(conn))
    )
else:
    provider.add_span_processor(BatchSpanProcessor(ConsoleSpanExporter()))

trace.set_tracer_provider(provider)

# Instrument the OpenAI Agents SDK
OpenAIAgentsInstrumentor().instrument(tracer_provider=trace.get_tracer_provider())

# Example: create a session span around your agent run
tracer = trace.get_tracer(__name__)
with tracer.start_as_current_span("agent_session[openai.agents]"):
    # ... run your agent here
    pass

Zobrazení stop na portálu Foundry

V projektu přejděte na Trasování a vyfiltrujte trasování podle potřeby.

Výběrem trasování můžete procházet jednotlivé rozsahy a identifikovat problémy při sledování toho, jak vaše aplikace reaguje. Tento proces vám pomůže ladit a určit problémy v aplikaci.

Zobrazení trasování v Azure Monitor

Pokud jste zaznamenali trasování pomocí předchozího fragmentu kódu, jste připraveni zobrazit své trasování v Azure Monitor Application Insights. Application Insights můžete otevřít z nabídky Správa zdroje dat a použít Zobrazení podrobností o transakci od začátku do konce pro další zkoumání.

Další informace o tom, jak odesílat trasování inference Azure AI do Azure Monitor a vytvářet prostředky Azure Monitor, naleznete v dokumentaci k Azure Monitor k OpenTelemetry.

Zobrazit výsledky vlákna na dětském hřišti Foundry Agents

Testovací prostředí agentů na portálu Foundry umožňuje zobrazit výsledky pro vlákna a spuštění, které vytvářejí vaši agenti. Pokud chcete zobrazit výsledky vlákna, vyberte protokoly vláken v aktivním vlákně. Volitelně můžete také vybrat metriky , které umožní automatické vyhodnocení výkonu modelu v několika dimenzích kvality AI a rizik a bezpečnosti.

Poznámka

Jak je uvedeno v části Důvěryhodnost a Pozorovatelnost na stránce s cenami, účtuje se vyhodnocení v dětském hřišti. Výsledky jsou k dispozici po dobu 24 hodin před vypršením platnosti. Pokud chcete získat výsledky vyhodnocení, vyberte požadované metriky a chatujte s vaším agentem.

Vyhodnocení nejsou k dispozici v následujících oblastech.
- australiaeast
- japaneast
- southindia
- uksouth

Po výběru protokolů vláken zkontrolujte:

Podrobnosti o vlákně
Informace o spuštění
Uspořádané kroky spuštění a volání nástrojů
Vstupy a výstupy mezi uživatelem a agentem
Propojené metriky vyhodnocení (pokud jsou povolené)

Tip

Pokud chcete zobrazit výsledky vlákna z předchozího vlákna, vyberte Moje vlákna na obrazovce Agenti . Zvolte vlákno a pak vyberte Vyzkoušet v dětském hřišti. Zobrazí se tlačítko Protokoly vláken v horní části obrazovky a zobrazí se výsledky trasování.

Poznámka

Funkce pozorovatelnosti, jako je hodnocení rizik a bezpečnosti, se účtují na základě spotřeby uvedené na stránce s cenami Azure.

Python samples obsahující plně spustitelný Python kód pro trasování pomocí synchronních a asynchronních klientů.
Ukázky Pythonu pro trasování agentů pomocí konzolového trasování a Azure Monitor.
Ukázky jazyka JavaScript obsahující plně spustitelný kód jazyka JavaScript pro trasování s využitím synchronních a asynchronních klientů.
C# Samples obsahující plně spustitelný kód jazyka C# pro odvozování pomocí synchronních a asynchronních metod.

Váš názor

Byla tato stránka užitečná?

Last updated on 2026-05-01

Trasování a sledování agentů AI v Microsoft Foundry (Preview) (Classic)

Přehled klíčových konceptů trasování

Osvědčené postupy

Rozšíření OpenTelemetry s pozorovatelností s více agenty

Nastavení trasování v sadě Microsoft Foundry SDK

Trasování instrumentace v kódu

Trasování protokolů místně

Alternativní: Foundry Toolkit pro VS Code

Trasování vlastních funkcí

Připojení zpětné vazby uživatelů k trasování

Použití názvu služby v datech trasování

Integrace

Trasování agentů založených na Microsoft Agent Frameworku a Sémantické jádro

Povolte sledování pro agenty postavené na LangChain a LangGraph

Ukázka: LangChain v1 agent s trasováním pomocí Azure AI

Instalace balíčků

Konfigurace prostředí

Nastavení traceru

Nastavení modelu (Azure OpenAI)

Definování nástrojů a výzvy

Použití kontextu modulu runtime a definování nástroje s informacemi o uživateli

Vytvoření agenta

Spusťte agenta s trasováním

Ukázka: Agent LangGraph s trasováním Azure AI

Instalace balíčků

Konfigurace prostředí

Nastavení traceru

Nástroje

Nastavení modelu (Azure OpenAI)

Sestavení pracovního postupu LangGraph

Spuštění s trasováním

Ukázka: Nastavení LangChain 0.3 s trasováním Azure AI

Instalace balíčků

Konfigurace prostředí

Trasování a nastavení modelu

Povolení trasování pro agenty založené na sadě OpenAI Agents SDK

Zobrazení stop na portálu Foundry

Zobrazení trasování v Azure Monitor

Zobrazit výsledky vlákna na dětském hřišti Foundry Agents

Související obsah

Váš názor

Další materiály