Configurer le suivi pour les infrastructures de l’agent IA (préversion)

Important

Les éléments indiqués comme (aperçu) dans cet article sont en aperçu public. Cette préversion est fournie sans contrat de niveau de service. Nous vous déconseillons donc de l’utiliser dans des charges de travail de production. Certaines fonctionnalités peuvent ne pas être prises en charge ou avoir des fonctionnalités contraintes. Pour plus d’informations, consultez Conditions d'utilisation supplémentaires pour les versions préliminaires de Microsoft Azure.

Note

Le suivi est généralement disponible uniquement pour les agents de prompt. Les agents hébergés, workflow et externes sont en préversion.

Lorsque les agents IA se comportent de façon inattendue en production, le suivi vous donne la visibilité pour identifier rapidement la cause racine. Le suivi capture des données de télémétrie détaillées, notamment les appels LLM, les appels d’outils et les flux de décision de l’agent, afin de pouvoir déboguer des problèmes, surveiller la latence et comprendre le comportement de l’agent entre les requêtes.

Microsoft Foundry fournit des intégrations de suivi pour les infrastructures d’agent populaires qui nécessitent des modifications de code minimales. Dans cet article, vous allez apprendre à :

Configurer le suivi automatique pour Microsoft Agent Framework et le noyau sémantique
Configurer la distribution Microsoft OpenTelemetry pour LangChain et LangGraph
Instrumenter le Kit de développement logiciel (SDK) Des agents OpenAI avec OpenTelemetry
Vérifier que les traces apparaissent dans le portail Foundry
Résoudre les problèmes de suivi courants

Conditions préalables

Un projet de fonderie. Pour plus d’informations, consultez Create a Foundry project.
Suivi connecté à une ressource de Application Insights de Azure Monitor. Pour le configurer, consultez Configurer le suivi dans Microsoft Foundry.
Rôle de contributeur ou d'un niveau supérieur sur la ressource Application Insights pour l’ingestion de traces.
Accès à la ressource Application Insights connectée pour afficher les traces. Pour les requêtes basées sur des logs, vous devrez peut-être également accéder à l'espace de travail Log Analytics associé.
Python 3.10 ou version ultérieure (obligatoire pour tous les exemples de code de cet article).
Package microsoft-opentelemetry (requis pour les exemples LangChain et LangGraph).
Si vous utilisez LangChain ou LangGraph, un environnement Python avec pip installé.

Vérifiez que vous pouvez afficher les données de télémétrie

Pour afficher les données de trace, vérifiez que votre compte a accès à la ressource Application Insights connectée.

Dans le portail Azure, ouvrez la ressource Application Insights connectée à votre projet Foundry.
Sélectionnez Contrôle d’accès (IAM).
Attribuez un rôle approprié à votre utilisateur ou groupe.

Si vous utilisez des requêtes basées sur les journaux, commencez par accorder le rôle Lecteur de Log Analytics.

Sécurité et confidentialité

Le suivi peut capturer des informations sensibles (par exemple, des entrées utilisateur, des sorties de modèle et des arguments et des résultats d’outils).

Activez l’enregistrement de contenu pendant le développement et le débogage pour afficher les données de requête et de réponse complètes. Désactivez l’enregistrement de contenu dans les environnements de production pour protéger les données sensibles. Dans les exemples de cet article, l’enregistrement de contenu est contrôlé par les variables OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENTd’environnement , OTEL_SEMCONV_STABILITY_OPT_INet AZURE_EXPERIMENTAL_ENABLE_GENAI_TRACING.
Ne stockez pas les secrets, les informations d’identification ou les jetons dans des requêtes ou des arguments d’outil.

Pour plus d’informations, consultez Sécurité et confidentialité.

Note

Les données de trace stockées dans Application Insights sont soumises aux paramètres de rétention des données de votre espace de travail et Azure Monitor tarification. Pour la gestion des coûts, envisagez d’ajuster les taux d’échantillonnage ou les périodes de rétention en production. Consultez Azure Monitor tarification et Configurer la rétention et l’archivage des données.

Configurer le suivi pour Microsoft Agent Framework et le noyau sémantique

Microsoft Foundry a des intégrations natives à Microsoft Agent Framework et au noyau sémantique. Les agents créés avec l’infrastructure émettent automatiquement des traces lorsque le suivi est activé pour votre projet Foundry. Aucun code ou packages supplémentaire n’est nécessaire.

Pour vérifier que le suivi fonctionne :

