> For clean Markdown of any page, append .md to the page URL. > For a complete documentation index, see https://www.comet.com/docs/opik/llms.txt. > For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://www.comet.com/docs/opik/_mcp/server. # Observability for Microsoft Agent Framework (.NET) with Opik > Start here to integrate Opik into your Microsoft Agent Framework-based .NET application for end-to-end LLM observability, unit testing, and optimization. [Microsoft Agent Framework](https://github.com/microsoft/agent-framework) is a comprehensive multi-language framework for building, orchestrating, and deploying AI agents and multi-agent workflows with support for both Python and .NET implementations. The framework provides everything from simple chat agents to complex multi-agent workflows with graph-based orchestration, built-in OpenTelemetry integration for distributed tracing and monitoring, and a flexible middleware system for request/response processing. ## Account Setup [Comet](https://www.comet.com/site?from=llm\&utm_source=opik\&utm_medium=colab\&utm_content=agent-framework-dotnet\&utm_campaign=opik) provides a hosted version of the Opik platform, [simply create an account](https://www.comet.com/signup?from=llm\&utm_source=opik\&utm_medium=colab\&utm_content=agent-framework-dotnet\&utm_campaign=opik) and grab your API Key. > You can also run the Opik platform locally, see the [installation guide](https://www.comet.com/docs/opik/self-host/overview/?from=llm\&utm_source=opik\&utm_medium=colab\&utm_content=agent-framework-dotnet\&utm_campaign=opik) for more information. ![Microsoft Agent Framework .NET tracing](/docs/opik/_fern-img/48921ee0bf44fa9697977842de4f72fe8cf1f64fc1295f5103ce323cdfb884e0.webp) ## Getting started To use the Microsoft Agent Framework .NET integration with Opik, you will need to have the Agent Framework and the required OpenTelemetry packages installed: ```bash # Agent Framework (2 packages) dotnet add package Microsoft.Agents.AI --prerelease dotnet add package Microsoft.Extensions.AI.OpenAI --prerelease # Hosting (1 package) dotnet add package Microsoft.Extensions.Hosting # OpenTelemetry (3 packages) dotnet add package OpenTelemetry.Exporter.OpenTelemetryProtocol dotnet add package OpenTelemetry.Extensions.Hosting dotnet add package OpenTelemetry.Instrumentation.Http ``` You will also need to configure your OpenAI API key: ```bash export OPENAI_API_KEY= ``` In addition, you will need to set the following environment variables to configure OpenTelemetry to send data to Opik: #### Opik Cloud If you are using Opik Cloud, you will need to set the following environment variables: ```bash wordWrap export OTEL_EXPORTER_OTLP_ENDPOINT=https://www.comet.com/opik/api/v1/private/otel/v1/traces export OTEL_EXPORTER_OTLP_HEADERS="Authorization=,Comet-Workspace=default" export OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf ``` > **Tip** > > To log the traces to a specific project, you can add the > `projectName` parameter to the `OTEL_EXPORTER_OTLP_HEADERS` > environment variable: > > ```bash wordWrap > export OTEL_EXPORTER_OTLP_HEADERS="Authorization=,Comet-Workspace=default,projectName=" > ``` > > You can also update the `Comet-Workspace` parameter to a different > value if you would like to log the data to a different workspace. #### Enterprise deployment If you are using an Enterprise deployment of Opik, you will need to set the following environment variables: ```bash wordWrap export OTEL_EXPORTER_OTLP_ENDPOINT=https:///opik/api/v1/private/otel/v1/traces export OTEL_EXPORTER_OTLP_HEADERS="Authorization=,Comet-Workspace=default" export OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf ``` > **Tip** > > To log the traces to a specific project, you can add the > `projectName` parameter to the `OTEL_EXPORTER_OTLP_HEADERS` > environment variable: > > ```bash wordWrap > export OTEL_EXPORTER_OTLP_HEADERS="Authorization=,Comet-Workspace=default,projectName=" > ``` > > You can also update the `Comet-Workspace` parameter to a different > value if you would like to log the data to a different workspace. #### Self-hosted instance If you are self-hosting Opik, you will need to set the following environment variables: ```bash export OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:5173/api/v1/private/otel/v1/traces export OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf ``` > **Tip** > > To log the traces to a specific project, you can add the `projectName` > parameter to the `OTEL_EXPORTER_OTLP_HEADERS` environment variable: > > ```bash > export OTEL_EXPORTER_OTLP_HEADERS="projectName=" > ``` ## Using Opik with Microsoft Agent Framework (.NET) The Microsoft Agent Framework has built-in OpenTelemetry instrumentation. You need to configure the OpenTelemetry SDK to use HTTP/Protobuf protocol and export to Opik. Here's a complete example: ```csharp using Microsoft.Agents.AI; using Microsoft.Extensions.AI; using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.Hosting; using OpenAI; using OpenTelemetry; using OpenTelemetry.Resources; using OpenTelemetry.Trace; #pragma warning disable OPENAI001 const string SourceName = "AgentFramework"; // Create host with OpenTelemetry configuration var builder = Host.CreateApplicationBuilder(args); // Configure OpenTelemetry builder.Services.AddOpenTelemetry() .ConfigureResource(resource => resource .AddService(serviceName: "agent-framework-demo", serviceVersion: "1.0.0")) .WithTracing(tracing => tracing .AddSource(SourceName) // Our custom spans .AddSource("*Microsoft.Extensions.AI") // Chat client telemetry .AddSource("*Microsoft.Extensions.Agents*") // Agent telemetry .AddHttpClientInstrumentation() // HTTP calls .AddOtlpExporter()); // Reads OTEL_EXPORTER_OTLP_* env vars automatically var host = builder.Build(); await host.StartAsync(); // Create instrumented chat client // Note: OpenAI SDK requires explicit API key, but you can read from env var var apiKey = Environment.GetEnvironmentVariable("OPENAI_API_KEY") ?? throw new InvalidOperationException("OPENAI_API_KEY environment variable is required"); using var instrumentedChatClient = new OpenAIClient(apiKey) .GetChatClient("gpt-4o-mini") .AsIChatClient() // Convert to Microsoft.Extensions.AI.IChatClient .AsBuilder() .UseOpenTelemetry( // Enable telemetry on chat client sourceName: SourceName, configure: (cfg) => cfg.EnableSensitiveData = true) .Build(); // Create instrumented agent var agent = new ChatClientAgent( instrumentedChatClient, name: "Assistant", instructions: "You are a helpful assistant.") .AsBuilder() .UseOpenTelemetry(SourceName) // Enable telemetry on agent .Build(); // Run agent - telemetry is automatic! Console.WriteLine(await agent.RunAsync("Write a haiku about AI agents.")); // Ensure traces are flushed var tracerProvider = host.Services.GetService(); tracerProvider?.ForceFlush(); await Task.Delay(2000); await host.StopAsync(); ``` > **Note** > > **Important**: The .NET OpenTelemetry SDK requires explicitly setting `OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf` to use HTTP with Protocol Buffers. If not set, it defaults to gRPC which is not supported by Opik's endpoint. > > You can also configure this programmatically: > > ```csharp > .AddOtlpExporter(options => > { > options.Protocol = OtlpExportProtocol.HttpProtobuf; > }) > ``` The framework will automatically: * Create traces for agent executions * Log input prompts and outputs * Track token usage and performance metrics * Capture any errors or exceptions ## Further improvements If you would like to see us improve this integration, simply open a new feature request on [Github](https://github.com/comet-ml/opik/issues). ## Reference For more information about the Microsoft Agent Framework OpenTelemetry integration, see: * [Agent Framework OpenTelemetry Sample](https://github.com/microsoft/agent-framework/tree/main/dotnet/samples/02-agents/AgentOpenTelemetry) * [OpenTelemetry .NET Documentation](https://opentelemetry.io/docs/languages/net/)