Function calling in .NET: let an LLM call your own code with Microsoft.Extensions.AI

# pull a model that supports tool calling (llama3.1, qwen3, mistral...)
$ ollama pull llama3.1

# start the server (it usually starts on its own)
$ ollama serve                 # http://localhost:11434

# quick check from the terminal
$ ollama run llama3.1 "Hi, who are you?"

# new Minimal API
$ dotnet new web -n ToolCallingDemo && cd ToolCallingDemo

# AI abstractions + Ollama provider (OllamaSharp) + Refit + Mongo driver
$ dotnet add package Microsoft.Extensions.AI
$ dotnet add package OllamaSharp
$ dotnet add package Refit.HttpClientFactory
$ dotnet add package MongoDB.Driver

{
  "Ollama": {
    "Endpoint": "http://localhost:11434",
    "ChatModel": "llama3.1"
  },
  "ExchangeRates": {
    "BaseUrl": "https://api.exchangerate.host"
  },
  "Mongo": {
    "ConnectionString": "mongodb://localhost:27017",
    "Database": "shopdemo"
  }
}

using Microsoft.Extensions.AI;
using MongoDB.Driver;
using OllamaSharp;
using Refit;
using ToolCallingDemo.Tools;

namespace ToolCallingDemo.Extensions;

// One extension method wires the whole stack: the Ollama chat client (via
// OllamaSharp), the function-invocation pipeline, MongoDB, the Refit client
// and the "tools" as typed services.
public static class AssistantServiceExtensions
{
    public static IServiceCollection AddAssistant(this IServiceCollection services, IConfiguration config)
    {
        var ollama = config.GetSection("Ollama");
        var chatClient = new OllamaApiClient(new Uri(ollama["Endpoint"]!), ollama["ChatModel"]!);

        // OllamaApiClient implements IChatClient. UseFunctionInvocation adds the
        // FunctionInvokingChatClient, which runs the tools the model requests on its own.
        services.AddChatClient(chatClient)
            .UseFunctionInvocation()
            .UseLogging();

        var mongo = config.GetSection("Mongo");
        var mongoClient = new MongoClient(mongo["ConnectionString"]);
        services.AddSingleton<IMongoDatabase>(_ => mongoClient.GetDatabase(mongo["Database"]));

        // Typed HTTP client with Refit: no hand-written HttpClient.
        services.AddRefitClient<IExchangeRateApi>()
            .ConfigureHttpClient(c => c.BaseAddress = new Uri(config["ExchangeRates:BaseUrl"]!));

        services.AddScoped<OrderTools>();
        services.AddScoped<PricingTools>();
        return services;
    }
}

using ToolCallingDemo.Endpoints;
using ToolCallingDemo.Extensions;

var builder = WebApplication.CreateBuilder(args);

// One line registers Ollama (chat + function invocation), MongoDB, Refit and the tools.
builder.Services.AddAssistant(builder.Configuration);

var app = builder.Build();

app.MapAssistantEndpoints();   // POST /assistant

app.Run();

using System.ComponentModel;
using MongoDB.Bson;
using MongoDB.Bson.Serialization.Attributes;
using MongoDB.Driver;

namespace ToolCallingDemo.Tools;

// Tools are plain C# methods. The [Description] attribute is what the model
// reads to understand WHEN and HOW to call them; parameters and return type
// become the tool's JSON schema.
public class OrderTools(IMongoDatabase database)
{
    private readonly IMongoCollection<Order> _orders = database.GetCollection<Order>("orders");

    [Description("Gets the status, total and delivery date of an order given its code.")]
    public async Task<OrderStatus> GetOrderStatusAsync(
        [Description("The order code, e.g. ORD-1024")] string orderCode,
        CancellationToken ct = default)
    {
        var order = await _orders.Find(o => o.Code == orderCode).FirstOrDefaultAsync(ct);
        if (order is null)
            return new OrderStatus(orderCode, "not_found", 0m, null);

        return new OrderStatus(order.Code, order.Status, order.Total, order.EstimatedDelivery);
    }
}

