DEV Community: Mehran Davoudi

AOT: .NET vs Java

Mehran Davoudi — Fri, 19 Sep 2025 12:39:44 +0000

⚔️ AOT Showdown: .NET vs Java in 2025; Who’s really production-ready?

In the race to optimize startup time, memory footprint, and deployment simplicity, Ahead-of-Time (AOT) compilation has become a game-changer. Both .NET and Java have embraced AOT, but not equally. If you're building microservices, serverless apps, or containerized workloads, knowing which platform delivers a smoother AOT experience can save you hours of frustration.

🚀 What Is AOT Compilation?

AOT compiles your code into native machine instructions before runtime, unlike Just-In-Time (JIT) compilation, which happens during execution. This means:

Faster startup
Lower memory usage
No runtime dependency on the VM or runtime engine

But the devil’s in the details.

.NET Native AOT

Microsoft introduced Native AOT as a first-class citizen in .NET 7 and refined it in .NET 8. It’s now a reliable option for production workloads.

✅ Highlights:

Self-contained executables: No need for the .NET runtime on the target machine.
Blazing fast startup: Ideal for cold-start-sensitive apps like serverless functions.
Smaller footprint: Trimmed assemblies and no JIT overhead.
Integrated tooling: Just use dotnet publish -r linux-x64 --self-contained.

⚠️ Trade-offs:

No dynamic code generation (e.g., Reflection.Emit).
Some libraries need AOT-friendly alternatives.
Limited runtime diagnostics compared to JIT.

Java GraalVM Native Image

Java’s AOT story revolves around GraalVM Native Image, which compiles bytecode into a native binary. It’s impressive, but not frictionless.

✅ Highlights:

No JVM required: Native binary runs independently.
Fast startup: Great for CLI tools and serverless.
Framework support: Quarkus and Micronaut are designed with AOT in mind.

⚠️ Trade-offs:

Closed-world assumption: All reachable code must be known at build time.
Reflection and proxies: Need manual configuration or substitution.
Longer build times: Native compilation is slower and more complex.

🧠 Head-to-Head Comparison

Feature	.NET Native AOT	Java GraalVM Native Image
Startup Time	⚡ Very fast	⚡ Fast
Memory Usage	🧠 Low	🧠 Low
Runtime Dependency	❌ None	❌ None
Dynamic Features	🚫 Limited	🚫 Limited
Tooling Integration	✅ Seamless	⚠️ Requires GraalVM setup
Ecosystem Compatibility	✅ Growing	⚠️ Needs manual config

🏁 Verdict: .NET Is Winning the AOT Race

If you're choosing between the two for production workloads in 2025, .NET Native AOT is more mature, better integrated, and easier to adopt. Java’s GraalVM is powerful, but still best suited for niche use cases or greenfield projects with AOT in mind.

💡 Final Thoughts

AOT isn’t just a performance tweak; it’s a deployment philosophy.

Whether you're optimizing for cold starts, trimming container sizes, or building resilient edge apps, understanding the strengths and limitations of each platform can help you make smarter architectural decisions.

Have you tried Native AOT in .NET or GraalVM in Java? Share your experience below, I’d love to hear how it’s working for you in real-world scenarios.

AI+UX: How to Bridge UI and Talk Seamlessly

Mehran Davoudi — Mon, 15 Sep 2025 23:24:33 +0000

In the evolving landscape of conversational interfaces, the line between UI and Talk is blurring, and CrystaCode.ai is a prime example of what’s possible when AI meets thoughtful UX design.

CrystaCode is a conversational AI platform (based in Dubai!) that interacts with users either through text-based chat or live voice. But what makes it truly exciting isn’t just the dual modality, it’s the unified infrastructure powering both experiences.

🧠 One Brain, Two Mouths: Unified AI Infrastructure

At the heart of CrystaCode is a shared backend that serves both chat and talk interactions. This isn’t just a convenience, it’s a design philosophy. By using the same orchestration logic, prompt engineering, and AI pipelines, we ensure consistent behavior and reduce duplication across modalities.

