Support for 'Structured outputs'

[SamKr]

Regarding this blogpost:

https://ollama.com/blog/structured-outputs

Does OllamaSharp support structured outputs yet?

[awaescher]

This was implemented by @mili-tan in 4.0.10

[SamKr]

Fantastic! Works like a charm. Thanks for the quick reply :)

[awaescher]

❤️

[plqplq]

In case anyone can't find it, its the 4th parameter to ChatAsync, called "format" and needs to be a json schema object like this:

 var format = new
            {
                type = "object",
                properties = new
                {
                    computernames = new
                    {
                        type = "array",
                        items = new { type = "string" }
                    },
                    ipaddresses = new
                    {
                        type = "array",
                        items = new { type = "string" }
                    },
                    users = new
                    {
                        type = "array",
                        items = new { type = "string" }
                    }
                },
                required = new[] { "computernames", "users" }
      };
   await foreach (var answerToken in chat.SendAsync(message, null, null, format))
   {
       Console.Write(answerToken);
   }

Does indeed work like a dream!

[Joy-less]

public class Dialog {
    public required DialogLine[] DialogLines { get; set; } = [];
}
public class DialogLine {
    public required string Name { get; set; } 
    public required string Speech { get; set; }
}
System.Text.Json.Nodes.JsonNode format = JsonSerializerOptions.Default.GetJsonSchemaAsNode(typeof(Dialog));

Hi, just letting you know that you can automatically generate schemas since #164. :)

[SamKr]

Fantastic, very clean, thank you! ❤️

[Shedletsky]

Hello, I am trying to figure out how to get this to work.

I have read that for Ollama to validate that a structured output actually matches the supplied schema, that the query needs to run with streaming set to false.

ChatGPT is telling me that there is no way in the current OllamaSharp API to send a request for structured output with streaming set to false and that I should fallback to building raw HTTP requests.

This seems like AI hallucination to me but I've been unable to find the correct way to do it and the answer above uses streaming.

[Shedletsky]

I figured it out, posting here because this discussion ranks high on Google for this question.

public class WeatherInfo
{
    public required string City { get; set; }
    public required float TemperatureC { get; set; }
    public required string[] Conditions { get; set; }
}

public async Task<WeatherInfo?> GetWeatherAsync(CancellationToken cancellationToken = default)
        {
            var ollama = GetClient("qwen3-vl:30b");

            var messages = new[]
            {
                new Message
                {
                    Role = ChatRole.User,
                    Content = "Return the current weather for Paris, France."
                }
            };

            // Either JsonNode schema (recommended)…
            JsonNode formatSchema =
                JsonSerializerOptions.Default.GetJsonSchemaAsNode(typeof(WeatherInfo));

            // …or anonymous object schema (see above).

            var chatRequest = new ChatRequest
            {
                Model = "qwen3-vl:30b",   // or description.ModelName, etc.
                Messages = messages,

                // 👇 This is the important bit: tell Ollama *not* to stream at HTTP level
                Stream = false,

                // If you have per-call options:
                // Options = options,  // temperature, etc.
                // Think = description.UseThinking, // if you’re using think mode

                // 👇 JSON schema for structured output
                Format = formatSchema
            };

            // Even with Stream = false, OllamaSharp still exposes this as an async stream –
            // but under the hood the HTTP call uses "stream": false and Ollama validates
            // the JSON before returning it. You’ll just get a single chunk.
            var sb = new StringBuilder();

            await foreach (var chunk in ollama.ChatAsync(chatRequest, cancellationToken))
            {
                if (chunk.Message?.Content is { } text)
                {
                    sb.Append(text);
                }
            }

            var json = sb.ToString();

            Console.WriteLine(json);

            // Case-insensitive deserialize so "city", "City", "CITY" all bind.
            var deserializeOptions = new JsonSerializerOptions
            {
                PropertyNameCaseInsensitive = true
            };

            return JsonSerializer.Deserialize<WeatherInfo>(json, deserializeOptions);
        }