Konfigurace trasování pro architektury agentů AI (Preview)

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.

Poznámka

Trasování je obecně k dispozici pro agenty promptů a hostované agenty. Pracovní postup a externí agenti jsou ve verzi Preview.

Když se agenti umělé inteligence chovají neočekávaně v produkčním prostředí, trasování vám poskytne přehled o rychlé identifikaci původní příčiny. Trasování zachycuje podrobnou telemetrii, včetně volání LLM, volání nástrojů a toků rozhodování agentů, abyste mohli ladit problémy, zkoumat latenci a porozumět chování agentů při různých požadavcích.

Microsoft Foundry poskytuje integrace trasování pro oblíbené architektury agentů, které vyžadují minimální změny kódu. V tomto článku se naučíte:

Konfigurace automatického trasování pro rozhraní Microsoft Agent Framework a sémantické jádro
Nastavení distrou Microsoft OpenTelemetry pro LangChain a LangGraph
Instrumentace sady OPENAI Agents SDK s využitím OpenTelemetry
Zkontrolujte, zda se stopy zobrazují v portálu Foundry.
Řešení běžných problémů s trasováním

Požadavky

Projekt Foundry. Další informace naleznete v tématu Vytvoření projektu Foundry.
Trasování připojeno k prostředku Application Insights služby Azure Monitor. Pokud ho chcete nastavit, přečtěte si téma Nastavení trasování v Microsoft Foundry.
Role přispěvatele nebo vyšší role prostředku Application Insights pro příjem sledování.
Přístup k připojenému prostředku Application Insights pro zobrazení tras. U dotazů založených na protokolech můžete také potřebovat přístup k přidruženému pracovnímu prostoru Log Analytics.
Python 3.10 nebo novější (vyžaduje se pro všechny ukázky kódu v tomto článku).
Balíček microsoft-opentelemetry (vyžadovaný pro ukázky LangChain a LangGraph).
Pokud používáte LangChain nebo LangGraph, potřebujete mít Python prostředí s nainstalovaným pipem.

Potvrzení, že můžete zobrazit telemetrii

Pokud chcete zobrazit data trasování, ujistěte se, že váš účet má přístup k připojenému prostředku Application Insights.

Na portálu Azure otevřete prostředek Application Insights připojený k projektu Foundry.
Vyberte Řízení přístupu (IAM).
Přiřaďte uživateli nebo skupině odpovídající roli.

Pokud používáte dotazy založené na protokolu, začněte udělením role čtenáře Log Analytics. Pokud jsou podkladové tabulky služby Log Analytics chráněné, přidělte také roli Privileged Monitoring Data Reader.

Zabezpečení a ochrana osobních údajů

Trasování může zaznamenávat citlivé informace (například vstupy uživatelů, výstupy modelu a argumenty a výsledky nástrojů).

Povolte nahrávání obsahu během vývoje a ladění, abyste viděli úplná data požadavků a odpovědí. Zakažte záznam obsahu v produkčních prostředích a chraňte citlivá data. V ukázkách v tomto článku je zaznamenávání obsahu řízeno proměnnými prostředí OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT, OTEL_SEMCONV_STABILITY_OPT_IN a AZURE_EXPERIMENTAL_ENABLE_GENAI_TRACING.
Neukládejte tajné kódy, přihlašovací údaje ani tokeny do výzev nebo argumentů nástroje.

Další pokyny najdete v tématu Zabezpečení a ochrana osobních údajů.

Poznámka

Sledující data uložená v Application Insights podléhají nastavení uchovávání dat ve vašem pracovním prostoru a cenám Azure Monitor. V případě správy nákladů zvažte úpravu vzorkovacích sazeb nebo období uchovávání v produkčním prostředí. Viz ceny Azure Monitor a Konfigurování uchovávání a archivace dat.

Konfigurace trasování pro rozhraní Microsoft Agent Framework a sémantické jádro

Microsoft Foundry má nativní integrace s rozhraním Microsoft Agent Framework a sémantickým jádrem. Agenti sestaveni s kterýmkoli frameworkem automaticky generují trasování, když je pro váš projekt Foundry povoleno trasování – nevyžadují se žádný další kód ani balíčky.

Ověření, že trasování funguje:

