Développer des applications intelligentes avec des frameworks IA

  • 15 minutes

La création d’applications IA prêtes pour la production nécessite plus que des fonctionnalités d’IA, ce qui nécessite une approche qui englobe la diffusion en continu en temps réel des données, les interfaces de langage naturel, les outils de productivité des développeurs et l’intégration cloud. SQL Server 2025 fournit une plateforme pour le développement d’applications qui s’adapte à partir de déploiements locaux vers des architectures natives cloud.

Cette approche intégrée signifie que vous pouvez créer des applications IA à l’aide d’outils et de frameworks tout en utilisant des fonctionnalités d’entreprise pour la sécurité, les performances et la fiabilité. Que vous créez des moteurs de recommandation en temps réel, des assistants d’IA conversationnels ou des tableaux de bord analytiques optimisés par AI Insights, SQL Server 2025 fournit les bases dont vous avez besoin.

Créer des interfaces IA conversationnelles

Les interfaces de langage naturel rendent les données d’entreprise accessibles aux utilisateurs sans avoir besoin de connaissances SQL ou d’expertise technique.

Concevoir des modèles de requête conversationnelle

Les modèles de requête conversationnels permettent aux utilisateurs de poser des questions en langage naturel et de recevoir des réponses pilotées par les données en convertissant leurs requêtes en SQL à l’aide de modèles IA tels que GPT-4.

Implémentez des fonctionnalités de langage naturel dans 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;

Cette procédure stockée utilise GPT-4 pour traduire des questions en langage naturel en requêtes SQL, ce qui permet l’accès conversationnel à vos données.

Implémenter des garde-fous de sécurité

Les garde-fous de sécurité empêchent les requêtes SQL générées par l’IA d’effectuer des opérations incorrectes telles que la suppression ou la modification de données, ce qui garantit uniquement l’accès en lecture seule à votre base de données.

Ajoutez la validation pour vous assurer que SQL généré est sécurisé :

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;

Ce wrapper ajoute des contrôles de sécurité pour empêcher les opérations destructrices, ce qui permet aux utilisateurs d’interroger uniquement les données, et de ne pas les modifier.

Créer des conversations à plusieurs tours

Les conversations multitours permettent aux utilisateurs d’avoir des dialogues naturels et contextuels avec vos données en conservant l’historique des conversations, en activant les questions de suivi sans répéter le contexte.

L’exemple suivant génère une IA conversationnelle qui gère le contexte entre plusieurs interactions, ce qui permet de répondre aux questions de suivi et de dialogue naturel avec vos données :

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;

Améliorer la productivité des développeurs avec des outils IA

SQL Server 2025 s’intègre aux outils de développement modernes pour accélérer le développement d’applications IA.

Utiliser l’extension MSSQL pour Visual Studio Code avec GitHub Copilot

L’extension MSSQL pour Visual Studio Code inclut l’intégration de GitHub Copilot, fournissant une assistance basée sur l’IA pour le développement de bases de données.

Note

L’intégration de GitHub Copilot à l’extension MSSQL est actuellement en préversion. Les fonctionnalités et les caractéristiques peuvent changer. Pour plus d’informations, consultez la documentation sur l’extension MSSQL.

L’intégration de GitHub Copilot fournit une assistance de code pour les tâches de développement de base de données :

  • Génération de requête : Décrire ce que vous voulez en langage naturel, obtenir du code T-SQL
  • Optimisation des requêtes : Obtenir des suggestions pour améliorer les performances des requêtes
  • Exploration du schéma : Poser des questions sur votre schéma de base de données
  • Assistance de migration : Générer des scripts pour les modifications de schéma et les migrations de données
  • Explication: Comprendre les requêtes complexes avec des explications générées par l’IA

L’exemple suivant montre comment GitHub Copilot peut générer une procédure stockée complète à partir d’un commentaire en langage naturel :

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

Utiliser Entity Framework Core avec des fonctionnalités IA

Entity Framework Core peut être utilisé pour créer des applications IA avec SQL Server. Vous pouvez utiliser des requêtes SQL brutes pour utiliser le type de données VECTOR et les fonctions IA de SQL Server :

Étant donné que Entity Framework Core ne prend pas en charge en mode natif le type de données VECTOR, cet exemple utilise FromSqlRaw pour exécuter T-SQL directement tout en bénéficiant des opérations asynchrones et du mappage d’objets d’EF Core. La méthode sérialise une requête d'incorporation au format JSON, exécute une recherche de similarité vectorielle à l’aide de VECTOR_DISTANCE, et retourne des produits avec des embeddings similaires, idéaux pour les systèmes de recommandation et la recherche sémantique.

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

