🧠 Comunicando o Entity Framework .NET com LLM – ██FR█████ █INTELL███████████

This content originally appeared on DEV Community and was authored by Danilo O. Pinheiro, dopme.io

Explorando como conectar modelos de linguagem (LLMs) a aplicações .NET modernas que utilizam o Entity Framework para fornecer consultas inteligentes, insights e automação de dados.

Introdução

Com o avanço dos Large Language Models (LLMs), integrar Inteligência Artificial diretamente às aplicações .NET deixou de ser uma tendência e passou a ser uma necessidade estratégica.
Enquanto o Entity Framework (EF Core) é o principal ORM para persistência e manipulação de dados em .NET, o LLM pode atuar como um “cérebro analítico”, capaz de interpretar consultas em linguagem natural, gerar queries otimizadas, validar dados ou sugerir insights baseados em padrões históricos.

O objetivo deste artigo é demonstrar como criar uma comunicação eficiente entre o Entity Framework e um modelo LLM, de forma arquiteturalmente limpa e escalável.

Arquitetura da Integração

A comunicação entre o EF Core e o LLM ocorre por meio de uma camada intermediária de orquestração inteligente, responsável por interpretar as intenções do usuário, transformar em consultas EF e retornar resultados significativos.

Camadas principais

Camada de Domínio (.NET + EF Core)
Responsável pelas entidades, contexto e operações CRUD.
Camada de Inteligência (LLM Kernel)
Interpreta o input humano e gera instruções ou consultas.
Camada de Aplicação (API ou Worker)
Faz a ponte entre o cliente e o motor de IA, coordenando requisições e respostas.

Fluxo Simplificado:

[Usuário] → [API .NET] → [Kernel LLM] → [Entity Framework Context] → [Banco de Dados]

Exemplo Prático — LLM interpretando comandos para EF Core

Cenário

Imagine uma API de relatórios financeiros. O usuário digita:

“Liste os clientes com faturamento acima de 10 mil nos últimos 3 meses.”

O LLM interpreta essa intenção e gera dinamicamente uma expressão LINQ para ser executada pelo EF Core.

Modelagem base

public class Cliente
{
    public int Id { get; set; }
    public string Nome { get; set; }
    public decimal FaturamentoMensal { get; set; }
    public DateTime DataCadastro { get; set; }
}

public class AppDbContext : DbContext
{
    public DbSet<Cliente> Clientes { get; set; }

    public AppDbContext(DbContextOptions<AppDbContext> options) : base(options) { }
}

Kernel LLM (OpenAI / Ollama / Azure)

public interface ILlmKernel
{
    Task<string> InterpretarAsync(string comando);
}

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> InterpretarAsync(string comando)
    {
        var request = new
        {
            model = "gpt-4o-mini",
            messages = new[]
            {
                new { role = "system", content = "Você é um tradutor de linguagem natural para queries LINQ em C#." },
                new { role = "user", content = comando }
            }
        };

        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();
    }
}

Serviço de Integração EF + LLM

public class InteligenciaRelatoriosService
{
    private readonly ILlmKernel _llmKernel;
    private readonly AppDbContext _dbContext;

    public InteligenciaRelatoriosService(ILlmKernel llmKernel, AppDbContext dbContext)
    {
        _llmKernel = llmKernel;
        _dbContext = dbContext;
    }

    public async Task<object> ExecutarConsultaInteligenteAsync(string comando)
    {
        var queryLinq = await _llmKernel.InterpretarAsync(comando);

        // ⚠ Em produção, use Parser/Whitelist para segurança contra injeção.
        var clientes = _dbContext.Clientes
            .Where(c => c.FaturamentoMensal > 10000)
            .ToList();

        return new
        {
            QueryGerada = queryLinq,
            Resultado = clientes
        };
    }
}

Controller para uso prático

[ApiController]
[Route("api/inteligencia")]
public class InteligenciaController : ControllerBase
{
    private readonly InteligenciaRelatoriosService _service;

    public InteligenciaController(InteligenciaRelatoriosService service)
    {
        _service = service;
    }

    [HttpPost("consultar")]
    public async Task<IActionResult> Consultar([FromBody] string comando)
    {
        var resultado = await _service.ExecutarConsultaInteligenteAsync(comando);
        return Ok(resultado);
    }
}

Casos de Uso

Consultas inteligentes: gerar relatórios dinâmicos com base em linguagem natural.
Análise preditiva: o LLM pode sugerir tendências e correlações.
Validação de dados: o modelo pode revisar regras de consistência antes da persistência.
Automações administrativas: geração automática de filtros, joins ou agrupamentos.

Boas Práticas Arquiteturais

Segurança: evite executar código gerado diretamente pelo LLM. Valide o output antes.
Camadas isoladas: mantenha o Kernel LLM desacoplado do contexto EF.
Observabilidade: monitore a latência entre as chamadas EF e LLM (Datadog, Application Insights).
Reutilização: trate prompts como componentes versionados dentro da aplicação.

Expansão — Kernel Semântico (Microsoft Semantic Kernel)

Para quem deseja uma solução mais robusta, a Microsoft fornece o Semantic Kernel, um SDK para orquestrar interações entre LLMs e dados empresariais.
Ele pode ser integrado ao EF Core com connectors e planners, permitindo interações contextuais e persistentes entre banco e modelo de linguagem.

Tecnologias Envolvidas

Componente	Descrição
.NET 8+	Base da aplicação e API
Entity Framework Core	ORM para persistência
LLM (OpenAI / Ollama / Azure OpenAI)	Inteligência de linguagem
Semantic Kernel (Opcional)	Framework de integração IA
Datadog / AppInsights	Monitoramento e métricas

Conclusão

Integrar Entity Framework com LLMs abre caminho para uma nova geração de aplicações .NET — capazes de compreender, interpretar e agir sobre os dados de forma inteligente.
Essa fusão entre persistência e IA representa o futuro do desenvolvimento empresarial, unindo automação, inteligência contextual e arquitetura limpa.