@shaykec/bridge 0.4.25 → 0.4.26

package/modules/prompt-engineering/quiz.md

@@ -0,0 +1,105 @@
+# Prompt Engineering — Quiz
+
+## Question 1
+
+Which component of a prompt sets the AI's persona and expertise?
+
+A) Context
+B) Task
+C) Role
+D) Format
+
+<!-- ANSWER: C -->
+<!-- EXPLANATION: Role sets who the AI is (e.g., "You are an expert Python developer"). Context provides background; Task is the request; Format defines output structure. -->
+
+## Question 2
+
+Few-shot prompting improves output most for:
+
+A) Simple translation
+B) Structured or style-sensitive tasks where the pattern matters
+C) Very long documents
+D) Questions with a single correct answer
+
+<!-- ANSWER: B -->
+<!-- EXPLANATION: Few-shot gives examples so the model learns the pattern. It helps when format, style, or edge-case handling matters. Simple translation often works with zero-shot. -->
+
+## Question 3
+
+Chain-of-thought prompting is most useful for:
+
+A) Short factual answers
+B) Logic, math, and multi-step reasoning tasks
+C) Creative writing
+D) Summarization only
+
+<!-- ANSWER: B -->
+<!-- EXPLANATION: CoT asks the model to "think step by step," which improves performance on reasoning, logic, and multi-step problems. It reduces errors by surfacing intermediate reasoning. -->
+
+## Question 4
+
+For extracting structured data (e.g., names, dates) from text, you should request:
+
+A) Freeform prose
+B) JSON or XML with specified keys
+C) Markdown only
+D) Bullet points
+
+<!-- ANSWER: B -->
+<!-- EXPLANATION: Structured output (JSON, XML) with specified keys makes the output machine-readable and parseable. Freeform prose requires extra parsing; structured format enables integration. -->
+
+## Question 5
+
+Low temperature (0–0.3) is best for:
+
+A) Brainstorming creative ideas
+B) Factual extraction, code generation, classification
+C) Varied storytelling
+D) Open-ended exploration
+
+<!-- ANSWER: B -->
+<!-- EXPLANATION: Low temperature makes output deterministic and consistent — good for factual tasks, code, extraction. High temperature increases variety and creativity but also randomness. -->
+
+## Question 6
+
+A prompt produces generic, off-topic output. The best first fix is usually:
+
+A) Add more constraints
+B) Add context and be more specific about the task
+C) Increase temperature
+D) Use a different model
+
+<!-- ANSWER: B -->
+<!-- EXPLANATION: Generic output often means insufficient context or vague task. Adding context and specificity usually helps before adding constraints. Temperature and model choice come later if needed. -->
+
+## Question 7
+
+<!-- VISUAL: drag-order -->
+
+Put these steps in the correct order for improving a vague prompt:
+
+A) Add few-shot examples if the format matters
+B) Define the role and context
+C) Specify the output format (JSON, markdown, etc.)
+D) Refine the task with concrete requirements
+
+<!-- ANSWER: B,D,C,A -->
+<!-- EXPLANATION: Start with role and context (B) to ground the AI. Then refine the task with specifics (D). Define output format (C) for parseability. Add examples (A) if style or structure is critical. -->
+
+## Question 8
+
+<!-- VISUAL: fill-blank -->
+
+Complete the prompt template for structured extraction:
+
+```
+You are a ___0___ assistant. Extract the following from the text:
+- name
+- date
+- amount
+
+Return valid JSON with keys: name, date, amount.
+```
+
+<!-- ANSWER: data extraction -->
+<!-- EXPLANATION: The template sets role (data extraction assistant), defines the task (extract specific fields), and specifies output format (JSON with keys). "data extraction" or "structured data" fits the role. -->

package/modules/prompt-engineering/resources.md

