ist jetzt verfügbar! Lesen Sie über die neuen Funktionen und Fehlerbehebungen vom November.

Tracing in AI Toolkit

AI Toolkit bietet Tracing-Funktionen, die Ihnen helfen, die Leistung Ihrer KI-Anwendungen zu überwachen und zu analysieren. Sie können die Ausführung Ihrer KI-Anwendungen, einschließlich Interaktionen mit generativen KI-Modellen, verfolgen, um Einblicke in deren Verhalten und Leistung zu gewinnen.

AI Toolkit hostet einen lokalen HTTP- und gRPC-Server zum Sammeln von Tracedaten. Der Collector-Server ist mit OTLP (OpenTelemetry Protocol) kompatibel, und die meisten SDKs für Sprachmodelle unterstützen entweder OTLP direkt oder verfügen über Nicht-Microsoft-Instrumentierungsbibliotheken, um dies zu unterstützen. Verwenden Sie AI Toolkit, um die gesammelten Instrumentierungsdaten zu visualisieren.

Alle Frameworks oder SDKs, die OTLP unterstützen und die semantischen Konventionen für generative KI-Systeme befolgen, werden unterstützt. Die folgende Tabelle enthält gängige KI-SDKs, die auf Kompatibilität getestet wurden.

Azure AI Inference Foundry Agent Service Anthropic Gemini LangChain OpenAI SDK 3 OpenAI Agents SDK
Python ✅ ✅ ✅ (traceloop, monocle)1,2 ✅ (monocle) ✅ (LangSmith, monocle)1,2 ✅ (opentelemetry-python-contrib, monocle)1 ✅ (Logfire, monocle)1,2
TS/JS ✅ ✅ ✅ (traceloop)1,2 ❌ ✅ (traceloop)1,2 ✅ (traceloop)1,2 ❌
  1. Die SDKs in Klammern sind Nicht-Microsoft-Tools, die OTLP-Unterstützung hinzufügen, da die offiziellen SDKs OTLP nicht unterstützen.
  2. Diese Tools folgen nicht vollständig den OpenTelemetry-Regeln für generative KI-Systeme.
  3. Für das OpenAI SDK wird nur die Chat Completions API unterstützt. Die Responses API wird noch nicht unterstützt.

Erste Schritte mit dem Tracing

  1. Öffnen Sie die Tracing-Webansicht, indem Sie im Baumansicht Tracing auswählen.

  2. Wählen Sie die Schaltfläche Collector starten, um den lokalen OTLP-Trace-Collector-Server zu starten.

    Screenshot showing the Start Collector button in the Tracing webview.

  3. Aktivieren Sie die Instrumentierung mit einem Code-Snippet. Weitere Code-Snippets für verschiedene Sprachen und SDKs finden Sie im Abschnitt Instrumentierung einrichten.

  4. Generieren Sie Tracedaten, indem Sie Ihre App ausführen.

  5. Wählen Sie in der Tracing-Webansicht die Schaltfläche Aktualisieren, um neue Tracedaten anzuzeigen.

    Screenshot showing the Trace List in the Tracing webview.

Instrumentierung einrichten

Richten Sie das Tracing in Ihrer KI-Anwendung ein, um Tracedaten zu sammeln. Die folgenden Code-Snippets zeigen, wie das Tracing für verschiedene SDKs und Sprachen eingerichtet wird.

Der Prozess ist für alle SDKs ähnlich

  • Fügen Sie Ihrem LLM- oder Agenten-App Tracing hinzu.
  • Richten Sie den OTLP-Trace-Exporter so ein, dass er den lokalen AITK-Collector verwendet.
Azure AI Inference SDK - Python

Installation

pip install opentelemetry-sdk opentelemetry-exporter-otlp-proto-http azure-ai-inference[opentelemetry]

Einrichtung

import os
os.environ["AZURE_TRACING_GEN_AI_CONTENT_RECORDING_ENABLED"] = "true"
os.environ["AZURE_SDK_TRACING_IMPLEMENTATION"] = "opentelemetry"

