Skapa tillämpningar för retrieval-förstärkt generering

17 minuter

RAG (Retrieval Augmented Generation) är ett mönster för AI-program som interagerar med data. I stället för att enbart förlita sig på de kunskaper som är inbäddade i stora språkmodeller under träningen hämtar RAG-program dynamiskt relevant information från databasen och ger den som kontext till AI-modellen. Den här metoden säkerställer att svaren baseras på dina aktuella, korrekta data när du använder språkmodellernas resonemangsfunktioner.

SQL Server 2025 är en komplett plattform för att skapa RAG-program, kombinera vektorsökningsfunktioner, inbyggd AI-integrering och datahantering i företagsklass. Den här integrerade metoden innebär att du kan skapa AI-program utan att hantera flera databaser, synkronisera data mellan system eller äventyra säkerhet och efterlevnad.

RAG åtgärdar begränsningarna för statiska AI-modeller – kunskapsavgränsningsdatum, felaktig information och brist på domänspecifik information – genom att utöka modellsvar med datahämtning i realtid. För utvecklare innebär det att skapa program som levererar korrekta, kontextuella och up-to-date-svar samtidigt som fullständig kontroll över de datakällor som används bibehålls.

Förstå RAG-mönstret

RAG-mönstret följer ett systematiskt arbetsflöde som kombinerar traditionella databasåtgärder med AI-funktioner.

Utforska RAG-arbetsflödet

RAG-mönstret samordnar interaktionen mellan din databas, AI-modeller och programanvändare. Att förstå det här arbetsflödet är viktigt för att skapa AI-baserade program som levererar korrekta, kontextuellt relevanta svar. Följande diagram från Microsofts Azure OpenAI-dokumentation visar hur de olika komponenterna i ett RAG-system fungerar tillsammans:

Diagrammet visar rag-arbetsflödet med tre faser: Mata in (ladda upp och bädda in data i sökbara index), Utveckla (skapa program med uppmaningar och sökinsikter) och Slutsatsdragning (bearbeta användarfrågor genom avsiktsgenerering, hämtning, filtrering/omvärdering och svarsgenerering).

Det här mönstret gäller FÖR SQL Server 2025 RAG-implementeringar, där data lagras och söks i SQL Server innan de skickas till språkmodeller för svarsgenerering.

En typisk RAG-implementering omfattar flera viktiga steg:

Datainmatning: Lagra dina källdokument eller data i SQL Server
Inbäddningsgenerering: Konvertera text till vektorbäddningar med hjälp av AI-modeller
Vektorlagring: Lagra inbäddningar tillsammans med dina relationsdata
Frågebearbetning: När en användare ställer en fråga genererar du en inbäddning för deras fråga
Likhetssökning: Hitta de mest relevanta dokumenten med hjälp av vektorsökning
Kontextsammansättning: Hämta det fullständiga innehållet i relevanta dokument
Fråga konstruktion: Skapa en uppmaning som innehåller användarens fråga och relevant kontext
AI-slutsatsdragning: Skicka uppmaningen till en språkmodell (till exempel GPT-4) för generering av svar
Svarsleverans: Returnera det AI-genererade svaret till användaren

Implementera grundläggande RAG med T-SQL

Med SQL Server 2025 kan du skapa RAG-program helt i databasen med hjälp av T-SQL.

Förbereda din kunskapsbas

Börja med att skapa en tabell för att lagra dokument och deras inbäddningar:

CREATE TABLE knowledge_base (
    doc_id INT IDENTITY(1,1) PRIMARY KEY,
    title NVARCHAR(200),
    content NVARCHAR(MAX),
    category NVARCHAR(100),
    created_date DATETIME2 DEFAULT GETDATE(),
    embedding VECTOR(1536)
);

-- Create a vector index for efficient similarity search
CREATE VECTOR INDEX idx_knowledge_embedding ON knowledge_base(embedding);

Den här tabellen lagrar både det ursprungliga innehållet och dess vektorbäddning . Vektorindexet möjliggör snabba likhetssökningar när användare frågar kunskapsbasen.

Generera och lagra inbäddningar

Infoga dokument och generera inbäddningar i en enda åtgärd:

-- Insert a document with embedding generation
DECLARE @content NVARCHAR(MAX) = N'SQL Server 2025 introduces native vector support for AI applications. Developers can store high-dimensional embeddings alongside relational data and perform semantic similarity searches using the VECTOR_DISTANCE function.';

