Śledzenie i obserwowanie agentów sztucznej inteligencji w usłudze Microsoft Foundry (wersja zapoznawcza) (wersja klasyczna)

Dotyczy tylko:Portal Foundry (klasyczny). Ten artykuł nie jest dostępny w nowym portalu Foundry. Dowiedz się więcej o nowym portalu.

Z tego artykułu dowiesz się, jak wykonywać następujące działania:

• Zrozumienie kluczowych pojęć dotyczących śledzenia.
• Śledzenie i obserwowanie agentów sztucznej inteligencji w narzędziu Foundry.
• Poznaj nowe konwencje semantyczne związane z wieloagentową obserwowalnością.
• Integracja z popularnymi strukturami agentów.
• Wyświetl ślady w portalu Foundry i Azure Monitor.
• Wyświetl wątki agenta w środowisku Agentów.

Określenie powodu działań agenta jest ważne w przypadku rozwiązywania problemów i debugowania. Jednak może to być trudne dla złożonych agentów z wielu powodów:

• Może istnieć duża liczba kroków związanych z generowaniem odpowiedzi, co utrudnia śledzenie wszystkich z nich.
• Sekwencja kroków może się różnić w zależności od danych wejściowych użytkownika.
• Dane wejściowe i wyjściowe na każdym etapie mogą być długie i zasługują na bardziej szczegółową inspekcję.
• Każdy krok czasu działania agenta może również obejmować zagnieżdżanie. Na przykład agent może wywołać narzędzie, które używa innego procesu, który następnie wywołuje inne narzędzie. Jeśli zauważysz dziwne lub nieprawidłowe dane wyjściowe z uruchomienia agenta najwyższego poziomu, może być trudno określić dokładnie, gdzie w wykonaniu został wprowadzony problem.

Wyniki śledzenia rozwiązują ten problem, umożliwiając wyświetlanie danych wejściowych i wyjściowych każdego elementu pierwotnego zaangażowanego w określone uruchomienie agenta. Wyniki są wyświetlane w kolejności wywoływanej przez element pierwotny, co ułatwia zrozumienie i debugowanie zachowania agenta sztucznej inteligencji.

Omówienie kluczowych pojęć dotyczących śledzenia

Poniżej przedstawiono krótkie omówienie kluczowych pojęć przed rozpoczęciem pracy:

Najlepsze rozwiązania

• Użyj atrybutów spójnego zakresu.
• Korelowanie identyfikatorów przebiegów oceny na potrzeby analizy jakości i wydajności.
• Redact wrażliwej zawartości. Unikaj przechowywania wpisów tajnych w atrybutach.

Rozszerzanie funkcji OpenTelemetry z obserwacją wielu agentów

Microsoft zwiększa obserwowalność wieloagentową, wprowadzając nowe konwencje semantyczne do OpenTelemetry, opracowane wspólnie z narzędziem inkubacji firmy Cisco. Te dodatki, oparte na technologii OpenTelemetry i W3C Trace Context, ustanawiają ustandaryzowane praktyki śledzenia i telemetrii w systemach z wieloma agentami. Ułatwiają one spójne rejestrowanie kluczowych metryk pod kątem jakości, wydajności, bezpieczeństwa i kosztów. Takie systematyczne podejście umożliwia bardziej kompleksowy wgląd w przepływy pracy obejmujące wiele agentów, w tym wywołania narzędzi i współpracę. Microsoft zintegrował te postępy w programach Microsoft Foundry, Microsoft Agent Framework, Semantic Kernel i Azure AI w pakietach LangChain, LangGraph i pakietach SDK agentów OpenAI. Korzystając z rozwiązania Foundry, klienci mogą uzyskać ujednoliconą obserwację systemów agentów utworzonych przy użyciu dowolnej z tych platform. Dowiedz się więcej na temat integracji śledzenia.

Konfigurowanie śledzenia w zestawie SDK Microsoft Foundry

