Construiți aplicații de generare augmentată de recuperare

Finalizat

Retrieval Augmented Generation (RAG) este un model pentru aplicațiile AI care interacționează cu datele. În loc să se bazeze exclusiv pe cunoștințele încorporate în modelele lingvistice mari în timpul antrenamentului, aplicațiile RAG preiau dinamic informații relevante din baza de date și le oferă ca context pentru modelul AI. Această abordare asigură că răspunsurile sunt bazate pe datele curente și precise, în timp ce utilizați capacitățile de raționament ale modelelor lingvistice.

SQL Server 2025 oferă o platformă completă pentru construirea de aplicații RAG, combinând capabilitățile de căutare vectorială, integrarea nativă AI și gestionarea datelor la nivel de întreprindere. Această abordare integrată înseamnă că puteți construi aplicații AI fără a gestiona mai multe baze de date, a sincroniza datele între sisteme sau a compromite securitatea și conformitatea.

RAG abordează limitările modelelor AI statice - date limită de cunoștințe, informații incorecte și lipsa de informații specifice domeniului - prin creșterea răspunsurilor modelului cu recuperarea datelor în timp real. Pentru dezvoltatori, acest lucru înseamnă construirea de aplicații care oferă răspunsuri precise, contextuale și up-to-date, menținând în același timp controlul deplin asupra surselor de date utilizate.

Înțelegeți modelul RAG

Modelul RAG urmează un flux de lucru sistematic care combină operațiunile tradiționale ale bazelor de date cu capabilitățile AI.

Explorați fluxul de lucru RAG

Modelul RAG orchestrează interacțiunea dintre baza de date, modelele AI și utilizatorii aplicației. Înțelegerea acestui flux de lucru este importantă pentru construirea de aplicații bazate pe inteligență artificială care oferă răspunsuri precise și relevante din punct de vedere contextual. Următoarea diagramă din documentația Microsoft Azure OpenAI ilustrează modul în care diferitele componente ale unui sistem RAG funcționează împreună:

Diagrama arată fluxul de lucru RAG în trei faze: Ingest (încărcarea și încorporarea datelor în indexuri care pot fi căutate), Develop (crearea de aplicații cu solicitări și intenții de căutare) și Inference (procesarea solicitărilor utilizatorilor prin generarea de intenții, recuperare, filtrare/reclasificare și generare de răspunsuri).

Acest model se aplică implementărilor SQL Server 2025 RAG, unde datele sunt stocate și căutate în SQL Server înainte de a fi trimise către modele de limbaj pentru generarea de răspunsuri.

O implementare tipică a RAG implică mai mulți pași cheie:

• Ingestia datelor: Stocarea documentelor sau datelor sursă în SQL Server
• Generarea de încorporare: Convertiți textul în încorporari vectoriale folosind modele AI
• Stocare vectorială: Stocați încorporarile alături de datele relaționale
• Procesarea interogărilor: Când un utilizator pune o întrebare, generați o încorporare pentru interogarea sa
• Căutare de similitudine: Găsiți cele mai relevante documente folosind căutarea vectorială
• Asamblare context: Preluați întregul conținut al documentelor relevante
• Construcție promptă: Creați o solicitare care include întrebarea utilizatorului și contextul relevant
• Inferența AI: Trimiteți solicitarea către un model de limbaj (cum ar fi GPT-4) pentru generarea răspunsului
• Livrarea răspunsului: Returnați utilizatorului răspunsul generat de AI

Implementați RAG de bază cu T-SQL

SQL Server 2025 vă permite să construiți aplicații RAG în întregime în baza de date folosind T-SQL.

Pregătiți-vă baza de cunoștințe

Începeți prin a crea un tabel pentru a stoca documentele și încorporarile acestora:

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

Acest tabel stochează atât conținutul original, cât și încorporarea vectorială . Indicele vectorial permite căutări rapide de similitudine atunci când utilizatorii interoghează baza de cunoștințe.

Generați și stocați încorporari

Introduceți documente și generați încorporari într-o singură operațiune:

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