from opentelemetry import trace, _events
from opentelemetry.sdk.resources import Resource
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.sdk._logs import LoggerProvider
from opentelemetry.sdk._logs.export import BatchLogRecordProcessor
from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
from opentelemetry.sdk._events import EventLoggerProvider
from opentelemetry.exporter.otlp.proto.http._log_exporter import OTLPLogExporter

resource = Resource(attributes={
    "service.name": "opentelemetry-instrumentation-azure-ai-agents"
})
provider = TracerProvider(resource=resource)
otlp_exporter = OTLPSpanExporter(
    endpoint="https://:4318/v1/traces",
)
processor = BatchSpanProcessor(otlp_exporter)
provider.add_span_processor(processor)
trace.set_tracer_provider(provider)

logger_provider = LoggerProvider(resource=resource)
logger_provider.add_log_record_processor(
    BatchLogRecordProcessor(OTLPLogExporter(endpoint="https://:4318/v1/logs"))
)
_events.set_event_logger_provider(EventLoggerProvider(logger_provider))

from azure.ai.inference.tracing import AIInferenceInstrumentor
AIInferenceInstrumentor().instrument(True)
Azure AI Inference SDK - TypeScript/JavaScript

Installation

npm install @azure/opentelemetry-instrumentation-azure-sdk @opentelemetry/api @opentelemetry/exporter-trace-otlp-proto @opentelemetry/instrumentation @opentelemetry/resources @opentelemetry/sdk-trace-node

Einrichtung

const { context } = require('@opentelemetry/api');
const { resourceFromAttributes } = require('@opentelemetry/resources');
const {
  NodeTracerProvider,
  SimpleSpanProcessor
} = require('@opentelemetry/sdk-trace-node');
const { OTLPTraceExporter } = require('@opentelemetry/exporter-trace-otlp-proto');

const exporter = new OTLPTraceExporter({
  url: 'https://:4318/v1/traces'
});
const provider = new NodeTracerProvider({
  resource: resourceFromAttributes({
    'service.name': 'opentelemetry-instrumentation-azure-ai-inference'
  }),
  spanProcessors: [new SimpleSpanProcessor(exporter)]
});
provider.register();

const { registerInstrumentations } = require('@opentelemetry/instrumentation');
const {
  createAzureSdkInstrumentation
} = require('@azure/opentelemetry-instrumentation-azure-sdk');

registerInstrumentations({
  instrumentations: [createAzureSdkInstrumentation()]
});
Foundry Agent Service - Python

Installation

pip install opentelemetry-sdk opentelemetry-exporter-otlp-proto-http azure-ai-inference[opentelemetry]

Einrichtung

import os
os.environ["AZURE_TRACING_GEN_AI_CONTENT_RECORDING_ENABLED"] = "true"
os.environ["AZURE_SDK_TRACING_IMPLEMENTATION"] = "opentelemetry"

from opentelemetry import trace, _events
from opentelemetry.sdk.resources import Resource
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.sdk._logs import LoggerProvider
from opentelemetry.sdk._logs.export import BatchLogRecordProcessor
from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
from opentelemetry.sdk._events import EventLoggerProvider
from opentelemetry.exporter.otlp.proto.http._log_exporter import OTLPLogExporter

resource = Resource(attributes={
    "service.name": "opentelemetry-instrumentation-azure-ai-agents"
})
provider = TracerProvider(resource=resource)
otlp_exporter = OTLPSpanExporter(
    endpoint="https://:4318/v1/traces",
)
processor = BatchSpanProcessor(otlp_exporter)
provider.add_span_processor(processor)
trace.set_tracer_provider(provider)

logger_provider = LoggerProvider(resource=resource)
logger_provider.add_log_record_processor(
    BatchLogRecordProcessor(OTLPLogExporter(endpoint="https://:4318/v1/logs"))
)
_events.set_event_logger_provider(EventLoggerProvider(logger_provider))

