Intelligente toepassingen ontwikkelen met AI-frameworks

  • 15 minuten

Voor het bouwen van ai-toepassingen die gereed zijn voor productie zijn meer dan alleen AI-mogelijkheden vereist. Hiervoor is een benadering vereist die realtime gegevensstreaming, interfaces voor natuurlijke taal, productiviteitshulpprogramma's voor ontwikkelaars en cloudintegratie omvat. SQL Server 2025 biedt een platform voor het ontwikkelen van toepassingen die worden geschaald van on-premises implementaties naar cloudeigen architecturen.

Deze geïntegreerde benadering betekent dat u AI-toepassingen kunt bouwen met behulp van hulpprogramma's en frameworks terwijl u bedrijfsfuncties gebruikt voor beveiliging, prestaties en betrouwbaarheid. Of u nu realtime aanbevelingsengines, conversationele AI-assistenten of analytische dashboards bouwt die worden aangedreven door AI-inzichten, SQL Server 2025 biedt de basis die u nodig hebt.

Ai-interfaces voor gesprekken bouwen

Interfaces in natuurlijke taal maken zakelijke gegevens toegankelijk voor gebruikers zonder dat hiervoor SQL-kennis of technische expertise nodig is.

Gesprekszoekopdrachtpatronen ontwerpen

Met gespreksquerypatronen kunnen gebruikers vragen stellen in natuurlijke taal en gegevensgestuurde antwoorden ontvangen door hun query's te vertalen in SQL met behulp van AI-modellen zoals GPT-4.

