Śledzenie i obserwowanie agentów sztucznej inteligencji w rozwiązaniu Microsoft Foundry (wersja zapoznawcza)

W tym artykule dowiesz się, jak:

• Zrozumienie kluczowych pojęć dotyczących śledzenia
• Śledzenie i obserwowanie agentów sztucznej inteligencji w narzędziu Foundry
• Eksplorowanie nowych konwencji semantycznych z obserwacją wielu agentów
• Integracja z popularnymi platformami agentów
• Wyświetlanie śladów w portalu Foundry i usłudze Azure Monitor
• Wyświetlanie wątków agenta na placu zabaw dla agentów

Określenie przyczyny wykonywania 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/wyjściowe na każdym etapie mogą być długie i zasługują na bardziej szczegółową inspekcję.
• Każdy krok środowiska uruchomieniowego 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ążą ten problem, umożliwiając wyświetlanie danych wejściowych i wyjściowych każdego elementu pierwotnego biorącego udział w konkretnym uruchomieniu agenta, wyświetlanego w kolejności wywoływanej, co ułatwia zrozumienie i debugowanie zachowania agenta sztucznej inteligencji.

Omówienie kluczowych koncepcji ś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 jakości i analizy wydajności.
• Ukryj poufną zawartość; unikaj przechowywania tajemnic w atrybutach.

Rozszerzanie funkcji OpenTelemetry z obserwacją wielu agentów

Microsoft zwiększa możliwości obserwacji wielu agentów, wprowadzając nowe konwencje semantyczne do technologii OpenTelemetry, opracowane wspólnie z inkubatorem Outshift firmy Cisco. Te dodatki — oparte na technologii OpenTelemetry i W3C Trace Context — ustanawiają standardowe rozwiązania dotyczące śledzenia i telemetrii w systemach wieloa agentów, ułatwiając 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ę. Te postępy zostały zintegrowane z pakietami Microsoft Foundry, Microsoft Agent Framework, Semantic Kernel i Azure AI dla pakietów LangChain, LangGraph i OpenAI Agents SDK, umożliwiając klientom ujednoliconą obserwację systemów agentów utworzonych przy użyciu dowolnej z tych struktur z narzędziem Foundry. Dowiedz się więcej na temat integracji śledzenia.

Konfigurowanie śledzenia w pakiecie Microsoft Foundry SDK

Aby uzyskać informacje o ukończeniu czatu lub agentach kompilacji za pomocą narzędzia Foundry, zainstaluj:

pip install azure-ai-projects azure-identity

Aby instrumentować śledzenie, należy zainstalować następujące biblioteki instrumentacji:

pip install azure-monitor-opentelemetry opentelemetry-sdk

Aby wyświetlić ślady w Foundry, musisz połączyć zasób 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). Należy pamiętać, że może to zawierać dane osobowe. Aby dowiedzieć się więcej, zobacz bibliotekę klienta Azure Core Tracing OpenTelemetry dla języka Python (Azure Core Tracing OpenTelemetry client library for 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 projektem sztucznej inteligencji platformy Azure przy użyciu elementu 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 usługi 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śledzić kod, w którym tworzysz i wykonujesz komunikat agenta i użytkownika w projekcie usługi Azure AI, aby zobaczyć szczegółowe kroki rozwiązywania problemów lub 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.

Lokalne rejestrowanie śladów

Aby nawiązać połączenie z Aspire Dashboard lub innym zapleczem zgodnym z technologią OpenTelemetry, zainstaluj eksportera protokołu OpenTelemetry (OTLP). Dzięki temu można wyświetlać ślady w konsoli lub korzystać z lokalnego narzędzia do przeglądania, takiego jak Aspire Dashboard.

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

Następnie skonfiguruj śledzenie dla danych wyjściowych 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)

Lub zmodyfikuj powyższy kod na podstawie Aspire Dashboard, aby umożliwić śledzenie w lokalnym podglądzie 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: AI Toolkit for VS Code

Zestaw narzędzi AI Toolkit umożliwia proste śledzenie 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 przykłady kodu specyficzne dla zestawu SDK, zobacz Śledzenie w zestawie narzędzi AI Toolkit.

Śledzenie funkcji niestandardowych

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

1. Skonfiguruj dostawcę śladu: Zainicjuj dostawcę śladu w celu zarządzania śladami i ich tworzenia.
2. Tworzenie zakresów: opakuj kod, który chcesz śledzić za pomocą zakresów. Każdy odcinek reprezentuje jednostkę pracy i można go zagnieżdżać w celu utworzenia drzewa trasowania.
3. Dodaj atrybuty: Wzbogacaj zakresy atrybutami, aby zapewnić więcej kontekstu dla danych ś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, zapoznaj się z 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, możesz instrumentować 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żesz 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 można przechwycić tylko wtedy, gdy użytkownik dostarczył reakcję na odpowiedź modelu GenAI. Jeśli to możliwe, powinno być przypisane do struktury GenAI opisującej taką odpowiedź.

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

Używanie nazwy usługi w danych śledzenia

Aby zidentyfikować swoją usługę za pomocą unikalnego identyfikatora w usłudze Application Insights, możesz użyć nazwy usługi w postaci właściwości OpenTelemetry w swoich danych śledzących. Jest to przydatne, 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 do ciągłego oceniania przez Relevance i App-2 do ciągłego oceniania przez Relevance. Można użyć nazwy usługi do filtrowania według Application podczas monitorowania aplikacji w portalu Foundry.