from azure.ai.agents.telemetry import AIAgentsInstrumentor
AIAgentsInstrumentor().instrument(True)
Foundry Agent Service - TypeScript/JavaScript

Installation

npm install @azure/opentelemetry-instrumentation-azure-sdk @opentelemetry/api @opentelemetry/exporter-trace-otlp-proto @opentelemetry/instrumentation @opentelemetry/resources @opentelemetry/sdk-trace-node

Einrichtung

const { context } = require('@opentelemetry/api');
const { resourceFromAttributes } = require('@opentelemetry/resources');
const {
  NodeTracerProvider,
  SimpleSpanProcessor
} = require('@opentelemetry/sdk-trace-node');
const { OTLPTraceExporter } = require('@opentelemetry/exporter-trace-otlp-proto');

const exporter = new OTLPTraceExporter({
  url: 'https://:4318/v1/traces'
});
const provider = new NodeTracerProvider({
  resource: resourceFromAttributes({
    'service.name': 'opentelemetry-instrumentation-azure-ai-inference'
  }),
  spanProcessors: [new SimpleSpanProcessor(exporter)]
});
provider.register();

const { registerInstrumentations } = require('@opentelemetry/instrumentation');
const {
  createAzureSdkInstrumentation
} = require('@azure/opentelemetry-instrumentation-azure-sdk');

registerInstrumentations({
  instrumentations: [createAzureSdkInstrumentation()]
});
Anthropic - Python

OpenTelemetry

Installation

pip install opentelemetry-sdk opentelemetry-exporter-otlp-proto-http opentelemetry-instrumentation-anthropic

Einrichtung

from opentelemetry import trace, _events
from opentelemetry.sdk.resources import Resource
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.sdk._logs import LoggerProvider
from opentelemetry.sdk._logs.export import BatchLogRecordProcessor
from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
from opentelemetry.sdk._events import EventLoggerProvider
from opentelemetry.exporter.otlp.proto.http._log_exporter import OTLPLogExporter

resource = Resource(attributes={
    "service.name": "opentelemetry-instrumentation-anthropic-traceloop"
})
provider = TracerProvider(resource=resource)
otlp_exporter = OTLPSpanExporter(
    endpoint="https://:4318/v1/traces",
)
processor = BatchSpanProcessor(otlp_exporter)
provider.add_span_processor(processor)
trace.set_tracer_provider(provider)

logger_provider = LoggerProvider(resource=resource)
logger_provider.add_log_record_processor(
    BatchLogRecordProcessor(OTLPLogExporter(endpoint="https://:4318/v1/logs"))
)
_events.set_event_logger_provider(EventLoggerProvider(logger_provider))

from opentelemetry.instrumentation.anthropic import AnthropicInstrumentor
AnthropicInstrumentor().instrument()

Monocle

Installation

pip install opentelemetry-sdk opentelemetry-exporter-otlp-proto-http monocle_apptrace

Einrichtung

from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter

# Import monocle_apptrace
from monocle_apptrace import setup_monocle_telemetry

# Setup Monocle telemetry with OTLP span exporter for traces
setup_monocle_telemetry(
    workflow_name="opentelemetry-instrumentation-anthropic",
    span_processors=[
        BatchSpanProcessor(
            OTLPSpanExporter(endpoint="https://:4318/v1/traces")
        )
    ]
)
Anthropic - TypeScript/JavaScript

Installation

npm install @traceloop/node-server-sdk

Einrichtung

const { initialize } = require('@traceloop/node-server-sdk');
const { trace } = require('@opentelemetry/api');

initialize({
  appName: 'opentelemetry-instrumentation-anthropic-traceloop',
  baseUrl: 'https://:4318',
  disableBatch: true
});
Google Gemini - Python

OpenTelemetry

Installation

pip install opentelemetry-sdk opentelemetry-exporter-otlp-proto-http opentelemetry-instrumentation-google-genai

Einrichtung