INSERT INTO knowledge_base (title, content, category, embedding)
VALUES (
    N'SQL Server 2025 Vector Support',
    @content,
    N'Product Features',
    AI_GENERATE_EMBEDDINGS(@content USE MODEL Ada2Embeddings)
);

Den här koden infogar ett dokument och genererar automatiskt dess inbäddning med hjälp av den externa modell som definierades tidigare. Inbäddningen lagras på samma rad som källtexten, vilket säkerställer datakonsekvens.

Köra semantisk sökning

Hämta relevanta dokument baserat på en användares fråga:

-- User's question
DECLARE @user_query NVARCHAR(MAX) = N'How do I use vectors in SQL Server?';

-- Generate embedding for the query
DECLARE @query_embedding VECTOR(1536) = AI_GENERATE_EMBEDDINGS(@user_query USE MODEL Ada2Embeddings);

-- Find top 5 most relevant documents
SELECT TOP 5
    doc_id,
    title,
    content,
    category,
    VECTOR_DISTANCE('cosine', @query_embedding, embedding) AS relevance_score
FROM knowledge_base
ORDER BY relevance_score;

Den här frågan hittar dokument som semantiskt liknar användarens fråga genom att jämföra inbäddningar för vektorer. Funktionen VECTOR_DISTANCE beräknar likhet, med lägre poäng som indikerar högre relevans.

Skapa prompter med kontext

Skapa en uppmaning som innehåller hämtad kontext:

DECLARE @user_query NVARCHAR(MAX) = N'How do I use vectors in SQL Server?';
DECLARE @query_embedding VECTOR(1536) = AI_GENERATE_EMBEDDINGS(@user_query USE MODEL Ada2Embeddings);

-- Retrieve relevant context
DECLARE @context NVARCHAR(MAX);

SELECT @context = STRING_AGG(
    CONCAT('Document: ', title, CHAR(10), 'Content: ', content, CHAR(10), CHAR(10)),
    ''
)
FROM (
    SELECT TOP 3
        title,
        content,
        VECTOR_DISTANCE('cosine', @query_embedding, embedding) AS score
    FROM knowledge_base
    ORDER BY score
) AS relevant_docs;

-- Construct the prompt
DECLARE @prompt NVARCHAR(MAX) = CONCAT(
    'You are a helpful assistant. Use the following context to answer the user''s question.',
    CHAR(10), CHAR(10),
    'Context:', CHAR(10),
    @context,
    CHAR(10),
    'Question: ', @user_query,
    CHAR(10),
    'Answer:'
);

SELECT @prompt AS constructed_prompt;

Den här koden hämtar de tre mest relevanta dokumenten, sammanfogar dem till en kontextsträng och skapar en fullständig uppmaning som instruerar AI-modellen att använda den angivna kontexten när frågan besvaras.

Generera AI-svar

Skicka den konstruerade prompten till en språkmodell:

-- Build the chat completion request
DECLARE @chat_request NVARCHAR(MAX) = JSON_OBJECT(
    'messages': JSON_ARRAY(
        JSON_OBJECT('role': 'system', 'content': 'You are a helpful assistant that answers questions based on provided context.'),
        JSON_OBJECT('role': 'user', 'content': @prompt)
    ),
    'max_tokens': 500,
    'temperature': 0.7
);

DECLARE @response NVARCHAR(MAX);

-- Call GPT-4
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 display the answer
SELECT JSON_VALUE(@response, '$.result.choices[0].message.content') AS ai_answer;

Detta slutför RAG-mönstret genom att skicka prompten med kontext till GPT-4 och returnera det genererade svaret. AI-modellen använder den hämtade kontexten för att tillhandahålla korrekta, databaserade svar.

Integrera med LangChain

LangChain är ett populärt ramverk för att skapa program med stora språkmodeller. SQL Server 2025 har stöd för LangChain-integrering, vilket gör att du kan använda SQL Server som ett vektorlager i dina LangChain-program.

Anmärkning

LangChain-integrering med SQL Server-vektorfunktioner finns i förhandsversion. Paketnamn, API:er och implementeringsinformation kan ändras. I LangChain-dokumentationen finns den senaste informationen om stöd för SQL Server-vektorarkiv.

Konfigurera LangChain med SQL Server

