Spåra och observera AI-agenter i Azure AI Foundry (förhandsversion)

I den här artikeln lär du dig att:

• Förstå viktiga spårningsbegrepp
• Spåra och observera AI-agenter i AI Foundry
• Utforska nya semantiska konventioner med observerbarhet för flera agenter
• Integrera med populära agentramverk
• Visa spårningar i AI Foundry-portalen och Azure Monitor
• Visa agenttrådar i agentlekplatsen

Det är viktigt att fastställa resonemanget bakom agentens körningar för felsökning och felsökning. Det kan dock vara svårt för komplexa agenter av många skäl:

• Det kan finnas ett stort antal steg som krävs för att generera ett svar, vilket gör det svårt att hålla reda på dem alla.
• Stegsekvensen kan variera beroende på användarens indata.
• Indata/utdata i varje steg kan vara långa och förtjänar mer detaljerad inspektion.
• Varje steg i en agent körning kan också innebära kapsling. En agent kan till exempel anropa ett verktyg som använder en annan process som sedan anropar ett annat verktyg. Om du ser konstiga eller felaktiga utdata från en agentkörning på toppnivå kan det vara svårt att avgöra exakt var i körningen problemet introducerades.

Spårningsresultat löser detta genom att låta dig visa indata och utdata för varje primitiv som är involverad i en viss agentkörning, som visas i den ordning de anropades, vilket gör det enkelt att förstå och felsöka AI-agentens beteende.

Översikt över spårningsnyckelbegrepp

Här är en kort översikt över viktiga begrepp innan du kommer igång:

Metodtips

• Använd konsekventa span-attribut.
• Korrelera utvärderingskörnings-ID:er för kvalitets- och prestandaanalys.
• Redigera känsligt innehåll; undvika att lagra hemligheter i attribut.

Utöka OpenTelemetry med observerbarhet för flera agenter

Microsoft förbättrar observerbarheten för flera agenter genom att introducera nya semantiska konventioner för OpenTelemetry, som utvecklats i samarbete med Outshift, Ciscos inkubationsmotor. Dessa tillägg – som bygger på OpenTelemetry och W3C Trace Context – upprättar standardiserade metoder för spårning och telemetri i system med flera agenter, vilket underlättar konsekvent loggning av nyckelmått för kvalitet, prestanda, säkerhet och kostnad. Den här systematiska metoden ger mer omfattande insyn i arbetsflöden med flera agenter, inklusive verktygsanrop och samarbete. Dessa framsteg har integrerats i Azure AI Foundry-, Microsoft Agent Framework-, Semantic Kernel- och Azure AI-paket för LangChain, LangGraph och OpenAI Agents SDK, vilket gör det möjligt för kunder att få enhetlig observerbarhet för agentiska system som skapats med något av dessa ramverk med Azure AI Foundry. Läs mer om spårning av integreringar.

Konfigurera spårning i Azure AI Foundry SDK

För att slutföra chattfunktioner eller bygga agenter med Azure AI Foundry, installera:

pip install azure-ai-projects azure-identity

För att instrumentspårning ska kunna användas måste du installera följande instrumentationsbibliotek:

pip install azure-monitor-opentelemetry opentelemetry-sdk

Om du vill visa spårningar i Azure AI Foundry måste du ansluta en Application Insights-resurs till ditt Azure AI Foundry-projekt.

1. Navigera till Spårning i det vänstra navigeringsfönstret i Azure AI Foundry-portalen.
2. Skapa en ny Application Insights-resurs om du inte redan har en.
3. Anslut resursen till ditt AI Foundry-projekt.

Instrumentspårning i koden

Om du vill spåra innehållet i chattmeddelanden anger du AZURE_TRACING_GEN_AI_CONTENT_RECORDING_ENABLED miljövariabeln till true (skiftlägesokänslig). Tänk på att detta kan innehålla personuppgifter. För att lära dig mer, se Azure Core Tracing OpenTelemetry klientbibliotek för Python.

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

