Microsoft Agent Framework

Microsoft's Agent Framework is an open-source toolkit for building intelligent agents. The framework offers components for creating agents that connect to services, execute tasks, and manage complex workflows. It supports multiple LLM providers including Azure OpenAI and OpenAI, with native OpenTelemetry integration for observability.

This guide covers routing telemetry from Microsoft Agent Framework applications to InteractiveAI for monitoring, debugging, and evaluating agent behavior.

Prerequisites

• InteractiveAI account with API credentials

• Azure OpenAI credentials or OpenAI API key

---

Installation

pip install agent-framework interactiveai

---

Configuration

Set your API credentials as environment variables:

import os

# InteractiveAI credentials
# Obtain keys from Settings > API Keys in the dashboard
os.environ["INTERACTIVEAI_PUBLIC_KEY"] = "pk-ia-..."
os.environ["INTERACTIVEAI_SECRET_KEY"] = "sk-ia-..."
os.environ["INTERACTIVEAI_HOST"] = "https://app.interactiveai.com"

# Azure OpenAI credentials
os.environ["AZURE_OPENAI_API_KEY"] = "your-azure-openai-key"
os.environ["AZURE_OPENAI_ENDPOINT"] = "https://your-resource.openai.azure.com/"
os.environ["AZURE_OPENAI_CHAT_DEPLOYMENT_NAME"] = "gpt-4o-mini"
os.environ["OPENAI_CHAT_MODEL_ID"] = "gpt-4o-mini"

Initialize the client and confirm connectivity:

from interactiveai import Interactive

client = Interactive(
    public_key=os.environ["INTERACTIVEAI_PUBLIC_KEY"],
    secret_key=os.environ["INTERACTIVEAI_SECRET_KEY"],
    host=os.environ.get("INTERACTIVEAI_HOST", "https://app.interactiveai.com")
)

if client.auth_check():
    print("Connection established")
else:
    print("Authentication failed - verify credentials")

---

Enabling Trace Capture

The Microsoft Agent Framework includes native OpenTelemetry support. Activate it by calling configure_otel_providers() to route traces to InteractiveAI:

from agent_framework.observability import configure_otel_providers

configure_otel_providers(enable_sensitive_data=True)

Setting enable_sensitive_data=True captures complete request and response payloads including function arguments and return values.

---

Running an Agent with Azure OpenAI

Here's a working example with a tool-equipped agent using Azure OpenAI:

import asyncio
from random import randint
from typing import Annotated
from agent_framework.azure import AzureOpenAIChatClient
from pydantic import Field

def get_stock_price(
    ticker: Annotated[str, Field(description="The stock ticker symbol to look up.")],
) -> str:
    """Get the current stock price for a given ticker."""
    prices = {"AAPL": 187, "MSFT": 378, "GOOGL": 141}
    price = prices.get(ticker.upper(), randint(50, 500))
    return f"{ticker.upper()} is currently trading at ${price}."

async def main():
    async with AzureOpenAIChatClient().create_agent(
        instructions="You are a helpful financial assistant.",
        tools=get_stock_price,
    ) as agent:
        query = "What's the current price of Microsoft stock?"
        print(f"User: {query}")
        result = await agent.run(query)
        print(f"Agent: {result}\n")

await main()

---

Running an Agent with OpenAI

The framework also supports direct OpenAI access. Use OpenAIResponsesClient instead of AzureOpenAIChatClient:

import os
from random import randint
from typing import Annotated
from agent_framework.openai import OpenAIResponsesClient
from pydantic import Field

os.environ["OPENAI_API_KEY"] = "sk-proj-..."
os.environ["OPENAI_RESPONSES_MODEL_ID"] = "gpt-4o-mini"

def get_stock_price(
    ticker: Annotated[str, Field(description="The stock ticker symbol to look up.")],
) -> str:
    """Get the current stock price for a given ticker."""
    prices = {"AAPL": 187, "MSFT": 378, "GOOGL": 141}
    price = prices.get(ticker.upper(), randint(50, 500))
    return f"{ticker.upper()} is currently trading at ${price}."

async def main():
    async with OpenAIResponsesClient().create_agent(
        instructions="You are a helpful financial assistant.",
        tools=get_stock_price,
    ) as agent:
        query = "What's the current price of Apple stock?"
        print(f"User: {query}")
        result = await agent.run(query)
        print(f"Agent: {result}\n")

await main()

---

Enriching Traces with Context

Combine the framework's integration with the InteractiveAI SDK to attach identifiers and metadata:

from interactiveai import Interactive
from agent_framework.azure import AzureOpenAIChatClient

client = Interactive(
    public_key=os.environ["INTERACTIVEAI_PUBLIC_KEY"],
    secret_key=os.environ["INTERACTIVEAI_SECRET_KEY"],
    host=os.environ.get("INTERACTIVEAI_HOST", "https://app.interactiveai.com")
)

async def run_with_context():
    with client.start_as_current_span(name="financial-agent-task") as span:
        
        client.update_current_trace(
            user_id="user_123",
            session_id="session_abc",
            tags=["microsoft-agent", "financial"],
            metadata={"department": "trading", "environment": "production"}
        )
        
        async with AzureOpenAIChatClient().create_agent(
            instructions="You are a helpful financial assistant.",
            tools=get_stock_price,
        ) as agent:
            query = "Compare the prices of Apple and Google stock."
            result = await agent.run(query)
            
            client.update_current_trace(
                input=query,
                output=str(result)
            )

    client.flush()

await run_with_context()

---

Trace Visibility

The InteractiveAI dashboard displays:

• Agent execution flow and task completion

• LLM calls with prompts and completions

• Tool invocations with arguments and results

• Token consumption and latency metrics

• Cost tracking per request