M09: RAG — Retrieval-Augmented Generation

# pip install openai
from openai import OpenAI
import json, re

client = OpenAI(base_url="http://localhost:11434/v1", api_key="ollama")

# Tool the model MUST use: answer split into claims, each citing one chunk
cite_tool = {
    "type": "function",
    "function": {
        "name": "answer_with_citations",
        "description": "Answer as a list of claims. Every claim cites the chunk it came from and quotes the exact supporting text.",
        "parameters": {
            "type": "object",
            "properties": {
                "claims": {
                    "type": "array",
                    "items": {
                        "type": "object",
                        "properties": {
                            "text":     {"type": "string", "description": "One sentence of the answer"},
                            "chunk_id": {"type": "string", "description": "ID of the supporting chunk, e.g. 'C2'"},
                            "quote":    {"type": "string", "description": "Verbatim span from that chunk"},
                        },
                        "required": ["text", "chunk_id", "quote"],
                    },
                }
            },
            "required": ["claims"],
        },
    },
}

def _norm(s: str) -> str:
    return re.sub(r"\s+", " ", s).strip().lower()

def answer_with_citations(question: str, chunks: list[dict]) -> list[dict]:
    """chunks: [{"id": "C1", "text": "..."}, ...] from your retriever."""
    context = "\n\n".join(f"[{c['id']}] {c['text']}" for c in chunks)
    by_id = {c["id"]: c["text"] for c in chunks}

    resp = client.chat.completions.create(
        model="mistral",
        tools=[cite_tool],
        tool_choice={"type": "function", "function": {"name": "answer_with_citations"}},
        messages=[
            {"role": "system", "content": "Answer ONLY from the chunks. Cite a chunk id and an exact quote for every claim."},
            {"role": "user", "content": f"Chunks:\n{context}\n\nQuestion: {question}"},
        ],
    )

    args = json.loads(resp.choices[0].message.tool_calls[0].function.arguments)
    claims = args["claims"]

    # VERIFY — the citation only counts once code confirms it
    for claim in claims:
        chunk_text = by_id.get(claim["chunk_id"], "")
        claim["verified"] = bool(chunk_text) and _norm(claim["quote"]) in _norm(chunk_text)
    return claims

# Demo
chunks = [
    {"id": "C1", "text": "UCC-1 filing 2024-001 names Acme Capital as the secured party."},
    {"id": "C2", "text": "The collateral is all inventory and accounts receivable of the debtor."},
]
for c in answer_with_citations("Who is the secured party and what is the collateral?", chunks):
    mark = "✓" if c["verified"] else "⚠ UNVERIFIED"
    print(f'{mark} {c["text"]}  [{c["chunk_id"]}: "{c["quote"]}"]')

# pip install pdfplumber
import pdfplumber

def pdf_to_text(path: str) -> str:
    """Extract prose AND tables from a digital (non-scanned) PDF."""
    parts = []
    with pdfplumber.open(path) as pdf:
        for page in pdf.pages:
            parts.append(page.extract_text() or "")
            for table in page.extract_tables():
                rows = ["\t".join((cell or "") for cell in row) for row in table]
                parts.append("\n".join(rows))
    return "\n\n".join(p for p in parts if p.strip())

# Feed the result straight into the chunk -> embed -> store pipeline you built earlier:
text = pdf_to_text("ucc_filing.pdf")
# chunks = chunk_text(text); add_to_chroma(chunks)   # same functions as before

# pip install pytesseract pdf2image pillow   (+ the Tesseract binary)
import pytesseract
from PIL import Image
from pdf2image import convert_from_path

# A single scanned image:
text = pytesseract.image_to_string(Image.open("scanned_form.png"))

# A scanned PDF: rasterize each page, then OCR it
def scanned_pdf_to_text(path: str, dpi: int = 300) -> str:
    pages = convert_from_path(path, dpi=dpi)
    return "\n\n".join(pytesseract.image_to_string(page) for page in pages)

text = scanned_pdf_to_text("scanned_contract.pdf")
# -> same chunk/embed/RAG path as Track 1