Intégrer à Microsoft Fabric

Microsoft Fabric fournit une plateforme d’analytique unifiée qui complète les fonctionnalités d’IA de SQL Server. SQL Server 2025 prend en charge la mise en miroir de bases de données vers Microsoft Fabric, ce qui permet une analytique quasi en temps réel sur des données opérationnelles sans la complexité des pipelines ETL traditionnels.

Diagramme montrant la mise en miroir de bases de données SQL Server 2025 vers Microsoft Fabric.

Diagramme montrant la mise en miroir de bases de données SQL Server 2025 vers Microsoft Fabric. À gauche, une base de données SQL Server 2025 réplique en continu les données dans Microsoft Fabric OneLake. Le diagramme illustre l’architecture zéro-ETL où les données opérationnelles circulent vers la plateforme d’analytique.

Configurer la mise en miroir de structures

La mise en miroir de structure est configurée via le portail Microsoft Fabric à l’aide d’une interface visuelle. La fonctionnalité de mise en miroir réplique en continu vos données dans la OneLake de Fabric au format Delta Lake, les rendant disponibles pour l'analytique sans impacter vos charges de travail opérationnelles.

Note

Pour obtenir des instructions de configuration pas à pas, consultez Tutoriel : Configurer des bases de données mises en miroir Microsoft Fabric à partir de SQL Server.

Voici quelques-uns des avantages de la mise en miroir Fabric :

  • Analytique en temps quasi réel : Les modifications de données sont répliquées en continu avec une latence minimale
  • architectureZero-ETL : Il n’est pas nécessaire de créer et de gérer des pipelines de données complexes
  • Format de données ouvert : Les données sont stockées au format Delta Lake dans OneLake pour une compatibilité étendue des outils
  • Analytique prête pour l’IA : Intégration directe avec les fonctionnalités d’IA et de Machine Learning de Fabric
  • Point de terminaison analytique SQL : Interroger des données répliquées à l’aide de la syntaxe T-SQL familière
  • Aucun impact opérationnel : La mise en miroir utilise le suivi des modifications sans affecter les charges de travail de production

Optimiser les performances de mise en miroir

Une fois la mise en miroir configurée, vous pouvez utiliser Resource Governor de SQL Server pour gérer son effet de performances sur vos charges de travail opérationnelles :

L’exemple de code suivant crée une configuration Resource Governor qui limite les ressources processeur et mémoire utilisées par les opérations de mise en miroir 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;

Dans l'exemple, le pool de ressources FabricMirrorPool restreint la mise en miroir pour une utilisation de 5 à 20 % du processeur et de la mémoire, empêchant un impact sur les charges de travail de production. Une fonction classifieur identifie les sessions de mise en miroir basées sur le nom de l’application et les route vers le groupe de charge de travail dédié, garantissant ainsi une allocation de ressources cohérente et des performances prévisibles pour les charges de travail opérationnelles et analytiques.

Resource Governor garantit que la mise en miroir Fabric n’affecte pas vos charges de travail opérationnelles.

Optimiser les performances des applications IA

Les performances sont essentielles pour les applications IA de production.

Optimiser les requêtes de recherche vectorielle

Utilisez des indicateurs de requête et l’optimisation d’index :

L’optimisation des performances de recherche vectorielle est essentielle pour les applications IA de production où le temps de réponse affecte directement l’expérience utilisateur.

L’exemple suivant illustre deux techniques d’optimisation clés : la création d’index vectoriels filtrés qui ciblent des sous-ensembles de données spécifiques (comme les catégories de produits) et l’utilisation d’indicateurs de requête pour contrôler le comportement d’exécution.

L’index idx_electronics_embedding filtré accélère les recherches dans la catégorie Electronics en indexant uniquement les vecteurs pertinents, en réduisant l’espace de recherche et en améliorant la vitesse des requêtes. L’indicateur MAXDOP 4 limite le traitement parallèle à quatre threads, en équilibrant les performances avec la consommation des ressources, ce qui est essentiel pour empêcher les recherches vectorielles de monopoliser les ressources du serveur et d’affecter d’autres charges de travail.

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

Vous pouvez utiliser des index et des indicateurs de requête pour optimiser la recherche vectorielle pour des scénarios spécifiques.

En suivant ces pratiques et en utilisant les fonctionnalités d’IA de SQL Server 2025, vous pouvez créer, déployer et exploiter des applications prêtes pour la production qui offrent une valeur métier réelle tout en conservant les normes d’entreprise pour la sécurité, les performances et la fiabilité.