Vývoj inteligentních aplikací s využitím architektur AI

15 min

Vytváření aplikací AI připravených pro produkční prostředí vyžaduje více než jen funkce umělé inteligence – vyžaduje přístup, který zahrnuje streamování dat v reálném čase, rozhraní přirozeného jazyka, vývojářské nástroje pro produktivitu a integraci do cloudu. SQL Server 2025 poskytuje platformu pro vývoj aplikací, které se škálují z místních nasazení na architektury nativní pro cloud.

Tento integrovaný přístup znamená, že můžete vytvářet aplikace AI pomocí nástrojů a architektur a současně používat podnikové funkce pro zabezpečení, výkon a spolehlivost. Ať už vytváříte moduly pro doporučování v reálném čase, konverzační asistenty AI nebo analytické řídicí panely využívající přehledy AI, SQL Server 2025 vám poskytne základ, který potřebujete.

Vytváření konverzačních rozhraní AI

Rozhraní přirozeného jazyka zpřístupnili podniková data uživatelům bez nutnosti znalostí SQL nebo technických znalostí.

Návrh vzorů konverzačních dotazů

Vzory konverzačních dotazů umožňují uživatelům klást otázky v přirozeném jazyce a přijímat odpovědi řízené daty tím, že přeloží dotazy do SQL pomocí modelů AI, jako je GPT-4.

Implementace funkcí přirozeného jazyka 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;

Tato uložená procedura používá GPT-4 k překladu otázek v přirozeném jazyce do dotazů SQL, což umožňuje konverzační přístup k vašim datům.

Implementace bezpečnostních mantinely

Bezpečnostní mantinely brání dotazům SQL generovaným pomocí umělé inteligence provádět nesprávné operace, jako je odstranění nebo úprava dat, a zajišťují tak přístup k databázi jen pro čtení.

Přidejte ověření, abyste zajistili, že je vygenerovaný SQL bezpečný:

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;

Tato obálka přidává bezpečnostní opatření, aby se zabránilo destruktivním operacím, takže uživatelé mohou pouze vyhledávat data, nikoli je upravovat.

Vytváření konverzací s vícenásobnou interakcí

Vícekrokové konverzace umožňují uživatelům vést přirozené, kontextové dialogy s vašimi daty díky zachování historie konverzací a umožňují kladení následných otázek bez opakování kontextu.

Následující příklad vytvoří konverzační AI, která udržuje kontext napříč několika interakcemi a umožňuje následné otázky a přirozený dialog s vašimi daty:

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;

Zvýšení produktivity vývojářů pomocí nástrojů AI

SQL Server 2025 se integruje s moderními vývojovými nástroji, které urychlují vývoj aplikací umělé inteligence.

Použití rozšíření MSSQL pro Visual Studio Code s GitHub Copilotem

Rozšíření MSSQL pro Visual Studio Code zahrnuje integraci GitHub Copilotu, která poskytuje pomoc s AI při vývoji databází.

Poznámka:

Integrace GitHub Copilotu s rozšířením MSSQL je aktuálně ve verzi Preview. Funkce a vlastnosti se můžou změnit. Nejnovější informace najdete v dokumentaci k rozšíření MSSQL.

Integrace GitHub Copilotu poskytuje pomoc s kódem pro úlohy vývoje databáze:

Generování dotazů: Popište, co chcete v přirozeném jazyce, získejte kód T-SQL.
Optimalizace dotazů: Získání návrhů pro zlepšení výkonu dotazů
Prozkoumávání schématu: Dotazování ke schématu databáze
Pomoc s migrací: Generování skriptů pro změny schématu a migrace dat
Vysvětlení: Vysvětlení složitých dotazů pomocí vysvětlení generovaných AI

Následující příklad ukazuje, jak GitHub Copilot může vygenerovat úplnou uloženou proceduru z komentáře v přirozeném jazyce:

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

Použití Entity Framework Core s funkcemi AI

Entity Framework Core lze použít k vytváření aplikací AI s SQL Serverem. Nezpracované dotazy SQL můžete použít k práci s datovým typem VECTOR a funkcemi AI SQL Serveru:

Vzhledem k tomu, že Entity Framework Core nativně nepodporuje datový typ VECTOR, tento příklad používá FromSqlRaw k přímému spuštění T-SQL a výhody asynchronních operací EF Core a mapování objektů. Metoda serializuje vložení dotazu do formátu JSON, provádí vyhledávání vektorové podobnosti pomocí VECTOR_DISTANCE a vrací produkty s podobnými vloženími – ideální pro systémy doporučení a sémantické vyhledávání.

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