Acest cod inserează un document și generează automat încorporarea acestuia folosind modelul extern definit anterior. Încorporarea este stocată în același rând cu textul sursă, asigurând consecvența datelor.

Executarea căutării semantice

Preluați documentele relevante pe baza interogării unui utilizator:

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

Această interogare găsește documente similare semantic cu întrebarea utilizatorului prin compararea încorporarilor vectoriale. Funcția VECTOR_DISTANCE calculează similitudinea, scorurile mai mici indicând o relevanță mai mare.

Construiți solicitări cu context

Creați o solicitare care include contextul preluat:

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;

Acest cod preia primele trei cele mai relevante documente, le concatenează într-un șir de context și construiește o solicitare completă care instruiește modelul AI să utilizeze contextul furnizat atunci când răspunde la întrebare.

Generați răspunsuri AI

Trimiteți promptul construit la un model de limbaj:

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

Acest lucru completează modelul RAG trimițând solicitarea cu context la GPT-4 și returnând răspunsul generat. Modelul AI folosește contextul preluat pentru a oferi răspunsuri precise, bazate pe date.

Integrare cu LangChain

LangChain este un cadru popular pentru construirea de aplicații cu modele lingvistice mari. SQL Server 2025 oferă suport pentru integrarea LangChain, permițându-vă să utilizați SQL Server ca depozit vectorial în aplicațiile LangChain.

Notă

Integrarea LangChain cu caracteristicile vectoriale SQL Server este în previzualizare. Numele pachetelor, API-urile și detaliile de implementare se pot schimba. Consultați documentația LangChain pentru cele mai recente informații despre suportul pentru depozitele vectoriale SQL Server.

Configurarea LangChain cu SQL Server

Instalați pachetele necesare:

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

Configurați conexiunea la 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"
)

Acest cod Python stabilește o conexiune între LangChain și baza de date SQL Server, permițându-vă să utilizați SQL Server ca depozit vectorial pentru aplicația RAG.

Construiți un lanț RAG cu LangChain

Creați un sistem complet de întrebări și răspunsuri:

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

Acest lucru creează o conductă RAG în care LangChain preia automat documentele relevante din SQL Server, construiește solicitări, apelează modelul lingvistic și returnează răspunsuri, toate cu doar câteva linii de cod.

Integrare cu nucleul semantic

Semantic Kernel este SDK-ul open-source al Microsoft pentru integrarea capabilităților AI în aplicații. SQL Server 2025 oferă suport pentru integrarea kernelului semantic, permițându-vă să utilizați SQL Server ca depozit vectorial în aplicațiile dvs.

Notă

Integrarea kernelului semantic cu caracteristicile vectoriale SQL Server este în previzualizare. Numele pachetelor, API-urile și detaliile de implementare se pot schimba. Consultați documentația kernelului semantic pentru cele mai recente informații despre suportul pentru depozitele vectoriale SQL Server.

Configurați nucleul semantic cu SQL Server

Configurați conexiunea în 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();

Aceasta configurează nucleul semantic să utilizeze SQL Server ca depozit vectorial și Azure OpenAI pentru inferența modelului de limbaj.

Implementați RAG cu nucleul semantic

Creați un plugin alimentat de RAG:

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

Acest plugin caută în depozitul vectorial SQL Server și oferă context relevant modelului de limbaj pentru generarea răspunsurilor.

Integrarea cu Azure AI Search

Azure AI Search oferă capacități avansate de căutare care completează caracteristicile de căutare vectorială ale SQL Server.

Configurarea căutării hibride cu Azure AI Search

Căutarea hibridă combină punctele forte atât ale căutării semantice bazate pe vectori, cât și ale căutării tradiționale în text complet bazate pe cuvinte cheie. Căutarea vectorială excelează în găsirea de conținut similar din punct de vedere conceptual chiar și atunci când cuvintele exacte nu se potrivesc, în timp ce căutarea în text complet surprinde terminologia precisă și frazele specifice domeniului. Această combinație este esențială pentru aplicațiile RAG, deoarece vă asigură că preluați documente care sunt atât relevante din punct de vedere semantic, cât și care conțin termenii specifici pe care utilizatorii îi solicită, ceea ce duce la răspunsuri AI mai precise și mai cuprinzătoare.

