Desenvolver aplicativos inteligentes com estruturas de IA

  • 15 minutos

A criação de aplicativos de IA prontos para produção requer mais do que apenas recursos de IA, o que exige uma abordagem que engloba streaming de dados em tempo real, interfaces de linguagem natural, ferramentas de produtividade do desenvolvedor e integração de nuvem. O SQL Server 2025 fornece uma plataforma para o desenvolvimento de aplicações que podem ser dimensionadas desde implantações locais até arquiteturas nativas de nuvem.

Essa abordagem integrada significa que você pode criar aplicativos de IA usando ferramentas e estruturas usando recursos corporativos para segurança, desempenho e confiabilidade. Se você estiver criando mecanismos de recomendação em tempo real, assistentes de IA de conversa ou painéis analíticos alimentados por insights de IA, o SQL Server 2025 fornece a base necessária.

Criar interfaces de IA de conversação

As interfaces de linguagem natural tornam os dados corporativos acessíveis aos usuários sem a necessidade de conhecimento do SQL ou conhecimento técnico.

Criar padrões de consulta dialogal

Os padrões de consulta de conversa permitem que os usuários façam perguntas em linguagem natural e recebam respostas controladas por dados traduzindo suas consultas para SQL usando modelos de IA como GPT-4.

Implementar linguagem natural para funcionalidades do SQL (NL2SQL):

-- Create a stored procedure that interprets natural language queries
CREATE PROCEDURE sp_ConversationalQuery
    @user_question NVARCHAR(MAX),
    @context NVARCHAR(MAX) OUTPUT,
    @sql_query NVARCHAR(MAX) OUTPUT
AS
BEGIN
    -- Build a prompt for the AI model to generate SQL
    DECLARE @prompt NVARCHAR(MAX) = CONCAT(
        'You are a SQL expert. Given the following database schema and user question, generate a SQL query.',
        CHAR(10), CHAR(10),
        'Schema:', CHAR(10),
        'products (product_id INT, product_name NVARCHAR(100), price DECIMAL(10,2), category NVARCHAR(50))',
        CHAR(10),
        'sales (sale_id INT, product_id INT, quantity INT, sale_date DATE)',
        CHAR(10), CHAR(10),
        'Question: ', @user_question,
        CHAR(10),
        'Generate only the SQL query, no explanations.'
    );
    
    -- Call GPT-4 to generate SQL
    DECLARE @request NVARCHAR(MAX) = JSON_OBJECT(
        'messages': JSON_ARRAY(
            JSON_OBJECT('role': 'system', 'content': 'You are a SQL query generator.'),
            JSON_OBJECT('role': 'user', 'content': @prompt)
        ),
        'max_tokens': 500
    );
    
    DECLARE @response NVARCHAR(MAX);
    EXEC sp_invoke_external_rest_endpoint
        @url = N'https://myopenai.openai.azure.com/openai/deployments/gpt-4/chat/completions?api-version=2024-02-15-preview',
        @method = 'POST',
        @credential = [MyAzureOpenAICredential],
        @payload = @request,
        @response = @response OUTPUT;
    
    -- Extract the generated SQL
    SET @sql_query = JSON_VALUE(@response, '$.result.choices[0].message.content');
    SET @context = 'Query generated successfully';
END;

Esse procedimento armazenado usa GPT-4 para traduzir perguntas de linguagem natural em consultas SQL, facilitando o acesso aos seus dados de forma conversacional.

Implementar guardrails de segurança

Os guardrails de segurança impedem que consultas SQL geradas por IA executem operações incorretas, como excluir ou modificar dados, garantindo apenas o acesso somente leitura ao banco de dados.

Adicione validação para garantir que o SQL gerado seja seguro:

CREATE PROCEDURE sp_SafeConversationalQuery
    @user_question NVARCHAR(MAX),
    @results NVARCHAR(MAX) OUTPUT
AS
BEGIN
    DECLARE @sql_query NVARCHAR(MAX);
    DECLARE @context NVARCHAR(MAX);
    
    -- Generate SQL from natural language
    EXEC sp_ConversationalQuery @user_question, @context OUTPUT, @sql_query OUTPUT;
    
    -- Validate the generated SQL
    IF @sql_query LIKE '%DROP%' 
        OR @sql_query LIKE '%DELETE%'
        OR @sql_query LIKE '%UPDATE%'
        OR @sql_query LIKE '%INSERT%'
        OR @sql_query LIKE '%ALTER%'
        OR @sql_query LIKE '%CREATE%'
    BEGIN
        SET @results = JSON_OBJECT('error': 'Generated query contains potentially unsafe operations');
        RETURN;
    END;
    
    -- Execute the query safely (read-only)
    BEGIN TRY
        EXEC sp_executesql @sql_query;
    END TRY
    BEGIN CATCH
        SET @results = JSON_OBJECT(
            'error': ERROR_MESSAGE(),
            'query': @sql_query
        );
    END CATCH;
