AIARTIGO

.NET – Criando Agentes com MAF e Ollama

.NET – Criando Agentes com MAF e Ollama
Imagem: José Carlos Macoratti

Aprenda a implementar agentes autônomos e fluxos colaborativos em C#↳C#68 conteúdosNovidades do C# 8.0: Default Interface MembersDev (Back & Front) · jun 2019C# 8.0 – Conheça suas novas funcionalidadesDev (Back & Front) · mai 2019Novidades do C# 8.0: Switch ExpressionsDev (Back & Front) · mar 2019Ver tudo em Dev (Back & Front) → utilizando o Microsoft Agent Framework (MAF) com modelos locais no Ollama e abstrações do Microsoft.Extensions.AI↳Inteligência artificial440 conteúdosUX e IA: Transformando Experiências Digitais com Inteligência ArtificialProduto & UX · jan 2025MCP: O que é e por que você vai ouvir falar disso em breve?AI · jul 2025IA generativa e a urgência de reconstruir nossa relação com a verdadeAI · jun 2025Ver tudo em AI → no .NET 10/11.

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.

é referência em Visual Basic no Brasil e autor dos livros "Aprenda Rápido: ASP" e "ASP, ADO e Banco de Dados na Internet". Mantenedor do site macoratti.net.

Mais de José Carlos Macoratti
Ver perfil →
Leia também