Spusťte agenta alespoň jednou.
Na portálu Foundry přejděte do Pozorovatelnost>Trasování.
Ověřte, že se zobrazí nové trasování s rozsahy operací vašeho agenta.

Stopy jsou obvykle zobrazeny během 2–5 minut od spuštění agenta. Pokročilou konfiguraci najdete v dokumentaci specifické pro danou architekturu:

Microsoft Agent Framework pracovní postupy – pozorovatelnost
Sémantická pozorovatelnost jádra

Konfigurace trasování pomocí knihoven instrumentace OpenInference

Microsoft Foundry podporuje OpenInference instrumentační knihovny pro trasování agentů AI. Tyto openinference-* balíčky poskytují automatickou instrumentaci pro širokou škálu frameworků a lze je použít ke trasování jak hostovaných agentů (agentů nasazených do Foundry), tak agentů mimo Foundry (agentů hostovaných mimo Foundry).

Projděte dostupné balíčky instrumentace na PyPI. Informace k LangChain najdete v ukázce Microsoft OpenTelemetry distro LangChain sample, která ukazuje, jak povolit export do Azure Monitoru a automatickou instrumentaci LangChain pomocí use_microsoft_opentelemetry.

Klíčovým požadavkem je korelace trasování OpenInference s konkrétním agentem. Jak toho dosáhnete, závisí na tom, kde běží váš agent:

Hostovaní agenti (nasazení do Foundry)

Když nasadíte agenta do Foundry pomocí jednoho z balíčků hostovaného serveru pro agenty, korelace trasování se zpracovává automaticky. Balíček serveru:

Konfiguruje export do Azure Monitoru pro span(y) OpenTelemetry.
Rozšiřuje všechny rozsahy o atributy projektu, názvu agenta, verze agenta a ID agenta, aby je uživatelské rozhraní Foundry mohl dotazovat a zobrazit.

Nevyžaduje se žádná další konfigurace. Nainstalujte příslušný openinference-* balíček instrumentace pro vaši architekturu a trasování se automaticky zobrazí na portálu Foundry.

agenti Microsoft Agent Framework hostovaní mimo Foundry

Pokud váš agent Microsoft Agent Framework není nasazen s balíčkem serveru agenta hostovaného ve Foundry, nakonfigurujte export do Azure Monitoru a instrumentaci architektury agenta pomocí distribuce Microsoft OpenTelemetry. Distribuce může povolit exportér Azure Monitor a přidat do spanů atributy identity agenta:

from microsoft.opentelemetry import use_microsoft_opentelemetry

use_microsoft_opentelemetry(
    enable_azure_monitor=True,
    azure_monitor_connection_string="...",
    sampling_ratio=1.0,
    enable_sensitive_data=True,
    instrumentation_options={
        "agent-framework": {
            "enabled": True,
            "agent_id": "ms-imagination-agent",
            "agent_name": "ms-imagination-agent",
        },
    },
)

Nastavte azure_monitor_connection_string na prostředek služby Application Insights připojený k vašemu projektu Foundry. Chcete-li zachytit obsah výzvy a dokončení během vývoje, nastavte enable_sensitive_data=True.

Agenti LangChain hostovaní mimo Foundry

Pokud váš agent není nasazen pomocí balíčku serveru hostovaného ve Foundry, nakonfigurujte export do Azure Monitoru a instrumentaci LangChain pomocí distribuce Microsoft OpenTelemetry. Distribuce může povolit exportér Azure Monitor a ke spanům LangChain přidat atributy identity agenta:

from microsoft.opentelemetry import use_microsoft_opentelemetry

use_microsoft_opentelemetry(
    enable_azure_monitor=True,
    sampling_ratio=1.0,
    instrumentation_options={
        "langchain": {
            "enabled": True,
            "agent_id": "weather_info_agent_771929",
            "agent_name": "Weather information agent",
        },
    },
)

Nastavte APPLICATIONINSIGHTS_CONNECTION_STRING na prostředek služby Application Insights připojený k vašemu projektu Foundry. Chcete-li během vývoje zachytávat obsah promptu a odpovědi, nastavte OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT=SPAN_AND_EVENT, OTEL_SEMCONV_STABILITY_OPT_IN=gen_ai_latest_experimental a AZURE_EXPERIMENTAL_ENABLE_GENAI_TRACING=true.

Konfigurace trasování pro LangChain a LangGraph

