LLM Applications And RAG

• Use RAG when knowledge changes often or must be cited/controlled per query.
• Use fine-tuning when you need style/formatting adaptation or domain reasoning patterns that do not rely on specific documents.
• Often, use both: RAG for grounding, light fine-tuning or prompt tuning for output style and task fit.

# Minimal, library-light sketch for clarity
import math

def embed(text: str):
    # Placeholder embedding: split chars into simple features.
    # Replace with a real embedding model in production.
    vec = [0]*26
    for ch in text.lower():
        if 'a' <= ch <= 'z':
            vec[ord(ch)-97] += 1
    # L2 normalize
    norm = math.sqrt(sum(v*v for v in vec)) or 1.0
    return [v/norm for v in vec]

def cosine(a, b):
    return sum(x*y for x,y in zip(a,b))

# Build index
documents = [
    {'doc_id': 'doc1', 'text': 'RAG combines retrieval with generation to ground answers.'},
    {'doc_id': 'doc2', 'text': 'Chunk text with overlap to preserve context across boundaries.'},
    {'doc_id': 'doc3', 'text': 'Use citations like [doc1] in the final answer.'},
]
index = [{'doc_id': d['doc_id'], 'text': d['text'], 'vec': embed(d['text'])} for d in documents]

def retrieve(query, k=2):
    qv = embed(query)
    scored = sorted(
        [{'doc_id': r['doc_id'], 'text': r['text'], 'score': cosine(qv, r['vec'])} for r in index],
        key=lambda x: x['score'], reverse=True
    )
    return scored[:k]

SYSTEM_PROMPT = (
    "You are a helpful assistant. Use ONLY the provided context. "
    "Cite sources like [doc_id]. If unsure, say 'I don't know'."
)

def llm_generate(prompt: str):
    # Placeholder: echo with a simple template.
    return f"Answer (simulated): Based on context, {prompt[:120]} ... [doc1]"

def answer_query(query):
    ctx = retrieve(query, k=2)
    context_text = "\n\n".join(f"[{c['doc_id']}] {c['text']}" for c in ctx)
    user_prompt = (
        f"{SYSTEM_PROMPT}\n\nContext:\n{context_text}\n\nQuestion: {query}\n" 
        f"Instructions: Provide a concise answer with citations."
    )
    return llm_generate(user_prompt)

print(answer_query('How does RAG ensure grounded answers?'))

# Structure messages and enforce output shape
system = (
    "Role: Enterprise QA Assistant.\n" 
    "Rules: \n- Use only provided context.\n- Cite sources like [doc_id].\n- If no evidence, say 'I don't know'.\n"
)
user = (
    "Context:\n[doc1] RAG combines retrieval with generation to ground answers.\n\n"
    "Question: Explain RAG grounding. Return JSON with fields: answer, citations (array), confidence (0-1)."
)
# Expected shape guidance (add to prompt):
shape = (
    "Respond EXACTLY as JSON: {\"answer\": string, \"citations\": [string], \"confidence\": number}."
)
# Combine into your model call; validate JSON after generation.

Tip: Keep rules short, explicit, and test with edge cases (no context, conflicting docs).

def chunk(text, max_chars=800, overlap=120):
    parts = []
    i = 0
    while i < len(text):
        parts.append(text[i:i+max_chars])
        i += max(1, max_chars - overlap)
    return parts

long_doc = "..."  # your source text
chunks = chunk(long_doc, max_chars=800, overlap=120)
# Index each chunk with metadata: doc_id, chunk_id, title

Guideline: start with 500–1000 characters (or 200–400 tokens) and overlap 10–20%.

def mmr(query_vec, candidates, lambda_mult=0.7, top_k=4):
    selected = []
    while candidates and len(selected) < top_k:
        best = None
        best_score = -1e9
        for c in candidates:
            relevance = cosine(query_vec, c['vec'])
            diversity = 0.0
            if selected:
                diversity = max(cosine(c['vec'], s['vec']) for s in selected)
            score = lambda_mult * relevance - (1 - lambda_mult) * diversity
            if score > best_score:
                best_score = score
                best = c
        selected.append(best)
        candidates = [c for c in candidates if c is not best]
    return selected

MMR balances relevance and diversity to reduce redundant chunks.

# Describe tools the assistant may call
TOOLS = [
    {
        'name': 'search_docs',
        'description': 'Semantic search over indexed enterprise documents',
        'input_schema': {'type': 'object', 'properties': {'query': {'type': 'string'}}, 'required': ['query']}
    },
    {
        'name': 'calc',
        'description': 'Perform arithmetic operations',
        'input_schema': {'type': 'object', 'properties': {'expr': {'type': 'string'}}, 'required': ['expr']}
    }
]

# Basic router based on intent heuristics
import re

def route(user_text):
    if re.search(r'\b(sum|add|\d+\s*[+\-*/])\b', user_text):
        return {'tool': 'calc', 'args': {'expr': user_text}}
    if len(user_text.split()) > 6:
        return {'tool': 'search_docs', 'args': {'query': user_text}}
    return {'tool': None, 'args': {}}

In production, let the LLM propose a tool call by outputting a structured JSON with tool name and arguments, then execute safely and pass results back.

BLOCKLIST = [
    r'password', r'api[-_ ]?key', r'ssn', r'credit\s*card'
]

import re

def violates(text):
    return any(re.search(pat, text, flags=re.I) for pat in BLOCKLIST)

def safe_answer(context, draft):
    if violates(draft):
        return "I can't share sensitive information. Please clarify your request without secrets."
    if 'I don\'t know' in draft or len(context.strip()) == 0:
        return "I don't know based on the provided context."
    return draft

Combine policy prompts with programmatic checks. Always prefer refusal over confident guessing.

• [ ] Outputs valid JSON consistently.
• [ ] At least one citation in every supported answer.
• [ ] Correct refusal when evidence absent.
• [ ] Passes offline eval with ≥ 70% faithfulness.
• [ ] Latency under 2s on average for your setup (adjust as needed).