Hva er RAG?
Slik gir du AI tilgang til
dine egne dokumenter

# pip install langchain chromadb sentence-transformers anthropic

from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.vectorstores import Chroma
from langchain_community.embeddings import SentenceTransformerEmbeddings
import anthropic, pathlib

# 1. Les inn og del opp dokumenter
tekst = pathlib.Path("rutiner.txt").read_text()
splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=50)
chunks = splitter.create_documents([tekst])

# 2. Embed og lagre lokalt — ingen server nødvendig
embeddings = SentenceTransformerEmbeddings(model_name="all-MiniLM-L6-v2")
db = Chroma.from_documents(chunks, embeddings, persist_directory="./min_rag_db")

# 3. Søk og generer svar
def spor(sporsmaal: str) -> str:
    treff = db.similarity_search(sporsmaal, k=4)
    kontekst = "

".join(t.page_content for t in treff)

    client = anthropic.Anthropic()
    svar = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=1024,
        system="Svar kun basert på dokumentene nedenfor. Si fra om du ikke finner svaret.",
        messages=[{"role": "user", "content": f"Dokumenter:
{kontekst}

Spørsmål: {sporsmaal}"}]
    )
    return svar.content[0].text

print(spor("Hva er prosedyren for å melde inn ferie?"))

-- Installer utvidelsen (én gang per database)
CREATE EXTENSION IF NOT EXISTS vector;

-- Tabell for chunks + embeddings
CREATE TABLE dokumenter (
    id          SERIAL PRIMARY KEY,
    kilde       TEXT,
    dato        DATE,
    tekst       TEXT,
    embedding   vector(384)  -- dimensjon avhenger av embedding-modellen
);

-- Indeks for rask nærhetssøk (IVFFlat eller HNSW)
CREATE INDEX ON dokumenter
    USING hnsw (embedding vector_cosine_ops);

-- Søk: finn de 5 nærmeste naboene til en gitt vektor
SELECT kilde, tekst, embedding <-> '[0.12, 0.34, ...]' AS distanse
FROM dokumenter
ORDER BY distanse
LIMIT 5;

# pip install psycopg2-binary pgvector sentence-transformers anthropic

import psycopg2
from pgvector.psycopg2 import register_vector
from sentence_transformers import SentenceTransformer
import anthropic

model = SentenceTransformer("all-MiniLM-L6-v2")
conn  = psycopg2.connect("postgresql://bruker:passord@localhost/mindb")
register_vector(conn)

# Indekser en chunk
def legg_til(tekst: str, kilde: str):
    vektor = model.encode(tekst).tolist()
    with conn.cursor() as cur:
        cur.execute(
            "INSERT INTO dokumenter (tekst, kilde, embedding) VALUES (%s, %s, %s)",
            (tekst, kilde, vektor)
        )
    conn.commit()

# Søk og svar
def spor(sporsmaal: str) -> str:
    vektor = model.encode(sporsmaal).tolist()
    with conn.cursor() as cur:
        cur.execute(
            "SELECT kilde, tekst FROM dokumenter ORDER BY embedding <-> %s LIMIT 4",
            (vektor,)
        )
        treff = cur.fetchall()

    kontekst = "

".join(f"[{r[0]}]
{r[1]}" for r in treff)
    client = anthropic.Anthropic()
    svar = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=1024,
        system="Svar kun basert på dokumentene nedenfor.",
        messages=[{"role": "user", "content": f"Dokumenter:
{kontekst}

Spørsmål: {sporsmaal}"}]
    )
    return svar.content[0].text

# pip install pypff extract-msg
# Merk: pypff krever libpff kompilert på systemet
# Alternativt: konverter til .msg i Outlook og bruk extract-msg

import pypff, pathlib

def les_mappe(mappe, dybde=0):
    """Rekursivt gå gjennom alle mapper i .pst"""
    for i in range(mappe.number_of_sub_messages):
        melding = mappe.get_sub_message(i)
        yield {
            "emne":   melding.subject or "",
            "fra":    melding.sender_name or "",
            "dato":   str(melding.delivery_time)[:10],
            "tekst":  melding.plain_text_body or "",
        }
    for i in range(mappe.number_of_sub_folders):
        yield from les_mappe(mappe.get_sub_folder(i), dybde+1)

pst = pypff.file()
pst.open("eksport.pst")
rotmappe = pst.get_root_folder()

epost_liste = list(les_mappe(rotmappe))
print(f"Fant {len(epost_liste)} e-poster")

import re

def rens(tekst: str) -> str:
    # Fjern videresend-headers og svar-sitater
    tekst = re.sub(rr"Fra:.*?
", "", tekst)
    tekst = re.sub(rr"Den \d.*?skrev:", "", tekst, flags=re.DOTALL)
    tekst = re.sub(rr"_{3,}.*", "", tekst, flags=re.DOTALL)  # signaturskillelinje
    # Fjern HTML-rester og normaliser whitespace
    tekst = re.sub(rr"<[^>]+>", " ", tekst)
    return re.sub(rr"\s+", " ", tekst).strip()

def bygg_chunks(epost_liste: list) -> list:
    chunks = []
    for e in epost_liste:
        tekst = rens(e["tekst"])
        if len(tekst) < 30:   # Hopp over tomme/trivielle e-poster
            continue

        # Inkluder emnet i teksten — hjelper retrieval
        chunk_tekst = f"Emne: {e['emne']}

{tekst}"

        chunks.append({
            "text": chunk_tekst,
            "metadata": {
                "emne":  e["emne"],
                "fra":   e["fra"],
                "dato":  e["dato"],
            }
        })
    return chunks

chunks = bygg_chunks(epost_liste)
print(f"{len(chunks)} chunks klare for indeksering")

CREATE EXTENSION IF NOT EXISTS vector;

CREATE TABLE epost_chunks (
    id        SERIAL PRIMARY KEY,
    emne      TEXT,
    fra       TEXT,
    dato      DATE,
    tekst     TEXT,
    embedding vector(384)
);

-- HNSW-indeks for rask nærhetssøk
CREATE INDEX ON epost_chunks
    USING hnsw (embedding vector_cosine_ops);

# pip install psycopg2-binary pgvector sentence-transformers anthropic

import psycopg2
from pgvector.psycopg2 import register_vector
from sentence_transformers import SentenceTransformer
import anthropic

model = SentenceTransformer("all-MiniLM-L6-v2")
conn  = psycopg2.connect("postgresql://bruker:passord@localhost/mindb")
register_vector(conn)

# Sett inn alle chunks i én batch
with conn.cursor() as cur:
    for c in chunks:
        vektor = model.encode(c["text"]).tolist()
        cur.execute(
            "INSERT INTO epost_chunks (emne, fra, dato, tekst, embedding)"
            "VALUES (%s, %s, %s, %s, %s)",
            (c["metadata"]["emne"],
             c["metadata"]["fra"],
             c["metadata"]["dato"],
             c["text"],
             vektor)
        )
conn.commit()
print("Indeksering ferdig")

def spor(sporsmaal: str, fra_dato: str = "2024-01-01") -> str:
    vektor = model.encode(sporsmaal).tolist()

    with conn.cursor() as cur:
        cur.execute("""
            SELECT emne, fra, dato, tekst
            FROM   epost_chunks
            WHERE  dato >= %s
            ORDER  BY embedding <-> %s
            LIMIT  5
        """, (fra_dato, vektor))
        treff = cur.fetchall()

    # Bygg kontekst med metadata synlig for modellen
    kontekst = "\n\n".join(
        f"[{r[2]} | Fra: {r[1]}]\nEmne: {r[0]}\n{r[3]}"
        for r in treff
    )

    client = anthropic.Anthropic()
    svar = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=1024,
        system="Svar kun basert på e-postene nedenfor. Referer til dato og avsender.",
        messages=[{
            "role": "user",
            "content": f"E-poster:\n{kontekst}\n\nSpørsmål: {sporsmaal}"
        }]
    )
    return svar.content[0].text

# Eksempel
print(spor("Hva ble besluttet om budsjettet for Q3?"))
print(spor("Har noen rapportert problemer med innlogging?", fra_dato="2023-01-01"))