# ollama pull llava
import base64
from openai import OpenAI

client = OpenAI(base_url="http://localhost:11434/v1", api_key="ollama")

with open("latency_chart.png", "rb") as f:
    img_b64 = base64.b64encode(f.read()).decode()

resp = client.chat.completions.create(
    model="llava",  # any multimodal model you've pulled into Ollama
    messages=[{
        "role": "user",
        "content": [
            {"type": "text", "text": "Read the latency chart and report the p95 value for the last 24h."},
            {"type": "image_url",
             "image_url": {"url": f"data:image/png;base64,{img_b64}"}},
        ],
    }],
)
description = resp.choices[0].message.content
print(description)
# Treat `description` as text: chunk + embed it into your RAG store like any document.

# pip install chromadb>=0.4.0 openai
import os
import glob

def load_documents(docs_dir: str) -> list[dict]:
    """Load all .md and .txt files from a directory."""
    docs = []
    for pattern in ["*.md", "*.txt"]:
        for path in glob.glob(os.path.join(docs_dir, pattern)):
            try:
                with open(path, "r", encoding="utf-8") as f:
                    docs.append({
                        "content": f.read(),
                        "source": os.path.basename(path),
                    })
            except (IOError, UnicodeDecodeError) as e:
                print(f"Skipping {path}: {e}")
    if not docs:
        raise FileNotFoundError(f"No documents found in {docs_dir}")
    return docs

def chunk_text(
    text: str, chunk_size: int = 500, overlap: int = 50
) -> list[str]:
    """Recursive character splitter with overlap."""
    if len(text) <= chunk_size:
        return [text]
    chunks = []
    start = 0
    while start < len(text):
        end = start + chunk_size
        chunk = text[start:end]
        # Try to break at a paragraph or sentence boundary
        if end < len(text):
            for sep in ["\n\n", "\n", ". ", " "]:
                last_sep = chunk.rfind(sep)
                if last_sep > chunk_size * 0.5:
                    end = start + last_sep + len(sep)
                    chunk = text[start:end]
                    break
        chunks.append(chunk.strip())
        start = end - overlap  # overlap for continuity
    return [c for c in chunks if c]

# Usage
docs = load_documents("./docs")
all_chunks = []
for doc in docs:
    chunks = chunk_text(doc["content"], chunk_size=500, overlap=50)
    for i, chunk in enumerate(chunks):
        all_chunks.append({
            "text": chunk,
            "source": doc["source"],
            "chunk_index": i,
        })
print(f"Loaded {len(docs)} docs, {len(all_chunks)} chunks")

import chromadb

# ChromaDB uses its own built-in embedding model by default
client = chromadb.Client()  # in-memory; use PersistentClient for disk
collection = client.get_or_create_collection(
    name="my_docs",
    metadata={"hnsw:space": "cosine"},  # use cosine similarity
)

# Add chunks with metadata
try:
    collection.add(
        ids=[f"chunk_{i}" for i in range(len(all_chunks))],
        documents=[c["text"] for c in all_chunks],
        metadatas=[{"source": c["source"], "index": c["chunk_index"]}
                   for c in all_chunks],
    )
    print(f"Stored {collection.count()} chunks in ChromaDB")
except Exception as e:
    print(f"Error storing chunks: {e}")
    raise

from openai import OpenAI

claude = OpenAI(base_url="http://localhost:11434/v1", api_key="ollama")

