Desarrollo de aplicaciones inteligentes con marcos de inteligencia artificial

  • 15 minutos

La creación de aplicaciones de inteligencia artificial preparadas para producción requiere más que solo funcionalidades de inteligencia artificial, sino que requiere un enfoque que abarque el streaming de datos en tiempo real, las interfaces de lenguaje natural, las herramientas de productividad para desarrolladores y la integración en la nube. SQL Server 2025 proporciona una plataforma para desarrollar aplicaciones que se escalan desde implementaciones locales a arquitecturas nativas de nube.

Este enfoque integrado significa que puede crear aplicaciones de inteligencia artificial mediante herramientas y marcos mientras usa características empresariales para la seguridad, el rendimiento y la confiabilidad. Tanto si va a crear motores de recomendaciones en tiempo real, asistentes de inteligencia artificial conversacionales como paneles analíticos con tecnología de AI Insights, SQL Server 2025 proporciona la base necesaria.

Desarrollo de interfaces de Inteligencia Artificial Conversacional

Las interfaces de lenguaje natural hacen que los datos empresariales sean accesibles para los usuarios sin necesidad de conocimientos técnicos o conocimientos técnicos de SQL.

Diseñar patrones de consulta conversacionales

Los patrones de consulta conversacional permiten a los usuarios formular preguntas en lenguaje natural y recibir respuestas controladas por datos mediante la traducción de sus consultas a SQL mediante modelos de IA como GPT-4.

Implemente funcionalidades de lenguaje natural en 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;

Este procedimiento almacenado usa GPT-4 para traducir preguntas de lenguaje natural en consultas SQL, lo que permite el acceso conversacional a los datos.

Implementación de barreras de seguridad

Las barreras de seguridad impiden que las consultas SQL generadas por IA realicen operaciones incorrectas, como eliminar o modificar datos, lo que garantiza el acceso de solo lectura a la base de datos.

Agregue la validación para asegurarse de que SQL generado es seguro:

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;

Este contenedor agrega comprobaciones de seguridad para evitar operaciones destructivas, garantizando que los usuarios podrán consultar los datos, pero no modificarlos.

Crear conversaciones multi turno

Las conversaciones multi turno permiten a los usuarios tener diálogos contextuales naturales con los datos manteniendo el historial de conversaciones, lo que permite realizar preguntas de seguimiento sin repetir el contexto.

En el ejemplo siguiente se crea una inteligencia artificial conversacional que mantiene el contexto en varias interacciones, lo que permite preguntas de seguimiento y diálogo natural con los datos:

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;

Mejora de la productividad del desarrollador con herramientas de inteligencia artificial

SQL Server 2025 se integra con herramientas de desarrollo modernas para acelerar el desarrollo de aplicaciones de IA.

Uso de la extensión MSSQL para Visual Studio Code con GitHub Copilot

La extensión MSSQL para Visual Studio Code incluye la integración de GitHub Copilot , lo que proporciona asistencia con tecnología de inteligencia artificial para el desarrollo de bases de datos.

Nota:

La integración de GitHub Copilot con la extensión MSSQL se encuentra actualmente en versión preliminar. Las características y la funcionalidad pueden cambiar. Para obtener la información más reciente, consulte la documentación de la extensión MSSQL.

La integración de GitHub Copilot proporciona ayuda de código para las tareas de desarrollo de bases de datos:

  • Generación de consultas: Describir lo que desea en lenguaje natural, obtener código T-SQL
  • Optimización de consultas: Obtención de sugerencias para mejorar el rendimiento de las consultas
  • Exploración de esquemas: Formular preguntas sobre el esquema de la base de datos
  • Asistencia para la migración: Generación de scripts para cambios de esquema y migraciones de datos
  • Explicación: Descripción de consultas complejas con explicaciones generadas por IA

En el ejemplo siguiente se muestra cómo GitHub Copilot puede generar un procedimiento almacenado completo a partir de un comentario de lenguaje natural:

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

Uso de Entity Framework Core con funcionalidades de IA

Entity Framework Core se puede usar para compilar aplicaciones de inteligencia artificial con SQL Server. Puede usar consultas SQL sin procesar para trabajar con el tipo de datos VECTOR de SQL Server y las funciones de IA:

Dado que Entity Framework Core no admite de forma nativa el tipo de datos VECTOR, en este ejemplo se usa FromSqlRaw para ejecutar T-SQL directamente mientras se beneficia de las operaciones asincrónicas y la asignación de objetos de EF Core. El método serializa una inserción de consultas en JSON, ejecuta una búsqueda de similitud vectorial mediante VECTOR_DISTANCEy devuelve productos con inserciones similares, ideales para sistemas de recomendaciones y búsqueda semántica.

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