Aby skonfigurować właściwość nazwy usługi, możesz to zrobić bezpośrednio w kodzie aplikacji, postępując zgodnie z krokami opisanymi w sekcji Używanie wielu dostawców śledzenia z różnymi zasobami. Alternatywnie możesz ustawić 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"

Integrations

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

Agenci śledzące opracowani w oparciu o Microsoft Agent Framework i Semantic Kernel

Platforma Foundry ma natywną integrację z programem Microsoft Agent Framework i jądrem semantycznym. Agenci zbudowani na tych dwóch frameworkach uzyskują natychmiastowy dostęp do funkcji śledzenia w Observability.

• Dowiedz się więcej o śledzeniu i obserwacji w Semantic Kernel i Microsoft Agent Framework.

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

Śledzenie dla LangChain można włączyć zgodnie ze standardami OpenTelemetry, korzystając z opentelemetry-instrumentation-langchain.

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

Przykład: LangChain v1 agent ze śledzeniem AI na platformie Azure

Użyj tej kompleksowej próbki, aby instrumentować agenta LangChain v1 przy użyciu langchain-azure-ai narzędzia tracer, które implementuje najnowszą specyfikację OpenTelemetry (OTel), dzięki czemu możesz wyświetlać szczegółowe ślady w observability.

Instalowanie pakietów

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

Konfigurowanie środowiska

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

Można je przechowywać w pliku .env na potrzeby rozwoju lokalnego.

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

Definiowanie narzędzi i wywołań

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

Uruchamianie 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 w wersji 1 (wywołania LLM, wywołania narzędzi, kroki agenta) są śledzone przy użyciu najnowszych konwencji semantycznych OpenTelemetry i pojawiają się w systemie Obserwowalności, powiązane z Twoim zasobem usługi Application Insights.

Przykład: Agent LangGraph ze śledzeniem AI w ramach Azure

W tym przykładzie pokazano prostego agenta LangGraph wyposażonego w langchain-azure-ai, który emituje ślady zgodne ze standardem OpenTelemetry dla działań w krokach grafu, wywołań narzędzi oraz 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: Parametry połączenia usługi Azure Monitor Application Insights do śledzenia.
• AZURE_OPENAI_ENDPOINT: Adres URL punktu końcowego usługi Azure OpenAI.
• AZURE_OPENAI_CHAT_DEPLOYMENT: nazwa wdrożenia modelu czatu.
• AZURE_OPENAI_VERSION: wersja interfejsu API, na przykład 2024-08-01-preview.

Można je przechowywać w pliku .env na potrzeby rozwoju lokalnego.

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

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]

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://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)

Budowanie przepływu pracy 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 langchain-azure-ai, LangGraph emituje zakresy zgodne ze standardem OpenTelemetry dla wywołań modelu, wywołań narzędzi oraz przejść grafu. Te ślady przepływają do Application Insights i pojawiają się w Observability.

Przykład: konfigurowanie aplikacji LangChain 0.3 za pomocą śledzenia sztucznej inteligencji platformy Azure

Ta konfiguracja minimalna pokazuje, jak włączyć śledzenie Azure AI w aplikacji LangChain 0.3 przy użyciu langchain-azure-ai tracera 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: Parametry połączenia usługi Application Insights do śledzenia.
• AZURE_OPENAI_ENDPOINT: Adres URL punktu końcowego usługi 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 interfejsu API usługi 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,
)

Dołącz callbacks=[azure_tracer] do łańcuchów, narzędzi lub agentów, aby upewnić się, że operacje LangChain 0.3 są śledzone i widoczne w Obserwowalności.

Włączanie śledzenia dla agentów wykorzystujących zestaw SDK OpenAI Agents

Ten fragment kodu służy do konfigurowania śledzenia OpenTelemetry dla zestawu SDK agentów OpenAI i instrumentowania frameworku. Eksportuje do usługi Azure Monitor, jeśli APPLICATION_INSIGHTS_CONNECTION_STRING jest ustawione; 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

Wyświetlanie śladów w portalu Foundry

W projekcie przejdź do Śledzenie, aby filtrować ślady według własnych preferencji.

Wybierając ślad, możesz przejść przez poszczególne zakresy i zidentyfikować problemy podczas obserwowania sposobu reagowania aplikacji. Może to pomóc w debugowanie i wskazanie problemów w aplikacji.

Wyświetlanie śladów w usłudze Azure Monitor

Jeśli zarejestrowano ślady przy użyciu poprzedniego fragmentu kodu, wszystko jest gotowe do wyświetlania śladów 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 usługi Azure AI do usługi Azure Monitor i tworzenia zasobu usługi Azure Monitor, zobacz dokumentację usługi Azure Monitor OpenTelemetry.

Wyświetlanie wyników wątków w środowisku testowym Foundry Agents

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)

Treści powiązane

• Przykłady języka Python zawierające w pełni uruchamiany kod języka Python do śledzenia przy użyciu klientów synchronicznych i asynchronicznych.
• Przykłady języka Python do śledzenia agentów za pomocą funkcji śledzenia konsoli i usługi Azure Monitor
• Przykłady języka JavaScript zawierające w pełni uruchamiany kod JavaScript do śledzenia przy użyciu klientów synchronicznych i asynchronicznych.
• Przykłady języka C# zawierające w pełni uruchamiany kod języka C# do wnioskowania przy użyciu metod synchronicznych i asynchronicznych.