To achieve this, we leveraged a couple of technologies:

Model Context Protocol (MCP): A flexible orchestration layer that abstracts AI interactions into composable units.
Microsoft.Extensions.AI.Abstractions: This abstraction layer allows us to plug in different AI providers while maintaining a consistent interface for both chat and voice.

This architecture means that whether a user types a question or speaks it aloud, the same intelligent backend processes the request, applies context, and returns a response.

🔊 Real-Time Voice with SignalR

Voice interactions demand low latency and real-time streaming. That’s where SignalR comes in. We use it to stream audio between the client and server, enabling live conversations with minimal delay.

SignalR’s streaming model fits perfectly with our AI pipeline, allowing us to push intermediate responses, handle interruptions, and maintain a fluid user experience.

🧩 Blazor for UI and Code Reusability

On the frontend, Blazor helps us maximize code reuse across chat and voice interfaces. With Blazor’s component model, we can build shared UI elements, manage state consistently, and even reuse validation and business logic across both modalities. For Blazor, we are using Bit Platform as we believe it has the state-of-the-art configuration to get the best from Blazor, both in functionality and performance.

This means faster development cycles and fewer bugs, plus a more cohesive user experience.

☁️ Azure OpenAI for Scale and Flexibility

To power the intelligence behind CrystaCode, we use Azure OpenAI. It gives us:

Access to cutting-edge language models
Enterprise-grade scalability
Fine-tuning and deployment flexibility

Combined with MCP, we can route requests to different models based on context, user profile, or even modality, without changing the frontend or orchestration logic.

✅ Semantic Integration Testing with skUnit

Building a conversational AI that feels natural across both chat and voice isn’t just about infrastructure; it’s about precision. That’s why we use skUnit, a testing framework purpose-built for semantic validation of AI interactions.

With skUnit, we create end-to-end integration tests that simulate real user conversations and validate the AI’s responses not just syntactically, but semantically. This means we can:

Assert that the AI understands context across turns
Validate that the tone, intent, and structure of responses match expectations
Catch regressions in prompt behavior or orchestration logic early

This level of testing is especially powerful when combined with MCP orchestrations, allowing us to simulate full conversational flows and verify outcomes across different model configurations and user scenarios.

By embedding skUnit into our CI pipeline, we’ve turned conversational quality into a measurable, repeatable discipline, raising the bar for what AI UX can deliver.

✨ The UX Payoff

This tech stack isn’t just elegant, it’s user-centric. By unifying the backend and optimizing the frontend, we deliver:

Seamless transitions between chat and voice
Faster response times
Consistent personality and tone across modalities
A scalable foundation for future features like multimodal input or emotion-aware responses

CrystaCode isn’t just an app; it’s a blueprint for how AI and UX can co-evolve.

[Boost]

Mehran Davoudi — Mon, 01 Sep 2025 14:24:57 +0000

Mehran Davoudi

Sep 1 '25

Using AIFunctions with OpenAI Realtime API in .NET

#dotnet #csharp #openai #ai

Comments

2 min read

Using AIFunctions with OpenAI Realtime API in .NET

Mehran Davoudi — Mon, 01 Sep 2025 13:51:34 +0000

If you've ever tried integrating Azure OpenAI's Realtime API into a .NET application, you've likely hit a frustrating wall: your beautifully crafted AIFunctions suddenly feel useless. The Realtime API demands raw JSON schemas for tools, and most examples out there force you to manually duplicate function definitions, stripping away the elegance of strongly typed C# models.

I ran into this exact pain point. So I built openai-realtime-sample, a comprehensive repo that shows how to reuse your existing AIFunctions as Realtime tools without rewriting a single line of JSON.

🚨 The Problem

.NET developers using Microsoft.Extensions.AI often define their functions using AIFunctionFactory.Create(...), complete with [Description] attributes and enums. This works beautifully for regular chat completions.