Do kompletacji czatu lub tworzenia agentów za pomocą narzędzia Foundry, zainstaluj:

pip install azure-ai-projects azure-identity

Aby włączyć śledzenie, zainstaluj następujące biblioteki instrumentacji:

pip install azure-monitor-opentelemetry opentelemetry-sdk

Aby wyświetlić ślady w narzędziu Foundry, połącz zasób usługi Application Insights z projektem foundry.

1. Przejdź do pozycji Śledzenie w okienku nawigacji po lewej stronie portalu Foundry.
2. Utwórz nowy zasób usługi Application Insights, jeśli jeszcze go nie masz.
3. Połącz zasób z projektem Foundry.

Śledzenie instrumentów w kodzie

Aby śledzić zawartość wiadomości czatu, ustaw zmienną AZURE_TRACING_GEN_AI_CONTENT_RECORDING_ENABLED środowiskową na true (bez uwzględniania wielkości liter). Ta zawartość może zawierać dane osobowe. Aby uzyskać więcej informacji, zobacz Azure Core Tracing OpenTelemetry client library for Python (Podstawowa biblioteka klienta śledzenia OpenTelemetry dla Python

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

Zacznijmy instrumentację agenta za pomocą funkcji śledzenia OpenTelemetry, zaczynając od uwierzytelniania i nawiązywania połączenia z Azure AI Project przy użyciu AIProjectClient.

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

Następnie pobierz parametry połączenia z zasobu usługi Application Insights połączonego z projektem i skonfiguruj eksporterów OTLP w celu wysyłania danych telemetrycznych 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

Teraz prześledź kod, w którym tworzysz i wykonujesz wiadomości agenta oraz użytkownika w projekcie Azure AI, aby zobaczyć szczegółowe kroki kontrolowania procesu rozwiązywania problemów oraz monitorowania.

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 uruchomieniu agenta można rozpocząć wyświetlanie śladów w portalu Foundry.

Lokalna analiza logów

Aby nawiązać połączenie z pulpitem Aspire Dashboard lub innym zapleczem zgodnym z OpenTelemetry, zainstaluj eksportera protokołu OpenTelemetry Protocol (OTLP). Korzystając z tego eksportera, można wydrukować logi w konsoli programu lub użyć przeglądarki lokalnej, takiej jak dashboard Aspire.

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

Następnie skonfiguruj śledzenie dla wyjścia konsoli:

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)

Możesz też zmodyfikować poprzedni kod oparty na Aspire Dashboard, aby śledzić za pomocą lokalnego przeglądarki OTLP.

Teraz włącz instrumentację agenta i uruchom 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)

Alternatywa: Foundry Toolkit for VS Code

Narzędzie Foundry Toolkit zapewnia prosty sposób śledzenia lokalnie w programie VS Code. Używa on lokalnego modułu zbierającego zgodnego z protokołem OTLP, co czyni go idealnym rozwiązaniem do programowania i debugowania.

Zestaw narzędzi obsługuje struktury sztucznej inteligencji, takie jak Foundry Agents Service, OpenAI, Anthropic i LangChain za pośrednictwem biblioteki OpenTelemetry. Ślady są widoczne natychmiast w programie VS Code bez konieczności uzyskiwania dostępu do chmury.

Aby uzyskać szczegółowe instrukcje dotyczące konfiguracji i specyficzne dla SDK przykłady kodu, zobacz Śledzenie w Foundry Toolkit.

Śledzenie funkcji niestandardowych

Aby śledzić funkcje niestandardowe, użyj zestawu OpenTelemetry SDK do instrumentacji kodu.

1. Konfigurowanie dostawcy śledzenia: zainicjować dostawcę śledzenia w celu zarządzania rozpiętościami i tworzenia ich.
2. Tworzenie zakresów: opakuj kod, który chcesz śledzić za pomocą zakresów. Każdy zakres reprezentuje jednostkę pracy i można zagnieżdżać zakresy w celu utworzenia drzewa śledzenia.
3. Dodaj atrybuty: Wzbogacaj zakresy o atrybuty, aby zapewnić więcej kontekstu danym śledzenia.
4. Konfigurowanie eksportera: wysyłanie danych śledzenia do zaplecza na potrzeby analizy i wizualizacji.