Configurați un indexor pentru a sincroniza datele din SQL Server cu Azure AI Search:

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

Configurați indexorul Azure AI Search prin portalul Azure sau API-ul REST pentru a extrage date din SQL Server, permițându-vă să utilizați atât capacitățile tranzacționale ale SQL Server, cât și analiza avansată a textului Azure AI Search.

Combinați căutarea vectorială și textul complet

Implementați o strategie de căutare hibridă:

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;

Această interogare combină similitudinea semantică (căutare vectorială) cu potrivirea cuvintelor cheie (căutare text complet) pentru a oferi rezultate relevante care surprind atât potriviri conceptuale, cât și exacte.

Creați aplicații RAG gata de producție

Trecerea de la prototip la producție necesită considerații suplimentare pentru performanță, fiabilitate și întreținere.

Optimizați generarea de încorporare

Generați încorporari pentru mai multe documente în mod eficient:

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

Această abordare procesează încorporarile în loturi gestionabile, reducând timpii de blocare a tranzacțiilor și permițându-vă să monitorizați progresul pentru colecțiile mari de documente.

Implementați strategii de cache

Întrebările frecvente din cache și răspunsurile acestora:

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;

Stocarea în cache a interogărilor reduce costurile și îmbunătățește timpii de răspuns prin reutilizarea răspunsurilor la întrebări similare.

Manipulați fragmentarea pentru documente mari

Împărțiți documentele mari în bucăți ușor de gestionat:

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

Fragmentarea asigură că contextul preluat se încadrează în limitele tokenului și îmbunătățește relevanța pasajelor recuperate.

Aplicarea celor mai bune practici RAG

Urmați aceste orientări pentru implementarea eficace a OAR:

Categorie	Obicei	Descriere
Proiectați solicitări eficiente	Fiți specific	Instruiți în mod clar modelul să utilizeze doar contextul furnizat
	Adăugați constrângeri	Specificați că modelul ar trebui să admită atunci când informațiile nu sunt în context
	Includeți exemple	Oferiți câteva exemple de fotografii ale formatului de răspuns dorit
	Setați tonul	Definiți persoana asistentului și stilul de comunicare
Reglați parametrii de recuperare	Reglați valoarea k	Experimentați cu recuperarea diferitelor numere de documente (de obicei 3-5)
	Setați praguri de similitudine	Filtrarea documentelor sub un prag de scor de relevanță
	Echilibrați precizia și reamintirea	Găsiți compromisul potrivit pentru cazul dvs.
	Testați cu diverse interogări	Asigurați-vă că recuperarea funcționează pentru diferite tipuri de întrebări
Asigurați calitatea datelor	Curățați documentele sursă	Eliminați zgomotul, problemele de formatare și conținutul irelevant
	Actualizați în mod regulat	Reîmprospătarea încorporarilor atunci când se modifică documentele sursă
	Validați încorporarile	Verificați dacă încorporarea reprezintă cu acuratețe conținutul
	Monitorizați deriva	Urmăriți dacă calitatea recuperării se degradează în timp
Aplicații RAG securizate	Controlați accesul la date	Utilizați securitatea la nivel de rând pentru a restricționa documentele pe care utilizatorii le pot prelua
	Auditați operațiunile AI	Înregistrați toate întrebările și răspunsurile pentru conformitate
	Igienizați intrările	Validați și curățați interogările utilizatorilor pentru a preveni atacurile de injecție
	Protejați cheile API	Utilizați identități gestionate și stocare securizată a acreditărilor

Urmând aceste practici și aplicând capacitățile AI integrate ale SQL Server 2025, puteți crea aplicații RAG gata de producție care oferă experiențe precise, contextuale și sigure bazate pe inteligență artificială.