Poznámka

Integrace trasování pro LangChain a LangGraph je aktuálně dostupná pouze v Python.

Pomocí distrou Microsoft OpenTelemetry vygenerujte rozsahy kompatibilní s OpenTelemetry pro operace LangChain a LangGraph. Tyto stopy se zobrazí v pohledu Observability>Traces na portálu Foundry.

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

Pomocí této ucelené ukázky můžete instrumentovat agenta LangChain v1 (Preview) pomocí distrou Microsoft OpenTelemetry. Distribuce umožňuje automatickou instrumentaci nástroje LangChain s nejnovějšími sémantickými konvencemi OpenTelemetry (OTel), takže si můžete ve Foundry v přehledu observability prohlížet podrobné trasovací záznamy.

LangChain v1: Instalace balíčků

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

LangChain v1: Konfigurace prostředí

APPLICATIONINSIGHTS_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.
SDK vyřeší přihlašovací údaje Azure pomocí DefaultAzureCredential, který podporuje proměnné prostředí, spravovanou identitu a přihlášení VS Code.

Tyto hodnoty uložte do .env souboru pro místní vývoj.

LangChain v1: Nastavení traceru

from dotenv import load_dotenv
from microsoft.opentelemetry import use_microsoft_opentelemetry

load_dotenv(override=True)

use_microsoft_opentelemetry(
    enable_azure_monitor=True,
    sampling_ratio=1.0,
    instrumentation_options={
        "langchain": {
            "enabled": True,
            "agent_id": "weather_info_agent_771929",
            "agent_name": "Weather information agent",
        },
    },
)

LangChain v1: 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://cognitiveservices.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,
)

LangChain v1: 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}!"

LangChain v1: Použití kontextu modulu runtime a definování nástroje pro informace 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]

LangChain v1: 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,
)

LangChain v1: Spuštění agenta se sledováním

from rich import print

def main():
    config = {"configurable": {"thread_id": "1"}}
    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ž je povolená distribuce Microsoft OpenTelemetry, všechny operace LangChain v1 (volání LLM, volání nástrojů, kroky agenta) emitují trasovací úseky OpenTelemetry v souladu s nejnovějšími sémantickými konvencemi. Tyto trasování se zobrazí v zobrazeníSledování> na portálu Foundry a jsou propojeny s prostředkem Application Insights.

Tip

Po spuštění agenta počkejte několik minut, než se zobrazí trasování. Pokud nevidíte žádné stopy, zkontrolujte, zda je váš připojovací řetězec Application Insights správný, a podívejte se do části Řešení běžných problémů.

Ověřte své LangChain v1 trasování

Po spuštění agenta:

Počkejte 2 až 5 minut, než se stopy rozšíří.
Na portálu Foundry přejděte do Pozorovatelnost>Trasování.
Vyhledejte stopu se zadaným názvem (například "Agent pro informace o počasí").
Rozbalte trasování a zobrazte rozsahy pro volání LLM, volání nástrojů a kroky agenta.

Pokud nevidíte stopy, zkontrolujte část Řešení běžných problémů.

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

Tato ukázka představuje jednoduchého agenta LangGraph instrumentovaného pomocí distribuce Microsoft OpenTelemetry, který generuje trasování kompatibilní s OpenTelemetry pro kroky grafu, volání nástrojů a vyvolání modelu.

LangGraph: Instalace balíčků

pip install \
  microsoft-opentelemetry \
  "langgraph>=1.0.0" \
  "langchain>=1.0.0" \
  langchain-openai \
  azure-identity \
  python-dotenv

LangGraph: Konfigurace prostředí

APPLICATIONINSIGHTS_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 uložte do .env souboru pro místní vývoj.

Nastavení trasování LangGraph

from dotenv import load_dotenv
from microsoft.opentelemetry import use_microsoft_opentelemetry

load_dotenv(override=True)

use_microsoft_opentelemetry(
    enable_azure_monitor=True,
    sampling_ratio=1.0,
    instrumentation_options={
        "langchain": {
            "enabled": True,
            "agent_name": "Music Player Agent",
        },
    },
)

LangGraph: 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]

LangGraph: 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://cognitiveservices.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)

LangGraph: Spusťte s trasováním

from langchain_core.messages import HumanMessage

config = {"configurable": {"thread_id": "1"}}
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()