END;

Esse wrapper adiciona verificações de segurança para evitar operações destrutivas, garantindo que os usuários possam apenas consultar dados, não modificá-los.

Criar conversas de vários turnos

Conversas com vários turnos permitem que os usuários tenham diálogos contextuais e naturais com seus dados mantendo o histórico de conversas, permitindo perguntas de acompanhamento sem contexto repetido.

O exemplo a seguir cria uma IA de conversa que mantém o contexto em várias interações, permitindo perguntas de acompanhamento e diálogo natural com seus dados:

CREATE TABLE conversation_history (
    conversation_id UNIQUEIDENTIFIER DEFAULT NEWID(),
    user_id NVARCHAR(100),
    turn_number INT,
    user_message NVARCHAR(MAX),
    assistant_message NVARCHAR(MAX),
    timestamp DATETIME2 DEFAULT GETDATE(),
    PRIMARY KEY (conversation_id, turn_number)
);

CREATE PROCEDURE sp_ConversationalChat
    @conversation_id UNIQUEIDENTIFIER,
    @user_id NVARCHAR(100),
    @user_message NVARCHAR(MAX),
    @response NVARCHAR(MAX) OUTPUT
AS
BEGIN
    -- Get conversation history
    DECLARE @history NVARCHAR(MAX);
    
    SELECT @history = STRING_AGG(
        JSON_OBJECT(
            'role': CASE WHEN turn_number % 2 = 1 THEN 'user' ELSE 'assistant' END,
            'content': CASE WHEN turn_number % 2 = 1 THEN user_message ELSE assistant_message END
        ),
        ','
    )
    FROM conversation_history
    WHERE conversation_id = @conversation_id
    ORDER BY turn_number;
    
    -- Build messages array with history
    DECLARE @messages NVARCHAR(MAX) = CONCAT('[', @history, ',', 
        JSON_OBJECT('role': 'user', 'content': @user_message), ']');
    
    -- Call GPT-4 with conversation context
    DECLARE @chat_request NVARCHAR(MAX) = JSON_OBJECT('messages': @messages);
    
    EXEC sp_invoke_external_rest_endpoint
        @url = N'https://myopenai.openai.azure.com/openai/deployments/gpt-4/chat/completions?api-version=2024-02-15-preview',
        @method = 'POST',
        @credential = [MyAzureOpenAICredential],
        @payload = @chat_request,
        @response = @response OUTPUT;
    
    -- Extract and store the response
    DECLARE @assistant_response NVARCHAR(MAX) = JSON_VALUE(@response, '$.result.choices[0].message.content');
    
    -- Save to conversation history
    DECLARE @next_turn INT = (SELECT ISNULL(MAX(turn_number), 0) + 1 FROM conversation_history WHERE conversation_id = @conversation_id);
    
    INSERT INTO conversation_history (conversation_id, user_id, turn_number, user_message, assistant_message)
    VALUES (@conversation_id, @user_id, @next_turn, @user_message, @assistant_response);
    
    SET @response = @assistant_response;
END;

Aprimorar a produtividade do desenvolvedor com ferramentas de IA

O SQL Server 2025 integra-se às ferramentas de desenvolvimento modernas para acelerar o desenvolvimento de aplicativos de IA.

Usar a extensão MSSQL para Visual Studio Code com o GitHub Copilot

A extensão MSSQL para Visual Studio Code inclui a integração do GitHub Copilot , fornecendo assistência de IA para desenvolvimento de banco de dados.

Observação

A integração do GitHub Copilot com a extensão MSSQL está atualmente em versão prévia. Recursos e funcionalidades podem mudar. Para obter as informações mais recentes, consulte a documentação de extensão do MSSQL.

A integração do GitHub Copilot fornece assistência de código para tarefas de desenvolvimento de banco de dados:

  • Geração de consulta: Descrever o que você deseja em linguagem natural, obter código T-SQL
  • Otimização de consulta: Obter sugestões para melhorar o desempenho da consulta
  • Exploração de esquema: Fazer perguntas sobre seu esquema de banco de dados
  • Assistência de migração: Gerar scripts para alterações de esquema e migrações de dados
  • Explicação: Entender consultas complexas com explicações geradas por IA

