---
description: Start here to integrate Opik into your Microsoft Agent Framework-based
.NET application for end-to-end LLM observability, unit testing, and optimization.
headline: Microsoft Agent Framework | Opik Documentation
og:description: Build and deploy AI agents with the Microsoft Agent Framework, featuring
multi-language support and advanced orchestration capabilities.
og:site_name: Opik Documentation
og:title: Microsoft Agent Framework for AI Development - Opik
title: Observability for Microsoft Agent Framework (.NET) with Opik
canonical-url: https://www.comet.com/docs/opik/integrations/microsoft-agent-framework-dotnet
---
[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.
## 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:
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
```
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.
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
```
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.
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
```
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();
```
**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/)