Azure AI Agents: Azure AI Agent Service vs Semantic Kernel vs LangChain

User: "Find the top 3 open support tickets and summarize their status"

Agent loop:
  Step 1: Use search_tickets tool → returns 50 tickets
  Step 2: Use filter_tickets tool → filters to "open" status
  Step 3: Use sort_tickets tool → sorts by priority
  Step 4: Selects top 3 tickets
  Step 5: Uses summarize tool on each
  Step 6: Returns compiled summary to user

from azure.ai.projects import AIProjectClient
from azure.ai.projects.models import CodeInterpreterTool, FileSearchTool
from azure.identity import DefaultAzureCredential

project_client = AIProjectClient.from_connection_string(
    conn_str="eastus.api.azureml.ms;subscription-id;resource-group;workspace",
    credential=DefaultAzureCredential()
)

agent = project_client.agents.create_agent(
    model="gpt-4o",
    name="azure-support-agent",
    instructions="""You are an Azure infrastructure support agent. 
    Help users diagnose and resolve Azure networking and AI deployment issues.
    Always cite the specific resource or configuration that needs to change.""",
    tools=[
        FileSearchTool().definitions,       # search uploaded documents
        CodeInterpreterTool().definitions,  # run Python for analysis
    ]
)

# Each conversation is a "thread"
thread = project_client.agents.create_thread()

# Add user message
project_client.agents.create_message(
    thread_id=thread.id,
    role="user",
    content="My Azure OpenAI deployments in eastus are returning 503 errors"
)

# Run the agent
run = project_client.agents.create_and_process_run(
    thread_id=thread.id,
    assistant_id=agent.id
)

# Get the response
messages = project_client.agents.list_messages(thread_id=thread.id)
answer = messages.get_last_message_by_role("assistant")

from semantic_kernel import Kernel
from semantic_kernel.functions import kernel_function
from semantic_kernel.connectors.ai.open_ai import AzureChatCompletion

kernel = Kernel()
kernel.add_service(
    AzureChatCompletion(
        deployment_name="gpt-4o",
        endpoint="https://yourresource.openai.azure.com",
        api_key="..."
    )
)

class AzureResourcePlugin:
    @kernel_function(description="Get the status of an Azure resource by name")
    async def get_resource_status(self, resource_name: str) -> str:
        # Call Azure Resource Manager API
        return f"Resource {resource_name}: Running (last checked 2m ago)"
    
    @kernel_function(description="Restart an Azure resource")
    async def restart_resource(self, resource_name: str) -> str:
        # Call Azure Resource Manager API
        return f"Restart initiated for {resource_name}"

kernel.add_plugin(AzureResourcePlugin(), plugin_name="AzureResources")

from semantic_kernel.agents import ChatCompletionAgent
from semantic_kernel.contents import ChatHistory

agent = ChatCompletionAgent(
    kernel=kernel,
    name="azure-ops-agent",
    instructions="You are an Azure operations agent. Use available plugins to help users manage their Azure resources."
)

history = ChatHistory()
history.add_user_message("Check the status of my API service and restart it if it's unhealthy")

async for message in agent.invoke(history=history):
    print(message.content)

from langchain_openai import AzureChatOpenAI
from langchain.agents import create_tool_calling_agent, AgentExecutor
from langchain.tools import tool
from langchain_core.prompts import ChatPromptTemplate

llm = AzureChatOpenAI(
    azure_deployment="gpt-4o",
    azure_endpoint="https://yourresource.openai.azure.com",
    api_key="...",
    api_version="2024-08-01-preview"
)

@tool
def search_azure_docs(query: str) -> str:
    """Search Azure documentation for a given query"""
    # Call Azure AI Search
    return "Search results..."

@tool
def get_azure_status(service: str) -> str:
    """Get current Azure service health status"""
    return f"{service}: Healthy"

tools = [search_azure_docs, get_azure_status]

prompt = ChatPromptTemplate.from_messages([
    ("system", "You are an Azure support agent. Use the tools to help users."),
    ("human", "{input}"),
    ("placeholder", "{agent_scratchpad}"),
])

agent = create_tool_calling_agent(llm, tools, prompt)
executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
result = executor.invoke({"input": "What are the current limits for Azure OpenAI?"})