But when switching to the Realtime API, you're expected to:

Manually define JSON schemas for each tool
Duplicate function shapes and descriptions
Lose the benefits of strong typing and metadata

This leads to brittle code and a lot of unnecessary duplication.

✅ The Solution

My repo shows how to elegantly convert AIFunctions into ConversationFunctionTool objects, making them compatible with the Realtime API. Here's the magic:

public static ConversationFunctionTool ConversationTool(this AIFunction function) =>
    new(function.Name)
    {
        Description = function.Description,
        Parameters = BinaryData.FromString(function.JsonSchema.ToString())
    };

This extension method (found in AIExtensions.cs) lets you do:

var tools = GetTools(); // AIFunction[]
var conversationTools = tools.Select(t => t.ConversationTool());
sessionOptions.Tools.AddRange(conversationTools);

And when a tool is invoked:

var tool = tools.First(t => t.Name == functionName);
var result = await tool.InvokeAsync(parsedArgs);
await session.AddItemAsync(RealtimeItem.CreateFunctionCallOutput(callId, result?.ToString() ?? ""));

🧪 Two Sample Projects

RealtimeSample.Console

A minimal, linear example with a single weather function. Perfect for copying into your own app.
RealtimeSample.BlazorHybrid (.NET MAUI)

A richer, event-driven UI that visualizes RealtimeUpdate events like session start, speech input, delta streaming, and tool invocation.

💡 Key Takeaways

No manual JSON duplication, just reuse your AIFunctions
Enums and descriptions flow automatically into the tool schema
Respond to tool calls with FunctionCallOutput referencing the original function_call_id
Trigger a new model turn with StartResponseAsync after supplying tool outputs

🛠 Requirements

.NET 9
Azure OpenAI Realtime deployment (via environment variables)

🔁 Extend It

Want to add more tools? Just return them from GetTools(), your enums and descriptions will be automatically included.

This repo bridges the gap between high-level .NET abstractions and the low-level Realtime API protocol. Whether you're building a console app or a hybrid UI, this pattern gives you a clean, reusable way to integrate OpenAI tools without sacrificing type safety or maintainability.

Check out the full repo on GitHub and feel free to adapt the extension method into your own shared library.

Testing MCP Orchestrations with skUnit

Mehran Davoudi — Tue, 26 Aug 2025 09:37:17 +0000

🧠 Why Test MCP Servers?

Model Context Protocol (MCP) servers are the backbone of tool-augmented AI systems. They expose tools that AI models can invoke—like checking the weather, scheduling meetings, or querying databases.

But when multiple MCP servers are orchestrated together, things get complex. You need to ensure:

Tools are discovered correctly
Functions are invoked with the right parameters
Responses are semantically accurate
Servers coordinate smoothly

Enter skUnit—a powerful .NET testing framework designed for AI units like IChatClient and MCP integrations.

🔧 Prerequisites

Before we dive in, make sure you have:

A working .NET environment
MCP servers (e.g., Time, Weather, Calendar) ready to launch
skUnit installed via NuGet:

  dotnet add package skUnit

🛠️ Step 1: Setup MCP Transports

Each MCP server needs a transport layer. Here's how to configure them:

var timeTransport = new StdioClientTransport(new StdioClientTransportOptions {
  Name = "Time MCP Server",
  Command = "cmd",
  Arguments = [
    "/c",
    "npx",
    "-y",
    "@smithery/cli@latest",
    "run",
    "@javilujann/timemcp"
});

var weatherTransport = new StdioClientTransport(new StdioClientTransportOptions {
  Name = "Some Weather MCP",
  Command = "cmd",
  Arguments = [ ... ]
});

var calendarTransport = new StdioClientTransport(new StdioClientTransportOptions {
    Name = "Calendar Server",
    Command = "node",
    Arguments = [ "calendar-server.js" ]
});

🧩 Step 2: Create MCP Clients and Discover Tools

var timeClient = await McpClientFactory.CreateAsync(timeTransport);
var weatherClient = await McpClientFactory.CreateAsync(weatherTransport);
var calendarClient = await McpClientFactory.CreateAsync(calendarTransport);

var allTools = new List<AITool>();
allTools.AddRange(await timeClient.ListToolsAsync());
allTools.AddRange(await weatherClient.ListToolsAsync());
allTools.AddRange(await calendarClient.ListToolsAsync());

🧠 Step 3: Build the Chat Client

Now wire up all tools into a unified chat client:

var chatClient = new ChatClientBuilder(baseChatClient)
    .ConfigureOptions(options => options.Tools = allTools.ToArray())
    .UseFunctionInvocation()
    .Build();

📜 Step 4: Write a Multi-Server Scenario

Create a Markdown file (multi-server-test.md) with your test scenario:

# SCENARIO Multi-Server Coordination

## [USER]
Check the weather in Toronto and schedule a meeting for tomorrow if it's sunny.

## [AGENT]
I checked the weather – it's going to be sunny tomorrow! I've scheduled your meeting for 2 PM.

### CHECK SemanticCondition
It mentions both weather information and confirms meeting scheduling.

### CHECK FunctionCall {
  "function_name": "get_weather"
  "arguments": {
    "location": [ "Equals", "Toronto" ]
  }
}

### CHECK FunctionCall {
  "function_name": "schedule_event",
  "arguments": {
    "dateTime": [ "SemanticCondition", "A time that refers 2 PM" ]
  }
}

✅ Step 5: Run the Test

var markdown = File.ReadAllText("multi-server-test.md");
var scenarios = await ChatScenario.LoadFromText(markdown);
await ScenarioAssert.PassAsync(scenarios, chatClient);

Boom 💥! You’ve just tested a multi-server orchestration with semantic checks and function call validations.

🧪 Bonus: Best Practices

Isolate First: Test each MCP server individually before combining.
Mock External APIs: Use test doubles for external dependencies.
Assert Everything: Use CHECK statements to validate function calls and semantic responses.
Fail Gracefully: Simulate server errors to test fallback logic.

🧭 Final Thoughts

skUnit turns AI orchestration testing into a breeze. Whether you're building a tool-rich assistant or validating complex workflows, this framework gives you confidence that your MCP servers are playing nicely together.

Want to dive deeper? Check out the official MCP testing guide on GitHub.

Assigning Tasks to Copilot

Mehran Davoudi — Sun, 24 Aug 2025 15:34:54 +0000

Ever had a GitHub issue linger for months because you simply didn’t have the time or bandwidth to tackle it? Same here.

Back in September 2024, I created a fairly complex issue that required deep focus and multiple steps to resolve:

⚡ Instant Action

Fast forward to August 2025, and I finally decided to try something different: I assigned the issue to GitHub Copilot.

No sooner had I clicked “Assign to Copilot” than it sprang into action. First move? It created a branch (copilot/fix6) to kick off the work and a Pull Request!

🧠 Thoughtful Execution

What impressed me most wasn’t just the speed; it was the clarity. Copilot even shared its reasoning behind the changes, giving me insight into its decision-making process.

📚 Beautiful Documentation

And to top it off, Copilot generated clean, readable documentation that made the codebase easier to understand and maintain.

💬 Final Thoughts

Assigning tasks to Copilot felt like having a tireless coding partner who not only executes but explains and documents. If you’re juggling multiple priorities or just want to accelerate your workflow, this feature is worth exploring.

And you can check the final result here:
https://github.com/mehrandvd/skunit/pull/30

Unit Test for MCP!

Mehran Davoudi — Tue, 15 Apr 2025 21:22:48 +0000

Imagine you have an MCP server; it's likely you'd want to create unit tests to ensure it functions as intended.

In this post, I'll walk through how to write unit tests for MCP servers. We'll be testing an existing MCP Server available in Smithery: Time Server MCP.

