IA Generativa no .NET e C#: Um breve resumo

O que é IA generativa e o papel dos LLMs

IA generativa é uma categoria de sistemas capazes de produzir novos conteúdos a partir de padrões aprendidos em grandes conjuntos de dados. Diferentemente de sistemas determinísticos, que seguem regras fixas, essas aplicações operam com base em probabilidades e inferência.

Os LLMs se tornaram particularmente relevantes porque interpretam linguagem natural, geram textos, resumem informações e classificam conteúdos. Na prática, eles também ajudam a automatizar decisões dentro de um contexto textual.

Por baixo dos panos, o modelo converte texto em tokens e representa significados como vetores numéricos, os embeddings. Assim, conceitos parecidos, como "gato" e "cachorro", ficam próximos nesse espaço, enquanto "gato" e "notebook" ficam distantes.

Em aplicações corporativas, essa capacidade costuma servir para:

• Automatizar tarefas de suporte e atendimento.
• Aprimorar pesquisas internas e consultas sobre documentação.
• Gerar conteúdo com base em templates e instruções.
• Extrair e estruturar dados a partir de texto livre.
• Aumentar a produtividade de times de engenharia com copilotos internos.

Se você quer entender o tema de forma mais ampla antes de partir para o código, a série sobre fundamentos da inteligência artificial é um bom ponto de partida.

Cenários comuns de IA generativa no .NET

Ao desenhar uma solução de IA generativa no .NET, reconheça que o modelo não é um "módulo mágico" universal. Ele se encaixa melhor em problemas com forte componente de linguagem natural, ambiguidade e necessidade de interpretação contextual.

Conceitos essenciais: prompt, contexto e limites do modelo

Trabalhar com IA generativa exige compreender três pilares técnicos. Eles definem tanto a qualidade das respostas quanto os riscos da solução.

Arquitetura para IA generativa no .NET

Uma integração bem projetada trata o modelo como um componente externo, com custo, latência e comportamento não determinístico. Assim, a arquitetura de IA generativa no .NET costuma separar responsabilidades em camadas:

• Aplicação (use cases): orquestra fluxos e regras.
• Domínio: mantém invariantes e decisões centrais.
• Infraestrutura: integra provedores de IA, armazenamento e logs.

A comunicação com o LLM deve ocorrer através de uma abstração. O Semantic Kernel, por exemplo, oferece interfaces como IChatCompletionService e ITextGenerationService, enquanto as bibliotecas Microsoft.Extensions.AI trazem IChatClient e IEmbeddingGenerator.

Esse design reduz o acoplamento e permite alternar provedores, como serviços gerenciados ou modelos locais, sem reescrever o restante do sistema.

O ecossistema de IA generativa no .NET

Segundo o time de .NET da Microsoft, o investimento em IA generativa no .NET se concentrou em extensões com APIs consistentes, universais e flexíveis. Hoje, as peças principais são as seguintes:

• Microsoft.Extensions.AI: abstrações unificadas, como IChatClient e IEmbeddingGenerator, além de middlewares para telemetria, cache e chamada automática de funções.
• Semantic Kernel: ferramentas para orquestrar prompts, memórias e plugins em C# ou Python.
• Microsoft.Extensions.VectorData: interfaces padronizadas para bancos vetoriais usados em soluções de RAG.
• Microsoft Agent Framework: SDK para construir agentes e fluxos com múltiplos agentes, apontado como sucessor do Semantic Kernel.

Do lado dos modelos, as opções vão do GitHub Models e do Microsoft Foundry até execução local com Foundry Local e Ollama. Como todos podem ser consumidos pelas mesmas abstrações, trocar de provedor vira uma decisão de configuração.

A documentação oficial do Microsoft.Extensions.AI recomenda que a maioria das aplicações referencie o pacote Microsoft.Extensions.AI junto com uma implementação concreta. Para uma visão mais detalhada dessas peças, confira o artigo sobre o novo .NET AI stack.

Como começar com IA generativa no .NET

O primeiro passo prático com IA generativa no .NET é escolher onde o modelo vai rodar. Para protótipos, o GitHub Models oferece um catálogo hospedado com API compatível com a OpenAI, sem exigir infraestrutura.