def query_rag(question: str, top_k: int = 3) -> str:
    """Retrieve relevant chunks and generate an answer with citations."""
    # Step 1: Retrieve
    try:
        results = collection.query(
            query_texts=[question],
            n_results=top_k,
        )
    except Exception as e:
        return f"Retrieval error: {e}"

    if not results["documents"] or not results["documents"][0]:
        return "No relevant documents found. I don't have enough information."

    # Check relevance threshold
    distances = results["distances"][0] if results.get("distances") else []
    chunks = results["documents"][0]
    sources = results["metadatas"][0]

    # Build context from retrieved chunks
    context_parts = []
    for i, (chunk, meta) in enumerate(zip(chunks, sources)):
        context_parts.append(
            f"[Source {i+1}: {meta['source']}]\n{chunk}"
        )
    context = "\n\n---\n\n".join(context_parts)

    # Step 2: Generate with the model
    try:
        response = claude.chat.completions.create(
            model="mistral",
            messages=[{
                "role": "user",
                "content": (
                    f"Context:\n{context}\n\n"
                    f"Question: {question}\n\n"
                    "Answer based on the context above, citing sources:"
                ),
            }],
        )
        return response.choices[0].message.content
    except openai.OpenAIError as e:
        return f"Generation error: {e}"

# Test it
answer = query_rag("What are the key features of the product?")
print(answer)

mkdir rag-lab && cd rag-lab
python -m venv venv && source venv/bin/activate   # Windows: venv\Scripts\activate
pip install openai "chromadb>=0.4.0"
# No API key needed — Ollama runs locally
# ollama serve          ← start Ollama daemon
# ollama pull mistral   ← download model if needed

# UCC Filing Guide

## Initial Filing (UCC-1)
A UCC-1 financing statement must be filed in the state where the debtor is located. For individuals, this is their principal residence. For registered organizations (corporations, LLCs), this is the state of organization.

The filing office assigns a unique file number and timestamps the filing. A properly filed UCC-1 is effective for 5 years from the date of filing.

## Continuation Statements
To maintain perfection beyond 5 years, a continuation statement (UCC-3) must be filed within 6 months before the 5-year lapse date. Missing this window means the filing lapses and the secured party loses priority.

## Amendments
Amendments can change the collateral description, add or remove debtors, or assign the financing statement to a new secured party. Each amendment receives its own file number but references the original UCC-1.

# Risk Assessment Criteria

## High Risk Indicators
- Debtor has multiple UCC filings from different secured parties (competing liens)
- Collateral description uses broad terms like "all assets" (blanket lien)
- Filing is within 90 days of a bankruptcy petition (preference risk)
- Debtor name on filing doesn't exactly match legal name (perfection defect)

## Medium Risk Indicators
- Continuation statement filed close to the deadline (less than 30 days before lapse)
- Collateral type is inventory or accounts receivable (high turnover)
- Secured party is an individual rather than an institution

## Low Risk Indicators
- Single secured party with specific collateral description
- Filing has been continued at least once (established relationship)
- Debtor is a well-established registered organization

Q: What happens if a continuation statement is filed late?
A: If filed after the 5-year lapse date, the original filing is no longer effective. The secured party must file a new UCC-1, and their priority date resets to the new filing date. Any liens filed by other parties in the gap period will have priority.

Q: Can a UCC filing be terminated?
A: Yes. The secured party can file a UCC-3 termination statement. Once filed, the financing statement is no longer effective. The debtor can also demand termination if the obligation has been satisfied.

Q: What is the difference between a UCC-1 and a UCC-3?
A: A UCC-1 is the initial financing statement that creates the public record. A UCC-3 is used for all subsequent changes: continuations, amendments, assignments, and terminations. The UCC-3 always references the original UCC-1 file number.

import os
import glob
import json
from openai import OpenAI
import chromadb

# ── Document Loading ─────────────────────────────────────────
def load_documents(docs_dir: str) -> list[dict]:
    """Load all .md and .txt files from a directory."""
    docs = []
    for pattern in ["*.md", "*.txt"]:
        for path in glob.glob(os.path.join(docs_dir, pattern)):
            try:
                with open(path, "r", encoding="utf-8") as f:
                    docs.append({"content": f.read(), "source": os.path.basename(path)})
            except (IOError, UnicodeDecodeError) as e:
                print(f"  Skipping {path}: {e}")
    if not docs:
        raise FileNotFoundError(f"No documents found in {docs_dir}")
    return docs

