Anwendungen zur abrufunterstützten Generierung erstellen

17 Minuten

Retrieval Augmented Generation (RAG) ist ein Muster für KI-Anwendungen, die mit Daten interagieren. Anstatt sich ausschließlich auf das wissen zu verlassen, das in große Sprachmodelle während der Schulung eingebettet ist, rufen RAG-Anwendungen relevante Informationen dynamisch aus Ihrer Datenbank ab und stellen es als Kontext zum KI-Modell bereit. Dieser Ansatz stellt sicher, dass die Antworten auf Ihren aktuellen, genauen Daten basieren und gleichzeitig die Schlussfolgerungsfähigkeiten von Sprachmodellen nutzen.

SQL Server 2025 bietet eine vollständige Plattform zum Erstellen von RAG-Anwendungen, kombinieren Vektorsuchfunktionen, native KI-Integration und Datenverwaltung auf Unternehmensniveau. Dieser integrierte Ansatz bedeutet, dass Sie KI-Anwendungen erstellen können, ohne mehrere Datenbanken zu verwalten, Daten über Systeme hinweg zu synchronisieren oder die Sicherheit und Compliance zu gefährden.

RAG befasst sich mit den Einschränkungen statischer KI-Modelle – Wissenskürzungsdaten, falsche Informationen und fehlende domänenspezifische Informationen – durch Erweitern von Modellantworten mit Echtzeitdatenabruf. Für Entwickler bedeutet dies, Anwendungen zu erstellen, die genaue, kontextbezogene und aktuelle Antworten liefern, während sie gleichzeitig die vollständige Kontrolle über die verwendeten Datenquellen behalten.

Grundlegendes zum RAG-Muster

Das RAG-Muster folgt einem systematischen Workflow, der herkömmliche Datenbankvorgänge mit KI-Funktionen kombiniert.

Erkunden des RAG-Workflows

Das RAG-Muster koordiniert die Interaktion zwischen Ihren Datenbank-, KI-Modellen und Anwendungsbenutzern. Das Verständnis dieses Workflows ist wichtig für die Erstellung KI-basierter Anwendungen, die genaue, kontextbezogene Antworten liefern. Das folgende Diagramm aus der Azure OpenAI-Dokumentation von Microsoft veranschaulicht, wie die verschiedenen Komponenten eines RAG-Systems zusammenarbeiten:

Das Diagramm zeigt den dreiphasigen RAG-Workflow: Erfassung (Hochladen und Einbetten von Daten in durchsuchbare Indizes), Entwickeln (Erstellen von Anwendungen mit Eingabeaufforderungen und Suchabsichten) und Inference (Verarbeiten von Benutzeraufforderungen durch die Absichtsgenerierung, Abruf, Filtration/Reranking und Reaktionsgenerierung).

Dieses Muster gilt für SQL Server 2025-RAG-Implementierungen, bei denen Daten in SQL Server gespeichert und durchsucht werden, bevor sie an Sprachmodelle für die Antwortgenerierung gesendet werden.

Eine typische RAG-Implementierung umfasst mehrere wichtige Schritte:

Datenaufnahme: Speichern Von Quelldokumenten oder -daten in SQL Server
Einbettungsgenerierung: Konvertieren von Text in Vektoreinbettungen mithilfe von KI-Modellen
Vektorspeicher: Speichern von Einbettungen zusammen mit relationalen Daten
Abfrageverarbeitung: Wenn ein Benutzer eine Frage stellt, generieren Sie eine Einbettung für ihre Abfrage.
Ähnlichkeitssuche: Suchen der relevantesten Dokumente mithilfe der Vektorsuche
Kontextzusammenstellung: Abrufen des vollständigen Inhalts von relevanten Dokumenten
Prompte Konstruktion: Erstellen einer Eingabeaufforderung, die die Frage des Benutzers und den relevanten Kontext enthält
KI-Ableitung: Senden der Eingabeaufforderung an ein Sprachmodell (z. B. GPT-4) für die Antwortgenerierung
Antwortübermittlung: Zurückgeben der vom KI generierten Antwort an den Benutzer

Implementieren grundlegender RAG mit T-SQL

MIT SQL Server 2025 können Sie RAG-Anwendungen vollständig in der Datenbank mit T-SQL erstellen.

Vorbereiten Ihrer Wissensbasis

Erstellen Sie zunächst eine Tabelle zum Speichern von Dokumenten und deren Einbettungen:

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

In dieser Tabelle werden sowohl der Originalinhalt als auch seine Vektoreinbettung gespeichert. Der Vektorindex ermöglicht schnelle Ähnlichkeitssuchen, wenn Benutzer die Wissensbasis abfragen.

Generieren und Speichern von Einbettungen

Einfügen von Dokumenten und Generieren von Einbettungen in einen einzelnen Vorgang:

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