Installera de paket som krävs:

# Install LangChain SQL Server connector (preview)
# Package names may vary - check documentation for latest
pip install langchain-sqlserver
pip install langchain-openai

Konfigurera anslutningen till SQL Server:

from langchain_sqlserver import SQLServerVectorStore
from langchain_openai import OpenAIEmbeddings, AzureChatOpenAI
from langchain.chains import RetrievalQA

# Configure Azure OpenAI
embeddings = OpenAIEmbeddings(
    deployment="text-embedding-ada-002",
    model="text-embedding-ada-002",
    azure_endpoint="https://myopenai.openai.azure.com",
    api_key="your-api-key"
)

# Connect to SQL Server vector store
vector_store = SQLServerVectorStore(
    connection_string="Driver={ODBC Driver 18 for SQL Server};Server=myserver;Database=mydb;Trusted_Connection=yes;",
    embedding_function=embeddings,
    table_name="knowledge_base",
    vector_column_name="embedding"
)

Den här Python-koden upprättar en anslutning mellan LangChain och SQL Server-databasen, så att du kan använda SQL Server som vektorlager för DITT RAG-program.

Skapa en RAG-kedja med LangChain

Skapa ett fullständigt system för frågesvar:

# Initialize the language model
llm = AzureChatOpenAI(
    deployment_name="gpt-4",
    azure_endpoint="https://myopenai.openai.azure.com",
    api_key="your-api-key"
)

# Create a retrieval QA chain
qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",
    retriever=vector_store.as_retriever(search_kwargs={"k": 3})
)

# Ask a question
question = "How do I use vectors in SQL Server?"
answer = qa_chain.run(question)
print(answer)

Detta skapar en RAG-pipeline där LangChain automatiskt hämtar relevanta dokument från SQL Server, skapar prompter, anropar språkmodellen och returnerar svar – allt med bara några rader kod.

Integrera med semantisk kernel

Semantisk kernel är Microsofts SDK med öppen källkod för integrering av AI-funktioner i program. SQL Server 2025 har stöd för semantisk kernelintegrering, så att du kan använda SQL Server som vektorarkiv i dina AI-program.

Anmärkning

Semantisk kernelintegrering med SQL Server-vektorfunktioner finns i förhandsversion. Paketnamn, API:er och implementeringsinformation kan ändras. I dokumentationen för semantisk kernel finns den senaste informationen om stöd för SQL Server-vektorarkiv.

Konfigurera semantisk kernel med SQL Server

Konfigurera anslutningen i C#:

using Microsoft.SemanticKernel;
using Microsoft.SemanticKernel.Connectors.SqlServer;
using Microsoft.SemanticKernel.Connectors.OpenAI;

// Build the kernel
var builder = Kernel.CreateBuilder();

// Add Azure OpenAI chat completion
builder.AddAzureOpenAIChatCompletion(
    deploymentName: "gpt-4",
    endpoint: "https://myopenai.openai.azure.com",
    apiKey: "your-api-key"
);

// Add SQL Server vector store (preview - API may change)
builder.AddSqlServerVectorStore(
    connectionString: "Server=myserver;Database=mydb;Trusted_Connection=True;",
    tableName: "knowledge_base",
    vectorColumnName: "embedding"
);

var kernel = builder.Build();

Detta konfigurerar semantisk kernel för att använda SQL Server som vektorarkiv och Azure OpenAI för inferens för språkmodeller.

Implementera RAG med semantisk kernel

Skapa ett RAG-baserat plugin-program:

using Microsoft.SemanticKernel;
using Microsoft.SemanticKernel.Memory;

public class KnowledgeBasePlugin
{
    private readonly ISemanticTextMemory _memory;
    
    public KnowledgeBasePlugin(ISemanticTextMemory memory)
    {
        _memory = memory;
    }
    
    [KernelFunction]
    [Description("Answers questions based on the knowledge base")]
    public async Task<string> AskQuestion(
        [Description("The user's question")] string question)
    {
        // Search for relevant documents
        var results = _memory.SearchAsync("knowledge_base", question, limit: 3);
        
        // Build context from retrieved documents
        var context = new StringBuilder();
        await foreach (var result in results)
        {
            context.AppendLine($"Document: {result.Metadata.Text}");
            context.AppendLine();
        }
        
        // The kernel will automatically use this context with the LLM
        return context.ToString();
    }
}