Nu ska vi börja instrumentera vår agent med OpenTelemetry-spårning genom att först autentisera och ansluta till ditt Azure AI-projekt med hjälp av AIProjectClient.

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

Hämta sedan anslutningssträngen från Application Insights-resursen som är ansluten till projektet och konfigurera OTLP-exportörerna för att skicka telemetri till 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

Spåra nu koden där du skapar och kör agenten och användarmeddelandet i azure AI-projektet, så att du kan se detaljerade steg för felsökning eller övervakning.

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)

När du har kört din agent kan du börja visa spårningar i Azure AI Foundry Portal.

Loggspårningar lokalt

För att ansluta till Aspire Dashboard eller en annan OpenTelemetry-kompatibel backend, installera OTLP-exportören (OpenTelemetry Protocol). På så sätt kan du skriva ut spårningar till konsolen eller använda ett lokalt visningsprogram, till exempel Aspire Dashboard.

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

Konfigurera sedan spårning för konsolutdata:

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)

Eller ändra koden ovan, baserat på Aspire-instrumentpanelen, för att spåra till ett lokalt OTLP-visningsprogram.

Aktivera agentinstrumentation och kör din agent:

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)

Alternativ: AI Toolkit för VS Code

AI Toolkit ger dig ett enkelt sätt att spåra lokalt i VS Code. Den använder en lokal OTLP-kompatibel insamlare, vilket gör den idealisk för utveckling och felsökning.

Verktygslådan stöder AI-ramverk som Azure AI Foundry Agents Service, OpenAI, Anthropic och LangChain via OpenTelemetry. Du kan se spårningar direkt i VS Code utan att behöva molnåtkomst.

Detaljerade installationsinstruktioner och SDK-specifika kodexempel finns i Spårning i AI Toolkit.

Spåra anpassade funktioner

Om du vill spåra dina anpassade funktioner använder du OpenTelemetry SDK för att instrumentera koden.

1. Konfigurera en spårningsprovider: Initiera en spårningsprovider för att hantera och skapa intervall.
2. Skapa intervall: Omslut koden som du vill spåra med intervall. Varje spann representerar en arbetsenhet och kan nästadderas för att bilda ett spårträd.
3. Lägg till attribut: Berika områden med attribut för att ge mer kontext för spårdata.
4. Konfigurera en exportör: Skicka spårningsdata till en serverdel för analys och visualisering.

Här är ett exempel på spårning av en anpassad funktion:

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

Detaljerade instruktioner och avancerad användning finns i dokumentationen om OpenTelemetry.

Bifoga användarfeedback till spårningar

Om du vill koppla användarfeedback till spårningar och visualisera den i Azure AI Foundry-portalen kan du instrumentera ditt program för att aktivera spårning och logga användarfeedback med hjälp av OpenTelemetrys semantiska konventioner.

Genom att korrelera feedbackspårningar med respektive spårning av chattbegäran med hjälp av svars-ID eller tråd-ID kan du visa och hantera dessa spårningar i Azure AI Foundry-portalen. OpenTelemetrys specifikation möjliggör standardiserade och berikade spårningsdata, som kan analyseras i Azure AI Foundry-portalen för prestandaoptimering och insikter om användarupplevelsen. Denna metod hjälper dig att använda hela potentialen av OpenTelemetry för förbättrad observabilitet i dina applikationer.

Om du vill logga användarfeedback följer du det här formatet:

Utvärderingshändelsen för användarfeedback kan samlas in om och endast om användaren har reagerat på GenAI-modellsvaret. Det BÖR, när det är möjligt, kopplas till GenAI-avsnittet som beskriver sådan respons.

Händelsetexten för användarfeedback har följande struktur:

Använda tjänstenamnet i spårningsdata

För att identifiera din tjänst via ett unikt ID i Application Insights kan du använda tjänstens namn OpenTelemetry-egenskap i din spårningsdata. Det här är användbart om du loggar data från flera program till samma Application Insights-resurs och du vill skilja mellan dem.