Dieser Code fügt ein Dokument ein und generiert automatisch seine Einbettung mithilfe des zuvor definierten externen Modells. Die Einbettung wird in derselben Zeile wie der Quelltext gespeichert, wodurch die Datenkonsistenz sichergestellt wird.

Semantiksuche ausführen

Abrufen relevanter Dokumente basierend auf der Abfrage eines Benutzers:

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

Diese Abfrage findet Dokumente semantisch ähnlich der Frage des Benutzers, indem Vektoreinbettungen verglichen werden. Die VECTOR_DISTANCE-Funktion berechnet die Ähnlichkeit, wobei niedrigere Punktzahlen eine höhere Relevanz anzeigen.

Erstellen von Eingabeaufforderungen mit Kontext

Erstellen Sie eine Eingabeaufforderung, die abgerufenen Kontext enthält:

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;

Dieser Code ruft die drei wichtigsten Dokumente ab, verkettet sie in einer Kontextzeichenfolge und erstellt eine vollständige Eingabeaufforderung, die das KI-Modell anweist, den bereitgestellten Kontext bei der Beantwortung der Frage zu verwenden.

Generieren von KI-Antworten

Senden Sie die erstellte Eingabeaufforderung an ein Sprachmodell:

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

Dadurch wird das RAG-Muster abgeschlossen, indem die Eingabeaufforderung mit dem Kontext an GPT-4 gesendet und die generierte Antwort zurückgegeben wird. Das KI-Modell verwendet den abgerufenen Kontext, um genaue, datenbasierte Antworten bereitzustellen.

Integrieren in LangChain

LangChain ist ein beliebtes Framework zum Erstellen von Anwendungen mit großen Sprachmodellen. SQL Server 2025 bietet Unterstützung für die LangChain-Integration, sodass Sie SQL Server als Vektorspeicher in Ihren LangChain-Anwendungen verwenden können.

Hinweis

Die LangChain-Integration mit SQL Server-Vektorfeatures befindet sich in der Vorschau. Paketnamen, APIs und Implementierungsdetails können sich ändern. In der LangChain-Dokumentation finden Sie die neuesten Informationen zur UNTERSTÜTZUNG des SQL Server-Vektorspeichers.

Einrichten der LangChain mit SQL Server

Installieren Sie die erforderlichen Pakete:

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

Konfigurieren sie die Verbindung mit 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"
)

Dieser Python-Code stellt eine Verbindung zwischen LangChain und Ihrer SQL Server-Datenbank her, sodass Sie SQL Server als Vektorspeicher für Ihre RAG-Anwendung verwenden können.

Eine RAG-Kette mit LangChain erstellen

Erstellen Sie ein vollständiges Fragebeantwortungssystem:

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

Dadurch wird eine RAG-Pipeline erstellt, in der LangChain relevante Dokumente automatisch aus SQL Server abruft, Eingabeaufforderungen erstellt, das Sprachmodell aufruft und Antworten zurückgibt – alles mit nur wenigen Codezeilen.

Integrieren mit semantischem Kernel

Der semantische Kernel ist das Open-Source-SDK von Microsoft für die Integration von KI-Funktionen in Anwendungen. SQL Server 2025 bietet Unterstützung für die Integration des semantischen Kernels, sodass Sie SQL Server als Vektorspeicher in Ihren KI-Anwendungen verwenden können.

Hinweis

Die Integration von Semantic Kernel mit den Vektorfunktionen von SQL Server befindet sich in der Vorschauphase. Paketnamen, APIs und Implementierungsdetails können sich ändern. In der Dokumentation zum semantischen Kernel finden Sie die neuesten Informationen zur Unterstützung des SQL Server-Vektorspeichers.

Konfigurieren des semantischen Kernels mit SQL Server

Einrichten der Verbindung in 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();

Dadurch wird der semantische Kernel so konfiguriert, dass SQL Server als Vektorspeicher und Azure OpenAI für die Ableitung des Sprachmodells verwendet wird.

Implementieren von RAG mit semantischem Kernel

Erstellen Sie ein RAG-gestütztes Plug-In:

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

Dieses Plug-In durchsucht den SQL Server-Vektorspeicher und stellt den relevanten Kontext für das Sprachmodell zum Generieren von Antworten bereit.

Integrieren Sie Azure AI Search

Azure AI Search bietet erweiterte Suchfunktionen, die die Vektorsuchfunktionen von SQL Server ergänzen.

Konfigurieren der Hybridsuche mit Azure AI Search

Die Hybridsuche kombiniert die Stärken der vektorbasierten semantischen Suche und der herkömmlichen schlüsselwortbasierten Volltextsuche. Die Vektorsuche zeichnet sich durch die Suche nach konzeptuellen ähnlichen Inhalten aus, auch wenn genaue Wörter nicht übereinstimmen, während die Volltextsuche präzise Terminologie und domänenspezifische Ausdrücke erfasst. Diese Kombination ist für RAG-Anwendungen wichtig, da sie sicherstellt, dass Sie Dokumente abrufen, die semantisch relevant sind und die spezifischen Begriffe enthalten, die Benutzer fragen, was zu genaueren und umfassenderen KI-Antworten führt.

