
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.









José Carlos Macoratti