Exécutez votre agent au moins une fois.
Dans le portail Foundry, accédez à Observabilité>Traces.
Vérifiez qu’une nouvelle trace s’affiche avec des étendues pour les opérations de votre agent.

Les traces apparaissent généralement dans un délai de 2 à 5 minutes après l’exécution de l’agent. Pour une configuration avancée, consultez la documentation spécifique à l’infrastructure :

Configurer le suivi avec les bibliothèques d’instrumentation OpenInference

Microsoft Foundry prend en charge les bibliothèques d’instrumentation OpenInference pour le traçage des agents IA. Ces openinference-* packages fournissent une instrumentation automatique pour un large éventail d’infrastructures et peuvent être utilisés pour tracer les agents hébergés (agents déployés sur Foundry) et les agents non-Foundry (agents hébergés en dehors de Foundry).

Parcourez les packages d’instrumentation disponibles sur PyPI. Pour LangChain, consultez l’exemple Microsoft OpenTelemetry distro LangChain, qui montre comment activer l’exportation Azure Monitor et l’instrumentation automatique LangChain avec use_microsoft_opentelemetry.

La condition essentielle consiste à corrélater les traces OpenInference à un agent spécifique. La manière d’y parvenir dépend de l’endroit où votre agent s’exécute :

Agents hébergés (déployés sur Foundry)

Lorsque vous déployez un agent sur Foundry à l’aide de l’un des packages de serveur d’agent hébergé, la corrélation de trace est gérée automatiquement. Package de serveur :

Configure l’exportation vers Azure Monitor des spans OpenTelemetry.
Enrichit toutes les étendues avec des attributs project, nom de l’agent, version de l’agent et ID d’agent afin que l’interface utilisateur Foundry puisse interroger et les afficher.

Aucune configuration supplémentaire n’est nécessaire. Installez le package d’instrumentation approprié pour votre framework openinference-* et les traces apparaîtront automatiquement dans le portail Foundry.

Agents Microsoft Agent Framework hébergés en dehors de Foundry

Si votre agent Microsoft Agent Framework n’est pas déployé avec un package de serveur d’agent hébergé par Foundry, configurez l’exportation vers Azure Monitor et l’instrumentation de l’Agent Framework avec la distribution Microsoft OpenTelemetry. La distribution peut activer l’exportateur Azure Monitor et ajouter des attributs d’identité de l’agent aux spans :

from microsoft.opentelemetry import use_microsoft_opentelemetry

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

Définissez azure_monitor_connection_string sur la ressource Application Insights connectée à votre projet Foundry. Pour capturer le contenu du prompt et de la réponse générée pendant le développement, définissez enable_sensitive_data=True.

Agents LangChain hébergés en dehors de Foundry

Si votre agent n’est pas déployé avec un package de serveur d’agent hébergé par Foundry, configurez l’exportation vers Azure Monitor et l’instrumentation LangChain avec la distribution Microsoft OpenTelemetry. La distribution peut activer l’exportateur Azure Monitor et ajouter des attributs d’identité d’agent aux spans LangChain :

from microsoft.opentelemetry import use_microsoft_opentelemetry

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

Définissez APPLICATIONINSIGHTS_CONNECTION_STRING sur la ressource Application Insights connectée à votre projet Foundry. Pour capturer le contenu du prompt et de la réponse pendant le développement, définissez OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT=SPAN_AND_EVENT, OTEL_SEMCONV_STABILITY_OPT_IN=gen_ai_latest_experimental et AZURE_EXPERIMENTAL_ENABLE_GENAI_TRACING=true.

Configurer le suivi pour LangChain et LangGraph

Note

L’intégration de suivi pour LangChain et LangGraph n’est actuellement disponible que dans Python.

Utilisez la distribution Microsoft OpenTelemetry pour émettre des étendues compatibles OpenTelemetry pour les opérations LangChain et LangGraph. Ces traces apparaissent dans la vue Observabilité>Traces dans le portail Foundry.

Exemple : Agent v1 LangChain avec traçage Azure IA

Utilisez cet exemple de bout en bout pour instrumenter un agent LangChain v1 (préversion) à l’aide de la distribution Microsoft OpenTelemetry. La distribution permet l’auto-instrumentation de LangChain avec les dernières conventions sémantiques OpenTelemetry (OTel), afin que vous puissiez consulter des traces détaillées dans la vue d’observabilité de Foundry.

LangChain v1 : Installer des packages

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

LangChain v1 : Configurer l’environnement