As shown, it includes the following tools:

Write Unit Test

First, we create a new xunit project and add skUnit from NuGet.

Next, according to the skUnit documentation, our only task is to configure it in the test constructor.

public class TimeServerMcpTests
{
  ScenarioAssert ScenarioAssert { get; set; }
  IChatClient ChatClient { get; set; }

   public TimeServerMcpTests(ITestOutputHelper output)
   {
     var configuration = new ConfigurationBuilder()
                              .AddUserSecrets<TimeServerMcpTests>()
                              .Build();

     var apiKey = configuration["AzureOpenAI_ApiKey"];
     var endpoint = configuration["AzureOpenAI_Endpoint"];
     var deploymentName = configuration["AzureOpenAI_Deployment"];

     ChatClient = new AzureOpenAIClient(
                    new Uri(endpoint),
                    new System.ClientModel.ApiKeyCredential(apiKey))
                  .GetChatClient(deploymentName)
                  .AsIChatClient();

            ScenarioAssert = new ScenarioAssert(ChatClient, output.WriteLine);
  }

  [Fact]
  public async Task Tools_MustWork()
  {
    // Our tests will be here...
  }
}

Let's start by writing the body for our test method. The first step is to establish a connection to the MCP Server.

var clientTransport = new StdioClientTransport(new StdioClientTransportOptions
{
    Name = "Time MCP Server",
    Command = "cmd",
    Arguments = [
        "/c",
        "npx",
        "-y",
        "@smithery/cli@latest",
        "run",
        "@yokingma/time-mcp"
    ],
});

// Here's our MCP ready for testing.
await using var mcp = await McpClientFactory.CreateAsync(clientTransport);

Now, we built a ChatClient on it:

var tools = await mcp.ListToolsAsync();

var builder = new ChatClientBuilder(ChatClient)
              .ConfigureOptions(options =>
              {
                  options.Tools = tools.ToArray();
              })
              .UseFunctionInvocation();

var chatClient = builder.Build();

and finally our 3 lines of skUnit to test the scenario:

var scenarioText = await File.ReadAllTextAsync("TestScenario.md");
var scenario = ChatScenario.LoadFromText(scenarioText);
await ScenarioAssert.PassAsync(scenario, chatClient);

And just like that, here’s the outcome!

Test Scenario

But how did we specify the test scenario, and what was in the TestScenario.md file that we loaded as our scenario?

As you can see in this scenario, we expect the answer to "What time is it?" should be any sentence or paragraph that has this semantic condition:

Semantic Condition: It should mention a time.

### CHECK SemanticCondition
It mentions a time.

We also expect it to utilize the current_time tool in MCP, and by following the assertion, we are ensuring this.

Function Call Check: It should call a tool.

### CHECK FunctionCall
{
  "function_name": "current_time",
}

Then, by asking "How many days are in January this year?", we test its other capability, ensuring it correctly calls days_in_month.

## [USER]
How many days are in this year's january?

## [AGENT]

### CHECK SemanticCondition
It mentions 31 days.

### CHECK FunctionCall
{
  "function_name": "days_in_month",
}

Finally!

Using skUnit, it's super easy to test your AI blocks like MCP Server, ChatClient, Kernel, and more. The full source code is available on my GitHub: Demo.TddMcp.

MCP Missing Pieces

Mehran Davoudi — Sun, 06 Apr 2025 17:33:27 +0000

I've been working with MCPs and building MCP servers for a while now. Here are my thoughts on the missing pieces in it.

While MCPs (Modular Component Protocols) present an exciting frontier in modularizing and streamlining server functionality, their current design and implementation still leave room for improvement. The key areas of dependency handling, versioning, and conflict resolution highlight the challenges we face as we aim to optimize MCP systems for more complex and interconnected use cases.

Dependency