O exemplo a seguir demonstra como o GitHub Copilot pode gerar um procedimento armazenado completo de um comentário em linguagem natural:

-- Type a comment describing what you want
-- Generate a stored procedure that finds products similar to a given product using vector search

-- GitHub Copilot suggests:
CREATE PROCEDURE sp_FindSimilarProducts
    @product_id INT,
    @top_n INT = 5
AS
BEGIN
    DECLARE @query_embedding VECTOR(1536);
    
    -- Get the embedding of the reference product
    SELECT @query_embedding = embedding
    FROM products
    WHERE product_id = @product_id;
    
    -- Find similar products
    SELECT TOP (@top_n)
        product_id,
        product_name,
        category,
        price,
        VECTOR_DISTANCE('cosine', @query_embedding, embedding) AS similarity_score
    FROM products
    WHERE product_id != @product_id
    ORDER BY similarity_score;
END;

Usar o Entity Framework Core com recursos de IA

O Entity Framework Core pode ser usado para criar aplicativos de IA com o SQL Server. Você pode usar consultas SQL brutas para trabalhar com o tipo de dados VECTOR do SQL Server e funções de IA:

Como o Entity Framework Core não dá suporte nativo ao tipo de dados VECTOR, este exemplo usa FromSqlRaw para executar o T-SQL diretamente, beneficiando-se das operações assíncronas e do mapeamento de objetos do EF Core. O método serializa uma inserção de consulta no JSON, executa uma pesquisa de similaridade de vetor usando VECTOR_DISTANCEe retorna produtos com inserções semelhantes , ideal para sistemas de recomendação e pesquisa semântica.

using Microsoft.EntityFrameworkCore;
using System.Text.Json;

public class Product
{
    public int ProductId { get; set; }
    public string ProductName { get; set; }
    public string Description { get; set; }
    public decimal Price { get; set; }
}

public class AppDbContext : DbContext
{
    public DbSet<Product> Products { get; set; }
}