APPLICATIONINSIGHTS_CONNECTION_STRING : Chaîne de connexion Azure Monitor Application Insights pour le suivi.
AZURE_OPENAI_ENDPOINT : URL de point de terminaison OpenAI de votre Azure.
AZURE_OPENAI_CHAT_DEPLOYMENT : nom du modèle de déploiement de conversation.
AZURE_OPENAI_VERSION: version de l’API, par exemple 2024-08-01-preview.
Le SDK résout les informations d'identification Azure à l’aide de DefaultAzureCredential, qui prend en charge les variables d'environnement, l'identité managée et la connexion à VS Code.

Stockez ces valeurs dans un .env fichier pour le développement local.

LangChain v1 : Configuration du traceur

from dotenv import load_dotenv
from microsoft.opentelemetry import use_microsoft_opentelemetry

load_dotenv(override=True)

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

LangChain v1 : Configuration du modèle (Azure OpenAI)

import os
import azure.identity
from langchain_openai import AzureChatOpenAI

token_provider = azure.identity.get_bearer_token_provider(
    azure.identity.DefaultAzureCredential(),
    "https://cognitiveservices.azure.com/.default",
)

model = AzureChatOpenAI(
    azure_endpoint=os.environ.get("AZURE_OPENAI_ENDPOINT"),
    azure_deployment=os.environ.get("AZURE_OPENAI_CHAT_DEPLOYMENT"),
    openai_api_version=os.environ.get("AZURE_OPENAI_VERSION"),
    azure_ad_token_provider=token_provider,
)

LangChain v1 : Définir des outils et des incitations

from dataclasses import dataclass
from langchain_core.tools import tool

system_prompt = """You are an expert weather forecaster, who speaks in puns.

You have access to two tools:

- get_weather_for_location: use this to get the weather for a specific location
- get_user_location: use this to get the user's location

If a user asks you for the weather, make sure you know the location.
If you can tell from the question that they mean wherever they are,
use the get_user_location tool to find their location."""

# Mock user locations keyed by user id (string)
USER_LOCATION = {
    "1": "Florida",
    "2": "SF",
}


@dataclass
class UserContext:
    user_id: str


@tool
def get_weather(city: str) -> str:
    """Get weather for a given city."""
    return f"It's always sunny in {city}!"

LangChain v1 : Utiliser le contexte d’exécution et définir un outil d’informations utilisateur

from langgraph.runtime import get_runtime
from langchain_core.runnables import RunnableConfig

@tool
def get_user_info(config: RunnableConfig) -> str:
    """Retrieve user information based on user ID."""
    runtime = get_runtime(UserContext)
    user_id = runtime.context.user_id
    return USER_LOCATION[user_id]

LangChain v1 : Créer l’agent

from langchain.agents import create_agent
from langgraph.checkpoint.memory import InMemorySaver
from dataclasses import dataclass


@dataclass
class WeatherResponse:
    conditions: str
    punny_response: str


checkpointer = InMemorySaver()

agent = create_agent(
    model=model,
    prompt=system_prompt,
    tools=[get_user_info, get_weather],
    response_format=WeatherResponse,
    checkpointer=checkpointer,
)

LangChain v1 : Exécuter l’agent avec le traçage

from rich import print

def main():
    config = {"configurable": {"thread_id": "1"}}
    context = UserContext(user_id="1")

    r1 = agent.invoke(
        {"messages": [{"role": "user", "content": "what is the weather outside?"}]},
        config=config,
        context=context,
    )
    print(r1.get("structured_response"))

    r2 = agent.invoke(
        {"messages": [{"role": "user", "content": "Thanks"}]},
        config=config,
        context=context,
    )
    print(r2.get("structured_response"))


if __name__ == "__main__":
    main()

Avec la distribution Microsoft OpenTelemetry activée, toutes les opérations LangChain v1 (appels LLM, appels d’outils, étapes de l’agent) émettent des étendues OpenTelemetry à l’aide des conventions sémantiques les plus récentes. Cestraces apparaissent dans la vue Traces > dans le portail Foundry et sont liées à votre ressource Application Insights.

Conseil

Après avoir exécuté l’agent, attendez quelques minutes pour voir apparaître les traces. Si vous ne voyez pas de traces, vérifiez que votre chaîne de connexion Application Insights est correcte et consultez la section Résolution des problèmes courants.

Vérifiez vos traces LangChain v1

Après avoir exécuté l’agent :