Když je povolená distribuce Microsoft OpenTelemetry, běh v LangGraphu generuje spany kompatibilní s OpenTelemetry pro volání modelu, volání nástrojů a přechody grafu. Tyto záznamy proudí do Application Insights a zobrazí se v zobrazení pozorovatelnosti>Sledování na portálu Foundry.

Tip

Každý uzel grafu a hraniční přechod vytvoří samostatné rozpětí, což usnadňuje vizualizaci rozhodovacího toku agenta.

Ověřte trasování LangGraph

Po spuštění agenta:

Počkejte 2 až 5 minut, než se stopy rozšíří.
Na portálu Foundry přejděte do Pozorovatelnost>Trasování.
Vyhledejte stopu s názvem, který jste zadali (například "Agent hudebního přehrávače").
Rozbalte trasování, aby se zobrazily rozsahy pro uzly grafu, volání nástrojů a modelů.

Pokud nevidíte stopy, zkontrolujte část Řešení běžných problémů.

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

Toto minimální nastavení ukazuje, jak povolit trasování umělé inteligence Azure v aplikaci LangChain 0.3 pomocí distro Microsoft OpenTelemetry a AzureChatOpenAI.

LangChain 0.3: Instalace balíčků

pip install \
  "langchain>=0.3,<0.4" \
  langchain-openai \
  microsoft-opentelemetry \
  python-dotenv

LangChain 0.3: Konfigurace prostředí

APPLICATIONINSIGHTS_CONNECTION_STRING: Application Insights připojovací řetězec pro trasování. Pokud chcete tuto hodnotu najít, otevřete prostředek Application Insights na portálu Azure, vyberte Overview a zkopírujte Connection String.
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.

Poznámka

V této ukázce se kvůli jednoduchosti používá ověřování pomocí klíče rozhraní API. V případě produkčních úloh použijte DefaultAzureCredential spolu s get_bearer_token_provider tak, jak je znázorněno v ukázkách LangChain v1 a LangGraph.

LangChain 0.3: Tracer a nastavení modelu

import os
from dotenv import load_dotenv
from microsoft.opentelemetry import use_microsoft_opentelemetry
from langchain_openai import AzureChatOpenAI

load_dotenv(override=True)

# Enable Azure Monitor export and LangChain auto-instrumentation
use_microsoft_opentelemetry(
    enable_azure_monitor=True,
    sampling_ratio=1.0,
    instrumentation_options={
        "langchain": {
            "enabled": True,
            "agent_id": "trip_planner_orchestrator_v3",
            "agent_name": "Trip Planner Orchestrator",
        },
    },
)

# Model: Azure OpenAI
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,
)

Při inicializaci distribuce jsou operace LangChain 0.3 automaticky instrumentované globálně. Po spuštění řetězu nebo agenta se za 2 až 5 minut zobrazí trasování v zobrazení PozorovatelnostTrasování na portálu Foundry.

Konfigurace trasování pro sadu OpenAI Agents SDK

Sada OpenAI Agents SDK podporuje instrumentaci OpenTelemetry. Pomocí následujícího fragmentu kódu nakonfigurujte rozsahy trasování a exportu do Azure Monitor. Pokud APPLICATION_INSIGHTS_CONNECTION_STRING není nastavený, exportér se vrátí do konzoly pro místní ladění.

Před spuštěním ukázky nainstalujte požadované balíčky:

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

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

Ověřit stopy na portálu Foundry

Přihlaste se k Microsoft Foundry. Ujistěte se, že je zapnutý přepínač New Foundry . Tyto kroky se vztahují na Foundry (nové).
Ověřte, že je trasování pro váš projekt připojené. V případě potřeby postupujte podle Nastavte trasování v Microsoft Foundry.
Spusťte agenta alespoň jednou.
Na portálu Foundry přejděte do Pozorovatelnost>Trasování.
Ověřte, že se zobrazí nové trasování s rozsahy operací vašeho agenta.

Stopy jsou obvykle zobrazeny během 2–5 minut od spuštění agenta. Pokud se stopy po této době stále nezobrazují, nahlédněte do Řešení běžných problémů.

Řešení běžných problémů

