Danilo O. Pinheiro, dopme.io

Posted on Oct 8

🧠 Comunicação .NET com Kernel LLM

#dotnet #mcp

Explorando como integrar Large Language Models (LLMs) em aplicações .NET modernas utilizando o conceito de Kernel.

🚀 Introdução

A Inteligência Artificial está cada vez mais integrada ao ciclo de desenvolvimento de software. No ecossistema .NET, a integração com LLMs (Large Language Models) — como OpenAI GPT, Azure OpenAI ou modelos locais como LLaMA e Mistral — tem se tornado uma das formas mais poderosas de adicionar inteligência às aplicações corporativas.

Um dos conceitos centrais nessa integração é o Kernel LLM, uma camada intermediária que abstrai a comunicação com o modelo, oferecendo estrutura, orquestração e extensibilidade ao desenvolvedor .NET.

🧩 O que é o Kernel LLM?

O Kernel LLM é uma camada de orquestração que permite que aplicações comuniquem-se com modelos de linguagem de forma estruturada. Ele:

Centraliza as chamadas ao modelo.
Garante controle sobre prompts, contexto e tokens.
Permite injeção de dependências e logging.
Facilita a troca entre provedores (OpenAI, Azure, Ollama, etc.).

Em outras palavras, ele atua como o “cérebro conector” entre o domínio da aplicação e o modelo de IA.

🏗️ Arquitetura da Integração

A arquitetura baseia-se em três camadas principais:

Camada de Aplicação (.NET WebAPI ou Worker)
Responsável por receber requisições e coordenar fluxos de negócio.
Kernel LLM (Camada de Inteligência)
Implementa os prompts, controla o contexto e faz chamadas para o modelo de linguagem.
Provedor LLM (Infraestrutura)
Pode ser o OpenAI, Azure OpenAI, HuggingFace, Ollama (para modelos locais), entre outros.

📊 Fluxo Simplificado:

[Client] → [API .NET] → [Kernel LLM] → [Modelo LLM]

⚙️ Implementando o Kernel em .NET

Você pode construir um Kernel customizado com uso de Dependency Injection, HttpClientFactory e Strategy Pattern.

📘 Exemplo básico

public interface ILlmKernel
{
    Task<string> ExecuteAsync(string prompt);
}

public class OpenAiKernel : ILlmKernel
{
    private readonly HttpClient _client;
    private readonly string _apiKey;

    public OpenAiKernel(HttpClient client, IConfiguration config)
    {
        _client = client;
        _apiKey = config["OpenAI:ApiKey"];
    }

    public async Task<string> ExecuteAsync(string prompt)
    {
        var request = new
        {
            model = "gpt-4o-mini",
            messages = new[] { new { role = "user", content = prompt } }
        };

        var response = await _client.PostAsJsonAsync("https://api.openai.com/v1/chat/completions", request);
        var result = await response.Content.ReadFromJsonAsync<JsonElement>();
        return result.GetProperty("choices")[0].GetProperty("message").GetProperty("content").GetString();
    }
}

🧠 Uso na Controller

[ApiController]
[Route("api/llm")]
public class LlmController : ControllerBase
{
    private readonly ILlmKernel _kernel;

    public LlmController(ILlmKernel kernel)
    {
        _kernel = kernel;
    }

    [HttpPost("ask")]
    public async Task<IActionResult> Ask([FromBody] string question)
    {
        var result = await _kernel.ExecuteAsync(question);
        return Ok(result);
    }
}

🧱 Boas Práticas Arquiteturais

🔒 Segurança: nunca exponha a API Key diretamente no código. Utilize o Secret Manager ou Azure Key Vault.
📦 Modularidade: mantenha o Kernel em um projeto separado (ex: MyApp.AI.Core).
📈 Observabilidade: registre métricas de requisições e tokens (Datadog, Application Insights).
🧠 Prompt Engineering: trate os prompts como parte da camada de domínio, versionando-os conforme mudanças de negócio.

🧪 Testando a Comunicação

Crie um teste simples usando o xUnit:

public class LlmKernelTests
{
    private readonly ILlmKernel _kernel;

    public LlmKernelTests()
    {
        _kernel = new OpenAiKernel(new HttpClient(), new ConfigurationBuilder().AddJsonFile("appsettings.json").Build());
    }

    [Fact]
    public async Task Should_Return_Response_From_Model()
    {
        var response = await _kernel.ExecuteAsync("Hello, who are you?");
        Assert.False(string.IsNullOrEmpty(response));
    }
}

🧭 Expandindo a Arquitetura

Em projetos modernos, o Kernel LLM pode ser integrado com:

Pipelines de mensageria (RabbitMQ/Kafka) para execução assíncrona;
Cognitive Services para análise de sentimento;
gRPC ou GraphQL para comunicação entre microsserviços;
Azure OpenAI Embeddings para busca semântica.

🧩 Integração com Semantic Kernel (Microsoft)

A Microsoft mantém o projeto Semantic Kernel, que é uma implementação oficial de um Kernel LLM em .NET.
Ele permite criar Skills, Planners e Connectors, simplificando a integração de LLMs em aplicações corporativas com segurança e rastreabilidade.

🧠 Conclusão

Integrar LLMs em aplicações .NET é um passo estratégico para modernizar produtos e criar experiências inteligentes.
O Kernel LLM atua como uma camada de abstração robusta que une IA e arquitetura limpa, permitindo escalabilidade, segurança e extensibilidade.

🤝 Conecte-se Comigo

Se você trabalha com .NET moderno e quer dominar arquitetura, C#, observabilidade, DevOps ou interoperabilidade, vamos conversar:

💼 LinkedIn
✍️ Medium
📬 dopme.io
📬 devsfree

Senhor, tu ouviste os desejos dos mansos; confortarás os seus corações; os teus ouvidos estarão abertos para eles; Salmos 10:17

DEV Community