# ── Chunking ─────────────────────────────────────────────────
def chunk_text(text: str, chunk_size: int = 500, overlap: int = 50) -> list[str]:
    """Split text into chunks with overlap at natural boundaries."""
    if len(text) <= chunk_size:
        return [text]
    chunks = []
    start = 0
    while start < len(text):
        end = start + chunk_size
        chunk = text[start:end]
        if end < len(text):
            for sep in ["\n\n", "\n", ". ", " "]:
                last_sep = chunk.rfind(sep)
                if last_sep > chunk_size * 0.5:
                    end = start + last_sep + len(sep)
                    chunk = text[start:end]
                    break
        chunks.append(chunk.strip())
        start = end - overlap
    return [c for c in chunks if c]

# ── Ingestion (Load → Chunk → Embed → Store) ────────────────
def ingest(docs_dir: str = "./docs") -> chromadb.Collection:
    """Load docs, chunk them, and store in ChromaDB."""
    print("── Ingestion Pipeline ──")
    docs = load_documents(docs_dir)
    print(f"  Loaded {len(docs)} documents")

    all_chunks = []
    for doc in docs:
        chunks = chunk_text(doc["content"], chunk_size=500, overlap=50)
        for i, chunk in enumerate(chunks):
            all_chunks.append({"text": chunk, "source": doc["source"], "index": i})
    print(f"  Created {len(all_chunks)} chunks")

    client = chromadb.Client()  # in-memory for simplicity
    collection = client.get_or_create_collection(
        name="rag_lab", metadata={"hnsw:space": "cosine"}
    )
    collection.add(
        ids=[f"chunk_{i}" for i in range(len(all_chunks))],
        documents=[c["text"] for c in all_chunks],
        metadatas=[{"source": c["source"], "index": c["index"]} for c in all_chunks],
    )
    print(f"  Stored {collection.count()} chunks in ChromaDB")
    return collection

# ── Run ingestion ────────────────────────────────────────────
if __name__ == "__main__":
    collection = ingest()
    print("\n✓ Ingestion complete. Ready for queries.")

# ── Query (Retrieve → Generate) ──────────────────────────────
def query_rag(collection, question: str, top_k: int = 3, verbose: bool = True) -> str:
    """Search for relevant chunks and generate an answer with the model."""
    client = OpenAI(base_url="http://localhost:11434/v1", api_key="ollama")

    # Retrieve
    results = collection.query(query_texts=[question], n_results=top_k)
    chunks = results["documents"][0]
    sources = results["metadatas"][0]
    distances = results["distances"][0] if results.get("distances") else []

    if verbose:
        print(f"\n  Query: {question}")
        print(f"  Retrieved {len(chunks)} chunks:")
        for i, (chunk, meta) in enumerate(zip(chunks, sources)):
            dist = f" (distance: {distances[i]:.3f})" if distances else ""
            print(f"    [{i+1}] {meta['source']}{dist}: {chunk[:80]}...")

    # Format context
    context = "\n\n---\n\n".join(
        f"[Source {i+1}: {meta['source']}]\n{chunk}"
        for i, (chunk, meta) in enumerate(zip(chunks, sources))
    )

    # Generate
    response = client.chat.completions.create(
        model="mistral",
        messages=[{
            "role": "user",
            "content": f"Context:\n{context}\n\nQuestion: {question}\n\nAnswer based on the context above, citing sources:",
        }],
    )
    return response.choices[0].message.content


# ── Test Queries ─────────────────────────────────────────────
if __name__ == "__main__":
    collection = ingest()

    print("\n" + "=" * 55)
    print("RAG QUERY TESTS")
    print("=" * 55)

    questions = [
        "How long is a UCC-1 filing effective?",
        "What are the high risk indicators for a UCC filing?",
        "What happens if a continuation statement is filed late?",
        "What is the difference between a UCC-1 and a UCC-3?",
        "What is the weather in Tokyo?",  # Should say "not in context"
    ]

    for q in questions:
        answer = query_rag(collection, q)
        print(f"\n  Answer: {answer[:200]}...")
        print(f"  {'─' * 50}")