Integración con Microsoft Fabric

Microsoft Fabric proporciona una plataforma de análisis unificada que complementa las funcionalidades de inteligencia artificial de SQL Server. SQL Server 2025 admite la creación de reflejo de la base de datos en Microsoft Fabric, lo que permite el análisis casi en tiempo real de los datos operativos sin la complejidad de las canalizaciones ETL tradicionales.

Diagrama que muestra la creación de reflejo de la base de datos de SQL Server 2025 en Microsoft Fabric.

Diagrama que muestra el reflejo de la base de datos de SQL Server 2025 en Microsoft Fabric. A la izquierda, una base de datos de SQL Server 2025 replica continuamente los datos en Microsoft Fabric OneLake. En el diagrama se muestra la arquitectura de cero ETL donde fluyen los datos operativos a la plataforma de análisis.

Configuración de la creación de reflejo del tejido

La función de Fabric Mirroring se configura a través del portal de Microsoft Fabric mediante una interfaz visual. La función de reflejo replica continuamente sus datos a OneLake de Fabric en formato Delta Lake, haciéndolos disponibles para análisis sin afectar a sus cargas de trabajo operativas.

Nota:

Para obtener instrucciones de configuración paso a paso, consulte Tutorial: Configuración de bases de datos reflejadas de Microsoft Fabric desde SQL Server.

Algunos de los beneficios del mirroring de Fabric son:

  • Análisis casi en tiempo real: Los cambios de datos se replican continuamente con una latencia mínima
  • Arquitectura Zero-ETL: No es necesario construir y mantener canalizaciones de datos complejas
  • Formato de datos abiertos: Los datos se almacenan en formato Delta Lake en OneLake para lograr una amplia compatibilidad con herramientas
  • Análisis listos para la inteligencia artificial: Integración directa con las funcionalidades de inteligencia artificial y aprendizaje automático de Fabric
  • Punto de conexión de SQL Analytics: consulta de datos reflejados mediante la sintaxis de T-SQL conocida
  • Sin impacto operativo: El reflejo de datos utiliza el seguimiento de cambios sin impactar las cargas de trabajo de producción

Optimizar el rendimiento del espejado

Una vez configurada la creación de reflejo, puede usar el regulador de recursos de SQL Server para administrar su efecto de rendimiento en las cargas de trabajo operativas:

En el ejemplo de código siguiente se crea una configuración de Resource Governor que limita los recursos de CPU y memoria utilizados por las operaciones de creación de reflejo de 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;

En el ejemplo, el grupo de recursos FabricMirrorPool restringe el espejado para utilizar entre el 5 y el 20% de CPU y memoria, evitando que impacte las cargas de trabajo de producción. Una función clasificadora identifica las sesiones de creación de reflejo basadas en el nombre de la aplicación y las enruta al grupo de cargas de trabajo dedicado, lo que garantiza una asignación de recursos coherente y un rendimiento predecible para cargas de trabajo operativas y de análisis.

El regulador de recursos garantiza que la creación de reflejo de Fabric no afecte a las cargas de trabajo operativas.

Optimización del rendimiento de las aplicaciones de IA

El rendimiento es fundamental para las aplicaciones de inteligencia artificial de producción.

Optimización de consultas de búsqueda vectorial

Use sugerencias de consulta y optimización de índices:

La optimización del rendimiento de la búsqueda vectorial es fundamental para las aplicaciones de inteligencia artificial de producción en las que el tiempo de respuesta afecta directamente a la experiencia del usuario.

En el ejemplo siguiente se muestran dos técnicas de optimización clave: crear índices vectoriales filtrados que tienen como destino subconjuntos de datos específicos (como categorías de producto) y usar sugerencias de consulta para controlar el comportamiento de ejecución.

El índice idx_electronics_embedding filtrado acelera las búsquedas dentro de la categoría Electrónica mediante la indexación de solo vectores relevantes, lo que reduce el espacio de búsqueda y mejora la velocidad de las consultas. La sugerencia limita el MAXDOP 4 procesamiento paralelo a cuatro subprocesos, lo que equilibra el rendimiento con el consumo de recursos, esencial para evitar que las búsquedas vectoriales sobresalcen los recursos del servidor y afecten a otras cargas de trabajo.

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

Puede usar índices y sugerencias de consulta para optimizar la búsqueda de vectores para escenarios específicos.

Al seguir estos procedimientos y usar las funcionalidades de inteligencia artificial de SQL Server 2025, puede crear, implementar y operar aplicaciones listas para producción que ofrecen valor empresarial real y mantienen estándares empresariales para la seguridad, el rendimiento y la confiabilidad.