// Query with vector similarity using raw SQL
public async Task<List<Product>> FindSimilarProducts(float[] queryEmbedding, int topN = 5)
{
    var embeddingJson = JsonSerializer.Serialize(queryEmbedding);
    
    var similarProducts = await _context.Products
        .FromSqlRaw(@"
            SELECT TOP {0} 
                product_id, 
                product_name, 
                description, 
                price
            FROM products
            WHERE VECTOR_DISTANCE('cosine', CAST({1} AS VECTOR(1536)), embedding) < 0.5
            ORDER BY VECTOR_DISTANCE('cosine', CAST({1} AS VECTOR(1536)), embedding)
        ", topN, embeddingJson)
        .ToListAsync();
    
    return similarProducts;
}

Integrar com o Microsoft Fabric

O Microsoft Fabric fornece uma plataforma de análise unificada que complementa os recursos de IA do SQL Server. O SQL Server 2025 dá suporte ao espelhamento de banco de dados para o Microsoft Fabric, permitindo análise quase em tempo real em dados operacionais sem a complexidade dos pipelines de ETL tradicionais.

Diagrama mostrando o espelhamento de banco de dados do SQL Server 2025 para o Microsoft Fabric.

Diagrama mostrando o espelhamento de banco de dados do SQL Server 2025 para o Microsoft Fabric. À esquerda, um banco de dados do SQL Server 2025 replica continuamente os dados para o Microsoft Fabric OneLake. O diagrama ilustra a arquitetura de ETL zero em que os dados operacionais fluem para a plataforma de análise.

Configurar espelhamento do Fabric

O Espelhamento do Fabric é configurado por meio do portal do Microsoft Fabric usando uma interface visual. O recurso de espelhamento replica continuamente seus dados para o OneLake do Fabric no formato Delta Lake, disponibilizando-os para análise sem afetar suas cargas de trabalho operacionais.

Observação

Para obter instruções de configuração passo a passo, consulte Tutorial: Configurar bancos de dados espelhados do Microsoft Fabric do SQL Server.

Alguns dos benefícios do espelhamento do Fabric são:

  • Análise quase em tempo real: As alterações de dados são replicadas continuamente com latência mínima
  • Arquitetura Zero-ETL: Não é necessário criar e manter pipelines de dados complexos
  • Abrir formato de dados: Os dados são armazenados no formato Delta Lake no OneLake para ampla compatibilidade de ferramentas
  • Análise pronta para IA: Integração direta com as funcionalidades de IA e machine learning do Fabric
  • Ponto de extremidade de análise do SQL: consultar dados espelhados usando a sintaxe T-SQL familiar
  • Nenhum impacto operacional: O espelhamento utiliza o rastreamento de alterações sem afetar as cargas de trabalho de produção

Otimizar o desempenho do espelhamento

Depois que o espelhamento estiver configurado, você poderá usar o Administrador de Recursos do SQL Server para gerenciar seu efeito de desempenho em suas cargas de trabalho operacionais:

O exemplo de código a seguir cria uma configuração do Resource Governor que limita os recursos de CPU e memória usados pelas operações de espelhamento do Fabric.

-- Create resource pool for mirroring
CREATE RESOURCE POOL FabricMirrorPool
WITH (
    MIN_CPU_PERCENT = 5,
    MAX_CPU_PERCENT = 20,
    MIN_MEMORY_PERCENT = 5,
    MAX_MEMORY_PERCENT = 20
);

-- Create workload group for mirroring
CREATE WORKLOAD GROUP FabricMirrorGroup
WITH (
    IMPORTANCE = MEDIUM
)
USING FabricMirrorPool;

-- Apply classifier function
CREATE FUNCTION dbo.FabricMirrorClassifier()
RETURNS SYSNAME
WITH SCHEMABINDING
AS
BEGIN
    DECLARE @workload_group SYSNAME = 'default';
    
    IF APP_NAME() LIKE '%Fabric Mirror%'
        SET @workload_group = 'FabricMirrorGroup';
    
    RETURN @workload_group;
END;

-- Enable resource governor
ALTER RESOURCE GOVERNOR 
WITH (CLASSIFIER_FUNCTION = dbo.FabricMirrorClassifier);

ALTER RESOURCE GOVERNOR RECONFIGURE;

No exemplo, o pool de recursos FabricMirrorPool restringe o espelhamento a ser usado entre 5 a 20% da CPU e da memória, impedindo que ele afete as cargas de trabalho de produção. Uma função de classificador identifica sessões de espelhamento com base no nome do aplicativo e as roteia para o grupo de carga de trabalho dedicado, garantindo alocação de recursos consistente e desempenho previsível para cargas de trabalho operacionais e de análise.

O administrador de recursos garante que o espelhamento do Fabric não afete as suas cargas de trabalho operacionais.

Otimizar o desempenho do aplicativo de IA

O desempenho é fundamental para aplicativos de IA de produção.

Otimizar consultas de pesquisa de vetor

Use dicas de consulta e otimização de índice:

Otimizar o desempenho da pesquisa de vetor é fundamental para aplicativos de IA de produção, em que o tempo de resposta afeta diretamente a experiência do usuário.

O exemplo a seguir demonstra duas técnicas de otimização de chave: criar índices de vetor filtrados destinados a subconjuntos de dados específicos (como categorias de produto) e usar dicas de consulta para controlar o comportamento de execução.

O índice idx_electronics_embedding filtrado acelera as pesquisas dentro da categoria Eletrônica indexando apenas vetores relevantes, reduzindo o espaço de pesquisa e melhorando a velocidade da consulta. A MAXDOP 4 dica limita o processamento paralelo a quatro threads, equilibrando o desempenho com o consumo de recursos , essencial para impedir que pesquisas de vetor monopolizem os recursos do servidor e afetem outras cargas de trabalho.

-- Create filtered vector index for specific categories
CREATE VECTOR INDEX idx_electronics_embedding 
ON products(embedding)
WHERE category = 'Electronics';

-- Use query hints for better performance
DECLARE @query_embedding VECTOR(1536) = AI_GENERATE_EMBEDDINGS(@user_query USE MODEL Ada2Embeddings);

SELECT TOP 10
    product_id,
    product_name,
    VECTOR_DISTANCE('cosine', @query_embedding, embedding) AS score
FROM products WITH (INDEX(idx_electronics_embedding))
WHERE category = 'Electronics'
ORDER BY score
OPTION (MAXDOP 4);

Você pode usar índices e dicas de consulta para otimizar a pesquisa de vetor para cenários específicos.

Seguindo essas práticas e usando os recursos de IA do SQL Server 2025, você pode criar, implantar e operar aplicativos prontos para produção que fornecem valor comercial real, mantendo os padrões corporativos de segurança, desempenho e confiabilidade.