Anta till exempel att du har två program: App-1 och App-2, med spårning konfigurerad för att logga data till samma Application Insights-resurs. Kanske vill du konfigurera App-1 som ska utvärderas kontinuerligt av Relevans och App-2 som ska utvärderas kontinuerligt av Relevans. Du kan använda tjänstnamnet för att filtrera Application efter när du övervakar ditt program i AI Foundry Portal.

För att ställa in egenskapen för tjänstenamn kan du göra det direkt i din applikationskod genom att följa stegen, se Using multiple tracer providers with different Resource. Du kan också ange miljövariabeln OTEL_SERVICE_NAME innan du distribuerar din app. För att lära dig mer om hur du arbetar med tjänstens namn, se OTEL-miljövariabler och semantiska konventioner för tjänsteresurser.

Fråga efter egenskapen cloud_roleName för att få spårningsdata för ett visst tjänstnamn.

| where cloud_RoleName == "service_name"

Integrations

Azure AI Foundry gör det enkelt att logga spårningar med minimala ändringar genom att använda våra spårningsintegreringar med Microsoft Agent Framework, Semantic Kernel, LangChain, LangGraph och OpenAI Agent SDK.

Spårningsagenter som bygger på Microsoft Agent Framework och Semantic Kernel

Azure AI Foundry har interna integreringar med Microsoft Agent Framework och Semantic Kernel. Agenter som bygger på dessa två ramverk får omedelbar spårning i Azure AI Foundry Observability.

• Läs mer om spårning och observerbarhet i Semantic Kernel och Microsoft Agent Framework.

Aktivera spårning för agenter som bygger på LangChain och LangGraph

Du kan aktivera spårning för LangChain som följer OpenTelemetry-standarder enligt opentelemetry-instrumentation-langchain.

När nödvändiga paket har installerats kan du enkelt börja spåra instrument i koden.

Exempel: LangChain v1-agent med Azure AI-spårning

Använd det här exemplet från slutpunkt till slutpunkt för att instrumentera en LangChain v1-agent med hjälp av spårningen langchain-azure-ai , som implementerar den senaste OpenTelemetry-specifikationen (OTel) så att du kan visa omfattande spårningar i Azure AI Foundry Observability.

Installera paket

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

Konfigurera miljö

• APPLICATION_INSIGHTS_CONNECTION_STRING: Azure Monitor Application Insights-anslutningssträng för spårning.
• AZURE_OPENAI_ENDPOINT: Url:en för Azure OpenAI-slutpunkten.
• AZURE_OPENAI_CHAT_DEPLOYMENT: Namnet på chattmodellens distribution.
• AZURE_OPENAI_VERSION: API-version, till exempel 2024-08-01-preview.
• Azure-autentiseringsuppgifter löses via DefaultAzureCredential (stöder miljövariabler, hanterad identitet, VS Code-inloggning osv.).

Du kan lagra dessa i en .env fil för lokal utveckling.

Konfiguration av spårningsverktyg

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]

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

Definiera verktyg och uppmaning

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}!"

Använd körkontext och definiera ett verktyg för användarinformation

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]

Skapa agenten

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

Köra agenten med loggning

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

Med langchain-azure-ai aktiverad spåras alla LangChain v1-åtgärder (LLM-anrop, verktygsanrop, agentsteg) med hjälp av de senaste semantiska opentelemetry-konventionerna och visas i Azure AI Foundry Observability, länkad till din Application Insights-resurs.

Exempel: LangGraph-agent med Azure AI-spårning

Det här exemplet visar en enkel LangGraph-agent som instrumenterats med langchain-azure-ai för att generera OpenTelemetry-kompatibla spårningar för grafsteg, verktygsanrop och modellanrop.

Installera paket

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

Konfigurera miljö

• APPLICATION_INSIGHTS_CONNECTION_STRING: Azure Monitor Application Insights-anslutningssträng för spårning.
• AZURE_OPENAI_ENDPOINT: Url:en för Azure OpenAI-slutpunkten.
• AZURE_OPENAI_CHAT_DEPLOYMENT: Namnet på chattmodellens distribution.
• AZURE_OPENAI_VERSION: API-version, till exempel 2024-08-01-preview.