// Typed DTOs: never object/dynamic/anonymous at a tool boundary.
public record OrderStatus(string OrderCode, string Status, decimal Total, DateOnly? EstimatedDelivery);

// MongoDB document read by the tool. [BsonId] maps the _id key and
// [BsonIgnoreExtraElements] keeps extra fields on the document from breaking
// deserialization (handy as the schema evolves).
[BsonIgnoreExtraElements]
public class Order
{
    [BsonId]
    public ObjectId Id { get; set; }

    public string Code { get; set; } = "";
    public string Status { get; set; } = "";

    // decimal -> Decimal128 is already the default; the attribute makes it
    // explicit and avoids surprises if an old document stored the amount as a double.
    [BsonRepresentation(BsonType.Decimal128)]
    public decimal Total { get; set; }

    public DateOnly? EstimatedDelivery { get; set; }
}

using System.ComponentModel;
using Refit;

namespace ToolCallingDemo.Tools;

// The external API contract is the interface itself: Refit generates the client.
// Params not in the path become the query string: /convert?from=EUR&to=USD&amount=100
public interface IExchangeRateApi
{
    [Get("/convert")]
    Task<ConvertResponse> ConvertAsync(string from, string to, decimal amount, CancellationToken ct = default);
}

public record ConvertResponse(decimal Result);

// Second tool group: converts an amount between two currencies at the current rate.
public class PricingTools(IExchangeRateApi api)
{
    [Description("Converts an amount from one currency to another at the current exchange rate.")]
    public async Task<decimal> ConvertPriceAsync(
        [Description("Amount to convert")] decimal amount,
        [Description("Source currency ISO 4217, e.g. EUR")] string from,
        [Description("Target currency ISO 4217, e.g. USD")] string to,
        CancellationToken ct = default)
    {
        var conversion = await api.ConvertAsync(from, to, amount, ct);
        return Math.Round(conversion.Result, 2);
    }
}

using Microsoft.Extensions.AI;
using ToolCallingDemo.Tools;

namespace ToolCallingDemo.Endpoints;

public record AssistantRequest(string Question);
public record AssistantReply(string Answer);

public static class AssistantEndpoints
{
    // POST /assistant — the model answers and, when needed, calls the tools on its own.
    public static void MapAssistantEndpoints(this IEndpointRouteBuilder app) =>
        app.MapPost("/assistant", async (
            AssistantRequest req,
            IChatClient chat,
            OrderTools orderTools,
            PricingTools pricingTools,
            CancellationToken ct) =>
        {
            // The two method groups become the tools available for this request.
            var options = new ChatOptions
            {
                Tools =
                [
                    AIFunctionFactory.Create(orderTools.GetOrderStatusAsync),
                    AIFunctionFactory.Create(pricingTools.ConvertPriceAsync)
                ]
            };

            var messages = new List<ChatMessage>
            {
                new(ChatRole.System,
                    "You are a shop assistant. Use the tools for real data on orders and prices. " +
                    "Do not invent statuses or amounts: if a tool finds nothing, say so."),
                new(ChatRole.User, req.Question)
            };

            var response = await chat.GetResponseAsync(messages, options, ct);
            return Results.Ok(new AssistantReply(response.Text));
        });
}

# an order status: the model will call GetOrderStatus on its own
$ curl http://localhost:5000/assistant \
    -H "Content-Type: application/json" \
    -d '{"question":"Where is order ORD-1024?"}'

# a conversion: the model will call ConvertPrice
$ curl http://localhost:5000/assistant \
    -H "Content-Type: application/json" \
    -d '{"question":"How much is 149.90 EUR in USD?"}'

using Microsoft.Extensions.AI;

// Same tools, but with explicit limits on the function-calling loop.
services.AddChatClient(chatClient)
    .UseFunctionInvocation(configure: c =>
    {
        c.MaximumIterationsPerRequest = 5;          // at most 5 round-trips with the model
        c.MaximumConsecutiveErrorsPerRequest = 2;   // stop after 2 errors in a row
        c.IncludeDetailedErrors = false;            // don't pass stack traces to the model
    })
    .UseLogging();