Dezvoltați aplicații inteligente cu cadre AI

  • 15 minute

Construirea de aplicații AI pregătite pentru producție necesită mai mult decât capabilități AI, ci o abordare care cuprinde streaming de date în timp real, interfețe în limbaj natural, instrumente de productivitate pentru dezvoltatori și integrare în cloud. SQL Server 2025 oferă o platformă pentru dezvoltarea de aplicații care se scalează de la implementări locale la arhitecturi native în cloud.

Această abordare integrată înseamnă că puteți construi aplicații AI folosind instrumente și cadre, utilizând în același timp funcții de întreprindere pentru securitate, performanță și fiabilitate. Indiferent dacă construiți motoare de recomandare în timp real, asistenți AI conversaționali sau tablouri de bord analitice bazate pe informații AI, SQL Server 2025 oferă fundația de care aveți nevoie.

Construiți interfețe AI conversaționale

Interfețele în limbaj natural fac datele de întreprindere accesibile utilizatorilor fără a necesita cunoștințe SQL sau expertiză tehnică.

Proiectarea modelelor de interogare conversaționale

Modelele de interogare conversaționale permit utilizatorilor să pună întrebări în limbaj natural și să primească răspunsuri bazate pe date prin traducerea interogărilor lor în SQL folosind modele AI precum GPT-4.

Implementați capabilitățile limbajului natural în 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;

Această procedură stocată folosește GPT-4 pentru a traduce întrebările de limbaj natural în interogări SQL, permițând accesul conversațional la datele dvs.

Implementați balustrade de siguranță

Barierele de siguranță împiedică interogările SQL generate de inteligență artificială să efectueze operațiuni incorecte, cum ar fi ștergerea sau modificarea datelor, asigurând doar acces doar în citire la baza de date.

Adăugați validare pentru a vă asigura că SQL generat este în siguranță:

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;

Acest wrapper adaugă verificări de securitate pentru a preveni operațiunile distructive, asigurându-se că utilizatorii pot interoga doar datele, nu le pot modifica.

Creați conversații cu mai multe ture

Conversațiile cu mai multe ture permit utilizatorilor să aibă dialoguri naturale și contextuale cu datele dvs., păstrând istoricul conversațiilor, permițând întrebări ulterioare fără a repeta contextul.

Următorul exemplu construiește o inteligență artificială conversațională care menține contextul în mai multe interacțiuni, permițând întrebări ulterioare și dialog natural cu datele dvs.:

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;

Îmbunătățiți productivitatea dezvoltatorilor cu instrumente AI

SQL Server 2025 se integrează cu instrumente moderne de dezvoltare pentru a accelera dezvoltarea aplicațiilor AI.

Utilizați extensia MSSQL pentru Visual Studio Code cu GitHub Copilot

Extensia MSSQL pentru Visual Studio Code include integrarea GitHub Copilot, oferind asistență bazată pe inteligență artificială pentru dezvoltarea bazelor de date.

Notă

Integrarea GitHub Copilot cu extensia MSSQL este în prezent în previzualizare. Caracteristicile și funcționalitățile se pot schimba. Pentru cele mai recente informații, consultați documentația extensiei MSSQL.

Integrarea GitHub Copilot oferă asistență de cod pentru sarcinile de dezvoltare a bazei de date:

  • Generarea interogărilor: Descrieți ce doriți în limbaj natural, obțineți cod T-SQL
  • Optimizarea interogărilor: Obțineți sugestii pentru îmbunătățirea performanței interogărilor
  • Explorarea schemei: Puneți întrebări despre schema bazei de date
  • Asistență pentru migrație: Generați scripturi pentru modificări de schemă și migrări de date
  • Explicație: Înțelegeți interogările complexe cu explicații generate de AI

Următorul exemplu demonstrează modul în care GitHub Copilot poate genera o procedură stocată completă dintr-un comentariu în limbaj 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;

Utilizați Entity Framework Core cu capabilități AI

Entity Framework Core poate fi folosit pentru a construi aplicații AI cu SQL Server. Puteți utiliza interogări SQL brute pentru a lucra cu tipul de date VECTOR al SQL Server și cu funcțiile AI:

Deoarece Entity Framework Core nu acceptă nativ tipul de date VECTOR, acest exemplu utilizează FromSqlRaw pentru a executa T-SQL direct, beneficiind în același timp de operațiunile asincrone și maparea obiectelor EF Core. Metoda serializează o interogare încorporată în JSON, execută o căutare de similitudine vectorială folosind VECTOR_DISTANCE, și returnează produse cu încorporari similare - ideal pentru sistemele de recomandare și căutarea semantică.

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