I think soon we will need MCPs built on top of other MCPs. For example, if I want to provide a service that takes lat/lon as input, and Google Maps has an MCP that gets an address and returns the lat/lon, it would be much more convenient if I could create an MCP assuming the client already has the dependent MCP (Google Maps for addresses).

MyMCP (v0.1.2)
|
+--+ GeoMCP (v0.0.5)
|  |
|  +-- GoogleMapMCP (v0.1.5)
+--+ OrganizerMCP (v0.6.8)
   | 
   +-- SlackMCP (v0.6.8)
   +-- TeamsMCP (v0.6.8)
   +-- CalendarMCP (v0.6.8)

The ability to build MCPs on top of other MCPs could revolutionize how developers create layered, collaborative systems. However, it also introduces significant challenges, such as ensuring compatibility between dependencies, managing updates across interconnected modules, and avoiding circular dependencies. A robust framework for managing these dependencies efficiently will be vital as the ecosystem grows.

Versioning

It currently has some versioning, but we need a more workable standard. Something like Semantic Versioning, but optimized for semantic components like MCP.

Current versioning practices are not sufficient to address the nuanced needs of semantic component systems like MCPs. Introducing an MCP-specific versioning standard, akin to Semantic Versioning but tailored to MCPs, could resolve ambiguities, streamline compatibility checks, and ensure smoother integration of updates.

Conflict Resolution (Priority)

At the moment, if multiple tools are available for a specific task, there's no way to indicate which one should be given higher priority.
For instance, consider two MCP servers that have tools for getting the time:

CalendarMCP
  - GetCurrentTime()

TimeMCP
  - GetNow()

Which one should be used now?

As MCPs proliferate, conflicts will inevitably arise when multiple modules offer overlapping functionalities. A standardized mechanism for prioritizing tools, perhaps guided by metadata, user preferences, or usage context, could provide clarity and prevent execution errors. Incorporating intelligent arbitration methods or user-defined priorities could further enhance system reliability.

Other missing pieces?

What other missing pieces do you think we have?

What are your thoughts on these challenges? Are there other aspects of MCPs you believe need attention? Let’s continue the conversation and explore how we can shape the future of MCP development together.

Create an MCP Server with .NET and C#

Mehran Davoudi — Sun, 23 Mar 2025 21:36:06 +0000

In this post, I'll show you how to create a simple MCP Server and test it in Cursor.

For this tutorial, I'm using the official csharp-sdk, which is still in its early stages:

https://github.com/modelcontextprotocol/csharp-sdk

1. Create a simple project

First, create an empty console project:

dotnet new console -n Tutorial.McpTimeServer

2. Install packages

Install these 2 packages:

dotnet add package Microsoft.Extensions.Hosting
dotnet add package ModelContextProtocol --prerelease

3. Write the code

Replace the Program.cs content with this:

using System.ComponentModel;
using Microsoft.Extensions.Hosting;
using ModelContextProtocol;
using ModelContextProtocol.Server;

Console.WriteLine("Hello MCP World!");

var builder = Host.CreateEmptyApplicationBuilder(settings: null);

builder.Services
       .AddMcpServer()
       .WithStdioServerTransport()
       .WithTools();

var host = builder.Build();
await host.RunAsync();


[McpToolType]
public static class TimeTool
{
    [McpTool, Description("Gets the current time.")]
    public static string GetCurrentTime() => DateTimeOffset.Now.ToString();
}

4. Run the project

If you run the project using dotnet run, you will see Hello MCP World! and the program will remain open as it's listening to stdin.

5. Test it on Cursor

Now it's time to configure it on Cursor. Go to File -> Preferences -> Cursor Settings.

Click on "Add new global MCP Server" or open .cursor/mcp.json and add your MCP Server information like this:

{
  "mcpServers": {
    "timemcp": {
      "command": "cmd",
      "args": [
        "/c",
        "C:/Users/Mehran/source/repos/Tutorial.McpTimeServer/bin/Debug/net9.0/Tutorial.McpTimeServer.exe"
      ]
    }
  }
}