Implementeer natuurlijke taal in SQL-mogelijkheden (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;

Deze opgeslagen procedure maakt gebruik van GPT-4 om vragen in natuurlijke taal te vertalen naar SQL-query's, waardoor gesprekstoegang tot uw gegevens mogelijk is.

Veiligheidsrails implementeren

Met veiligheidsrails voorkomt u dat DOOR AI gegenereerde SQL-query's onjuiste bewerkingen uitvoeren, zoals het verwijderen of wijzigen van gegevens, waardoor alleen-lezentoegang tot uw database wordt gegarandeerd.

Validatie toevoegen om ervoor te zorgen dat gegenereerde SQL veilig is:

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;

Met deze wrapper worden beveiligingscontroles toegevoegd om destructieve bewerkingen te voorkomen, zodat gebruikers alleen query's kunnen uitvoeren op gegevens, niet kunnen wijzigen.

Gesprekken met meerdere beurten maken

Met gesprekken met meerdere paden kunnen gebruikers natuurlijke, contextuele dialogen met uw gegevens voeren door de gespreksgeschiedenis te onderhouden en vervolgvragen in te schakelen zonder context te herhalen.

In het volgende voorbeeld wordt een conversationele AI gebouwd die context behoudt voor meerdere interacties, waardoor vervolgvragen en natuurlijke dialoog met uw gegevens mogelijk zijn:

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;

Verbeter de productiviteit van ontwikkelaars met AI-hulpprogramma's

SQL Server 2025 kan worden geïntegreerd met moderne ontwikkelhulpprogramma's om de ontwikkeling van AI-toepassingen te versnellen.

MSSQL-extensie gebruiken voor Visual Studio Code met GitHub Copilot

De MSSQL-extensie voor Visual Studio Code bevat GitHub Copilot-integratie , die ai-ondersteuning biedt voor databaseontwikkeling.

Opmerking

GitHub Copilot-integratie met de MSSQL-extensie is momenteel in preview. Functies en functionaliteit kunnen mogelijk veranderen. Zie de documentatie voor de MSSQL-extensie voor de meest recente informatie.

De GitHub Copilot-integratie biedt hulp bij code voor databaseontwikkelingstaken:

  • Query genereren: Beschrijven wat u in natuurlijke taal wilt, T-SQL-code ophalen
  • Queryoptimalisatie: Suggesties krijgen voor het verbeteren van queryprestaties
  • Schemaverkenning: Vragen stellen over uw databaseschema
  • Hulp bij migratie: Scripts genereren voor schemawijzigingen en gegevensmigraties
  • Uitleg: Complexe query's begrijpen met door AI gegenereerde uitleg

In het volgende voorbeeld ziet u hoe GitHub Copilot een volledige opgeslagen procedure kan genereren op basis van een opmerking in natuurlijke taal:

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

Entity Framework Core gebruiken met AI-mogelijkheden

Entity Framework Core kan worden gebruikt voor het bouwen van AI-toepassingen met SQL Server. U kunt onbewerkte SQL-query's gebruiken om te werken met het gegevenstype VECTOR van SQL Server en AI-functies:

Omdat Entity Framework Core het VECTOR-gegevenstype niet systeemeigen ondersteunt, wordt FromSqlRaw in dit voorbeeld gebruikgemaakt van het rechtstreeks uitvoeren van T-SQL terwijl u profiteert van asynchrone bewerkingen en objecttoewijzing van EF Core. De methode serialiseert een query die wordt ingesloten in JSON, voert een vector-overeenkomstenzoekopdracht uit met behulp van VECTOR_DISTANCEen retourneert producten met vergelijkbare insluitingen, ideaal voor aanbevelingssystemen en semantische zoekopdrachten.

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

Integreren met Microsoft Fabric

Microsoft Fabric biedt een geïntegreerd analyseplatform dat de AI-mogelijkheden van SQL Server aanvult. SQL Server 2025 ondersteunt databasespiegeling naar Microsoft Fabric, waardoor bijna realtime analyses op operationele gegevens mogelijk zijn zonder de complexiteit van traditionele ETL-pijplijnen.

Diagram dat de databasespiegeling van SQL Server 2025 naar Microsoft Fabric toont.

Diagram met SQL Server 2025-databasespiegeling naar Microsoft Fabric. Aan de linkerkant repliceert een SQL Server 2025-database continu gegevens naar Microsoft Fabric OneLake. Het diagram illustreert de zero-ETL-architectuur waarbij operationele gegevens naar het analyseplatform stromen.

Fabric-spiegeling configureren

Fabric Mirroring wordt geconfigureerd via de Microsoft Fabric-portal met behulp van een visuele interface. De functie voor spiegeling repliceert uw gegevens continu naar de OneLake van Fabric in Delta Lake-indeling, waardoor deze beschikbaar is voor analyses zonder dat dit van invloed is op uw operationele workloads.

Opmerking

Voor stapsgewijze configuratie-instructies raadpleegt u Zelfstudie: Gespiegelde Databases van Microsoft Fabric configureren vanuit SQL Server.

Enkele voordelen van Fabric-spiegeling zijn:

  • Bijna realtime analyses: Gegevenswijzigingen worden continu gerepliceerd met minimale latentie
  • Zero-ETL architectuur: U hoeft geen complexe gegevenspijplijnen te bouwen en te onderhouden
  • Open data formaat: Gegevens worden opgeslagen in Delta Lake-indeling in OneLake voor brede toolcompatibiliteit
  • Analyse die gereed is voor AI: Directe integratie met ai- en machine learning-mogelijkheden van Fabric
  • SQL Analytics-eindpunt: Gespiegelde gegevens opvragen met behulp van bekende T-SQL-syntaxis
  • Geen operationele impact: Spiegeling maakt gebruik van wijzigingen bijhouden zonder dat dit van invloed is op productieworkloads

Prestaties van spiegeling optimaliseren

Zodra spiegeling is geconfigureerd, kunt u Resource Governor van SQL Server gebruiken om het prestatie-effect op uw operationele workloads te beheren:

In het volgende codevoorbeeld wordt een Resource Governor-configuratie gemaakt die de CPU- en geheugenresources beperkt die worden gebruikt door mirroringbewerkingen van 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;

In het voorbeeld beperkt de resourcepool FabricMirrorPool spiegeling tot gebruik tussen 5-20% van CPU en geheugen om ervoor te zorgen dat het geen invloed heeft op productieworkloads. Een classificatiefunctie identificeert spiegelingssessies op basis van de naam van de toepassing en stuurt deze door naar de toegewezen workloadgroep, waardoor consistente resourcetoewijzing en voorspelbare prestaties worden gegarandeerd voor zowel operationele als analyseworkloads.

Resource Governor zorgt ervoor dat Fabric-mirroring geen invloed heeft op uw operationele workloads.

Prestaties van AI-toepassingen optimaliseren

Prestaties zijn essentieel voor AI-toepassingen voor productie.

Vectorzoekqueries optimaliseren

Gebruik queryhints en indexoptimalisatie:

Het optimaliseren van de prestaties van vectorzoekopdrachten is essentieel voor productie-AI-toepassingen waarbij de reactietijd rechtstreeks van invloed is op de gebruikerservaring.

In het volgende voorbeeld ziet u twee belangrijke optimalisatietechnieken: het maken van gefilterde vectorindexen die gericht zijn op specifieke gegevenssubsets (zoals productcategorieën) en het gebruik van queryhints om het uitvoeringsgedrag te beheren.

De gefilterde index idx_electronics_embedding versnelt zoekopdrachten binnen de categorie Elektronica door alleen relevante vectoren te indexeren, de zoekruimte te verminderen en de querysnelheid te verbeteren. De MAXDOP 4 hint beperkt parallelle verwerking tot vier threads, waarbij de prestaties worden afgestemd op het resourceverbruik. Dit is essentieel om te voorkomen dat vectorzoekopdrachten serverresources in beslag kunnen brengen en andere werkbelastingen beïnvloeden.

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

U kunt indexen en queryhints gebruiken om vectorzoekopdrachten te optimaliseren voor specifieke scenario's.

Door deze procedures te volgen en de AI-mogelijkheden van SQL Server 2025 te gebruiken, kunt u toepassingen bouwen, implementeren en gebruiken die echte bedrijfswaarde bieden en tegelijkertijd bedrijfsstandaarden voor beveiliging, prestaties en betrouwbaarheid handhaven.