Entwickeln intelligenter Anwendungen mit KI-Frameworks

  • 15 Minuten

Das Erstellen produktionsfähiger KI-Anwendungen erfordert mehr als nur KI-Funktionen – es erfordert einen Ansatz, der Echtzeitdatenstreaming, natürliche Sprachschnittstellen, Entwicklerproduktivitätstools und Cloudintegration umfasst. SQL Server 2025 bietet eine Plattform für die Entwicklung von Anwendungen, die von lokalen Bereitstellungen bis hin zu cloudeigenen Architekturen skaliert werden.

Dieser integrierte Ansatz bedeutet, dass Sie KI-Anwendungen mithilfe von Tools und Frameworks erstellen können, während Sie Unternehmensfeatures für Sicherheit, Leistung und Zuverlässigkeit verwenden. Ganz gleich, ob Sie Echtzeit-Empfehlungsmodule, Unterhaltungs-KI-Assistenten oder analytische Dashboards erstellen, die von KI-Insights unterstützt werden, SQL Server 2025 bietet die Grundlage, die Sie benötigen.

Erstellen von dialogorientierten KI-Schnittstellen

Natürliche Sprachschnittstellen machen Unternehmensdaten für Benutzer zugänglich, ohne dass SQL-Kenntnisse oder technisches Fachwissen erforderlich sind.

Entwerfen von Unterhaltungsabfragemustern

Unterhaltungsabfragemuster ermöglichen Es Benutzern, Fragen in natürlicher Sprache zu stellen und datengesteuerte Antworten zu erhalten, indem sie ihre Abfragen mithilfe von KI-Modellen wie GPT-4 in SQL übersetzen.