Problém	Příčina	Rozlišení
V Foundry se nezobrazují stopy	Trasování není aktivní, není žádný nedávný provoz, nebo zpracování dat je zpožděné	Potvrďte připojení Application Insights, vygenerujte nový provoz a aktualizujte se po 2 až 5 minutách.
Nezobrazují se oblasti LangChain ani LangGraph.	Distribuce Microsoft OpenTelemetry není inicializována nebo není povolená instrumentace LangChain.	Před spuštěním agenta ověřte, že voláte `use_microsoft_opentelemetry(...)` s parametrem `"langchain": {"enabled": True}`.
LangChain spans se zobrazí, ale chybí volání funkcí nástrojů	Nástroje nejsou svázané s modelem nebo uzlem nástrojů nejsou nakonfigurované.	Zkontrolujte, zda se `bind_tools()` nástroje předají na model a zda se uzly nástrojů přidají do vašeho grafu.
Zobrazují se stopy, ale nejsou kompletní nebo chybí úseky.	Nahrávání obsahu je zakázané, není nastavená možnost souhlasu sémantickou konvencí GenAI nebo se některé operace ne instrumentují.	Pro LangChain a LangGraph nastavte `OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT=SPAN_AND_EVENT`, `OTEL_SEMCONV_STABILITY_OPT_IN=gen_ai_latest_experimental` a `AZURE_EXPERIMENTAL_ENABLE_GENAI_TRACING=true` během vývoje. Pro vlastní operace přidejte ruční rozsahy pomocí sady OpenTelemetry SDK.
Při dotazování telemetrie se zobrazují chyby autorizace.	Chybějící oprávnění RBAC ve službě Application Insights nebo Log Analytics	Potvrďte přístup v řízení přístupu (IAM) pro připojené prostředky. U dotazů protokolu přiřaďte roli čtenáře Log Analytics. Pokud jsou tabulky chráněné, přiřaďte také roli Čtenář privilegovaných monitorovacích dat.
Citlivý obsah se objevuje ve stopách.	Nahrávání obsahu je povolené a výzvy, argumenty nástrojů nebo výstupy obsahují citlivá data.	Zakázat záznam obsahu v produkčním prostředí a redigovat citlivá data před jejich vstupem do telemetrie.

Seznamte se se základními koncepty a architekturou v přehledu trasování agentů.
Pokud jste trasování ještě nepovolili, přečtěte si téma Nastavte trasování v Microsoft Foundry.
Vizualizujte metriky stavu agenta a výkonu pomocí řídicího panelu monitorování agenta.
Prozkoumejte širší možnosti pozorovatelnosti v pozorovatelnosti v generativní umělé inteligenci.

Váš názor

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

Last updated on 2026-06-19

Konfigurace trasování pro architektury agentů AI (Preview)

Požadavky

Potvrzení, že můžete zobrazit telemetrii

Zabezpečení a ochrana osobních údajů

Konfigurace trasování pro rozhraní Microsoft Agent Framework a sémantické jádro

Konfigurace trasování pomocí knihoven instrumentace OpenInference

Hostovaní agenti (nasazení do Foundry)

agenti Microsoft Agent Framework hostovaní mimo Foundry

Agenti LangChain hostovaní mimo Foundry

Konfigurace trasování pro LangChain a LangGraph

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

LangChain v1: Instalace balíčků

LangChain v1: Konfigurace prostředí

LangChain v1: Nastavení traceru

LangChain v1: Nastavení modelu (Azure OpenAI)

LangChain v1: Definování nástrojů a výzvy

LangChain v1: Použití kontextu modulu runtime a definování nástroje pro informace o uživateli

LangChain v1: Vytvoření agenta

LangChain v1: Spuštění agenta se sledováním

Ověřte své LangChain v1 trasování

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

LangGraph: Instalace balíčků

LangGraph: Konfigurace prostředí

Nastavení trasování LangGraph

LangGraph: Nástroje

LangGraph: Nastavení modelu (Azure OpenAI)

Sestavení pracovního postupu LangGraph

LangGraph: Spusťte s trasováním

Ověřte trasování LangGraph

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

LangChain 0.3: Instalace balíčků

LangChain 0.3: Konfigurace prostředí

LangChain 0.3: Tracer a nastavení modelu

Konfigurace trasování pro sadu OpenAI Agents SDK

Ověřit stopy na portálu Foundry

Řešení běžných problémů

Související obsah

Váš názor

Další materiály