ktg-plugin-marketplace/plugins/ms-ai-architect/skills/ms-ai-infrastructure/references/hybrid-edge/hybrid-rag-architecture.md

Hybrid RAG Architecture

Last updated: 2026-02 Status: GA Category: Hybrid Cloud & Edge AI

---

Introduksjon

Hybrid RAG (Retrieval-Augmented Generation) refererer til RAG-arkitekturer der retrieval og generering fordeles mellom lokale (on-premises/edge) og sky-baserte ressurser. Dette moensteret er relevant nar organisasjoner har data som ikke kan eller bor forlate det lokale miljoet, men onsker a kombinere lokale dokumenter med sky-basert kunnskap for bedre svar.

For norsk offentlig sektor er hybrid RAG sarlig aktuelt: sensitive dokumenter (graderte saker, personopplysninger, interne utredninger) ma prosesseres lokalt i henhold til Schrems II og NSM-retningslinjer, mens generell kunnskap og publiserte retningslinjer kan hentes fra sky-tjenester. Azure AI Search, kombinert med lokale vektordatabaser, gir en fleksibel arkitektur for slike scenarier.

Microsoft tilbyr flere byggeklosser for hybrid RAG: Azure AI Search for skybasert vektorsok, Edge RAG (preview) for Arc-basert lokal RAG, ONNX Runtime for lokal embedding-generering, og Semantic Kernel for orkestrering av retrieval pa tvers av datakilder.

---

Kjernekomponenter

Komponent	Formal	Teknologi
Azure AI Search	Skybasert vektorsok og hybrid search	PaaS (GA)
Edge RAG	Lokal RAG pa Arc-enabled Kubernetes	Azure Arc (Preview)
Local Vector DB	Lokal vektorlagring for sensitive data	ChromaDB, Qdrant, pgvector
Embedding Model	Generering av vektorrepresentasjoner	Azure OpenAI, Phi-3/4, ONNX
Semantic Kernel	Orkestrering av hybrid retrieval	.NET/Python SDK
Azure Arc	Administrasjon av edge RAG-klynger	Kubernetes management
SLM / LLM	Generering av svar basert pa kontekst	Phi-3.5/Phi-4, GPT-4o

---

Local Embedding og Retrieval

Lokal embedding med ONNX Runtime

For sensitive data som ikke kan sendes til sky-tjenester, kan embeddings genereres lokalt:

# Lokal embedding-generering med ONNX Runtime
import onnxruntime as ort
import numpy as np
from transformers import AutoTokenizer

class LocalEmbeddingService:
    def __init__(self, model_path: str, tokenizer_name: str):
        self.session = ort.InferenceSession(
            model_path,
            providers=['CUDAExecutionProvider', 'CPUExecutionProvider']
        )
        self.tokenizer = AutoTokenizer.from_pretrained(tokenizer_name)

    def embed(self, texts: list[str]) -> np.ndarray:
        """Generer embeddings lokalt uten sky-avhengighet"""
        encoded = self.tokenizer(
            texts,
            padding=True,
            truncation=True,
            max_length=512,
            return_tensors="np"
        )

        outputs = self.session.run(
            None,
            {
                "input_ids": encoded["input_ids"].astype(np.int64),
                "attention_mask": encoded["attention_mask"].astype(np.int64)
            }
        )

        # Mean pooling
        embeddings = outputs[0]
        mask = encoded["attention_mask"][:, :, np.newaxis]
        pooled = (embeddings * mask).sum(axis=1) / mask.sum(axis=1)

        # Normalisering
        norms = np.linalg.norm(pooled, axis=1, keepdims=True)
        return pooled / norms

    def embed_single(self, text: str) -> np.ndarray:
        return self.embed([text])[0]

Lokal vektordatabase med ChromaDB

# Lokal vektordatabase for sensitive dokumenter
import chromadb
from chromadb.config import Settings