Integrarea cu Microsoft Fabric

Microsoft Fabric oferă o platformă de analiză unificată care completează capacitățile AI ale SQL Server. SQL Server 2025 acceptă oglindirea bazei de date în Microsoft Fabric, permițând analize aproape în timp real ale datelor operaționale fără complexitatea conductelor ETL tradiționale.

Diagramă care arată oglindirea bazei de date SQL Server 2025 în Microsoft Fabric.

Diagramă care arată oglindirea bazei de date SQL Server 2025 în Microsoft Fabric. În stânga, o bază de date SQL Server 2025 replică continuu datele în Microsoft Fabric OneLake. Diagrama ilustrează arhitectura zero-ETL în care datele operaționale circulă către platforma de analiză.

Configurarea oglindirii structurii

Fabric Mirroring este configurat prin portalul Microsoft Fabric utilizând o interfață vizuală. Funcția de oglindire vă reproduce continuu datele în formatul OneLake de la Fabric în Delta Lake, făcându-le disponibile pentru analiză fără a vă afecta fluxurile de lucru operaționale.

Notă

Pentru instrucțiuni de configurare pas cu pas, consultați Tutorial: Configurarea bazelor de date în oglindă Microsoft Fabric din SQL Server.

Unele dintre beneficiile oglindirii țesăturii sunt:

  • Analize aproape în timp real: Modificările de date sunt replicate continuu cu latență minimă
  • Zero-ETL arhitectură: Nu este nevoie să construiți și să întrețineți conducte de date complexe
  • Formatul datelor deschise: Datele sunt stocate în format Delta Lake în OneLake pentru o compatibilitate largă a sculelor
  • Analize pregătite pentru inteligență artificială: Integrare directă cu capabilitățile AI și de învățare automată ale Fabric
  • Punct final de analiză SQL: Interogarea datelor în oglindă folosind sintaxa familiară T-SQL
  • Fără impact operațional: Oglindirea utilizează urmărirea modificărilor fără a afecta fluxurile de lucru de producție

Optimizați performanța de oglindire

După configurarea oglindirii, puteți utiliza Resource Governor al SQL Server pentru a-și gestiona efectul de performanță asupra fluxurilor de lucru operaționale:

Următorul exemplu de cod creează o configurație Resource Governor care limitează resursele CPU și de memorie utilizate de operațiunile de oglindire 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;

În exemplu, pool-ul FabricMirrorPool de resurse restricționează oglindirea pentru a utiliza între 5-20% de CPU și memorie, împiedicându-l să afecteze fluxurile de lucru de producție. O funcție de clasificare identifică sesiunile de oglindire pe baza numelui aplicației și le direcționează către grupul de sarcini de lucru dedicat, asigurând o alocare consecventă a resurselor și performanțe previzibile atât pentru fluxurile de lucru operaționale, cât și pentru cele de analiză.

Resource governor se asigură că oglindirea Fabric nu vă afectează fluxurile de lucru operaționale.

Optimizați performanța aplicațiilor AI

Performanța este esențială pentru aplicațiile AI de producție.

Optimizați interogările de căutare vectorială

Utilizați sugestii de interogare și optimizarea indexului:

Optimizarea performanței căutării vectoriale este esențială pentru aplicațiile AI de producție în care timpul de răspuns are un impact direct asupra experienței utilizatorului.

Următorul exemplu demonstrează două tehnici cheie de optimizare: crearea de indici vectoriali filtrați care vizează anumite subseturi de date (cum ar fi categoriile de produse) și utilizarea sugestiilor de interogare pentru a controla comportamentul de execuție.

Indexul idx_electronics_embedding filtrat accelerează căutările din categoria Electronice prin indexarea numai a vectorilor relevanți, reducerea spațiului de căutare și îmbunătățirea vitezei de interogare. Sugestia MAXDOP 4 limitează procesarea paralelă la patru fire de execuție, echilibrând performanța cu consumul de resurse - esențial pentru a preveni căutările vectoriale să monopolizeze resursele serverului și să afecteze alte sarcini de lucru.

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

Puteți utiliza indexuri și sugestii de interogare pentru optimizarea căutării vectoriale pentru anumite scenarii.

Urmând aceste practici și utilizând capacitățile AI ale SQL Server 2025, puteți construi, implementa și opera aplicații gata de producție care oferă valoare reală pentru afaceri, menținând în același timp standardele întreprinderii pentru securitate, performanță și fiabilitate.