@@ -0,0 +1,36 @@
+# Prompt Engineering — Resources
+
+## Official Docs
+
+- [Anthropic — Prompt Engineering](https://docs.anthropic.com/en/docs/build-with-claude/prompt-engineering) — Claude prompting guide.
+- [OpenAI — Prompt Engineering Guide](https://platform.openai.com/docs/guides/prompt-engineering) — OpenAI best practices.
+- [Google — Introduction to Prompt Design](https://cloud.google.com/vertex-ai/docs/generative-ai/learn/prompt-design-strategies) — Vertex AI prompting.
+
+## Videos
+
+- [Anthropic — Prompt Engineering](https://www.youtube.com/results?search_query=Anthropic+prompt+engineering) — Claude prompting videos.
+- [Andrej Karpathy — Prompt Engineering](https://www.youtube.com/results?search_query=Karpathy+prompt+engineering) — LLM prompting concepts.
+- [Fireship — Prompt Engineering](https://www.youtube.com/results?search_query=Fireship+prompt+engineering) — Quick overview.
+
+## Articles
+
+- [Learn Prompting](https://learnprompting.org/) — Free prompt engineering course.
+- [Lilian Weng — Prompt Engineering](https://lilianweng.github.io/posts/2023-03-15-prompt-engineering/) — Technical overview.
+- [Simon Willison — Prompting](https://simonwillison.net/series/prompting/) — Practical prompt patterns.
+- [OpenAI — Prompt Engineering Techniques](https://platform.openai.com/docs/guides/prompt-engineering/prompting-guide) — Few-shot, CoT, structured output.
+
+## Books
+
+- **Prompt Engineering Guide** (various) — Prompt patterns and techniques.
+- **AI Engineering** by Chip Huyen — Production ML and LLM systems.
+
+## Podcasts
+
+- [Practical AI](https://changelog.com/practicalai) — Episodes on prompting and LLM workflows.
+- [The TWIML AI Podcast](https://twimlai.com/) — ML and LLM industry discussions.
+
+## Tools
+
+- [OpenAI Playground](https://platform.openai.com/playground) — Experiment with prompts.
+- [Claude API](https://docs.anthropic.com/en/api/getting-started) — Claude prompting and parameters.
+- [LangSmith](https://smith.langchain.com/) — Prompt debugging and tracing.

package/modules/prompt-engineering/walkthrough.md

@@ -0,0 +1,81 @@
+# Prompt Engineering Walkthrough — Learn by Doing
+
+## Step 1: Structure a Basic Prompt
+
+<!-- hint:code language="text" highlight="1,3" -->
+
+**Task:** You want the AI to summarize a meeting transcript. Write a prompt that includes: role, context (what kind of meeting), task (summarize), format (bullet points? sections?), and one constraint (e.g., max 200 words).
+
+**Question:** What would happen if you only said "Summarize this"? What does each component add?
+
+**Checkpoint:** The user's prompt has at least role, context, task, format, and one constraint. They can explain why each piece improves output (e.g., format ensures machine-readable structure).
+
+---
+
+## Step 2: Zero-Shot vs Few-Shot
+
+<!-- hint:buttons type="single" prompt="When do you need few-shot examples?" options="Simple classification,Style-sensitive tasks,Broad summarization" -->
+
+**Task:** You need the AI to classify support tickets as "bug", "feature request", or "question". Write (a) a zero-shot prompt and (b) a few-shot prompt with 2–3 examples. Run both (or predict): which would you expect to perform better? Why?
+
+**Question:** For which tasks would zero-shot be enough? When do you *need* few-shot?
+
+**Checkpoint:** The user has both prompts. They understand few-shot establishes the pattern for structured or style-sensitive tasks. They can name cases where zero-shot suffices (simple translation, broad summarization).
+
+---
+
+## Step 3: Chain-of-Thought for Reasoning
+
+<!-- hint:card type="concept" title="Chain-of-Thought" -->
+
+**Task:** Ask the AI: "If a train leaves Station A at 60 mph and Station B at 40 mph toward each other, 200 miles apart, when do they meet?" Use a prompt that asks the model to "think step by step" before giving the answer. Compare to a prompt that doesn't.
+
+**Question:** Why does "show your reasoning" help? What kinds of tasks benefit most from chain-of-thought?
+
+**Checkpoint:** The user has used CoT. They observe: CoT reduces errors on logic and math; it makes output verifiable. They can name other CoT-suitable tasks (multi-step planning, debugging).
+
+---
+
+## Step 4: Structured Output
+
+<!-- hint:diagram mermaid-type="flowchart" topic="prompt structure" -->
+
+**Embed:** https://docs.anthropic.com/en/docs/build-with-claude/prompt-engineering
+
+**Task:** Ask the AI to extract names, emails, and phone numbers from a short paragraph of text. Request the output as JSON with keys `names`, `emails`, `phones`. Run it. If the format drifts, add more explicit structure (e.g., "Return valid JSON only, no markdown").
+
+**Question:** Why is JSON useful for downstream use? What if the model returns markdown-wrapped JSON?
+
+**Checkpoint:** The user has gotten JSON output. They understand structured output enables parsing and integration. They can handle common drift (e.g., "valid JSON only").
+
+---
+
+## Step 5: Iterate on a Failing Prompt
+
+**Task:** Your prompt for "write a product description" produces generic, marketing-fluffy text. Iterate: add (a) a constraint ("no buzzwords"), (b) an example of the tone you want, (c) a length limit. Which change helped most?
+
+**Question:** When would you add an example vs a constraint? What's the risk of too many constraints at once?
+
+**Checkpoint:** The user has iterated and seen improvement. They understand: examples establish style; constraints narrow scope. They recognize constraint overload can confuse the model.
+
+---
+
+## Step 6: Choose Temperature
+
+<!-- hint:buttons type="single" prompt="Lower temperature reduces what?" options="Creativity,Hallucination risk,Speed" -->
+
+**Task:** For each scenario, choose temperature (0, 0.3, 0.7, 1.0) and justify: (a) Extracting entity names from text. (b) Brainstorming 10 product names. (c) Writing unit tests from a spec. (d) Creative short story.
+
+**Question:** Why does low temperature reduce hallucination risk? When is high temperature useful despite that risk?
+
+**Checkpoint:** The user matches: extraction (0–0.3), brainstorming (0.7–1.0), tests (0–0.3), story (0.7–1.0). They connect low temp to factual consistency and high temp to creativity.
+
+---
+
+## Step 7: System vs User Prompts
+
+**Task:** Many APIs support a system prompt and user messages. Design a system prompt for a "helpful coding assistant" that: (a) sets the role, (b) specifies output format (code blocks, explain briefly), (c) adds one guardrail (e.g., "don't assume APIs we don't have"). Why put this in the system prompt vs the user message?
+
+**Question:** What should *not* go in the system prompt? When would you put task-specific instructions in the user message instead?
+
+**Checkpoint:** The user has a system prompt with role, format, and guardrail. They understand system = persistent context; user = per-request. They can distinguish what belongs where.

package/modules/rag-fundamentals/content.md

@@ -0,0 +1,111 @@
+# RAG — Retrieval-Augmented Generation for Grounded AI
+
+<!-- hint:slides topic="RAG pipeline: indexing, chunking, embedding, retrieval, augmented generation, and evaluation" slides="6" -->
+
+## The Problem RAG Solves
+
+LLMs don't know your data. They have a **knowledge cutoff**, can **hallucinate**, and can't access private docs, live data, or domain-specific content. **RAG (Retrieval-Augmented Generation)** solves this by retrieving relevant context and augmenting the prompt with it.
+
+## How RAG Works
+
+```mermaid
+flowchart TB
+    subgraph index["Indexing (offline)"]
+        D[Docs] --> C[Chunk]
+        C --> E[Embed]
+        E --> S[Store]
+    end
+    subgraph query["Query (online)"]
+        Q[Query] --> EQ[Embed Query]
+        EQ --> R[Retrieve]
+        S --> R
+        R --> A[Augment Prompt]
+        A --> G[Generate]
+        G --> Out[Answer]
+    end
+```
+
+**Indexing:** Docs → Chunk → Embed → Store (vector DB)  
+**Query:** Query → Embed → Retrieve → Augment prompt → Generate
+
+## The Full RAG Pipeline
+
+```mermaid
+flowchart LR
+    D[Docs] --> C[Chunk]
+    C --> E[Embed]
+    E --> V[Vector Store]
+    Q[Query] --> EQ[Embed Query]
+    EQ --> R[Retrieve]
+    V --> R
+    R --> A[Augment]
+    A --> P[Prompt]
+    P --> G[Generate]
+    G --> Out[Output]
+```
+
+## Embeddings
+
+**Embeddings** convert text to vectors (lists of numbers) that capture semantic meaning. Similar texts → similar vectors. Use cosine similarity or dot product to find "nearest" chunks.
+
+- "How do I reset my password?" ≈ "Password reset instructions"
+- Different from keyword search: captures meaning, not just words
+
+## Vector Databases
+
+Store embeddings and support **similarity search**:
+
+| Tool | Notes |
+|------|-------|
+| **Pinecone** | Managed, scalable |
+| **Weaviate** | Open-source, hybrid search |
+| **Chroma** | Lightweight, embedded |
+| **pgvector** | PostgreSQL extension |
+
+## Chunking Strategies
+
+| Strategy | When to Use |
+|----------|-------------|
+| **Fixed-size** | Simple; split every N tokens |
+| **Semantic** | Split on meaning boundaries (paragraphs, sections) |
+| **Recursive** | Hierarchical: try sentence → paragraph → section |
+| **Overlap** | Overlap chunks to preserve context at boundaries |
+
+Bad chunking = retrieval misses relevant context or returns fragments that don't make sense alone.
+
+## Retrieval Quality
+
+- **Top-k** — Return k most similar chunks. Tune k (often 3–10).
+- **Similarity threshold** — Only return chunks above a score. Filters noise.
+- **Re-ranking** — Second pass: cross-encoder or LLM to rank top candidates. Improves precision.
+
+## Hybrid Search
+
+Combine **keyword** (BM25, full-text) with **semantic** (embeddings). Keyword finds exact terms; semantic finds paraphrases. Merge scores (e.g., weighted average, Reciprocal Rank Fusion).
+
+## Evaluation
+
+| Metric | What It Measures |
+|--------|------------------|
+| **Faithfulness** | Does the answer stay grounded in the retrieved context? |
+| **Relevance** | Do retrieved chunks match the query? |
+| **Answer correctness** | Is the final answer factually correct? |
+
+## Common Pitfalls
+
+| Pitfall | Fix |
+|---------|-----|
+| **Bad chunking** | Use semantic or recursive; tune chunk size and overlap |
+| **No metadata filtering** | Filter by source, date, type before retrieval |
+| **Stuffing too much** | Limit context; use re-ranking; summarize if needed |
+| **Wrong embedding model** | Match model to domain (e.g., code vs. prose) |
+
+---
+
+## Key Takeaways
+
+1. **RAG** — Retrieve relevant docs → augment prompt → generate
+2. **Embeddings** — Text → vectors; similarity = semantic match
+3. **Chunking** — Fixed, semantic, or recursive; overlap helps
+4. **Retrieval** — Top-k, threshold, re-ranking
+5. **Evaluate** — Faithfulness, relevance, correctness

package/modules/rag-fundamentals/exercises.md

@@ -0,0 +1,80 @@
+# RAG Fundamentals Exercises
+
+## Exercise 1: Choose a Chunking Strategy
+
+**Task:** For each document type, pick a chunking strategy and justify in one sentence: (a) Legal contract, (b) FAQ page, (c) Codebase documentation, (d) Blog posts.
+
+**Validation:**
+- [ ] Legal: semantic/paragraph (preserve clause boundaries)
+- [ ] FAQ: by Q&A pair (natural unit)
+- [ ] Code docs: semantic by function/section
+- [ ] Blog: paragraph or recursive
+
+**Hints:**
+1. Legal: clauses matter; don't split mid-clause
+2. FAQ: each Q&A is a natural chunk
+3. Code: function, class, or section
+4. Blog: paragraphs or sections
+
+---
+
+## Exercise 2: Design Metadata for Retrieval
+
+**Task:** You're indexing a product docs site. What metadata would you store with each chunk? How would you use it at query time? List 4 metadata fields and one filter scenario for each.
+
+**Validation:**
+- [ ] At least: source, section, product, last_updated
+- [ ] Each has a filter use case (e.g., "only v2 docs", "only API reference")
+
+**Hints:**
+1. `source`: "Which file/page"
+2. `section`: "API, Getting Started, etc."
+3. `product`: "Product A, B"
+4. `last_updated`: Filter stale content
+
+---
+
+## Exercise 3: Compare Keyword vs Semantic Search
+
+**Task:** Write a query that keyword search would handle well, and one that semantic search would handle better. For each, explain why. Example: "exact error code XYZ" vs "how to fix connection timeout".
+
+**Validation:**
+- [ ] Keyword: exact phrase, specific term, part number
+- [ ] Semantic: paraphrased, conceptual, "how do I...?"
+
+**Hints:**
+1. Keyword good: "ERROR_CODE_404", "API v2.1"
+2. Semantic good: "payment failed" ≈ "transaction declined", "troubleshoot slow API"
+
+---
+
+## Exercise 4: Write an Augmented Prompt Template
+
+**Task:** Write a prompt template for RAG. Placeholders: `{context}` (retrieved chunks), `{question}` (user query). Include instructions: use only the context, say "I don't know" if the answer isn't there, cite the source when possible.
+
+**Validation:**
+- [ ] Has {context} and {question}
+- [ ] Instructs to use only context
+- [ ] Handles "not in context" case
+- [ ] Asks for citation/source when possible
+
+**Hints:**
+1. "Use ONLY the following context. If the answer isn't there, say so."
+2. "When possible, cite which part of the context supports your answer."
+3. Template: "Context:\n{context}\n\nQuestion: {question}\n\nAnswer:"
+
+---
+
+## Exercise 5: Propose Evaluation Metrics
+
+**Task:** For a customer-support RAG bot, propose 3 metrics you'd track. For each: name, what it measures, how you'd compute it (human eval, model-as-judge, or automated).
+
+**Validation:**
+- [ ] Faithfulness: answer grounded in context (model-as-judge or human)
+- [ ] Relevance: retrieved chunks match query (human or relevance model)
+- [ ] Correctness: answer is factually right (human or comparison to gold)
+
+**Hints:**
+1. Faithfulness: "Does the answer only use the provided context?"
+2. Relevance: "Do retrieved chunks address the question?"
+3. Correctness: "Is the answer factually correct?"

package/modules/rag-fundamentals/module.yaml

@@ -0,0 +1,45 @@
+slug: rag-fundamentals
+title: "RAG — Retrieval-Augmented Generation for Grounded AI"
+version: 1.0.0
+description: "Ground LLMs with your data using retrieval, embeddings, vector databases, and the full RAG pipeline."
+category: ai-and-llm
+tags: [rag, retrieval, embeddings, vector-database, grounding, knowledge-base]
+difficulty: intermediate
+
+xp:
+  read: 15
+  walkthrough: 40
+  exercise: 25
+  quiz: 20
+  quiz-perfect-bonus: 10
+
+time:
+  quick: 5
+  read: 20
+  guided: 50
+
+prerequisites: [llm-fundamentals]
+related: [ai-agents, prompt-engineering]
+
+triggers:
+  - "What is RAG?"
+  - "How do I ground AI with my own data?"
+  - "What are embeddings?"
+  - "How do vector databases work?"
+
+visuals:
+  diagrams: [diagram-mermaid, diagram-architecture]
+  quiz-types: [quiz-drag-order, quiz-matching]
+  playground: bash
+  slides: true
+
+sources:
+  - url: "https://docs.langchain.com"
+    label: "LangChain Documentation"
+    type: docs
+  - url: "https://docs.llamaindex.ai"
+    label: "LlamaIndex Documentation"
+    type: docs
+  - url: "https://www.pinecone.io/learn"
+    label: "Pinecone Learning Center"
+    type: docs

package/modules/rag-fundamentals/quick-ref.md

@@ -0,0 +1,58 @@
+# RAG Fundamentals Quick Reference
+
+## RAG Pipeline
+
+**Indexing:** Docs → Chunk → Embed → Store (vector DB)
+
+**Query:** Query → Embed → Retrieve → Augment prompt → Generate
+
+## Embeddings
+
+- Text → vectors (numbers)
+- Similar meaning → similar vectors
+- Use cosine similarity or dot product for retrieval
+
+## Vector Databases
+
+| Tool      | Use Case          |
+|-----------|-------------------|
+| Pinecone  | Managed, scalable  |
+| Weaviate  | Open-source, hybrid|
+| Chroma    | Lightweight        |
+| pgvector  | PostgreSQL         |
+
+## Chunking
+
+| Strategy    | Pros / Cons                    |
+|-------------|--------------------------------|
+| Fixed-size  | Simple; can split mid-sentence|
+| Semantic    | Preserves meaning; uneven size |
+| Recursive   | Flexible; more config         |
+| Overlap     | Keeps context at boundaries   |
+
+## Retrieval Tuning
+
+- **Top-k** — How many chunks (often 3–10)
+- **Threshold** — Minimum similarity score
+- **Re-ranking** — Second pass for precision
+- **Hybrid** — Keyword + semantic
+
+## Evaluation
+
+- **Faithfulness** — Grounded in context?
+- **Relevance** — Right chunks retrieved?
+- **Correctness** — Factually right?
+
+## Common Pitfalls
+
+- Bad chunking → tune size, overlap, strategy
+- No metadata → add filters (source, date)
+- Too much context → limit k, re-rank
+- Wrong embeddings → match model to domain
+
+## One-Liners
+
+- **RAG** — Retrieve → Augment → Generate.
+- **Embeddings** — Semantic similarity, not just keywords.
+- **Chunking** — Semantic beats fixed for coherence.
+- **Evaluate** — Faithfulness, relevance, correctness.

package/modules/rag-fundamentals/quiz.md

@@ -0,0 +1,75 @@
+# RAG Fundamentals Quiz
+
+## Question 1
+
+What does RAG stand for and what problem does it solve?
+
+A) Random Algorithm Generation — generates random code
+B) Retrieval-Augmented Generation — grounds LLM answers with retrieved documents
+C) Recursive Auto-Regression — a type of model training
+D) Real-time Annotation Gateway — data labeling tool
+
+<!-- ANSWER: B -->
+<!-- EXPLANATION: RAG (Retrieval-Augmented Generation) retrieves relevant documents, augments the prompt with them, and generates answers grounded in that context. It addresses LLM knowledge cutoff and hallucination. -->
+
+## Question 2
+
+What do embeddings represent?
+
+A) Compressed versions of documents
+B) Numerical vectors that capture semantic meaning; similar text → similar vectors
+C) Encryption keys for secure storage
+D) Token counts for pricing
+
+<!-- ANSWER: B -->
+<!-- EXPLANATION: Embeddings map text to vectors in a high-dimensional space. Semantically similar texts produce similar vectors, enabling similarity search. -->
+
+## Question 3
+
+Drag the RAG pipeline steps into the correct order:
+
+<!-- VISUAL: quiz-drag-order -->
+
+A) Docs → Chunk → Embed → Store → Query → Embed → Retrieve → Augment → Generate
+B) Query → Retrieve → Chunk → Embed → Generate
+C) Embed → Chunk → Store → Retrieve → Generate
+D) Chunk → Query → Embed → Retrieve → Augment → Generate
+
+<!-- ANSWER: A -->
+<!-- EXPLANATION: Indexing: Docs → Chunk → Embed → Store. Query: Query → Embed → Retrieve (from store) → Augment prompt → Generate. -->
+
+## Question 4
+
+Which chunking strategy preserves meaning boundaries best?
+
+A) Fixed-size only
+B) Semantic (e.g., by paragraph or section)
+C) Random split
+D) Single chunk per document
+
+<!-- ANSWER: B -->
+<!-- EXPLANATION: Semantic chunking splits on natural boundaries (paragraphs, sections) so each chunk is a coherent unit. Fixed-size can split mid-sentence. -->
+
+## Question 5
+
+What does "re-ranking" do in RAG?
+
+A) Re-trains the embedding model
+B) Re-ranks retrieved chunks with a second pass to improve precision before sending to the LLM
+C) Reorders user queries by priority
+D) Restores deleted chunks
+
+<!-- ANSWER: B -->
+<!-- EXPLANATION: Re-ranking takes the top-k retrieved chunks and uses a cross-encoder or LLM to re-score them, improving which chunks are passed to the generator. -->
+
+## Question 6
+
+Which is a common RAG pitfall?
+
+A) Using too few chunks (e.g., top-1 only)
+B) Stuffing too much context into the prompt, diluting relevance
+C) Using keyword search instead of embeddings
+D) Evaluating with too many metrics
+
+<!-- ANSWER: B -->
+<!-- EXPLANATION: Stuffing too much retrieved context can add noise, exceed context limits, and dilute the most relevant information. Tune top-k and use re-ranking. -->