Det här plugin-programmet söker i SQL Server-vektorarkivet och ger relevant kontext till språkmodellen för att generera svar.

Integrera med Azure AI Search

Azure AI Search innehåller avancerade sökfunktioner som kompletterar SQL Server-vektorsökningsfunktionerna.

Konfigurera hybridsökning med Azure AI Search

Hybridsökning kombinerar fördelarna med både vektorbaserad semantisk sökning och traditionell nyckelordsbaserad fulltextsökning. Vektorsökning utmärker sig för att hitta konceptuellt liknande innehåll även när exakta ord inte matchar, medan fulltextsökning fångar exakt terminologi och domänspecifika fraser. Den här kombinationen är viktig för RAG-program eftersom den säkerställer att du hämtar dokument som både är semantiskt relevanta och innehåller de specifika termer som användarna frågar om, vilket leder till mer exakta och omfattande AI-svar.

Konfigurera en indexerare för att synkronisera data från SQL Server till Azure AI Search:

-- Enable Change Tracking on your table
ALTER DATABASE mydb SET CHANGE_TRACKING = ON;
ALTER TABLE knowledge_base ENABLE CHANGE_TRACKING;

Konfigurera Azure AI Search-indexeraren via Azure-portalen eller REST-API:et för att hämta data från SQL Server, så att du kan använda både SQL Server-transaktionsfunktionerna och Azure AI Searchs avancerade textanalys.

Kombinera vektor- och fulltextsökning

Implementera en hybridsökningsstrategi:

DECLARE @user_query NVARCHAR(MAX) = N'machine learning with SQL Server';
DECLARE @query_embedding VECTOR(1536) = AI_GENERATE_EMBEDDINGS(@user_query USE MODEL Ada2Embeddings);

-- Hybrid search combining vector similarity and full-text search
SELECT 
    kb.doc_id,
    kb.title,
    kb.content,
    VECTOR_DISTANCE('cosine', @query_embedding, kb.embedding) AS vector_score,
    fts.RANK AS text_score,
    -- Combined score (weighted average)
    (VECTOR_DISTANCE('cosine', @query_embedding, kb.embedding) * 0.5) + 
    ((1.0 - fts.RANK/1000.0) * 0.5) AS combined_score
FROM knowledge_base kb
INNER JOIN CONTAINSTABLE(knowledge_base, content, @user_query) fts
    ON kb.doc_id = fts.[KEY]
ORDER BY combined_score;

Den här frågan kombinerar semantisk likhet (vektorsökning) med nyckelordsmatchning (fulltextsökning) för att leverera relevanta resultat som fångar både konceptuella och exakta matchningar.

Skapa produktionsklara RAG-program

Att flytta från prototyp till produktion kräver extra överväganden för prestanda, tillförlitlighet och underhåll.

Optimera inbäddningsgenerering

Generera inbäddningar för flera dokument effektivt:

-- Update embeddings for documents that don't have them yet
-- Note: AI_GENERATE_EMBEDDINGS executes once per row, not as a batch operation
UPDATE knowledge_base
SET embedding = AI_GENERATE_EMBEDDINGS(content USE MODEL Ada2Embeddings)
WHERE embedding IS NULL;

-- For large-scale operations, process in smaller batches to avoid long transactions
DECLARE @batch_size INT = 100;

WHILE EXISTS (SELECT 1 FROM knowledge_base WHERE embedding IS NULL)
BEGIN
    -- Update a limited number of rows at a time
    UPDATE TOP (@batch_size) knowledge_base
    SET embedding = AI_GENERATE_EMBEDDINGS(content USE MODEL Ada2Embeddings)
    WHERE embedding IS NULL;
    
    -- Optional: Add a small delay to avoid overloading the API endpoint
    WAITFOR DELAY '00:00:01';
END;

Den här metoden bearbetar inbäddningar i hanterbara batchar, vilket minskar transaktionslåsningstiderna och gör att du kan övervaka förloppet för stora dokumentsamlingar.

Implementera strategier för cachelagring

Cachelagrar vanliga frågor och svar:

CREATE TABLE query_cache (
    cache_id INT IDENTITY(1,1) PRIMARY KEY,
    query_text NVARCHAR(500),
    query_embedding VECTOR(1536),
    response_text NVARCHAR(MAX),
    created_date DATETIME2 DEFAULT GETDATE(),
    hit_count INT DEFAULT 0,
    INDEX idx_query_embedding (query_embedding)
);