Attendez 2 à 5 minutes pour que les traces se propagent.
Dans le portail Foundry, accédez à Observabilité>Traces.
Recherchez une trace portant le nom que vous avez spécifié (par exemple, « Agent d’informations météorologiques »).
Développez la trace pour voir les plages des appels LLM, les appels d’outils et les étapes de l’agent.

Si vous ne voyez pas de traces, consultez la section Résoudre les problèmes courants .

Exemple : agent LangGraph avec suivi Azure AI

Cet exemple montre un agent LangGraph simple instrumenté avec la distribution Microsoft OpenTelemetry pour émettre des traces conformes à OpenTelemetry pour les étapes de graphique, les appels d’outils et les appels de modèle.

LangGraph : Installer des packages

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

LangGraph : Configurer l’environnement

APPLICATIONINSIGHTS_CONNECTION_STRING : Chaîne de connexion Azure Monitor Application Insights pour le suivi.
AZURE_OPENAI_ENDPOINT : URL de point de terminaison OpenAI de votre Azure.
AZURE_OPENAI_CHAT_DEPLOYMENT : nom du modèle de déploiement de conversation.
AZURE_OPENAI_VERSION: version de l’API, par exemple 2024-08-01-preview.

Stockez ces valeurs dans un .env fichier pour le développement local.

Configuration du traceur LangGraph

from dotenv import load_dotenv
from microsoft.opentelemetry import use_microsoft_opentelemetry

load_dotenv(override=True)

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

LangGraph : Outils

from langchain_core.tools import tool

@tool
def play_song_on_spotify(song: str):
    """Play a song on Spotify"""
    # Integrate with Spotify API here.
    return f"Successfully played {song} on Spotify!"


@tool
def play_song_on_apple(song: str):
    """Play a song on Apple Music"""
    # Integrate with Apple Music API here.
    return f"Successfully played {song} on Apple Music!"


tools = [play_song_on_apple, play_song_on_spotify]

LangGraph : Configuration du modèle (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)

Générer le flux de travail LangGraph

from langgraph.graph import END, START, MessagesState, StateGraph
from langgraph.prebuilt import ToolNode
from langgraph.checkpoint.memory import MemorySaver

tool_node = ToolNode(tools)

def should_continue(state: MessagesState):
    messages = state["messages"]
    last_message = messages[-1]
    return "continue" if getattr(last_message, "tool_calls", None) else "end"


def call_model(state: MessagesState):
    messages = state["messages"]
    response = model.invoke(messages)
    return {"messages": [response]}


workflow = StateGraph(MessagesState)
workflow.add_node("agent", call_model)
workflow.add_node("action", tool_node)

workflow.add_edge(START, "agent")
workflow.add_conditional_edges(
    "agent",
    should_continue,
    {
        "continue": "action",
        "end": END,
    },
)
workflow.add_edge("action", "agent")

memory = MemorySaver()
app = workflow.compile(checkpointer=memory)

LangGraph : Exécuter avec le tracé

from langchain_core.messages import HumanMessage

config = {"configurable": {"thread_id": "1"}}
input_message = HumanMessage(content="Can you play Taylor Swift's most popular song?")

for event in app.stream({"messages": [input_message]}, config, stream_mode="values"):
    event["messages"][-1].pretty_print()

Avec la distribution Microsoft OpenTelemetry activée, votre exécution LangGraph émet des étendues compatibles OpenTelemetry pour les appels de modèle, les appels d’outils et les transitions de graphique. Ces traces sont envoyées vers Application Insights et apparaissent dans la vue d'Observabilité>Traces dans le portail Foundry.

Conseil

Chaque nœud de graphe et transition de périphérie crée une étendue distincte, ce qui facilite la visualisation du flux de décision de l’agent.

Vérifiez vos traces LangGraph

Après avoir exécuté l’agent :

Attendez 2 à 5 minutes pour que les traces se propagent.
Dans le portail Foundry, accédez à Observabilité>Traces.
Recherchez une trace portant le nom que vous avez spécifié (par exemple, « Agent de lecteur de musique »).
Développez la trace pour voir les plages des nœuds de graphe, les appels d’outils et les appels de modèle.

Si vous ne voyez pas de traces, consultez la section Résoudre les problèmes courants .

Exemple : Configuration de LangChain 0.3 avec le tracing de l'IA Azure

Cette configuration minimale montre comment activer le traçage d’Azure AI dans une application LangChain 0.3 à l’aide de la distribution Microsoft OpenTelemetry et de AzureChatOpenAI.