from opentelemetry import trace, _events
from opentelemetry.sdk.resources import Resource
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.sdk._logs import LoggerProvider
from opentelemetry.sdk._logs.export import BatchLogRecordProcessor
from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
from opentelemetry.sdk._events import EventLoggerProvider
from opentelemetry.exporter.otlp.proto.http._log_exporter import OTLPLogExporter

resource = Resource(attributes={
    "service.name": "opentelemetry-instrumentation-google-genai"
})
provider = TracerProvider(resource=resource)
otlp_exporter = OTLPSpanExporter(
    endpoint="https://:4318/v1/traces",
)
processor = BatchSpanProcessor(otlp_exporter)
provider.add_span_processor(processor)
trace.set_tracer_provider(provider)

logger_provider = LoggerProvider(resource=resource)
logger_provider.add_log_record_processor(
    BatchLogRecordProcessor(OTLPLogExporter(endpoint="https://:4318/v1/logs"))
)
_events.set_event_logger_provider(EventLoggerProvider(logger_provider))

from opentelemetry.instrumentation.google_genai import GoogleGenAiSdkInstrumentor
GoogleGenAiSdkInstrumentor().instrument(enable_content_recording=True)

Monocle

Installation

pip install opentelemetry-sdk opentelemetry-exporter-otlp-proto-http monocle_apptrace

Einrichtung

from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter

# Import monocle_apptrace
from monocle_apptrace import setup_monocle_telemetry

# Setup Monocle telemetry with OTLP span exporter for traces
setup_monocle_telemetry(
    workflow_name="opentelemetry-instrumentation-google-genai",
    span_processors=[
        BatchSpanProcessor(
            OTLPSpanExporter(endpoint="https://:4318/v1/traces")
        )
    ]
)
LangChain - Python

LangSmith

Installation

pip install langsmith[otel]

Einrichtung

import os
os.environ["LANGSMITH_OTEL_ENABLED"] = "true"
os.environ["LANGSMITH_TRACING"] = "true"
os.environ["OTEL_EXPORTER_OTLP_ENDPOINT"] = "https://:4318"

Monocle

Installation

pip install opentelemetry-sdk opentelemetry-exporter-otlp-proto-http monocle_apptrace

Einrichtung

from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter

# Import monocle_apptrace
from monocle_apptrace import setup_monocle_telemetry

# Setup Monocle telemetry with OTLP span exporter for traces
setup_monocle_telemetry(
    workflow_name="opentelemetry-instrumentation-langchain",
    span_processors=[
        BatchSpanProcessor(
            OTLPSpanExporter(endpoint="https://:4318/v1/traces")
        )
    ]
)
LangChain - TypeScript/JavaScript

Installation

npm install @traceloop/node-server-sdk

Einrichtung

const { initialize } = require('@traceloop/node-server-sdk');
initialize({
  appName: 'opentelemetry-instrumentation-langchain-traceloop',
  baseUrl: 'https://:4318',
  disableBatch: true
});
OpenAI - Python

OpenTelemetry

Installation

pip install opentelemetry-sdk opentelemetry-exporter-otlp-proto-http opentelemetry-instrumentation-openai-v2

Einrichtung

from opentelemetry import trace, _events
from opentelemetry.sdk.resources import Resource
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.sdk._logs import LoggerProvider
from opentelemetry.sdk._logs.export import BatchLogRecordProcessor
from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
from opentelemetry.sdk._events import EventLoggerProvider
from opentelemetry.exporter.otlp.proto.http._log_exporter import OTLPLogExporter
from opentelemetry.instrumentation.openai_v2 import OpenAIInstrumentor
import os

os.environ["OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT"] = "true"

# Set up resource
resource = Resource(attributes={
    "service.name": "opentelemetry-instrumentation-openai"
})

# Create tracer provider
trace.set_tracer_provider(TracerProvider(resource=resource))

# Configure OTLP exporter
otlp_exporter = OTLPSpanExporter(
    endpoint="https://:4318/v1/traces"
)

# Add span processor
trace.get_tracer_provider().add_span_processor(
    BatchSpanProcessor(otlp_exporter)
)