Now your MCP Servers page should look like this:

5. Test your MCP Server

Now ask about the time, and it will use your tool.

And if you click on "Run tool," it displays the time when the MCP tool we created was called.

6. Find the code

You can find the complete code on my GitHub:

https://github.com/mehrandvd/tutorial-mcp-server-dotnet

Demystifying AIContents in Microsoft.Extensions.AI

Mehran Davoudi — Mon, 13 Jan 2025 21:07:50 +0000

At the core of Microsoft.Extensions.AI is an IChatClient, which serves as a unified approach to working with various OpenAI service providers.

It utilizes a list of messages (IList<ChatMessage>) to provide input for CompleteAsync().

Each message has a property called Contents, allowing each message have multiple contents sequentially, making it a multi-modal message.

IList<ChatMessage>
  1- ChatMessage
    - Role: User
    - Contents:
      - Text: "Hello, what is in my image?"
      - Image: "[Image1.jpg]"
  2- ChatMessage
    - Role: Assistant
    - Contents:
      - Text: "There is a BMW car in your image"
      - Audio: "[Voice of above sentence.]"
  3- ChatMessage
    - Role: User
    - Contents:
      - Text: "What’s its price?"
  4- ChatMessage
    - Role: Tool
    - Contents:
      - FunctionCall: "GetPrice(“BMW“)"

In this blog, I will clarify the types of content currently supported. Firstly, of these contents derive from a base class called AIContent.

The inheritance hierarchy AIContent as follows:

Different AI Contents

AIContent:

TextContent
DataContent
- ImageContent
- AudioContent
UsageContent
FunctionCallContent
FunctionResultContent

AIContent

Every content is an AIContent. It contains the shared functionalities between different types.

AdditionalProperties: Some key-value properties. -RawRepresentation*: The original raw representation of the content from an underlying implementation. It contains an of the proper with the underlying technology, whether it is an *OpenAI, AzureOpenAI, Ollama, or ...

TextContent

It's simple text content having one property: Text.

new TextContent
{
  Text = "Hello, what can you do for me?"
}

ImageContent & AudioContent

Both of these types are DataContent and are very like each other.

new ImageContent(
  uri: new Uri("https://www.example.com/image)"),
  mediaType: "image/png"
);

new AudioContent(
  uri: new Uri("https://www.example.com/voice)"),
  mediaType: "audio/wav"
);

UsageContent

This type of content includes data about the token consumption of the request.

new UsageContent(
    new UsageDetails { 
        InputTokenCount = 10,
        OutputTokenCount = 20, 
        TotalTokenCount = 30}
    );

FunctionCallContent

It indicates a function call that is requested by AI to be evaluated.

new FunctionCallContent(
    callId: "fx12",
    name: "GetFoodMenu",
    arguments: new Dictionary<string, object?>
    {
        ["mood"] =  "Happy"
    }
);

FunctionResultContent

It indicates that a function call been invoked by client, and the result is ready to be reported to the AI

new FunctionResultContent(
    callId: "fx12",
    name: "GetFoodMenu",
    result: "Pizza, Burger, Ice Cream"
);

Summary

In conclusion, the Microsoft.Extensions.AI library offers a versatile and unified approach to working with various OpenAI service providers through its IChatClient. By utilizing a list of messages (IList<ChatMessage>) with a Contents property, it supports multi-modal messages that can include text, images, audio, and function calls. This flexibility allows for more dynamic and interactive AI-driven applications.

The different types of content supported by Microsoft.Extensions.AI all inherit from the base class AIContent, which provides shared functionalities. These content types include TextContent, ImageContent, AudioContent, UsageContent, FunctionCallContent, and FunctionResultContent, each with specific properties and functionalities. The provided code examples demonstrate how these content types can be effectively used in practice, making the library a powerful tool for developers looking to integrate AI capabilities into their applications.

Parse OpenAI answers as JSON