LangChain 0.3 : Installer des packages

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

LangChain 0.3 : Configurer l’environnement

APPLICATIONINSIGHTS_CONNECTION_STRING : Chaîne de connexion Application Insights pour le suivi des données. Pour trouver cette valeur, ouvrez votre ressource Application Insights dans le portail Azure, sélectionnez Overview et copiez la chaîne de connexion .
AZURE_OPENAI_ENDPOINT : URL de point de terminaison OpenAI Azure.
AZURE_OPENAI_CHAT_DEPLOYMENT: Nom du déploiement du modèle de conversation.
AZURE_OPENAI_VERSION: version de l’API, par exemple 2024-08-01-preview.
AZURE_OPENAI_API_KEY : clé API Azure OpenAI.

Note

Cet exemple utilise l’authentification par clé API par souci de simplicité. Pour les charges de travail de production, utilisez DefaultAzureCredential avec get_bearer_token_provider comme indiqué dans les exemples de LangChain v1 et LangGraph.

LangChain 0.3 : Traçage et configuration du modèle

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

load_dotenv(override=True)

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

# Model: Azure OpenAI
llm = AzureChatOpenAI(
    azure_deployment=os.environ.get("AZURE_OPENAI_CHAT_DEPLOYMENT"),
    api_key=os.environ.get("AZURE_OPENAI_API_KEY"),
    azure_endpoint=os.environ.get("AZURE_OPENAI_ENDPOINT"),
    api_version=os.environ.get("AZURE_OPENAI_VERSION"),
    temperature=0.2,
)

Avec la distribution initialisée, les opérations LangChain 0.3 sont instrumentées automatiquement dans le monde entier. Après avoir exécuté votre chaîne ou agent, les traces apparaissent dans la vue Observabilité>Traces du portail Foundry au bout de 2 à 5 minutes.

Configurer le traçage pour le Kit de développement logiciel (SDK) OpenAI Agents

Le Kit de développement logiciel (SDK) Des agents OpenAI prend en charge l’instrumentation OpenTelemetry. Utilisez l’extrait de code suivant pour configurer les étendues de suivi et d’exportation pour Azure Monitor. Si APPLICATION_INSIGHTS_CONNECTION_STRING n'est pas défini, l'exportateur revient à la console pour le débogage local.

Avant d’exécuter l’exemple, installez les packages requis :

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

import os
from opentelemetry import trace
from opentelemetry.instrumentation.openai_agents import OpenAIAgentsInstrumentor
from opentelemetry.sdk.resources import Resource
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor, ConsoleSpanExporter

# Configure tracer provider + exporter
resource = Resource.create({
    "service.name": os.getenv("OTEL_SERVICE_NAME", "openai-agents-app"),
})
provider = TracerProvider(resource=resource)

conn = os.getenv("APPLICATION_INSIGHTS_CONNECTION_STRING")
if conn:
    from azure.monitor.opentelemetry.exporter import AzureMonitorTraceExporter
    provider.add_span_processor(
        BatchSpanProcessor(AzureMonitorTraceExporter.from_connection_string(conn))
    )
else:
    provider.add_span_processor(BatchSpanProcessor(ConsoleSpanExporter()))

trace.set_tracer_provider(provider)

# Instrument the OpenAI Agents SDK
OpenAIAgentsInstrumentor().instrument(tracer_provider=trace.get_tracer_provider())

# Example: create a session span around your agent run
tracer = trace.get_tracer(__name__)
with tracer.start_as_current_span("agent_session[openai.agents]"):
    # ... run your agent here
    pass

Vérifier les traces dans le portail Foundry

Connectez-vous à Microsoft Foundry. Vérifiez que le commutateur New Foundry est activé. Ces étapes font référence à Foundry (nouveau).
Vérifiez que le suivi est connecté pour votre projet. Si nécessaire, suivez Configurer le suivi dans Microsoft Foundry.
Exécutez votre agent au moins une fois.
Dans le portail Foundry, accédez à Observabilité>Traces.
Vérifiez qu’une nouvelle trace s’affiche avec des étendues pour les opérations de votre agent.

Les traces apparaissent généralement dans un délai de 2 à 5 minutes après l’exécution de l’agent. Si les traces n’apparaissent toujours pas après cette période, consultez Résoudre les problèmes courants.

Résoudre les problèmes courants