-- Check cache before executing full RAG pipeline
DECLARE @user_query NVARCHAR(MAX) = N'What are vectors?';
DECLARE @query_embedding VECTOR(1536) = AI_GENERATE_EMBEDDINGS(@user_query USE MODEL Ada2Embeddings);
DECLARE @cached_response NVARCHAR(MAX);

-- Look for similar cached queries
SELECT TOP 1 @cached_response = response_text
FROM query_cache
WHERE VECTOR_DISTANCE('cosine', @query_embedding, query_embedding) < 0.05
ORDER BY VECTOR_DISTANCE('cosine', @query_embedding, query_embedding);

IF @cached_response IS NOT NULL
BEGIN
    -- Return cached response
    SELECT @cached_response AS answer;
    
    -- Increment hit count
    UPDATE query_cache
    SET hit_count = hit_count + 1
    WHERE response_text = @cached_response;
END
ELSE
BEGIN
    -- Execute full RAG pipeline
    -- ... (RAG code here)
    
    -- Cache the new response
    INSERT INTO query_cache (query_text, query_embedding, response_text)
    VALUES (@user_query, @query_embedding, @generated_response);
END;

Cachelagring av frågor minskar kostnaderna och förbättrar svarstiderna genom att återanvända svar på liknande frågor.

Hantera segmentering för stora dokument

Dela upp stora dokument i hanterbara segment:

-- Use AI_GENERATE_CHUNKS for text splitting
DECLARE @large_document NVARCHAR(MAX) = N'... very long document content ...';

-- Generate chunks with AI_GENERATE_CHUNKS
-- The function splits text into fixed-size character chunks
INSERT INTO knowledge_base (title, content, embedding)
SELECT 
    CONCAT('Document Chunk ', c.chunk_order),
    c.chunk,
    AI_GENERATE_EMBEDDINGS(c.chunk USE MODEL Ada2Embeddings)
FROM AI_GENERATE_CHUNKS(
    source = @large_document,
    chunk_type = FIXED,
    chunk_size = 512  -- Size in characters (not tokens)
) AS c;

Segmentering säkerställer att hämtad kontext passar inom tokengränser och förbättrar relevansen för hämtade passager.

Tillämpa metodtips för RAG

Följ dessa riktlinjer för effektiva RAG-implementeringar:

Kategori	Practice	Description
Utforma effektiva frågor	Var specifik	Instruera modellen att endast använda den angivna kontexten
	Lägg till begränsningar	Ange att modellen ska erkänna när informationen inte finns i kontexten
	Ta med exempel	Ange några exempel på önskat svarsformat
	Ställ in ton	Definiera assistentens persona- och kommunikationsstil
Justera hämtningsparametrar	Justera k-värde	Experimentera med att hämta olika antal dokument (vanligtvis 3–5)
	Ange tröskelvärden för likhet	Filtrera bort dokument under ett tröskelvärde för relevanspoäng
	Balansera precision och återkallning	Hitta rätt kompromiss för ditt användningsfall
	Testa med olika frågor	Säkerställ att datahämtning fungerar för olika frågetyper.
Säkerställa datakvalitet	Rensa källdokument	Ta bort brus, formateringsproblem och irrelevant innehåll
	Uppdatera regelbundet	Uppdatera inbäddningar när källdokument ändras
	Verifiera inbäddningar	Kontrollera att inbäddningar korrekt representerar innehåll
	Övervaka för drift	Spåra om hämtningskvaliteten försämras med tiden
Säkra RAG-applikationer	Kontrollera dataåtkomst	Använd säkerhet på radnivå för att begränsa vilka dokument som användare kan hämta
	Granska AI-åtgärder	Logga alla frågor och svar för efterlevnad
	Sanera indata	Verifiera och rensa frågekommandon för att förhindra injektionsattacker
	Skydda API-nycklar	Använda hanterade identiteter och säker lagring av autentiseringsuppgifter

Genom att följa dessa metoder och tillämpa SQL Server 2025:s integrerade AI-funktioner kan du skapa produktionsklara RAG-program som levererar korrekta, kontextuella och säkra AI-baserade upplevelser.

Feedback

Var den här sidan till hjälp?