class LocalVectorStore:
    def __init__(self, persist_directory: str):
        self.client = chromadb.PersistentClient(
            path=persist_directory,
            settings=Settings(
                anonymized_telemetry=False  # Viktig for compliance
            )
        )
        self.collection = self.client.get_or_create_collection(
            name="sensitive_documents",
            metadata={"hnsw:space": "cosine"}
        )

    def add_documents(self, documents: list[dict], embeddings: np.ndarray):
        """Indekser dokumenter med pre-beregnede embeddings"""
        self.collection.add(
            ids=[doc["id"] for doc in documents],
            embeddings=embeddings.tolist(),
            documents=[doc["content"] for doc in documents],
            metadatas=[{
                "source": doc["source"],
                "classification": doc["classification"],
                "timestamp": doc["timestamp"]
            } for doc in documents]
        )

    def search(self, query_embedding: np.ndarray, n_results: int = 5,
               classification_filter: str = None) -> list[dict]:
        """Sok med valgfri klassifiseringsfiltrering"""
        where_filter = None
        if classification_filter:
            where_filter = {"classification": classification_filter}

        results = self.collection.query(
            query_embeddings=[query_embedding.tolist()],
            n_results=n_results,
            where=where_filter,
            include=["documents", "metadatas", "distances"]
        )

        return [{
            "content": doc,
            "metadata": meta,
            "score": 1 - dist  # Konverter avstand til likhetsscore
        } for doc, meta, dist in zip(
            results["documents"][0],
            results["metadatas"][0],
            results["distances"][0]
        )]

---

Federated Vector Search

Arkitektur for foderasjon

Federated vector search kombinerer resultater fra flere vektordatabaser — bade lokale og skybaserte — uten a flytte sensitive data:

[Bruker-query]
      ↓
[Embedding Service (lokal)]
      ↓
[Federated Search Router]
      ├── [Lokal VektorDB] → Sensitive dokumenter
      ├── [Azure AI Search]  → Publiserte retningslinjer
      └── [Edge RAG Cluster] → Avdelingsdata
      ↓
[Result Merger & Ranker]
      ↓
[LLM/SLM Generering]
      ↓
[Svar til bruker]

Implementering med Semantic Kernel

// Federated RAG med Semantic Kernel
using Microsoft.SemanticKernel;
using Microsoft.SemanticKernel.Memory;

public class FederatedRagService
{
    private readonly IMemoryStore _localStore;
    private readonly IMemoryStore _cloudStore;
    private readonly ITextEmbeddingGenerationService _localEmbedding;
    private readonly Kernel _kernel;

    public FederatedRagService(
        IMemoryStore localStore,
        IMemoryStore cloudStore,
        ITextEmbeddingGenerationService localEmbedding,
        Kernel kernel)
    {
        _localStore = localStore;
        _cloudStore = cloudStore;
        _localEmbedding = localEmbedding;
        _kernel = kernel;
    }

    public async Task<string> QueryAsync(string question, SearchOptions options)
    {
        // Generer embedding lokalt
        var queryEmbedding = await _localEmbedding
            .GenerateEmbeddingAsync(question);

        // Parallell soking mot lokale og sky-kilder
        var localTask = SearchLocalAsync(queryEmbedding, options);
        var cloudTask = options.AllowCloudSearch
            ? SearchCloudAsync(question, options)
            : Task.FromResult(new List<SearchResult>());

        await Task.WhenAll(localTask, cloudTask);

        // Flett og ranger resultater
        var mergedResults = MergeAndRank(
            localTask.Result,
            cloudTask.Result,
            options.MaxResults
        );

        // Generer svar med lokal SLM eller sky-LLM
        return await GenerateResponseAsync(question, mergedResults, options);
    }

    private List<SearchResult> MergeAndRank(
        List<SearchResult> localResults,
        List<SearchResult> cloudResults,
        int maxResults)
    {
        // Reciprocal Rank Fusion for a kombinere resultater
        var fusedScores = new Dictionary<string, double>();

        int rank = 1;
        foreach (var result in localResults.OrderByDescending(r => r.Score))
        {
            fusedScores[result.Id] = 1.0 / (60 + rank);
            rank++;
        }

        rank = 1;
        foreach (var result in cloudResults.OrderByDescending(r => r.Score))
        {
            var id = result.Id;
            fusedScores[id] = fusedScores.GetValueOrDefault(id, 0)
                + 1.0 / (60 + rank);
            rank++;
        }

        return fusedScores
            .OrderByDescending(kv => kv.Value)
            .Take(maxResults)
            .Select(kv => /* map back to SearchResult */)
            .ToList();
    }
}