Oto przykład śledzenia funkcji niestandardowej:

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

Aby uzyskać szczegółowe instrukcje i zaawansowane użycie, zobacz dokumentację biblioteki OpenTelemetry.

Dołączanie opinii użytkowników do śladów

Aby dołączyć opinie użytkowników do śladów i zwizualizować je w portalu Foundry, instrumentuj aplikację w celu włączenia śledzenia i rejestrowania opinii użytkowników przy użyciu konwencji semantycznych openTelemetry.

Korelując ślady opinii z odpowiednimi śladami żądań czatu przy użyciu identyfikatora odpowiedzi lub identyfikatora wątku, można wyświetlić te ślady i zarządzać nimi w portalu Foundry. Specyfikacja biblioteki OpenTelemetry umożliwia ustandaryzowane i wzbogacone dane śledzenia, które można analizować w portalu Foundry na potrzeby optymalizacji wydajności i szczegółowych informacji o środowisku użytkownika. Takie podejście ułatwia korzystanie z pełnej możliwości platformy OpenTelemetry w celu zwiększenia możliwości obserwacji w aplikacjach.

Aby rejestrować opinie użytkowników, postępuj zgodnie z następującym formatem:

Zdarzenie oceny opinii użytkowników jest przechwytywane tylko wtedy, gdy użytkownik zapewnia reakcję na odpowiedź modelu GenAI. Jeśli to możliwe, przypisuj to zdarzenie do przedziału GenAI opisującego taką odpowiedź.

Treść zdarzenia opinii użytkownika ma następującą strukturę:

Używanie nazwy usługi w danych śledzenia

Aby zidentyfikować usługę za pomocą unikatowego identyfikatora w usłudze Application Insights, użyj właściwości OpenTelemetry zawierającej nazwę usługi w danych śledzenia. Ta właściwość jest przydatna, jeśli rejestrujesz dane z wielu aplikacji do tego samego zasobu usługi Application Insights i chcesz je rozróżnić.

Załóżmy na przykład, że masz dwie aplikacje: App-1 i App-2 ze śledzeniem skonfigurowanym do rejestrowania danych w tym samym zasobie usługi Application Insights. Być może chcesz skonfigurować App-1, aby był ciągle oceniany przez Relevance, i App-2, aby był ciągle oceniany przez Relevance. Możesz użyć nazwy usługi do filtrowania za pomocą Application, gdy monitorujesz swoją aplikację w portalu Foundry.

Aby skonfigurować właściwość nazwy usługi, dodaj ją bezpośrednio w kodzie aplikacji, wykonując kroki opisane w temacie Używanie wielu dostawców śledzenia z różnymi zasobami. Alternatywnie ustaw zmienną środowiskową OTEL_SERVICE_NAME przed wdrożeniem aplikacji. Aby dowiedzieć się więcej na temat pracy z nazwą usługi, zobacz Zmienne środowiskowe OTEL i konwencje semantyczne zasobów usługi.

Aby wysłać zapytanie dotyczące danych śledzenia dla danej nazwy usługi, wykonaj zapytanie dotyczące cloud_roleName właściwości.

| where cloud_RoleName == "service_name"

Integracje

Narzędzie Foundry ułatwia rejestrowanie śladów przy minimalnych zmianach przy użyciu integracji śledzenia z Microsoft Agent Framework, Semantic Kernel, LangChain, LangGraph i OpenAI Agent SDK.

Śledzenie agentów opartych na programie Microsoft Agent Framework i Semantic Kernel

Platforma Foundry ma natywne integracje z platformą Microsoft Agent Framework i Semantic Kernel. Agenci zbudowani na tych dwóch platformach uzyskują wbudowane śledzenie w możliwości obserwacji.