# Set up logger provider
logger_provider = LoggerProvider(resource=resource)
logger_provider.add_log_record_processor(
    BatchLogRecordProcessor(OTLPLogExporter(endpoint="https://:4318/v1/logs"))
)
_events.set_event_logger_provider(EventLoggerProvider(logger_provider))

# Enable OpenAI instrumentation
OpenAIInstrumentor().instrument()

Monocle

Installation

pip install opentelemetry-sdk opentelemetry-exporter-otlp-proto-http monocle_apptrace

Einrichtung

from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter

# Import monocle_apptrace
from monocle_apptrace import setup_monocle_telemetry

# Setup Monocle telemetry with OTLP span exporter for traces
setup_monocle_telemetry(
    workflow_name="opentelemetry-instrumentation-openai",
    span_processors=[
        BatchSpanProcessor(
            OTLPSpanExporter(endpoint="https://:4318/v1/traces")
        )
    ]
)
OpenAI - TypeScript/JavaScript

Installation

npm install @traceloop/instrumentation-openai @traceloop/node-server-sdk

Einrichtung

const { initialize } = require('@traceloop/node-server-sdk');
initialize({
  appName: 'opentelemetry-instrumentation-openai-traceloop',
  baseUrl: 'https://:4318',
  disableBatch: true
});
OpenAI Agents SDK - Python

Logfire

Installation

pip install logfire

Einrichtung

import logfire
import os

os.environ["OTEL_EXPORTER_OTLP_TRACES_ENDPOINT"] = "https://:4318/v1/traces"

logfire.configure(
    service_name="opentelemetry-instrumentation-openai-agents-logfire",
    send_to_logfire=False,
)
logfire.instrument_openai_agents()

Monocle

Installation

pip install opentelemetry-sdk opentelemetry-exporter-otlp-proto-http monocle_apptrace

Einrichtung

from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter

# Import monocle_apptrace
from monocle_apptrace import setup_monocle_telemetry

# Setup Monocle telemetry with OTLP span exporter for traces
setup_monocle_telemetry(
    workflow_name="opentelemetry-instrumentation-openai-agents",
    span_processors=[
        BatchSpanProcessor(
            OTLPSpanExporter(endpoint="https://:4318/v1/traces")
        )
    ]
)

Beispiel 1: Tracing mit dem Azure AI Inference SDK unter Verwendung von Opentelemetry einrichten

Das folgende End-to-End-Beispiel verwendet das Azure AI Inference SDK in Python und zeigt, wie der Tracing-Provider und die Instrumentierung eingerichtet werden.

Voraussetzungen

Um dieses Beispiel auszuführen, benötigen Sie die folgenden Voraussetzungen

Entwicklungsumgebung einrichten

Verwenden Sie die folgenden Anweisungen, um eine vorkonfigurierte Entwicklungsumgebung bereitzustellen, die alle erforderlichen Abhängigkeiten für die Ausführung dieses Beispiels enthält.

  1. GitHub Personal Access Token einrichten

    Verwenden Sie die kostenlosen GitHub Models als Beispielmodell.

    Öffnen Sie die GitHub-Entwicklereinstellungen und wählen Sie Neues Token generieren.

    Wichtig

    models:read Berechtigungen sind für das Token erforderlich, andernfalls wird ein Fehler "unauthorized" zurückgegeben. Das Token wird an einen Microsoft-Dienst gesendet.

  2. Umgebungsvariable erstellen

    Erstellen Sie eine Umgebungsvariable, um Ihr Token als Schlüssel für den Client-Code mit einem der folgenden Code-Snippets festzulegen. Ersetzen Sie <your-github-token-goes-here> durch Ihr tatsächliches GitHub-Token.

    bash

    export GITHUB_TOKEN="<your-github-token-goes-here>"

    powershell

    $Env:GITHUB_TOKEN="<your-github-token-goes-here>"

    Windows-Eingabeaufforderung

    set GITHUB_TOKEN=<your-github-token-goes-here>

  3. Python-Pakete installieren

    Der folgende Befehl installiert die erforderlichen Python-Pakete für das Tracing mit dem Azure AI Inference SDK

    pip install opentelemetry-sdk opentelemetry-exporter-otlp-proto-http azure-ai-inference[opentelemetry]

  4. Tracing einrichten

    1. Erstellen Sie ein neues lokales Verzeichnis auf Ihrem Computer für das Projekt.

      mkdir my-tracing-app

    2. Navigieren Sie zu dem von Ihnen erstellten Verzeichnis.

      cd my-tracing-app

    3. Öffnen Sie Visual Studio Code in diesem Verzeichnis

      code .

  5. Python-Datei erstellen

    1. Erstellen Sie im Verzeichnis my-tracing-app eine Python-Datei namens main.py.

      Sie fügen den Code zum Einrichten des Tracings und zur Interaktion mit dem Azure AI Inference SDK hinzu.

    2. Fügen Sie den folgenden Code zu main.py hinzu und speichern Sie die Datei

      import os