Richten Sie einen Indexer zum Synchronisieren von Daten aus SQL Server mit Azure AI Search ein:

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

Konfigurieren Sie den Azure AI Search-Indexer über das Azure-Portal oder die REST-API, um Daten aus SQL Server abzurufen, sodass Sie sowohl die Transaktionsfunktionen von SQL Server als auch die erweiterte Textanalyse von Azure AI Search verwenden können.

Kombinieren von Vektor- und Volltextsuche

Implementieren einer Hybridsuchstrategie:

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;

Diese Abfrage kombiniert semantische Ähnlichkeit (Vektorsuche) mit Stichwortabgleich (Volltextsuche), um relevante Ergebnisse zu liefern, die sowohl konzeptionelle als auch genaue Übereinstimmungen erfassen.

Erstellen von produktionsfähigen RAG-Anwendungen

Der Wechsel von Prototyp zu Produktion erfordert zusätzliche Überlegungen zur Leistung, Zuverlässigkeit und Wartung.

Optimieren der Einbettungsgenerierung

Effizientes Generieren von Einbettungen für mehrere Dokumente:

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

Dieser Ansatz verarbeitet Einbettungen in verwaltbare Batches, wodurch die Transaktionssperrzeiten reduziert werden und es Ihnen ermöglicht, den Fortschritt großer Dokumentsammlungen zu überwachen.

Implementieren von Zwischenspeicherungsstrategien

Zwischenspeichern häufig gestellter Fragen und deren Antworten:

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;

Die Abfragezwischenspeicherung reduziert Kosten und verbessert die Reaktionszeiten, indem Antworten auf ähnliche Fragen erneut verwendet werden.

Behandeln von Blöcken für große Dokumente

Unterteilen Sie große Dokumente in verwaltbare Blöcke:

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

Chunking stellt sicher, dass der abgerufene Kontext innerhalb der Token-Grenzen liegt und die Relevanz der abgerufenen Passagen verbessert.

Anwenden bewährter Praktiken für RAG

Befolgen Sie die folgenden Richtlinien für effektive RAG-Implementierungen:

Kategorie	Praxis	Description
Entwerfen effektiver Eingabeaufforderungen	Seien Sie spezifisch	Weisen Sie das Modell eindeutig an, nur den bereitgestellten Kontext zu verwenden.
	Einschränkungen hinzufügen	Geben Sie an, dass das Modell zugeben soll, wenn Informationen nicht im Kontext enthalten sind.
	Beispiele einschließen	Bereitstellung einiger Beispiele für das gewünschte Antwortformat
	Ton festlegen	Definieren Sie den Persönlichkeits- und Kommunikationsstil des Assistenten
Optimieren von Abrufparametern	K-Wert anpassen	Experimentieren Sie mit dem Abrufen unterschiedlicher Anzahl von Dokumenten (in der Regel 3-5)
	Festlegen von Ähnlichkeitsschwellenwerten	Filtern Sie Dokumente mit einer Relevanzbewertung unterhalb eines Schwellenwertes
	Balance zwischen Präzision und Rückruf	Finden Sie den richtigen Kompromiss für Ihren Anwendungsfall
	Testen mit verschiedenen Abfragen	Sicherstellen, dass der Abruf über verschiedene Fragetypen hinweg funktioniert
Sicherstellen der Datenqualität	Bereinigen von Quelldokumenten	Entfernen von Rauschen, Formatierungsproblemen und irrelevanten Inhalten
	Regelmäßig aktualisieren	Aktualisieren von Einbettungen beim Ändern von Quelldokumenten
	Validierung von Einbettungen	Überprüfen, ob Einbettungen Inhalte korrekt darstellen
	Monitor für Drift	Nachverfolgen, ob die Abrufqualität im Laufe der Zeit beeinträchtigt wird
Sichere RAG-Anwendungen	Steuern des Datenzugriffs	Verwenden Sie die Sicherheit auf Zeilenebene, um zu steuern, welche Dokumente Benutzern gezeigt werden können.
	Überwachen von KI-Vorgängen	Protokollieren aller Abfragen und Antworten für die Compliance
	Sanitierung von Eingaben	Überprüfen und Bereinigen von Benutzerabfragen zum Verhindern von Einfügungsangriffen
	Schützen von API-Schlüsseln	Verwenden von verwalteten Identitäten und sicherer Speicherung von Anmeldeinformationen

Indem Sie diese Methoden ausführen und die integrierten KI-Funktionen von SQL Server 2025 anwenden, können Sie produktionsfähige RAG-Anwendungen erstellen, die genaue, kontextbezogene und sichere KI-basierte Erfahrungen liefern.

Feedback

War diese Seite hilfreich?