Problème	Cause	Résolution
Vous ne voyez pas de traces dans Foundry	Le suivi n’est pas connecté, il n’y a pas de trafic récent, ou l’ingestion est retardée	Confirmez la connexion Application Insights, générez un nouveau trafic et actualisez après 2 à 5 minutes.
Vous ne voyez pas les étendues LangChain ou LangGraph	La distribution Microsoft OpenTelemetry n'est pas initialisée ou l'instrumentation LangChain n'est pas activée	Confirmez que vous appelez `use_microsoft_opentelemetry(...)` avec `"langchain": {"enabled": True}` avant d’exécuter votre agent.
Les segments LangChain s’affichent, mais les appels d’outil sont manquants.	Les outils ne sont pas liés au modèle ou le nœud de l'outil n'est pas configuré.	Vérifiez que les outils sont transmis à `bind_tools()` sur le modèle et que les nœuds d'outil sont ajoutés à votre graphe.
Les traces apparaissent, mais sont incomplètes ou il manque des sections	L’enregistrement du contenu est désactivé, l’activation de la convention sémantique pour GenAI n’est pas configurée, ou certaines opérations ne sont pas instrumentées	Pour LangChain et LangGraph, définissez `OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT=SPAN_AND_EVENT`, `OTEL_SEMCONV_STABILITY_OPT_IN=gen_ai_latest_experimental`et `AZURE_EXPERIMENTAL_ENABLE_GENAI_TRACING=true` pendant le développement. Pour les opérations personnalisées, ajoutez des étendues manuelles à l’aide du kit SDK OpenTelemetry.
Vous voyez des erreurs d’autorisation lorsque vous interrogez des données de télémétrie	Autorisations RBAC manquantes sur Application Insights ou Log Analytics	Confirmez l’accès dans le contrôle d’accès (IAM) pour les ressources connectées. Pour les requêtes de journal, affectez le rôle lecteur Log Analytics.
Le contenu sensible apparaît dans les traces	L’enregistrement de contenu est activé et les invites, les arguments de l’outil ou les sorties incluent des données sensibles	Désactivez l’enregistrement de contenu en production et réactez les données sensibles avant d’entrer dans la télémétrie.

Découvrez les concepts de base et l’architecture dans la vue d’ensemble du suivi de l’agent.
Si vous n'avez pas encore activé le suivi, consultez Set up tracing in Microsoft Foundry.
Visualisez les métriques d’intégrité et de performances de l’agent avec le tableau de bord surveillance de l’agent.
Explorez les fonctionnalités d’observabilité plus larges dans l’observabilité dans l’IA générative.

Commentaires

Cette page a-t-elle été utile ?

Last updated on 2026-06-03

Configurer le suivi pour les infrastructures de l’agent IA (préversion)

Conditions préalables

Vérifiez que vous pouvez afficher les données de télémétrie

Sécurité et confidentialité

Configurer le suivi pour Microsoft Agent Framework et le noyau sémantique

Configurer le suivi avec les bibliothèques d’instrumentation OpenInference

Agents hébergés (déployés sur Foundry)

Agents Microsoft Agent Framework hébergés en dehors de Foundry

Agents LangChain hébergés en dehors de Foundry

Configurer le suivi pour LangChain et LangGraph

Exemple : Agent v1 LangChain avec traçage Azure IA

LangChain v1 : Installer des packages

LangChain v1 : Configurer l’environnement

LangChain v1 : Configuration du traceur

LangChain v1 : Configuration du modèle (Azure OpenAI)

LangChain v1 : Définir des outils et des incitations

LangChain v1 : Utiliser le contexte d’exécution et définir un outil d’informations utilisateur

LangChain v1 : Créer l’agent

LangChain v1 : Exécuter l’agent avec le traçage

Vérifiez vos traces LangChain v1

Exemple : agent LangGraph avec suivi Azure AI

LangGraph : Installer des packages

LangGraph : Configurer l’environnement

Configuration du traceur LangGraph

LangGraph : Outils

LangGraph : Configuration du modèle (Azure OpenAI)

Générer le flux de travail LangGraph

LangGraph : Exécuter avec le tracé

Vérifiez vos traces LangGraph

Exemple : Configuration de LangChain 0.3 avec le tracing de l'IA Azure

LangChain 0.3 : Installer des packages

LangChain 0.3 : Configurer l’environnement

LangChain 0.3 : Traçage et configuration du modèle

Configurer le traçage pour le Kit de développement logiciel (SDK) OpenAI Agents

Vérifier les traces dans le portail Foundry

Résoudre les problèmes courants

Contenu connexe

Commentaires

Ressources supplémentaires