### Set up for OpenTelemetry tracing ###
os.environ["AZURE_TRACING_GEN_AI_CONTENT_RECORDING_ENABLED"] = "true"
os.environ["AZURE_SDK_TRACING_IMPLEMENTATION"] = "opentelemetry"

from opentelemetry import trace, _events
from opentelemetry.sdk.resources import Resource
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.sdk._logs import LoggerProvider
from opentelemetry.sdk._logs.export import BatchLogRecordProcessor
from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
from opentelemetry.sdk._events import EventLoggerProvider
from opentelemetry.exporter.otlp.proto.http._log_exporter import OTLPLogExporter

github_token = os.environ["GITHUB_TOKEN"]

resource = Resource(attributes={
    "service.name": "opentelemetry-instrumentation-azure-ai-inference"
})
provider = TracerProvider(resource=resource)
otlp_exporter = OTLPSpanExporter(
    endpoint="https://:4318/v1/traces",
)
processor = BatchSpanProcessor(otlp_exporter)
provider.add_span_processor(processor)
trace.set_tracer_provider(provider)

logger_provider = LoggerProvider(resource=resource)
logger_provider.add_log_record_processor(
    BatchLogRecordProcessor(OTLPLogExporter(endpoint="https://:4318/v1/logs"))
)
_events.set_event_logger_provider(EventLoggerProvider(logger_provider))

from azure.ai.inference.tracing import AIInferenceInstrumentor
AIInferenceInstrumentor().instrument()
### Set up for OpenTelemetry tracing ###

from azure.ai.inference import ChatCompletionsClient
from azure.ai.inference.models import UserMessage
from azure.ai.inference.models import TextContentItem
from azure.core.credentials import AzureKeyCredential

client = ChatCompletionsClient(
    endpoint = "https://models.inference.ai.azure.com",
    credential = AzureKeyCredential(github_token),
    api_version = "2024-08-01-preview",
)

response = client.complete(
    messages = [
        UserMessage(content = [
            TextContentItem(text = "hi"),
        ]),
    ],
    model = "gpt-4.1",
    tools = [],
    response_format = "text",
    temperature = 1,
    top_p = 1,
)

print(response.choices[0].message.content)

  6. Code ausführen

    1. Öffnen Sie ein neues Terminal in Visual Studio Code.

    2. Führen Sie den Code im Terminal mit dem Befehl python main.py aus.

  7. Tracedaten in AI Toolkit überprüfen

    Nachdem Sie den Code ausgeführt und die Tracing-Webansicht aktualisiert haben, gibt es eine neue Spur in der Liste.

    Wählen Sie die Spur aus, um die Detailansicht der Spur zu öffnen.

    Screenshot showing selecting a trace from the Trace List in the Tracing webview.

    Überprüfen Sie den vollständigen Ausführungsfluss Ihrer App in der linken Span-Baumansicht.

    Wählen Sie einen Span in der rechten Span-Detailansicht aus, um generative KI-Nachrichten im Tab Input + Output anzuzeigen.

    Wählen Sie den Tab Metadaten, um die Rohmetadaten anzuzeigen.

    Screenshot showing the Trace Details view in the Tracing webview.

