Opracowywanie inteligentnych aplikacji za pomocą struktur sztucznej inteligencji

Tworzenie gotowych do produkcji aplikacji sztucznej inteligencji wymaga więcej niż tylko możliwości sztucznej inteligencji — wymaga podejścia obejmującego przesyłanie strumieniowe danych w czasie rzeczywistym, interfejsy języka naturalnego, narzędzia do produktywności deweloperów i integrację z chmurą. Program SQL Server 2025 udostępnia platformę do tworzenia aplikacji skalowanych z wdrożeń lokalnych do architektur natywnych dla chmury.

To zintegrowane podejście oznacza, że można tworzyć aplikacje sztucznej inteligencji przy użyciu narzędzi i struktur, korzystając z funkcji przedsiębiorstwa na potrzeby zabezpieczeń, wydajności i niezawodności. Niezależnie od tego, czy tworzysz systemy rekomendacji w czasie rzeczywistym, konwersacyjne asystenty sztucznej inteligencji, czy analityczne pulpity nawigacyjne wspierane przez AI, SQL Server 2025 zapewnia niezbędną bazę.

Tworzenie konwersacyjnych interfejsów sztucznej inteligencji

Interfejsy języka naturalnego sprawiają, że dane przedsiębiorstwa są dostępne dla użytkowników bez konieczności znajomości języka SQL ani wiedzy technicznej.

Projektowanie wzorców zapytań konwersacyjnych

Wzorce zapytań konwersacyjnych umożliwiają użytkownikom zadawanie pytań w języku naturalnym i odbieranie odpowiedzi opartych na danych przez tłumaczenie zapytań na język SQL przy użyciu modeli sztucznej inteligencji, takich jak GPT-4.

Implementowanie możliwości języka naturalnego 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;

Ta procedura składowana używa biblioteki GPT-4 do tłumaczenia pytań w języku naturalnym na zapytania SQL, umożliwiając konwersacyjny dostęp do danych.

Implementowanie barier bezpieczeństwa

Zabezpieczenia zapobiegają wykonywaniu nieprawidłowych operacji w języku SQL generowanych przez sztuczną inteligencję, takich jak usuwanie lub modyfikowanie danych, zapewniając dostęp tylko do odczytu do bazy danych.

Dodaj walidację, aby upewnić się, że wygenerowany kod SQL jest bezpieczny:

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;

Ta otoczka dodaje kontrole zabezpieczeń w celu zapobiegania destrukcyjnym operacjom, zapewniając, że użytkownicy mogą wykonywać zapytania tylko o dane, a nie modyfikować.

Tworzenie konwersacji wielozwrotowych

Konwersacje wielozadaniowe umożliwiają użytkownikom prowadzenie naturalnych, kontekstowych dialogów z Twoimi danymi dzięki zachowaniu historii konwersacji, umożliwiając zadawanie pytań uzupełniających bez powtarzania kontekstu.

Poniższy przykład tworzy konwersacyjną sztuczną inteligencję, która utrzymuje kontekst w wielu interakcjach, umożliwiając kolejne pytania i naturalny dialog z danymi:

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;

Zwiększanie produktywności deweloperów za pomocą narzędzi sztucznej inteligencji

Program SQL Server 2025 integruje się z nowoczesnymi narzędziami programistycznymi w celu przyspieszenia tworzenia aplikacji sztucznej inteligencji.

Używanie rozszerzenia MSSQL dla programu Visual Studio Code z rozwiązaniem GitHub Copilot

Rozszerzenie MSSQL dla programu Visual Studio Code obejmuje integrację z rozwiązaniem GitHub Copilot, zapewniając pomoc w zakresie tworzenia baz danych przy użyciu sztucznej inteligencji.

Integracja z narzędziem GitHub Copilot zapewnia pomoc w kodzie dla zadań tworzenia bazy danych:

• Generowanie zapytań: Opisz, czego potrzebujesz w języku naturalnym, pobierz kod T-SQL
• Optymalizacja zapytań: Uzyskiwanie sugestii dotyczących poprawy wydajności zapytań
• Eksploracja schematu: Zadawanie pytań dotyczących schematu bazy danych
• Pomoc dotycząca migracji: Generowanie skryptów na potrzeby zmian schematu i migracji danych
• Wyjaśnienie: Omówienie złożonych zapytań przy użyciu wyjaśnień generowanych przez sztuczną inteligencję

W poniższym przykładzie pokazano, jak narzędzie GitHub Copilot może wygenerować pełną procedurę składowaną z komentarza języka naturalnego:

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

Korzystanie z platformy Entity Framework Core z funkcjami sztucznej inteligencji

Program Entity Framework Core może służyć do tworzenia aplikacji sztucznej inteligencji za pomocą programu SQL Server. Nieprzetworzone zapytania SQL umożliwiają pracę z typem danych VECTOR programu SQL Server i funkcjami sztucznej inteligencji:

Ponieważ program Entity Framework Core nie obsługuje natywnie typu danych VECTOR, w tym przykładzie użyto FromSqlRaw metody do bezpośredniego wykonywania języka T-SQL przy jednoczesnym wykorzystaniu operacji asynchronicznych i mapowania obiektów platformy EF Core. Metoda serializuje zapytanie osadzania w formacie JSON, wykonuje wyszukiwanie podobieństwa wektorów przy użyciu metody VECTOR_DISTANCEi zwraca produkty z podobnymi osadzaniami — idealne dla systemów rekomendacji i wyszukiwania semantycznego.

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