Já para cenários corporativos, o Microsoft Foundry reúne catálogos de modelos e fluxos com agentes. Por outro lado, quando os dados não podem sair do ambiente, o Foundry Local e o Ollama executam modelos na própria máquina ou servidor.

Em seguida, adicione os pacotes ao projeto. Em uma aplicação que usa um modelo local com Ollama, por exemplo, bastam dois comandos:

# Abstrações e middlewares do ecossistema
dotnet add package Microsoft.Extensions.AI

# Implementação de IChatClient para o Ollama
dotnet add package OllamaSharp

Depois disso, todo o restante do código conversa com as abstrações, e não com o SDK do provedor. Assim, a IA generativa no .NET entra no projeto como mais uma dependência registrada no container de injeção de dependência.

Integração prática: chamando um modelo com C#

O desenvolvimento com IA generativa no .NET costuma envolver três operações básicas. Primeiro, enviar uma entrada (prompt ou mensagens); depois, receber uma saída textual; por fim, processar e validar o resultado.

public interface ITextGenerationService
{
    Task<string> GenerateAsync(string prompt, CancellationToken ct = default);
}

public class ProductDescriptionGenerator
{
    private readonly ITextGenerationService _ai;

    public ProductDescriptionGenerator(ITextGenerationService ai)
        => _ai = ai;

    public Task<string> GenerateDescriptionAsync(string productName, CancellationToken ct)
    {
        // O prompt fica isolado em um único ponto, o que facilita versionar e testar
        var prompt = $"Write a technical and objective description for the product: {productName}.";
        return _ai.GenerateAsync(prompt, ct);
    }
}

using Microsoft.Extensions.AI;
using OllamaSharp;

var builder = Host.CreateApplicationBuilder();

builder.Services.AddDistributedMemoryCache();

// Registra um IChatClient apontando para um modelo local no Ollama
builder.Services
    .AddChatClient(new OllamaApiClient(new Uri("http://localhost:11434"), "llama3.1"))
    .UseDistributedCache();

var host = builder.Build();

var chatClient = host.Services.GetRequiredService<IChatClient>();
var response = await chatClient.GetResponseAsync("What is generative AI?");

Console.WriteLine(response.Text);

Embeddings e busca vetorial em C#

O padrão RAG depende de embeddings, e o Microsoft.Extensions.AI também padroniza essa etapa. A interface IEmbeddingGenerator<TInput, TEmbedding> representa qualquer gerador de embeddings, independentemente do provedor.

Na prática, o fluxo de RAG com IA generativa no .NET fica assim: um IEmbeddingGenerator gera os vetores dos documentos, um banco vetorial os armazena e o IChatClient responde usando os trechos recuperados. Para a etapa de armazenamento, o pacote Microsoft.Extensions.VectorData oferece interfaces comuns para diferentes bancos.

Dessa forma, você troca o banco vetorial ou o modelo de embeddings sem reescrever a lógica de busca. O artigo sobre dados vetoriais no .NET com Microsoft.Extensions.VectorData mostra esse processo em detalhes.

Confiabilidade: validação e pós-processamento da saída

Trate a saída de um LLM como entrada não confiável, assim como os dados fornecidos pelo usuário. Por isso, limite o formato de retorno, exigindo JSON por exemplo, e valide o resultado com schema, regex ou parsing.

Além disso, implemente fallbacks quando o output fugir do esperado. Um padrão útil é solicitar respostas em JSON e validar no servidor:

public record AiAnswer(string Title, string Summary);

public static class AiAnswerParser
{
    public static AiAnswer Parse(string json)
        => System.Text.Json.JsonSerializer.Deserialize<AiAnswer>(json)
           ?? throw new InvalidOperationException("Invalid model response");
}

O Microsoft.Extensions.AI também oferece saída estruturada de forma nativa. Nesse caso, o método genérico GetResponseAsync<T> pede ao modelo um JSON compatível com o tipo e já devolve o objeto desserializado:

var response = await chatClient.GetResponseAsync<AiAnswer>(
    "Summarize the release notes below and return a title and a summary.");

// Result contém o objeto já convertido para AiAnswer
AiAnswer answer = response.Result;

Mesmo assim, continue validando regras de negócio sobre o objeto recebido. Dessa forma, o comportamento do sistema fica mais previsível e confiável.