package/modules/rag-fundamentals/resources.md

@@ -0,0 +1,34 @@
+# RAG Fundamentals — Resources
+
+## Official Docs
+
+- [LangChain](https://docs.langchain.com) — RAG chains, retrievers, vector stores.
+- [LlamaIndex](https://docs.llamaindex.ai) — Data frameworks, indexing, and RAG pipelines.
+- [Pinecone Learning Center](https://www.pinecone.io/learn/) — Vector DB concepts and tutorials.
+
+## Videos
+
+- [3Blue1Brown — Neural Networks](https://www.youtube.com/watch?v=aircAruvnKk) — Foundation for understanding embeddings.
+- [Andrej Karpathy — Embeddings](https://www.youtube.com/results?search_query=Andrej+Karpathy+embeddings) — Embedding intuition.
+- [AI Explained — RAG](https://www.youtube.com/results?search_query=AI+Explained+RAG) — RAG overviews.
+- [Fireship — RAG in 100 Seconds](https://www.youtube.com/results?search_query=Fireship+RAG) — Quick RAG intro.
+
+## Articles
+
+- [Lilian Weng — Retrieval-Augmented Generation](https://lilianweng.github.io/posts/2023-06-23-agent/) — RAG and agent patterns.
+- [Chip Huyen — RAG](https://huyenchip.com/) — Production RAG considerations.
+- [Simon Willison — RAG](https://simonwillison.net/series/rag/) — Practical RAG examples.
+
+## Books
+
+- **Build a Large Language Model (From Scratch)** by Sebastian Raschka — Embeddings and retrieval concepts.
+- **AI Engineering** by Chip Huyen — RAG in production.
+
+## Tools
+
+- [LangChain](https://docs.langchain.com) — RAG framework.
+- [LlamaIndex](https://docs.llamaindex.ai) — Data and RAG framework.
+- [Pinecone](https://www.pinecone.io/) — Vector database.
+- [Chroma](https://www.trychroma.com/) — Lightweight vector DB.
+- [OpenAI Embeddings](https://platform.openai.com/docs/guides/embeddings) — Text embedding API.
+- [Hugging Face Sentence Transformers](https://www.sbert.net/) — Open embedding models.