Implementing Agentic AI with C# Using Azure OpenAI: A Practical, Tool-Driven Approach

Weather Tool – External Capability Simulation

public static string ExecuteWeatherTool(BinaryData functionArguments)
{
    Console.WriteLine("Executing Weather Method");

    var args = JsonDocument.Parse(functionArguments);
    string city = args.RootElement.GetProperty("city").GetString() ?? "Noida";
    string unit = args.RootElement.TryGetProperty("unit", out var unitel)
        ? unitel.GetString() ?? "celcius"
        : "Farenheit";

    var result = new
    {
        city,
        unit,
        temperature = 13,
        description = $"The weather in {city} is 13 degrees {unit}, extreme hot."
    };

    return JsonSerializer.Serialize(result);
}

🔹 In real projects, this can call:

• Weather APIs

• Internal services

• Microservices

• Databases

This is how AI agents interact with the real world.

4. Vector Model for Future Memory & Search

public class CloudServiceModel
{
    [VectorStoreKey]
    public string Key { get; set; } = string.Empty;

    [VectorStoreData]
    public string Name { get; set; } = string.Empty;

    [VectorStoreData]
    public string Description { get; set; } = string.Empty;

    [VectorStoreVector(
        Dimensions: 3072,
        DistanceFunction = DistanceFunction.CosineSimilarity)]
    public ReadOnlyMemory<float> Vector { get; set; }
}

✅ Architectural significance

• Ready for semantic search

• Enterprise memory support

• Compatible with Azure AI Search

• Scalable knowledge base design

This is forward-looking agent architecture.

5. Chat Orchestration Layer (Agent Controller)

Utility.GetAzureOpenAIConfig(out endpoint, out key, out deploymentName, out string embed);

var azureOpenAIClient = Utility.GetAzureOpenAIClient();
ChatClient chatClient = azureOpenAIClient.GetChatClient(deploymentName);

List<ChatMessage> chatHistory = new();
chatHistory.Add(new SystemChatMessage(
    "You are a helpful assistant. keep answers short"));

Controlled System Prompt

The system message:

• Defines AI behavior

• Prevents verbose or unsafe output

• Acts as AI governance layer

Interactive Chat Loop

while (true)
{
    Console.Write("Q. ");
    string userInput = Console.ReadLine()!;

    chatHistory.Add(new UserChatMessage(userInput));

    var response = await chatClient.CompleteChatAsync(chatHistory.ToArray());

    Console.WriteLine($"AI Reply. {response.Value.Content[0].Text}");
}

✅ What this demonstrates

• Persistent conversation memory

• Controlled AI output

• Simple but extensible orchestration

• Ready for tool-calling extension

Application Configuration (appsettings.json)

{
  "ai": {
    "azure": {
      "endpoint": "https://xyz.azure.com/",
      "key": "sdfsfsfsfsfsfsfs",
      "deploymentname": "gpt-4o-mini"
    }
  }
}

✔ Supports:

• Secure deployments

• Multiple environments

• DevOps pipelines

How This Becomes a Full Agent

Your current implementation already has 80% of an AI agent.

To make it fully agentic:

1. Add function calling support

2. Let the model decide which tool to call

3. Execute the tool

4. Feed the result back to the model

Your ExecuteCalculationTool and ExecuteWeatherTool are perfect agent tools.

Why This Design Works for Enterprises

• ✔ Strong separation of concerns

• ✔ Deterministic tool execution

• ✔ Secure configuration handling

• ✔ Extensible for memory and search

• ✔ Production-ready C# patterns

This is not a demo chatbot — this is an enterprise AI foundation.

Conclusion

This article demonstrated a real, working implementation of agent-style AI using C# and Azure OpenAI.

Instead of relying purely on LLM responses, we:

• Delegated calculations to C#

• Controlled AI behavior

• Prepared for vector memory

• Designed for scale and governance

For organizations building serious Generative AI systems, this approach offers the right balance of intelligence, control, and architecture.