.NET - Criando Agentes com MAF e Ollama
   Aprenda a implementar agentes autônomos e fluxos colaborativos em C# utilizando o Microsoft Agent Framework (MAF) com modelos locais no Ollama e abstrações do Microsoft.Extensions.AI no .NET 10/11. (Adaptado com ajuda da IA e corrigido e ajustado por Macoratti)

Aplicações baseadas em agentes (Agentic applications) utilizam personas e modelos de Inteligência Artificial para executar tarefas complexas de forma colaborativa e autônom

Nota: personas são perfis ou papéis definidos por instruções (prompts do sistema) que moldam o comportamento, o tom, o conhecimento especializado e os limites de atuação de uma IA ou de um agente autônomo.

O Microsoft Agent Framework (MAF) unifica as melhores práticas do ecossistema .NET, padronizando a comunicação com modelos de linguagem por meio da abstração oficial Microsoft.Extensions.AI.

Quando combinado com o Ollama executando localmente, este ecossistema permite criar agentes de alto desempenho, seguros, com total privacidade e sem custos com consumo de tokens em APIs de nuvem.

 

1. Visão Geral da Arquitetura

A arquitetura moderna de agentes em C# no .NET 10 apoia-se em três pilares fundamentais:

- Microsoft.Extensions.AI (IChatClient): A abstração que permite à aplicação .NET interagir com diferentes provedores de modelos de IA por meio de uma interface comum.
- OllamaSharp:  Biblioteca .NET que fornece um cliente para comunicação com o servidor Ollama. O OllamaApiClient pode ser adaptado à abstração IChatClient
do Microsoft.Extensions.AI.
- Microsoft Agent Framework (Microsoft.Agents.*): Framework usado para criar, executar e orquestrar agentes de IA, incluindo colaboração entre agentes, gerenciamento de estado e definição de fluxos de execução.

2. Configurando o Ambiente e Criando a Solução

Certifique-se de ter o .NET 10 SDK  (ou o .NET 11 preview) e o Ollama instalados.

No terminal, inicie o serviço do Ollama e baixe o modelo desejado:
 
ollama serve
ollama pull qwen2.5:1.5b

Em seguida, crie a solução e o primeiro projeto Console para o agente especialista:
 
dotnet new sln -n MafOllamaSolution
dotnet new console -n MafOllamaDemo -f net10.0
dotnet sln add MafOllamaDemo/MafOllamaDemo.csproj
cd MafOllamaDemo

dotnet add package Microsoft.Extensions.AI --prerelease
dotnet add package Microsoft.Agents.Core --prerelease
dotnet add package OllamaSharp

3. Implementando um Agente Especialista (MafOllamaDemo)

No projeto MafOllamaDemo, substitua o conteúdo do arquivo Program.cs pelo código a seguir. Ele configura o cliente do Ollama via IChatClient e define uma persona de Arquiteto .NET:

using System;
using System.Collections.Generic;
using Microsoft.Extensions.AI;
using OllamaSharp;

// 1. Configuração do endpoint local do Ollama e modelo
var endpoint = new Uri("http://localhost:11434");
var modelId = "qwen2.5:1.5b";

// OllamaApiClient implementa a interface IChatClient
IChatClient chatClient = new OllamaApiClient(endpoint, modelId);

Console.WriteLine("=== Microsoft Agent Framework + Ollama (.NET 10) ===");
Console.WriteLine($"Conectado ao modelo: {modelId}\n");
Console.WriteLine("\nPressione algo para prosseguir...");
Console.ReadKey();

// 2. Definição da persona do Agente e da mensagem do Usuário
var systemPrompt = """
    \nVocê é um arquiteto de software especialista em C#, .NET 10 e Clean Architecture.
    Forneça respostas técnicas, diretas e código idiomático.
    """;

var userPrompt = "Como implementar o padrão Result Pattern em C# utilizando
 sealed record class?";

var messages = new List<ChatMessage>
{
    new(ChatRole.System, systemPrompt),
    new(ChatRole.User, userPrompt)
};

Console.WriteLine($"[Usuário]: {userPrompt}\n");
Console.WriteLine("\nAguarde...\n");