Observabilidade de IA generativa no .NET

Levar IA generativa no .NET para produção exige rastreabilidade. Sem observabilidade adequada, fica difícil explicar respostas, identificar degradação de qualidade e controlar custos.

Portanto, registre o tempo de resposta do modelo, os tokens consumidos e a taxa de erros e rejeições. Registre também o prompt e os parâmetros, de forma segura e auditável.

Em ambientes corporativos, também é comum aplicar correlação por traceId, logs estruturados e telemetria centralizada. Nesse ponto, o Microsoft.Extensions.AI ajuda bastante, porque permite montar um pipeline com OpenTelemetry:

// Cada chamada ao modelo passa pelo cache e gera traces e métricas
IChatClient client = new ChatClientBuilder(innerClient)
    .UseDistributedCache()
    .UseOpenTelemetry(sourceName: "ProductCatalog.AI")
    .Build();

Assim, as chamadas ao LLM aparecem nas mesmas ferramentas que já monitoram o restante da aplicação.

Segurança e governança da IA generativa no .NET

Aplicações de IA generativa no .NET precisam considerar riscos específicos. Entre eles estão a exposição acidental de dados sensíveis, o prompt injection e as respostas fora de política.

Como contramedidas, filtre e classifique os dados antes de enviá-los ao modelo e evite enviar PII sem necessidade. Além disso, implemente políticas de conteúdo e controle as permissões de acesso aos dados usados no RAG.

Em outras palavras, um usuário nunca deve receber, via modelo, um documento que ele não poderia abrir diretamente. A governança também inclui auditoria, conformidade e controles de retenção de dados.

Boas práticas para IA generativa no .NET em produção

Para adotar IA generativa no .NET de forma sustentável, trate a integração como um produto de engenharia com requisitos próprios. Na prática, isso significa:

• Começar com um caso de uso bem definido.
• Medir o sucesso por métricas objetivas.
• Utilizar prompts consistentes, baseados em templates.
• Reduzir a variabilidade, por exemplo controlando a temperatura.
• Implementar cache quando aplicável.
• Planejar testes e regressão de prompts.

A temperatura, aliás, é um parâmetro simples de ajustar no ChatOptions. Valores próximos de zero deixam as respostas mais estáveis, o que ajuda em tarefas de extração e classificação.

Conclusão

A IA generativa com LLMs deixou de ser um experimento isolado e passou a integrar a arquitetura de aplicações modernas. No ecossistema de IA generativa no .NET, é possível construir soluções robustas em C# com abstrações adequadas, boas práticas de arquitetura, segurança e observabilidade.

Ao tratar o LLM como um componente externo sujeito a falhas, custos e comportamento não determinístico, os times exploram o potencial da tecnologia sem comprometer a confiabilidade do produto. Em resumo, o caminho mais consistente envolve:

• Projetar contratos claros de integração.
• Controlar o formato e a qualidade das respostas.
• Aplicar validação e guardrails.
• Ancorar respostas em dados internos via RAG quando necessário.
• Medir continuamente desempenho, custo e qualidade.

Com esses fundamentos, você desenvolve aplicações que geram valor real, aumentam a produtividade e entregam melhores experiências, mantendo critérios sólidos de engenharia de software.

FAQ

Qual biblioteca usar para IA generativa no .NET?

Para a maioria das aplicações, o ponto de partida é o pacote Microsoft.Extensions.AI com uma implementação do provedor escolhido. Para agentes e orquestração mais complexa, o Microsoft Agent Framework complementa essa base.

Qual a diferença entre IChatClient e IChatCompletionService?

O IChatClient pertence ao Microsoft.Extensions.AI e é a abstração base do ecossistema. Já o IChatCompletionService é a interface de chat do Semantic Kernel.

Posso rodar um LLM localmente com .NET?

Sim. O Ollama e o Foundry Local executam modelos na sua máquina, e você os consome pelas mesmas abstrações.

O RAG elimina as alucinações do modelo?

Não elimina, mas reduz bastante. Ele ancora as respostas em trechos recuperados dos seus próprios dados.

Por que validar a resposta do LLM?

Porque o modelo pode errar com alta confiança ou fugir do formato pedido. Validar evita que dados incorretos cheguem ao restante do sistema.