Mehran Davoudi — Thu, 20 Jun 2024 21:07:24 +0000

Certainly! Here's a revised version of your blog post that is concise, simple, and friendly:

Working with OpenAI can be tricky when it comes to parsing JSON responses, especially when they include extra characters like ''' or a leading json:. To tackle this, I've developed PowerParseJson<T>(), a handy tool that simplifies the process.

var result = await client.GetChatCompletionsAsync(chatCompletionsOptions);
string answer = result.Value.Choices.FirstOrDefault()?.Message.Content;

// No more exceptions!
var json = SemanticUtils.PowerParseJson<JsonObject>(answer);

You can find PowerParseJson<T>() on my GitHub: mehrandvd/SemanticValidation. It is also available here as a Nuget package: SemanticValidation Nuget

While newer GPT models offer settings for cleaner JSON outputs, many models still lack this feature. PowerParseJson<T>() is here to bridge that gap and make your OpenAI experience smoother.

Semantic Tests for SemanticKernel Plugins using skUnit

Mehran Davoudi — Thu, 04 Jan 2024 14:20:28 +0000

Exploring SemanticKernel

This week, I had the chance to explore the SemanticKernel code base, particularly the core plugins. SemanticKernel comes equipped with these built-in plugins:

ConversationSummaryPlugin
FilePlugin
HttpPlugin
MathPlugin
TextPlugin
TimePlugin
WaitPlugin

When I looked at the Plugins.UnitTests project, I noticed that all the unit tests are passing. But there's something interesting:

Each plugin has a corresponding test file, except for ConversationSummaryPlugin.

You might wonder why!?

Here's the thing. All the other plugins have outputs that can be tested because they're deterministic. But ConversationSummaryPlugin is a different story.

For instance, it has a function called SummarizeConversation that does exactly what it says - it summarizes a conversation. But how do you test something like that? You need to check the meaning of the output, not just if the strings are identical.

Let's consider this test case:

USER: Is Eiffel tall?
AGENT: Yes it is
USER: What about Everest mountain?
AGENT: Yes it is tall too
USER: What about a mouse?
AGENT: No it is not tall.

If you call SummarizeConversation with this input, you should get something like:

Expected output: The conversation is about the heights of different things. Both the Eiffel Tower and Mount Everest are considered tall, while a mouse is not.

But how do you write a test for that? You need to use semantic assertions, something like:

SemanticAssert.HasCondition(
   output, 
   "It mentions that both the Eiffel Tower and Mount Everest are tall.")

While you can do this now with the SemanticValidation library, I'm going to introduce an even simpler way in this post: using the skUnit library for semantic unit testing. Sounds exciting, right?

Let's Dive into Testing with skUnit

With skUnit, you can whip up scenarios in markdown files. Here's an example:

# SCENARIO Height Discussion

## PARAMETER input
USER: Is Eiffel tall?
AGENT: Yes it is
USER: What about Everest mountain?
AGENT: Yes it is tall too
USER: What about a mouse?
AGENT: No it is not tall.


## ANSWER
The conversation revolves around the heights of different things. Both the Eiffel Tower and Mount Everest get the tall vote, while a mouse doesn't.

## CHECK SemanticCondition
It mentions that both the Eiffel Tower and Mount Everest are tall.

## CHECK SemanticCondition
It mentions that a mouse isn't tall.

As you can see, in a scenario, you can set the parameters and the expected answer. Then, you can specify the semantic conditions that the output should meet. The best part? skUnit can run this test for you automatically, and you can see it acing the test. How cool is that?

What’s great is that these scenarios are valid .md files. This means they’re not just for the tech-savvy among us - anyone can read and understand them! Isn’t that neat?

Finally

I enjoy writing semantic tests for SemanticKernel plugins, and I have created a repository to share some of them: https://github.com/mehrandvd/semantic-kernel-skunit-tests

You can see an example of a test scenario for the SummarizeConversationPlugin here.