• Dowiedz się więcej na temat śledzenia i możliwości obserwowania w Semantic Kernel i Microsoft Agent Framework.

Włączanie śledzenia dla agentów utworzonych na platformie LangChain i LangGraph

Śledzenie dla elementu LangChain można włączyć zgodnie ze standardami OpenTelemetry za pomocą opentelemetry-instrumentation-langchain.

Po zainstalowaniu niezbędnych pakietów można łatwo włączyć śledzenie w kodzie.

Przykład: agent LangChain w wersji 1 ze śledzeniem Azure AI

Użyj tego kompleksowego przykładu, aby skonfigurować agenta LangChain w wersji 1 przy użyciu narzędzia langchain-azure-ai tracer. Implementuje ona najnowszą specyfikację OpenTelemetry (OTel), dzięki czemu można wyświetlać zaawansowane ślady w funkcji Obserwacja.

Instalowanie pakietów

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

Konfigurowanie środowiska

• APPLICATION_INSIGHTS_CONNECTION_STRING: Ciąg połączenia Azure Monitor Application Insights do śledzenia operacji.
• AZURE_OPENAI_ENDPOINT: Adres URL punktu końcowego Azure OpenAI.
• AZURE_OPENAI_CHAT_DEPLOYMENT: nazwa wdrożenia modelu czatu.
• AZURE_OPENAI_VERSION: wersja interfejsu API, na przykład 2024-08-01-preview.
• Azure poświadczenia są rozpoznawane za pośrednictwem DefaultAzureCredential (obsługuje zmienne środowiskowe, tożsamość zarządzaną, logowanie programu VS Code i nie tylko).

Te wartości można przechowywać w pliku na potrzeby programowania lokalnego .env .

Konfiguracja narzędzia Tracer

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]

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

Definiowanie narzędzi i monitów

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

Używanie kontekstu środowiska uruchomieniowego i definiowanie narzędzia user-info

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]

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

Uruchom agenta ze śledzeniem

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

Po włączeniu langchain-azure-ai wszystkie operacje LangChain v1 (wywołania LLM, wywołania narzędzi, kroki agenta) są śledzone zgodnie z najnowszymi konwencjami semantycznymi OpenTelemetry. Są one widoczne w obszarze Obserwowaność, połączone z zasobem usługi Application Insights.

Przykład: agent LangGraph z śledzeniem sztucznej inteligencji Azure

W tym przykładzie pokazano prostego agenta LangGraph skonfigurowanego z użyciem langchain-azure-ai, aby emitować ślady zgodne ze standardem OpenTelemetry dla kroków grafu, wywołań narzędzi i wywołań modelu.

Instalowanie pakietów

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

Konfigurowanie środowiska

• APPLICATION_INSIGHTS_CONNECTION_STRING: Ciąg połączenia Azure Monitor Application Insights do śledzenia operacji.
• AZURE_OPENAI_ENDPOINT: Adres URL punktu końcowego Azure OpenAI.
• AZURE_OPENAI_CHAT_DEPLOYMENT: nazwa wdrożenia modelu czatu.
• AZURE_OPENAI_VERSION: wersja interfejsu API, na przykład 2024-08-01-preview.

Te wartości można przechowywać w pliku na potrzeby programowania lokalnego .env .

Konfiguracja narzędzia Tracer

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

Narzędzia

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]

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

Budowanie procesu 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)

Uruchamianie za pomocą śledzenia

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

Po włączeniu funkcji langchain-azure-ai działanie LangGraph emituje spany zgodne ze standardem OpenTelemetry dla wywołań modelu, wywołań narzędzi i przejść grafu. Te ślady są przesyłane do Application Insights i są widoczne w Observability.

Przykład: konfiguracja pakietu LangChain 0.3 przy użyciu śledzenia sztucznej inteligencji Azure