Integracja z usługą Microsoft Fabric

Usługa Microsoft Fabric udostępnia ujednoliconą platformę analizy, która uzupełnia możliwości sztucznej inteligencji programu SQL Server. Program SQL Server 2025 obsługuje dublowanie baz danych w usłudze Microsoft Fabric, umożliwiając niemal w czasie rzeczywistym analizę danych operacyjnych bez złożoności tradycyjnych potoków ETL.

Diagram przedstawiający dublowanie bazy danych programu SQL Server 2025 w usłudze Microsoft Fabric. Po lewej stronie baza danych programu SQL Server 2025 stale replikuje dane do usługi Microsoft Fabric OneLake. Diagram przedstawia architekturę zero-ETL, w której dane operacyjne przepływują do platformy analitycznej.

Konfigurowanie dublowania sieci szkieletowej

Dublowanie Fabric jest konfigurowane za pośrednictwem portalu Microsoft Fabric przy użyciu interfejsu wizualnego. Funkcja dublowania stale replikuje dane do usługi OneLake sieci szkieletowej w formacie Delta Lake, dzięki czemu jest dostępna do analizy bez wpływu na obciążenia operacyjne.

Oto niektóre zalety dublowania sieci szkieletowej:

• Analiza niemal w czasie rzeczywistym: Zmiany danych są replikowane w sposób ciągły z minimalnym opóźnieniem
• architekturaZero-ETL: Nie trzeba tworzyć i obsługiwać złożonych potoków danych
• Otwórz format danych: Dane są przechowywane w formacie usługi Delta Lake w usłudze OneLake w celu zapewnienia szerokiej zgodności z narzędziami
• Analiza gotowa do użycia sztucznej inteligencji: Bezpośrednia integracja z możliwościami sztucznej inteligencji i uczenia maszynowego w usłudze Fabric
• Punkt końcowy analizy SQL: Wykonywanie zapytań dotyczących danych dublowanych przy użyciu znanej składni języka T-SQL
• Brak wpływu operacyjnego: Dublowanie korzysta ze śledzenia zmian bez wpływu na obciążenia produkcyjne

Optymalizowanie wydajności dublowania

Po skonfigurowaniu dublowania można użyć zarządcy zasobów programu SQL Server, aby zarządzać jego wpływem na wydajność obciążeń operacyjnych:

Poniższy przykład kodu tworzy konfigurację Resource Governor, która ogranicza wykorzystanie zasobów procesora i pamięci przez operacje replikacji 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;

W tym przykładzie pula FabricMirrorPool zasobów ogranicza użycie mirroringu do 5–20% CPU i pamięci, uniemożliwiając jego wpływ na obciążenia produkcyjne. Funkcja klasyfikatora identyfikuje sesje dublowania na podstawie nazwy aplikacji i kieruje je do dedykowanej grupy obciążeń, zapewniając spójną alokację zasobów i przewidywalną wydajność zarówno dla obciążeń operacyjnych, jak i analitycznych.

Zarządca zasobów zapewnia, że mirroring Fabric nie wpływa na obciążenia operacyjne.

Optymalizowanie wydajności aplikacji sztucznej inteligencji

Wydajność ma kluczowe znaczenie dla produkcyjnych aplikacji sztucznej inteligencji.

Optymalizowanie zapytań wyszukiwania wektorów

Użyj wskazówek dotyczących zapytań i optymalizacji indeksu:

Optymalizacja wydajności wyszukiwania wektorów ma kluczowe znaczenie dla produkcyjnych aplikacji sztucznej inteligencji, w których czas odpowiedzi ma bezpośredni wpływ na środowisko użytkownika.

W poniższym przykładzie przedstawiono dwie kluczowe techniki optymalizacji: tworzenie filtrowanych indeksów wektorów przeznaczonych dla określonych podzestawów danych (takich jak kategorie produktów) i używanie wskazówek dotyczących zapytań w celu kontrolowania zachowania wykonywania.

Filtrowany indeks idx_electronics_embedding przyspiesza wyszukiwanie w kategorii Elektronika, indeksując tylko odpowiednie wektory, zmniejszając obszar wyszukiwania i zwiększając szybkość zapytań. Wskazówka MAXDOP 4 ogranicza przetwarzanie równoległe do czterech wątków, równoważąc wydajność z użyciem zasobów — co jest niezbędne do zapobiegania wyszukiwaniom wektorowym przejęcia zasobów serwera i wpływania na inne obciążenia.

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

Możesz użyć indeksów i wskazówek dotyczących zapytań, aby zoptymalizować wyszukiwanie wektorów dla określonych scenariuszy.

Stosując te rozwiązania i korzystając z możliwości sztucznej inteligencji programu SQL Server 2025, można tworzyć, wdrażać i obsługiwać aplikacje gotowe do produkcji, które zapewniają rzeczywistą wartość biznesową przy zachowaniu standardów przedsiębiorstwa w zakresie zabezpieczeń, wydajności i niezawodności.