RAG Fundamentals and Python Pipelines

Trace how a Markdown or Python source file becomes retrieved context in an LLM prompt.

Identify the responsibilities and interfaces of the loader, chunker, embedder, vector store, retriever, generator, and citation layer.

Diagnose whether a simple RAG failure originated during ingestion, retrieval, context assembly, or generation.

Use pathlib to discover only Markdown and Python files while excluding irrelevant paths.

Load text files while handling encodings, unreadable files, and empty files explicitly.

Create document metadata containing source path, file type, modification state, and a stable identifier.

Recognize headings, paragraphs, lists, and fenced code blocks as structural units in Markdown.

Interpret the nodes and source spans for modules, classes, functions, and methods in a Python abstract syntax tree.

Normalize source text without losing the line-number information needed for citations.

Detect duplicate or unchanged source documents using content hashes.

Explain how chunk size, overlap, boundaries, and context loss affect retrieval quality.

Compare fixed-size, token-based, and structure-aware chunking on the same source document.

Measure chunk size with the tokenizer used by an embedding or generation model.

Split Markdown along heading and block boundaries while retaining its heading hierarchy.

Split Python by module, class, function, and method boundaries using source spans from its syntax tree.

Attach source path, line range, structural heading or symbol name, and chunk identifier to every chunk.

Add limited parent context or overlap without creating excessive duplicate retrieval results.

Test a chunker for coverage, stable ordering, valid line ranges, and reconstruction of the source.

Explain how an embedding represents semantic similarity and where that representation can fail for technical text.

Calculate cosine similarity between a query vector and document vectors and interpret the resulting ranking.

Compare semantic similarity with exact term matching for natural-language prose and Python identifiers.

Define a vector-record schema that keeps embeddings, chunk text, and citation metadata connected.

Explain the trade-off between exact nearest-neighbor search and approximate nearest-neighbor indexing.

Maintain consistent embedding models and vector dimensions across indexing and querying.

Perform insert, update, delete, and rebuild operations without leaving stale chunks in the vector store.

Inspect nearest-neighbor results to detect poor chunks, weak metadata, or unsuitable embeddings.

Convert a user question into a retrieval query and use it to obtain top-k vector matches.

Tune top-k and similarity thresholds to balance missing evidence against irrelevant context.

Apply metadata filters without accidentally excluding relevant source material.

Explain why exact names, paths, and code symbols can require lexical retrieval in addition to embeddings.

Combine lexical and vector rankings into a hybrid retrieval result.

Remove redundant results and prioritize chunks that contribute distinct evidence.

Assemble retrieved chunks into a context window while preserving citation labels and respecting a token budget.

Diagnose retrieval results by separating query, ranking, filtering, and context-budget failures.

Construct a prompt that clearly separates system instructions, the user question, and retrieved source context.

Instruct an LLM to answer only from supplied evidence and to abstain when that evidence is insufficient.

Treat instructions found inside retrieved documents as untrusted content rather than executable directions.

Assign compact citation labels that map unambiguously to source paths and line ranges.

Generate an answer containing inline citations linked to the chunks that support each claim.

Check that every emitted citation exists and that its referenced chunk supports the associated claim.

Expose insufficient retrieval as a clear user-facing response instead of allowing unsupported generation.

Connect loading, chunking, indexing, retrieval, generation, and citation handling in a synchronous Python pipeline.

Create a small evaluation set containing representative questions, expected evidence, and difficult edge cases.

Label which source chunks are relevant to each evaluation question.

Calculate retrieval recall at k for a labeled evaluation set.

Calculate mean reciprocal rank to measure how early relevant evidence appears.

Assess whether an answer is supported by its retrieved context rather than by unsupported model knowledge.

Measure whether citations are valid, relevant, and sufficiently complete for the answer's claims.

Compare chunking or retrieval configurations while changing only one variable at a time.

Classify observed failures by pipeline stage and select the appropriate corrective action.

Organize the RAG project into replaceable Python components with explicit data contracts between stages.

Design a repeatable indexing workflow that distinguishes full rebuilds from incremental file updates.

Persist configuration and index metadata needed to reproduce an indexing run.

Add structured logging that traces a source file, chunk, retrieval result, answer, and citation without exposing sensitive content.

Write focused tests for source discovery, chunk boundaries, metadata integrity, retrieval, and citation mapping.

Explain the security and privacy risks associated with source access, prompt injection, generated answers, and logs.

Map each vendor-neutral RAG component to the corresponding category of Oracle database or cloud capability.

Present the system using an architecture diagram, one traced question, evaluation evidence, known limitations, and justified design choices.