Du kan lagra dessa i en .env fil för lokal utveckling.

Konfiguration av spårningsverktyg

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

Tools

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]

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

Skapa LangGraph-arbetsflödet

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)

Kör med spårning

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

Med langchain-azure-ai aktiverat genererar LangGraph-körningen OpenTelemetry-kompatibla intervall för modellanrop, verktygsanrop och grafövergångar. Dessa spårningar flödar till Application Insights och visas i Azure AI Foundry Observability.

Exempel: Konfiguration av LangChain 0.3 med Azure AI-spårning

Den här minimala konfigurationen visar hur du aktiverar Azure AI-spårning i ett LangChain 0.3-program med hjälp av spårningen langchain-azure-ai och AzureChatOpenAI.

Installera paket

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

Konfigurera miljö

• APPLICATION_INSIGHTS_CONNECTION_STRING: Application Insights-anslutningssträng för spårning.
• AZURE_OPENAI_ENDPOINT: Url för Azure OpenAI-slutpunkt.
• AZURE_OPENAI_CHAT_DEPLOYMENT: Namn på distribution av chattmodell.
• AZURE_OPENAI_VERSION: API-version, till exempel 2024-08-01-preview.
• AZURE_OPENAI_API_KEY: Azure OpenAI API-nyckel.

Spårnings- och modellkonfiguration

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

Anslut callbacks=[azure_tracer] till dina kedjor, verktyg eller agenter för att säkerställa att LangChain 0.3-åtgärder spåras och visas i Azure AI Foundry Observability.

Aktivera spårning för agenter som bygger på OpenAI Agents SDK

Använd det här kodfragmentet för att konfigurera OpenTelemetry-spårning för OpenAI Agents SDK och instrumentera ramverket. Den exporterar till Azure Monitor om APPLICATION_INSIGHTS_CONNECTION_STRING är inställd; annars återgår den till konsolen.

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

Visa spårningar i Azure AI Foundry-portalen

I projektet går du till Spårning för att filtrera dina spårningar som du vill.

Genom att välja en spårning kan du gå igenom varje intervall och identifiera problem samtidigt som du observerar hur programmet svarar. Detta kan hjälpa dig att felsöka och identifiera problem i ditt program.

Visa spårningar i Azure Monitor

Om du loggade spårningar med det tidigare kodfragmentet är du redo att visa dina spårningar i Azure Monitor Application Insights. Du kan öppna Application Insights från Hantera datakälla och använda vyn för transaktionsinformation från början till slut för att undersöka vidare.

Mer information om hur du skickar Azure AI-slutsatsdragningsspårningar till Azure Monitor och skapar Azure Monitor-resurs finns i Dokumentation om Azure Monitor OpenTelemetry.

Visa trådresultat i Lekplatsen för Azure AI Foundry Agents

Agenternas arbetsyta i Azure AI Foundry-portalen låter dig visa resultat för diskussioner och körningar som dina agenter producerar. Om du vill se trådresultat väljer du Trådloggar i en aktiv tråd. Du kan också välja Mått för att aktivera automatiska utvärderingar av modellens prestanda i flera dimensioner av AI-kvalitet och risk och säkerhet.

När du har valt Trådloggar granskar du:

• Trådinformation
• Köruppgifter
• Ordnade exekveringssteg och verktygsanrop
• Indata och utdata mellan användare och agent
• Länkade utvärderingsmått (om de är aktiverade)

Relaterat innehåll

• Python-exempel som innehåller fullt körbar Python-kod för spårning med hjälp av synkrona och asynkrona klienter.
• Python-exempel för spårningsagenter med konsolspårning och Azure Monitor
• JavaScript-exempel som innehåller fullständigt körbar JavaScript-kod för spårning med synkrona och asynkrona klienter.
• C# Samples som innehåller fullt körbar C#-kod för att utföra inferens med hjälp av synkrona och asynkrona metoder.