Ta minimalna konfiguracja pokazuje, jak włączyć śledzenie sztucznej inteligencji Azure w aplikacji LangChain 0.3 przy użyciu langchain-azure-ai i AzureChatOpenAI.

Instalowanie pakietów

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

Konfigurowanie środowiska

• APPLICATION_INSIGHTS_CONNECTION_STRING: ciąg połączenia usługi Application Insights do śledzenia.
• AZURE_OPENAI_ENDPOINT: Adres URL punktu końcowego Azure OpenAI.
• AZURE_OPENAI_CHAT_DEPLOYMENT: Nazwa wdrożenia modelu czatu.
• AZURE_OPENAI_VERSION: wersja interfejsu API, na przykład 2024-08-01-preview.
• AZURE_OPENAI_API_KEY: Klucz API Azure OpenAI.

Tracer i konfiguracja 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,
)

Podłącz callbacks=[azure_tracer] do swoich łańcuchów, narzędzi lub agentów, aby operacje LangChain 0.3 były śledzone i widoczne w obserwowalności.

Włącz śledzenie dla agentów opartych na zestawie SDK OpenAI Agents

Zainstaluj wymagane pakiety:

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

Ten fragment kodu służy do konfigurowania śledzenia OpenTelemetry dla pakietu SDK agentów OpenAI i instrumentowania frameworku. Eksportuje do Azure Monitor, jeśli APPLICATION_INSIGHTS_CONNECTION_STRING jest ustawiony; w przeciwnym razie wraca do konsoli.

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

Przeglądaj ślady w portalu Foundry

W projekcie przejdź do pozycji Śledzenie , aby filtrować ślady zgodnie z potrzebami.

Wybierając ślad, możesz przejść przez poszczególne zakresy i zidentyfikować problemy podczas obserwowania sposobu reagowania aplikacji. Ten proces pomaga debugować i określać problemy w aplikacji.

Wyświetlanie śladów w Azure Monitor

Jeśli zarejestrowano ślady przy użyciu poprzedniego fragmentu kodu, wszystko jest ustawione, aby wyświetlić ślady w usłudze Azure Monitor Application Insights. Możesz otworzyć usługę Application Insights z obszaru Zarządzanie źródłem danych i użyć widoku Szczegóły transakcji kompleksowej , aby dokładniej zbadać.

Aby uzyskać więcej informacji na temat wysyłania śladów wnioskowania sztucznej inteligencji Azure do Azure Monitor oraz tworzenia zasobu Azure Monitor, zobacz dokumentację OpenTelemetry Azure Monitor.

Wyświetlanie wyników wątków w środowisku testowym dla agentów Foundry

Plac zabaw agentów w portalu Foundry umożliwia wyświetlanie wyników wątków i przebiegów, które tworzą agenci. Aby wyświetlić wyniki wątku, wybierz pozycję Dzienniki wątków w aktywnym wątku. Opcjonalnie możesz również wybrać pozycję Metryki , aby włączyć automatyczne oceny wydajności modelu w kilku wymiarach jakości sztucznej inteligencji i ryzyka i bezpieczeństwa.

Po wybraniu dzienników wątków przejrzyj następujące elementy:

• Szczegóły wątku
• Informacje o uruchomieniu
• Uporządkowane kroki uruchamiania i wywołania narzędzi
• Dane wejściowe i wyjściowe między użytkownikiem a agentem
• Połączone metryki oceny (jeśli są włączone)

Powiązana zawartość

• Przykłady Pythona zawierające kompletny kod wykonawczy w Pythonie do śledzenia przy użyciu klientów synchronicznych i asynchronicznych.
• przykłady w Pythonie do śledzenia agentów ze śledzeniem w konsoli i Azure Monitor
• przykłady JavaScript zawierające w pełni działający kod JavaScript w celu śledzenia przy użyciu klientów synchronicznych i asynchronicznych.
• C# Samples zawierający w pełni uruchamiany kod języka C# do wnioskowania przy użyciu metod synchronicznych i asynchronicznych.