Beispiel 2: Tracing mit dem OpenAI Agents SDK unter Verwendung von Monocle einrichten

Das folgende End-to-End-Beispiel verwendet das OpenAI Agents SDK in Python mit Monocle und zeigt, wie das Tracing für ein Multi-Agenten-Reisebuchungssystem eingerichtet wird.

Voraussetzungen

Um dieses Beispiel auszuführen, benötigen Sie die folgenden Voraussetzungen

Entwicklungsumgebung einrichten

Verwenden Sie die folgenden Anweisungen, um eine vorkonfigurierte Entwicklungsumgebung bereitzustellen, die alle erforderlichen Abhängigkeiten für die Ausführung dieses Beispiels enthält.

  1. Umgebungsvariable erstellen

    Erstellen Sie eine Umgebungsvariable für Ihren OpenAI API-Schlüssel mit einem der folgenden Code-Snippets. Ersetzen Sie <your-openai-api-key> durch Ihren tatsächlichen OpenAI API-Schlüssel.

    bash

    export OPENAI_API_KEY="<your-openai-api-key>"

    powershell

    $Env:OPENAI_API_KEY="<your-openai-api-key>"

    Windows-Eingabeaufforderung

    set OPENAI_API_KEY=<your-openai-api-key>

    Alternativ können Sie eine Datei .env in Ihrem Projektverzeichnis erstellen

    OPENAI_API_KEY=<your-openai-api-key>

  2. Python-Pakete installieren

    Erstellen Sie eine Datei requirements.txt mit folgendem Inhalt

    opentelemetry-sdk
opentelemetry-exporter-otlp-proto-http
monocle_apptrace
openai-agents
python-dotenv

    Installieren Sie die Pakete mit

    pip install -r requirements.txt

  3. Tracing einrichten

    1. Erstellen Sie ein neues lokales Verzeichnis auf Ihrem Computer für das Projekt.

      mkdir my-agents-tracing-app

    2. Navigieren Sie zu dem von Ihnen erstellten Verzeichnis.

      cd my-agents-tracing-app

    3. Öffnen Sie Visual Studio Code in diesem Verzeichnis

      code .

  4. Python-Datei erstellen

    1. Erstellen Sie im Verzeichnis my-agents-tracing-app eine Python-Datei namens main.py.

      Sie fügen den Code hinzu, um das Tracing mit Monocle einzurichten und mit dem OpenAI Agents SDK zu interagieren.

    2. Fügen Sie den folgenden Code zu main.py hinzu und speichern Sie die Datei

      import os

from dotenv import load_dotenv

# Load environment variables from .env file
load_dotenv()

from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter

# Import monocle_apptrace
from monocle_apptrace import setup_monocle_telemetry

# Setup Monocle telemetry with OTLP span exporter for traces
setup_monocle_telemetry(
    workflow_name="opentelemetry-instrumentation-openai-agents",
    span_processors=[
        BatchSpanProcessor(
            OTLPSpanExporter(endpoint="https://:4318/v1/traces")
        )
    ]
)

from agents import Agent, Runner, function_tool

# Define tool functions
@function_tool
def book_flight(from_airport: str, to_airport: str) -> str:
    """Book a flight between airports."""
    return f"Successfully booked a flight from {from_airport} to {to_airport} for 100 USD."

@function_tool
def book_hotel(hotel_name: str, city: str) -> str:
    """Book a hotel reservation."""
    return f"Successfully booked a stay at {hotel_name} in {city} for 50 USD."

@function_tool
def get_weather(city: str) -> str:
    """Get weather information for a city."""
    return f"The weather in {city} is sunny and 75°F."

# Create specialized agents
flight_agent = Agent(
    name="Flight Agent",
    instructions="You are a flight booking specialist. Use the book_flight tool to book flights.",
    tools=[book_flight],
)