// 3. Execução assíncrona da chamada ao agente
ChatCompletion response = await chatClient.CompleteAsync(messages);

Console.WriteLine("[Arquiteto .NET]:");
Console.WriteLine(response.Message.Text);
Console.ReadKey();

4. Colaboração Multi-Agente (Coder e Reviewer)

Para implementar a colaboração entre múltiplos agentes, vamos criar um segundo projeto onde duas personas distintas interagem: o Coder (que implementa a solução) e o Reviewer (que analisa performance e memória).

Retorne à pasta raiz e crie o novo projeto Console:
 
cd ..
dotnet new console -n MafMultiAgentOllamaDemo -f net10.0
dotnet sln add MafMultiAgentOllamaDemo/MafMultiAgentOllamaDemo.csproj
cd MafMultiAgentOllamaDemo

dotnet add package Microsoft.Extensions.AI --prerelease
dotnet add package Microsoft.Agents.Core --prerelease
dotnet add package OllamaSharp

Agora, no arquivo Program.cs do projeto MafMultiAgentOllamaDemo, adicione o código da orquestração:

using Microsoft.Extensions.AI;
using OllamaSharp;

var endpoint = new Uri("http://localhost:11434");
var modelId = "qwen2.5:1.5b";

IChatClient chatClient = new OllamaApiClient(endpoint, modelId);

Console.WriteLine("=== Fluxo Colaborativo Multi-Agente ===\n");

var instrucao1 = "Você é um desenvolvedor C#. Escreva implementações limpas e 
                  concisas conforme solicitado.";
var instrucao2 = "Crie um método de extensão em C# para validar CPF com cálculo 
                  de dígitos verificadores.";

Console.WriteLine(instrucao1);
Console.WriteLine(instrucao2);

// --- 1. Agente Desenvolvedor (Coder) ---
var coderMessages = new List<ChatMessage>
{
    new(ChatRole.System, instrucao1),
    new(ChatRole.User, instrucao2)
};

Console.WriteLine("\n1. Coder gerando a solução inicial...");
Console.WriteLine("Aguarde...");

ChatCompletion coderResponse = await chatClient.CompleteAsync(coderMessages);
var generatedCode = coderResponse.Message.Text ?? string.Empty;

Console.WriteLine($"\n[Código do Coder]:\n{generatedCode}\n");
Console.WriteLine("Pressione algo para continuar...");
Console.ReadKey();

var review1 = "Você é um revisor de código focado em performance, Memory<T>, 
               Span<T> e alocações de heap.";
var review2 = "Analise o código acima e aponte melhorias de alocação de memória
               usando ReadOnlySpan<char>.";

// --- 2. Agente Revisor (Architecture Reviewer) ---
var reviewerMessages = new List<ChatMessage>
{
    new(ChatRole.System, review1),
    new(ChatRole.User, $"{review2}\n\n{generatedCode}")
};

Console.WriteLine("\n2. Reviewer analisando o código...");
Console.WriteLine("Aguarde...");

ChatCompletion reviewerResponse = await chatClient.CompleteAsync(reviewerMessages);

Console.WriteLine($"\n[Análise do Reviewer]:\n{reviewerResponse.Message.Text}");
Console.WriteLine("\n ### Revisão Concluida ###");
Console.ReadKey();

5. Executando os Projetos

Para rodar individualmente os projetos da solução a partir da raiz:
 
// Executa o Agente Individual
dotnet run --project MafOllamaDemo/MafOllamaDemo.csproj



// Executa a Colaboração Multi-Agente
dotnet run --project MafMultiAgentOllamaDemo/MafMultiAgentOllamaDemo.csproj



Conclusão


A evolução para o Microsoft Agent Framework e a padronização através de Microsoft.Extensions.AI com OllamaSharp traz desacoplamento e robustez ao desenvolvimento na plataforma .NET. Você ganha independência de infraestrutura, código fortemente tipado e a liberdade de alternar para qualquer provedor sem quebrar as regras de orquestração dos seus agentes.

E estamos conversados..

Código do projeto: MafOllamaDemo.zip

"(Disse Jesus)E este evangelho do reino será pregado em todo o mundo, em testemunho a todas as nações, e então virá o fim."
Mateus 24:14

Referências:


José Carlos Macoratti