Integrace s Microsoft Fabric

Microsoft Fabric poskytuje jednotnou analytickou platformu, která doplňuje funkce AI SQL Serveru. SQL Server 2025 podporuje zrcadlení databáze do Microsoft Fabric, což umožňuje analýzu provozních dat téměř v reálném čase bez složitosti tradičních kanálů ETL.

Diagram ukazující zrcadlení databáze SQL Server 2025 v Microsoft Fabric. Nalevo databáze SQL Serveru 2025 průběžně replikuje data do Microsoft Fabric OneLake. Diagram znázorňuje architekturu nulového ETL, kde provozní data proudí do analytické platformy.

Konfigurace zrcadlení prostředků infrastruktury

Zrcadlení Fabric se konfiguruje prostřednictvím portálu Microsoft Fabric pomocí vizuálního rozhraní. Funkce zrcadlení průběžně replikuje vaše data do OneLake ve formátu Delta Lake v Fabric a zpřístupňuje je pro analýzy, aniž by to mělo vliv na provozní úlohy.

Poznámka:

Podrobné pokyny ke konfiguraci najdete v tématu Kurz: Konfigurace zrcadlených databází Microsoft Fabric z SQL Serveru.

Mezi výhody zrcadlení v síťové textilii patří:

Analýzy téměř v reálném čase: Změny dat se replikují nepřetržitě s minimální latencí.
architekturaZero-ETL: Není potřeba vytvářet a udržovat složité datové kanály.
Otevřít formát dat: Data se ukládají ve formátu Delta Lake ve oneLake kvůli široké kompatibilitě nástrojů.
Analýzy připravené na AI: Přímá integrace s funkcemi umělé inteligence a strojového učení ve Fabricu
Koncový bod analýzy SQL: Dotazování zrcadlených dat pomocí známé syntaxe T-SQL
Žádný provozní dopad: Zrcadlení využívá sledování změn bez ovlivnění produkčních úloh.

Optimalizace výkonu zrcadlení

Po nakonfigurování zrcadlení můžete pomocí Resource Governor SQL Serveru spravovat vliv na výkon vašich provozních úloh:

Následující příklad kódu vytvoří konfiguraci Řízení prostředků, která omezuje prostředky procesoru a paměti používané operacemi zrcadlení Fabricu.

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

V tomto příkladu fond prostředků FabricMirrorPool omezuje replikování na konkrétní rozmezí 5 až 20 % využití CPU a paměti, aby to neovlivnilo produkční úlohy. Funkce klasifikátoru identifikuje relace zrcadlení na základě názvu aplikace a směruje je do vyhrazené skupiny zátěže, čímž zajišťuje konzistentní přidělování prostředků a předvídatelný výkon jak pro provozní, tak analytické úlohy.

Správce prostředků zajišťuje, že zrcadlení v rámci Fabricu neovlivňuje vaše provozní úlohy.

Optimalizace výkonu aplikace AI

Výkon je kritický pro produkční aplikace AI.

Optimalizace vektorových vyhledávacích dotazů

Použijte nápovědy k dotazům a optimalizaci indexu:

Optimalizace výkonu vektorového vyhledávání je důležitá pro produkční aplikace AI, kde doba odezvy přímo ovlivňuje uživatelské prostředí.

Následující příklad ukazuje dvě klíčové techniky optimalizace: vytvoření filtrovaných vektorových indexů , které cílí na konkrétní podmnožinu dat (jako jsou kategorie produktů) a použití tipů dotazu k řízení chování provádění.

Filtrovaný index idx_electronics_embedding zrychluje vyhledávání v kategorii Electronics indexováním pouze relevantních vektorů, snížením prostoru vyhledávání a zlepšením rychlosti dotazů. Nápověda MAXDOP 4 omezuje paralelní zpracování na čtyři vlákna, což vyvažuje výkon se spotřebou prostředků a je nezbytné k zabránění monopolizaci serverových prostředků vektorovými vyhledáváními a ovlivňování ostatních úloh.

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

Pro konkrétní scénáře můžete použít indexy a rady dotazů, které optimalizují vektorové vyhledávání.

Díky těmto postupům a používání funkcí umělé inteligence SQL Serveru 2025 můžete vytvářet, nasazovat a provozovat aplikace připravené pro produkční prostředí, které poskytují skutečnou obchodní hodnotu a současně udržují podnikové standardy pro zabezpečení, výkon a spolehlivost.

Váš názor

Byla tato stránka užitečná?