Implementieren sie natürliche Sprache in SQL-Funktionen (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;

Diese gespeicherte Prozedur verwendet GPT-4 zum Übersetzen natürlicher Sprachfragen in SQL-Abfragen und ermöglicht den Unterhaltungszugriff auf Ihre Daten.

Implementieren von Sicherheitsschutzschienen

Sicherheitsschutzschienen verhindern, dass KI-generierte SQL-Abfragen falsche Vorgänge ausführen, z. B. Das Löschen oder Ändern von Daten, wodurch sichergestellt wird, dass nur schreibgeschützter Zugriff auf Ihre Datenbank gewährleistet ist.

Hinzufügen einer Überprüfung, um sicherzustellen, dass generiertes SQL sicher ist:

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;

Dieser Wrapper fügt Sicherheitsprüfungen hinzu, um destruktive Vorgänge zu verhindern, um sicherzustellen, dass Benutzer nur Daten abfragen und nicht ändern können.

Erstellen von mehrstufigen Dialogen

Konversationen mit Mehrfachdurchläufen ermöglichen es Benutzern, natürliche, kontextbezogene Dialoge mit Ihren Daten zu führen, indem der Gesprächsverlauf beibehalten wird, sodass Anschlussfragen ohne Wiederholung des Kontexts gestellt werden können.

Im folgenden Beispiel wird eine Unterhaltungs-KI erstellt, die den Kontext über mehrere Interaktionen hinweg aufrechterhält, wodurch Nachverfolgungsfragen und natürlicher Dialog mit Ihren Daten ermöglicht werden:

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;

Verbessern der Entwicklerproduktivität mit KI-Tools

SQL Server 2025 ist in moderne Entwicklungstools integriert, um die KI-Anwendungsentwicklung zu beschleunigen.

Verwenden der MSSQL-Erweiterung für Visual Studio Code mit GitHub Copilot

Die MSSQL-Erweiterung für Visual Studio Code umfasst die GitHub Copilot-Integration , die KI-gestützte Unterstützung für die Datenbankentwicklung bereitstellt.

Hinweis

Die GitHub Copilot-Integration mit der MSSQL-Erweiterung befindet sich derzeit in der Vorschauphase. Merkmale und Funktionen können sich ändern. Die neuesten Informationen finden Sie in der MSSQL-Erweiterungsdokumentation.

Die GitHub Copilot-Integration bietet Codeunterstützung für Datenbankentwicklungsaufgaben:

  • Abfragegenerierung: Beschreiben Sie, was Sie in natürlicher Sprache wünschen, rufen Sie T-SQL-Code ab.
  • Abfrageoptimierung: Abrufen von Vorschlägen zur Verbesserung der Abfrageleistung
  • Schemaerkundung: Fragen zu Ihrem Datenbankschema stellen
  • Migrationsunterstützung: Generieren von Skripts für Schemaänderungen und Datenmigrationen
  • Erklärung: Verständnis komplexer Abfragen durch KI-generierte Erklärungen

Im folgenden Beispiel wird veranschaulicht, wie GitHub Copilot eine vollständige gespeicherte Prozedur aus einem Kommentar in natürlicher Sprache generieren kann:

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

Verwenden von Entity Framework Core mit KI-Funktionen

Entity Framework Core kann zum Erstellen von KI-Anwendungen mit SQL Server verwendet werden. Sie können unformatierte SQL-Abfragen verwenden, um mit dem VECTOR-Datentyp und ai-Funktionen von SQL Server zu arbeiten:

Da Entity Framework Core den VECTOR-Datentyp nicht nativ unterstützt, wird in diesem Beispiel T-SQL mithilfe von FromSqlRaw direkt ausgeführt, wobei die asynchronen Vorgänge und die Objektzuordnung von EF Core genutzt werden. Die Methode serialisiert eine Abfrageeinbettung in JSON, führt eine Vektor-Ähnlichkeitssuche mit VECTOR_DISTANCEund gibt Produkte mit ähnlichen Einbettungen zurück – ideal für Empfehlungssysteme und semantische Suche.

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

Integrieren mit Microsoft Fabric

Microsoft Fabric bietet eine einheitliche Analyseplattform, die die KI-Funktionen von SQL Server ergänzt. SQL Server 2025 unterstützt die Datenbankspiegelung in Microsoft Fabric und ermöglicht nahezu Echtzeitanalysen für Betriebsdaten ohne die Komplexität herkömmlicher ETL-Pipelines.

Diagramm, das die SQL Server 2025-Datenbankspiegelung in Microsoft Fabric zeigt.

Diagramm, das die SQL Server 2025-Datenbankspiegelung in Microsoft Fabric zeigt. Auf der linken Seite repliziert eine SQL Server 2025-Datenbank kontinuierlich Daten in Microsoft Fabric OneLake. Das Diagramm veranschaulicht die Zero-ETL-Architektur, in der Betriebsdaten zur Analyseplattform fließen.

Konfigurieren der Fabric-Spiegelung

Fabric Mirroring wird über das Microsoft Fabric-Portal mithilfe einer visuellen Schnittstelle konfiguriert. Das Spiegelungsfeature repliziert Ihre Daten kontinuierlich in das OneLake-Format von Fabric im Delta Lake-Format, sodass sie für Analysen verfügbar ist, ohne dass sich dies auf Ihre betrieblichen Workloads auswirkt.

Hinweis

Schrittweise Anleitungen zur Konfiguration finden Sie im Lernprogramm: Konfigurieren von gespiegelten Microsoft Fabric-Datenbanken aus SQL Server.

Einige der Vorteile der Fabric-Spiegelung sind:

  • Nahezu Echtzeitanalysen: Datenänderungen werden kontinuierlich mit minimaler Latenz repliziert.
  • Zero-ETL Architektur: Es ist nicht erforderlich, komplexe Datenpipelinen zu erstellen und zu verwalten
  • Datenformat öffnen: Daten werden im Delta Lake-Format in OneLake gespeichert, um eine umfassende Toolkompatibilität zu gewährleisten.
  • KI-fähige Analysen: Direkte Integration mit den KI- und Maschinellen Lernfunktionen von Fabric
  • SQL-Analyseendpunkt: Abfragen gespiegelter Daten mit vertrauter T-SQL-Syntax
  • Keine betrieblichen Auswirkungen: Die Spiegelung verwendet die Änderungsnachverfolgung ohne Auswirkungen auf Produktionsworkloads

Optimieren der Spiegelungsleistung

Nachdem die Spiegelung konfiguriert wurde, können Sie den Ressourcengouverneur von SQL Server verwenden, um seine Leistungswirkung auf Ihre betrieblichen Workloads zu verwalten:

Im folgenden Codebeispiel wird eine Ressourcenkontrolle-Konfiguration erstellt, die die CPU- und Arbeitsspeicherressourcen beschränkt, die von Fabric-Spiegelungsvorgängen verwendet werden.

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

Im Beispiel schränkt der Ressourcenpool FabricMirrorPool die Spiegelung auf die Verwendung zwischen 5 und 20% CPU und Arbeitsspeicher ein und verhindert, dass sich dies auf Produktionsworkloads auswirkt. Eine Klassifiziererfunktion identifiziert Spiegelungssitzungen basierend auf dem Anwendungsnamen und leitet sie an die dedizierte Workloadgruppe weiter und stellt eine konsistente Ressourcenzuordnung und eine vorhersagbare Leistung für Betriebs- und Analyseworkloads sicher.

Die Ressourcenkontrolle stellt sicher, dass sich die Fabric-Spiegelung nicht auf Ihre betrieblichen Arbeitslasten auswirkt.

Optimieren der Leistung von KI-Anwendungen

Die Leistung ist für KI-Produktionsanwendungen von entscheidender Bedeutung.

Optimieren von Vektorsuchabfragen

Verwenden Sie Abfragehinweise und Indexoptimierung:

Die Optimierung der Vektorsuchleistung ist für KI-Produktionsanwendungen von entscheidender Bedeutung, bei denen sich die Reaktionszeit direkt auf die Benutzererfahrung auswirkt.

Im folgenden Beispiel werden zwei wichtige Optimierungstechniken veranschaulicht: Das Erstellen gefilterter Vektorindizes , die auf bestimmte Datenuntermengen (z. B. Produktkategorien) abzielen, und die Verwendung von Abfragehinweisen zum Steuern des Ausführungsverhaltens.

Der gefilterte Index idx_electronics_embedding beschleunigt Suchvorgänge innerhalb der Kategorie "Elektronik", indem nur relevante Vektoren indiziert werden, der Suchraum reduziert und die Abfragegeschwindigkeit verbessert wird. Der MAXDOP 4 Hinweis schränkt die parallele Verarbeitung auf vier Threads ein, wobei die Leistung mit dem Ressourcenverbrauch ausgeglichen wird. Dies ist unerlässlich, um Vektorsuchen daran zu hindern, Serverressourcen zu monopolisieren und andere Workloads zu beeinträchtigen.

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

Sie können Indizes und Abfragehinweise verwenden, um die Vektorsuche für bestimmte Szenarien zu optimieren.

Indem Sie diese Methoden befolgen und die KI-Funktionen von SQL Server 2025 verwenden, können Sie produktionsfähige Anwendungen erstellen, bereitstellen und betreiben, die einen echten Geschäftswert bieten und gleichzeitig Die Sicherheit, Leistung und Zuverlässigkeit des Unternehmens gewährleisten.