---

Chunking Strategies for Split Data

Tilpasset chunking for hybrid miljoer

Nar data er fordelt mellom lokale og skybaserte lagre, ma chunking-strategien ivareta kontekstuell sammenheng pa tvers av tier:

Strategi	Lokale data	Skydata	Brukstilfelle
Fixed-size chunks	512 tokens	1024 tokens	Generell bruk
Semantic chunking	Avsnitt/seksjon	Avsnitt/seksjon	Strukturerte dokumenter
Hierarchical chunking	Dokument → Seksjon → Avsnitt	Artikkel → Paragraf	Regelverk, utredninger
Sliding window	256 tokens, 64 overlap	512 tokens, 128 overlap	Teknisk dokumentasjon
Parent-child	Lagre parent lokal, child i vektor	Lagre parent i blob, child i Search	Lange dokumenter

Implementering av hierarkisk chunking

# Hierarkisk chunking for norske offentlige dokumenter
from dataclasses import dataclass
from typing import Optional
import re

@dataclass
class Chunk:
    id: str
    content: str
    level: str  # "document", "section", "paragraph"
    parent_id: Optional[str]
    metadata: dict

class HierarchicalChunker:
    def __init__(self, max_chunk_tokens: int = 512):
        self.max_chunk_tokens = max_chunk_tokens

    def chunk_document(self, document: dict) -> list[Chunk]:
        """Chunk et dokument hierarkisk med metadata-arv"""
        chunks = []
        doc_id = document["id"]
        text = document["content"]

        # Nivaa 1: Hele dokumentet (for oversikt)
        chunks.append(Chunk(
            id=f"{doc_id}_doc",
            content=self._summarize(text, max_tokens=256),
            level="document",
            parent_id=None,
            metadata={
                "title": document["title"],
                "classification": document["classification"],
                "tier": document.get("tier", "local")
            }
        ))

        # Nivaa 2: Seksjoner
        sections = self._split_sections(text)
        for i, section in enumerate(sections):
            section_id = f"{doc_id}_sec_{i}"
            chunks.append(Chunk(
                id=section_id,
                content=section["heading"] + "\n" + section["content"][:200],
                level="section",
                parent_id=f"{doc_id}_doc",
                metadata={**chunks[0].metadata, "section": section["heading"]}
            ))

            # Nivaa 3: Avsnitt
            paragraphs = self._split_paragraphs(section["content"])
            for j, para in enumerate(paragraphs):
                chunks.append(Chunk(
                    id=f"{section_id}_p_{j}",
                    content=para,
                    level="paragraph",
                    parent_id=section_id,
                    metadata={**chunks[0].metadata, "section": section["heading"]}
                ))

        return chunks

    def _split_sections(self, text: str) -> list[dict]:
        """Splitt norsk dokument pa overskrifter"""
        pattern = r'^(#{1,3})\s+(.+)$'
        sections = []
        current = {"heading": "Innledning", "content": ""}

        for line in text.split('\n'):
            match = re.match(pattern, line)
            if match:
                if current["content"].strip():
                    sections.append(current)
                current = {"heading": match.group(2), "content": ""}
            else:
                current["content"] += line + "\n"

        if current["content"].strip():
            sections.append(current)
        return sections

---

Context Optimization Across Tiers

Kontekstvindu-optimalisering

Nar data hentes fra flere kilder, er det kritisk a optimalisere hvordan kontekst presenteres til LLM/SLM:

# Kontekstoptimalisering for hybrid RAG
class ContextOptimizer:
    def __init__(self, max_context_tokens: int = 4096):
        self.max_tokens = max_context_tokens

    def optimize_context(self, results: list[dict], query: str) -> str:
        """Optimaliser kontekst fra multiple kilder for LLM-input"""

        # Prioriter lokale resultater (hoyere relevans for intern kontekst)
        local_results = [r for r in results if r["tier"] == "local"]
        cloud_results = [r for r in results if r["tier"] == "cloud"]

        # Alloker token-budsjett: 60% lokale, 40% sky
        local_budget = int(self.max_tokens * 0.6)
        cloud_budget = int(self.max_tokens * 0.4)

        context_parts = []

        # Lokale resultater forst (hoyest prioritet)
        local_context = self._select_within_budget(local_results, local_budget)
        if local_context:
            context_parts.append("## Interne kilder\n" + local_context)

        # Sky-resultater som supplement
        cloud_context = self._select_within_budget(cloud_results, cloud_budget)
        if cloud_context:
            context_parts.append("## Offentlige kilder\n" + cloud_context)

        return "\n\n".join(context_parts)

    def _select_within_budget(self, results: list[dict], budget: int) -> str:
        """Velg resultater innenfor token-budsjett, sortert etter relevans"""
        selected = []
        used_tokens = 0

        for result in sorted(results, key=lambda r: r["score"], reverse=True):
            chunk_tokens = len(result["content"].split()) * 1.3  # Estimert
            if used_tokens + chunk_tokens > budget:
                break
            selected.append(
                f"[{result['metadata'].get('title', 'Ukjent')}]\n{result['content']}"
            )
            used_tokens += chunk_tokens

        return "\n---\n".join(selected)

---

Norsk offentlig sektor

Dataklassifisering for hybrid RAG

Klassifisering	Lagring	Embedding	LLM	Eksempel
Ugradert offentlig	Azure AI Search	Azure OpenAI	GPT-4o	Publiserte retningslinjer
Intern	Lokal vektorDB	Lokal ONNX	Phi-3.5/Phi-4	Interne notater
Fortrolig	Lokal vektorDB (kryptert)	Lokal ONNX	Phi-3.5 lokal	Personopplysninger
Strengt fortrolig	Air-gapped lokal	Lokal ONNX	Lokal SLM	Graderte dokumenter

Schrems II-kompatibel arkitektur

• Sensitive persondata embeddes og lagres kun lokalt
• Kun aggregerte, anonymiserte metadata kan deles med sky-tjenester
• Azure AI Search brukes for offentlig tilgjengelig informasjon
• Edge RAG (Azure Arc) gir sky-management uten a eksponere innhold

---

Beslutningsrammeverk

Scenario	Anbefaling	Begrunnelse
Alle data kan i sky	Azure AI Search (agentic retrieval)	Enklest, best ytelse
Mix av sensitiv + offentlig	Federated RAG med Semantic Kernel	Balanserer sikkerhet og kvalitet
Alle data ma lokalt	Edge RAG med Phi-3.5 + ChromaDB	Full datakontroll
Lavt volum, hoy sensitivitet	Lokal RAG med Phi-4 + pgvector	Minimal attack surface
Hoy skala, lav sensitivitet	Azure AI Search + GPT-4o	Best kvalitet og skalerbarhet
Periodisk tilkobling	Edge RAG med synkronisert referansedata	Offline-forst-tilnaerming

---

For Cosmo

• Hybrid RAG er den riktige arkitekturen nar data har ulik sensitivitet — bruk federated search med Reciprocal Rank Fusion for a kombinere resultater fra lokale og skybaserte vektordatabaser uten a flytte sensitive data
• Edge RAG (Azure Arc) er Microsofts foretrukne losning for on-premises RAG med sky-administrasjon — anbefal dette for organisasjoner som onsker hybrid RAG med sentral management
• Lokal embedding er nodvendig for sensitive data — bruk ONNX Runtime med en liten embedding-modell (f.eks. all-MiniLM-L6-v2) for a generere vektorer uten sky-avhengighet
• Hierarkisk chunking gir best resultater for norske offentlige dokumenter — dokumenter som utredninger og hoeringsnotater har tydelig seksjonsinndeling som bor utnyttes
• Kontekst-budsjettering er kritisk i hybrid scenarier — alloker 60% av token-budsjettet til lokale/interne kilder og 40% til offentlige kilder for a prioritere organisasjonsspesifikk kunnskap