hotel_agent = Agent(
    name="Hotel Agent",
    instructions="You are a hotel booking specialist. Use the book_hotel tool to book hotels.",
    tools=[book_hotel],
)

weather_agent = Agent(
    name="Weather Agent",
    instructions="You are a weather information specialist. Use the get_weather tool to provide weather information.",
    tools=[get_weather],
)

# Create a coordinator agent with tools
coordinator = Agent(
    name="Travel Coordinator",
    instructions="You are a travel coordinator. Delegate flight bookings to the Flight Agent, hotel bookings to the Hotel Agent, and weather queries to the Weather Agent.",
    tools=[
        flight_agent.as_tool(
            tool_name="flight_expert",
            tool_description="Handles flight booking questions and requests.",
        ),
        hotel_agent.as_tool(
            tool_name="hotel_expert",
            tool_description="Handles hotel booking questions and requests.",
        ),
        weather_agent.as_tool(
            tool_name="weather_expert",
            tool_description="Handles weather information questions and requests.",
        ),
    ],
)

# Run the multi-agent workflow
if __name__ == "__main__":
    import asyncio

    result = asyncio.run(
        Runner.run(
            coordinator,
            "Book me a flight today from SEA to SFO, then book the best hotel there and tell me the weather.",
        )
    )
    print(result.final_output)

  5. Code ausführen

    1. Öffnen Sie ein neues Terminal in Visual Studio Code.

    2. Führen Sie den Code im Terminal mit dem Befehl python main.py aus.

  6. Tracedaten in AI Toolkit überprüfen

    Nachdem Sie den Code ausgeführt und die Tracing-Webansicht aktualisiert haben, gibt es eine neue Spur in der Liste.

    Wählen Sie die Spur aus, um die Detailansicht der Spur zu öffnen.

    Screenshot showing selecting a trace from the Trace List in the Tracing webview.

    Überprüfen Sie den vollständigen Ausführungsfluss Ihrer App in der linken Span-Baumansicht, einschließlich Agentenaufrufen, Toolaufrufen und Agentendelegationen.

    Wählen Sie einen Span in der rechten Span-Detailansicht aus, um generative KI-Nachrichten im Tab Input + Output anzuzeigen.

    Wählen Sie den Tab Metadaten, um die Rohmetadaten anzuzeigen.

    Screenshot showing the Trace Details view in the Tracing webview.

Was Sie gelernt haben

In diesem Artikel haben Sie gelernt, wie Sie

  • Richten Sie das Tracing in Ihrer KI-Anwendung mit dem Azure AI Inference SDK und OpenTelemetry ein.
  • Konfigurieren Sie den OTLP-Trace-Exporter so, dass Tracedaten an den lokalen Collector-Server gesendet werden.
  • Führen Sie Ihre Anwendung aus, um Tracedaten zu generieren und Spuren in der AI Toolkit-Webansicht anzuzeigen.
  • Verwenden Sie die Tracing-Funktion mit mehreren SDKs und Sprachen, einschließlich Python und TypeScript/JavaScript, sowie Nicht-Microsoft-Tools über OTLP.
  • Instrumentieren Sie verschiedene KI-Frameworks (Anthropic, Gemini, LangChain, OpenAI und mehr) mit den bereitgestellten Code-Snippets.
  • Verwenden Sie die Benutzeroberfläche der Tracing-Webansicht, einschließlich der Schaltflächen Collector starten und Aktualisieren, um Tracedaten zu verwalten.
  • Richten Sie Ihre Entwicklungsumgebung ein, einschließlich Umgebungsvariablen und Paketinstallation, um das Tracing zu ermöglichen.
  • Analysieren Sie den Ausführungsfluss Ihrer App mithilfe der Span-Baum- und Detailansicht, einschließlich des Nachrichtenflusses und der Metadaten für generative KI.
10/03/2025
© . This site is unofficial and not affiliated with Microsoft.