Rastreo de integraciones (versión preliminar)

Microsoft Foundry facilita el registro de seguimientos con cambios mínimos mediante nuestras integraciones de seguimiento con Microsoft Agent Framework, Kernel semántico, LangChain, LangGraph y el SDK del agente openAI.

Microsoft Agent Framework

Foundry tiene integraciones nativas con Microsoft Agent Framework. Los agentes creados con los marcos de trabajo de Microsoft Agent obtienen un seguimiento inmediato en Observability.

Para obtener más información sobre el seguimiento y la observabilidad en Microsoft Agent Framework, consulte Flujos de trabajo de Microsoft Agent Framework: observabilidad.

Kernel semántico

Foundry tiene integraciones nativas con el kernel semántico de Microsoft. Los agentes basados en el kernel semántico de Microsoft obtienen una trazabilidad integrada en la observabilidad.

Más información sobre el seguimiento y la observabilidad en kernel semántico

LangChain & LangGraph

Puede habilitar el seguimiento de LangChain siguiendo los estándares de OpenTelemetry mediante opentelemetry-instrumentation-langchain. Una vez instalados los paquetes necesarios, puede empezar fácilmente a instrumentar el seguimiento en el código.

Ejemplo: Agente langChain v1 con seguimiento de Azure AI

Utilice este ejemplo integral para instrumentar un agente LangChain v1 utilizando el rastreador langchain-azure-ai, que implementa la última especificación de OpenTelemetry (OTel) para que pueda ver trazas enriquecidas en el ámbito de la Observabilidad.

LangChain v1: Instalación de paquetes

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

LangChain v1: Configuración del entorno

• APPLICATION_INSIGHTS_CONNECTION_STRING: cadena de conexión de Application Insights de Azure Monitor para el seguimiento.
• AZURE_OPENAI_ENDPOINT: dirección URL del punto de conexión de Azure OpenAI.
• AZURE_OPENAI_CHAT_DEPLOYMENT: nombre de implementación del modelo de chat.
• AZURE_OPENAI_VERSION: versión de API, por ejemplo 2024-08-01-preview.
• Las credenciales de Azure se resuelven a través DefaultAzureCredential de (admite variables de entorno, identidad administrada, inicio de sesión de VS Code, etc.).

Puede almacenarlos en un .env archivo para el desarrollo local.

LangChain v1: configuración de 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]

LangChain v1: configuración del modelo (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: Definir herramientas e indicaciones

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: uso del contexto en tiempo de ejecución y definición de una herramienta de información de usuario

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: Creación del agente

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: ejecutar el agente con seguimiento

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

Con langchain-azure-ai habilitado, se realiza un seguimiento de todas las operaciones de LangChain v1 (llamadas LLM, invocaciones de herramientas, pasos del agente) mediante las convenciones semánticas de OpenTelemetry más recientes y aparecen en Observabilidad, vinculadas al recurso de Application Insights.

Muestra: agente de LangGraph con seguimiento de Azure AI

En este ejemplo se muestra un agente simple de LangGraph instrumentado con langchain-azure-ai para emitir trazas compatibles con OpenTelemetry para pasos de grafos, llamadas a herramientas e invocaciones de modelo.

LangGraph: Instalación de paquetes

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

LangGraph: Configuración del entorno

• APPLICATION_INSIGHTS_CONNECTION_STRING: cadena de conexión de Application Insights de Azure Monitor para el seguimiento.
• AZURE_OPENAI_ENDPOINT: dirección URL del punto de conexión de Azure OpenAI.
• AZURE_OPENAI_CHAT_DEPLOYMENT: nombre de implementación del modelo de chat.
• AZURE_OPENAI_VERSION: versión de API, por ejemplo 2024-08-01-preview.

Puede almacenarlos en un .env archivo para el desarrollo local.

Configuración del seguimiento de LangGraph

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

LangGraph: Herramientas

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: configuración del modelo (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)

Compilación del flujo de trabajo de 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: Ejecutar con trazabilidad

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

Con langchain-azure-ai habilitado, la ejecución de LangGraph emite intervalos compatibles con OpenTelemetry para llamadas de modelo, invocaciones de herramientas y transiciones de grafos. Estos rastros fluyen hacia Application Insights y aparecen en Observabilidad.

Ejemplo: Configuración de LangChain 0.3 con el seguimiento de Azure AI

Esta configuración mínima muestra cómo habilitar el trazado de Azure AI en una aplicación LangChain 0.3 mediante el langchain-azure-ai tracer y AzureChatOpenAI.

LangChain 0.3: Instalación de paquetes

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

LangChain 0.3: Configuración del entorno

• APPLICATION_INSIGHTS_CONNECTION_STRING: cadena de conexión de Application Insights para el seguimiento.
• AZURE_OPENAI_ENDPOINT: dirección URL del punto de conexión de Azure OpenAI.
• AZURE_OPENAI_CHAT_DEPLOYMENT: nombre de implementación del modelo de chat.
• AZURE_OPENAI_VERSION: versión de API, por ejemplo 2024-08-01-preview.
• AZURE_OPENAI_API_KEY: clave de API de Azure OpenAI.

LangChain 0.3: Seguimiento y configuración del modelo

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

Adjunte callbacks=[azure_tracer] a sus cadenas, herramientas o agentes para asegurarse de que las operaciones de LangChain 0.3 se rastrean y son visibles en la Observabilidad.

SDK de agentes de OpenAI

Use este fragmento de código para configurar el rastreo de OpenTelemetry para el SDK de agentes de OpenAI e instrumentar el framework. Exporta a Azure Monitor si APPLICATION_INSIGHTS_CONNECTION_STRING está configurado; de lo contrario, vuelve a la consola.

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

Contenido relacionado

• Vista general del seguimiento del agente