{"query":"agentic loop RAG difference"}

[
  {
    "start": 4000,
    "content": "esult.\n\nThe `result` is a `LoopResult` with `all_messages` (the full\nconversation), token counts, and `cost` (computed from token usage).\n\n## Cost and tokens\n\nLook at what the call cost:\n\n```python\nresult.cost\n```\n\nUseful while developing - especially with multi-turn agents where one\nprompt can trigger several model calls. The handwritten loop made you\ncompute this by hand. The framework keeps a running total for you.\n\nYou can also look at the full message history.\n\n```python\nresult.all_messages\n```\n\nThis is just a list - the same `messages` list we maintained by hand.\n\n## Continuing the conversation\n\nTake the messages from the previous result and pass them as\n`previous_messages` on the next `loop` call:\n\n```python\nresult2 = runner.loop(\n    prompt=\"How do I run a different model?\",\n    previous_messages=result.all_messages,\n    callback=callback,\n)\n```\n\nThe runner picks up where the last call left off, with the same agent\nloop and an extended history. The model knows \"different model\" refers\nto Ollama because it sees the previous turn in memory. Without that\nhistory, it would have no idea what we're asking about.\n\n## Interactive chat\n\nFor a chat-like workflow, run the built-in input loop:\n\n```python\nrunner.run()\n```\n\nType questions and get answers. Type \"stop\" to exit.\n\n[\u2190 The Agentic Loop](14-agentic-loop.md) | [Other Frameworks \u2192](16-other-frameworks.md)",
    "filename": "01-agentic-rag/lessons/15-frameworks.md"
  },
  {
    "start": 0,
    "content": "# RAG with Vector Search\n\nVideo: [Watch this lesson](https://www.youtube.com/watch?v=-GBW3g3PVTM&list=PL3MmuxUbc_hLZFNgSad56pDBKK8KO0XIv)\n\nIn module 1, we built a RAG pipeline with three steps:\n\n```python\ndef rag(question):\n    search_results = search(question)\n    user_prompt = build_prompt(question, search_results)\n    return llm(user_prompt)\n```\n\nThe search step used keyword search. Now we swap in vector search.\nBecause RAG is modular, search is the only step we touch. Build prompt\nand the LLM call stay exactly as they were.\n\n## Using RAGBase\n\nIn [module 1](../../01-agentic-rag/) we put all the RAG logic into a\n[`RAGBase`](../../01-agentic-rag/code/rag_helper.py) helper class. It\nhas `search`, `build_prompt`, and `llm` methods, so we only need to\noverride `search`.\n\nDownload `rag_helper.py` (and `ingest.py` if you didn't get it earlier)\ninto your project:\n\n```bash\nwget https://raw.githubusercontent.com/DataTalksClub/llm-zoomcamp/main/01-agentic-rag/code/rag_helper.py\nwget https://raw.githubusercontent.com/DataTalksClub/llm-zoomcamp/main/01-agentic-rag/code/ingest.py\n```\n\nFirst, create the OpenAI client:\n\n```python\nfrom dotenv import load_dotenv\nfrom openai import OpenAI\n\nload_dotenv()\nopenai_client = OpenAI()\n```\n\nNext, download and index the data:\n\n```python\nfrom ingest import load_faq_data, build_index\n\ndocuments = load_faq_data()\nindex = build_index(documents)\n```\n\nThen use the `RAGBase` class:\n\n```python\nfrom rag_helper import RAGBase\n\nassistant = RAGBase(\n    index=index,\n    llm_client=openai_client,\n)\n```\n\nAsk it a question:\n\n```python\nquery = \"I just found out about the program, can I still sign up?\"\nassistant.rag(query)\n```\n\nThis still uses keyword search. Text search isn't bad here, so the\nanswer may already look right. Next we replace search with vector\nsearch.\n\nWe already have:\n\n- All the indexed documents `documents`\n- The embeddings matrix `X` with all these documents\n- The vector search engine `vindex`\n\nWe can't pass `vindex` to RAG as-is. Text sea",
    "filename": "02-vector-search/lessons/06-rag-vector.md"
  },
  {
    "start": 0,
    "content": "# AI Agents\n\nVideo: [Agentic Workflows](https://youtu.be/7tvpR8EE0gs)\n\nIn [Module 1](../../01-agentic-rag/lessons/11-agents-intro.md) you built the agentic loop by hand: a `while` loop that called the LLM, executed any tool calls it returned, sent the results back, and stopped when the model produced a final answer with no more tool calls. That pattern is the foundation of every agent framework.\n\nIn Kestra, the `AIAgent` plugin handles that loop for you. You define the goal, the tools, and optionally a system message - Kestra drives the loop, manages conversation history, and surfaces the result as a task output.\n\n> Note: The flows in this lesson use `{{ secret('GEMINI_API_KEY') }}`. Make sure you've completed the [setup instructions](03-setup.md) to configure this secret before running them.\n\nThe example flows use Gemini, but the `provider` block supports any major AI provider \u2014 swap `io.kestra.plugin.ai.provider.GoogleGemini` for `OpenAI`, `Anthropic`, or others. See the [full list of supported providers](https://kestra.io/plugins/plugin-ai/provider).\n\nTraditional Workflow \u2014 fixed sequence, predetermined logic:\n\n```yaml\ntasks:\n  - id: step1\n    type: Task1\n  - id: step2\n    type: Task2\n  - id: step3\n    type: Task3\n```\n\nAI Agent Workflow \u2014 agent decides what to do, in what order, based on the goal:\n\n```yaml\ntasks:\n  - id: agent\n    type: io.kestra.plugin.ai.agent.AIAgent\n    prompt: \"Research data engineering trends and create a report\"\n    tools:\n      - WebSearch\n      - TaskExecution\n```\n\n## When to Use AI Agents\n\nUse AI Agents when the exact sequence of steps isn't known in advance, decisions depend on dynamic changing information, or you need to adapt to unexpected conditions.\n\nUse traditional workflows when steps are deterministic and repeatable, compliance requires exact auditable processes, or cost and latency must be minimized.\n\n## Anatomy of an AI Agent\n\n```yaml\nid: example_agent\nnamespace: zoomcamp\n\ntasks:\n  - id: agent\n    type: io.kestra.plugin.ai.age",
    "filename": "03-orchestration/lessons/06-agents.md"
  },
  {
    "start": 7000,
    "content": "```python\nusage = response.usage\nusage.input_tokens, usage.output_tokens\n```\n\nFor each model the provider publishes a price per million input tokens\nand per million output tokens. Plug those numbers in to convert tokens\nto dollars.\n\n```python\ndef calculate_gpt54mini_price(input_tokens, output_tokens):\n    INPUT_PRICE_PER_MILLION = 0.15\n    OUTPUT_PRICE_PER_MILLION = 0.60\n\n    input_cost = (input_tokens / 1_000_000) * INPUT_PRICE_PER_MILLION\n    output_cost = (output_tokens / 1_000_000) * OUTPUT_PRICE_PER_MILLION\n    total_cost = input_cost + output_cost\n\n    return {\n        \"input_cost\": input_cost,\n        \"output_cost\": output_cost,\n        \"total_cost\": total_cost,\n    }\n\nresult = calculate_gpt54mini_price(652, 33)\nprint(\"Total cost: $\", round(result[\"total_cost\"], 8))\n```\n\nThis usage is only for the second API call. The first call also has\nits own usage and its own cost. That was the call where the model\ndecided to invoke `search`. Two calls means we pay twice. We pay even\nmore on the second call, because we resend the full history as input.\n\nWith a real agent loop the model can make many calls, so the costs add\nup. Keep an eye on `usage` while you develop.\n\n[\u2190 Quick RAG Revision](12-rag-revision.md) | [The Agentic Loop \u2192](14-agentic-loop.md)",
    "filename": "01-agentic-rag/lessons/13-function-calling.md"
  },
  {
    "start": 3000,
    "content": "   developer_prompt=instructions,\n    chat_interface=chat_interface,\n    llm_client=OpenAIClient(model=\"gpt-5.4-mini\")\n)\n```\n\nThe `chat_interface` handles display in the notebook. The `callback`\nrenders model messages and tool calls as they happen. The runner runs\nthe agent loop, the same `while True` we wrote by hand. It sends\nmessages, executes function calls, adds tool outputs back, and repeats\nuntil the model is done.\n\nWe pick `gpt-5.4-mini` here on purpose. Without it, ToyAIKit falls\nback to a smaller, faster default that doesn't follow the instructions\nas reliably.\n\n## Running one prompt\n\nRun a single prompt:\n\n```python\nresult = runner.loop(\n    prompt=\"How do I run Olama locally?\",\n    callback=callback,\n)\n```\n\nWe used the typo \"Olama\" on purpose. The agent searches and gets poor\nresults, then retries with \"Ollama\". The recovery is the same as the\nhandwritten loop. The notebook output is nicer to watch. Each tool\ncall and message renders inline, so you can look at every search\nresult.\n\nThe `result` is a `LoopResult` with `all_messages` (the full\nconversation), token counts, and `cost` (computed from token usage).\n\n## Cost and tokens\n\nLook at what the call cost:\n\n```python\nresult.cost\n```\n\nUseful while developing - especially with multi-turn agents where one\nprompt can trigger several model calls. The handwritten loop made you\ncompute this by hand. The framework keeps a running total for you.\n\nYou can also look at the full message history.\n\n```python\nresult.all_messages\n```\n\nThis is just a list - the same `messages` list we maintained by hand.\n\n## Continuing the conversation\n\nTake the messages from the previous result and pass them as\n`previous_messages` on the next `loop` call:\n\n```python\nresult2 = runner.loop(\n    prompt=\"How do I run a different model?\",\n    previous_messages=result.all_messages,\n    callback=callback,\n)\n```\n\nThe runner picks up where the last call left off, with the same agent\nloop and an extended history. The model knows \"different model\"",
    "filename": "01-agentic-rag/lessons/15-frameworks.md"
  }
]

{"query":"agentic loop lesson retrieval generation iteration"}

[
  {
    "start": 4000,
    "content": "while` loop. The loop keeps calling the model until\nit returns a response without any function calls. We also keep an\niteration counter so we can see how many round-trips happened.\n\n```python\nit = 1\n\nwhile True:\n    print(f\"iteration #{it}...\")\n    has_function_calls = False\n\n    response = openai_client.responses.create(\n        model=\"gpt-5.4-mini\",\n        input=messages,\n        tools=[search_tool],\n    )\n\n    messages.extend(response.output)\n\n    for item in response.output:\n        if item.type == \"function_call\":\n            print(\"function_call:\", item.name, item.arguments)\n            call_output = make_call(item)\n            messages.append(call_output)\n            has_function_calls = True\n\n        elif item.type == \"message\":\n            print(\"ASSISTANT:\")\n            print(item.content[0].text)\n\n    it = it + 1\n    if has_function_calls == False:\n        break\n```\n\nThis is the core agent loop. The model reasons about the next action.\nYour code performs it, and the model sees the result on the next turn.\nThe loop stops when the model returns a final answer with no more tool\ncalls.\n\nWe don't decide how many times the model searches. The model does,\nand we keep looping until it stops asking for tools.\n\nThe exit condition is the simplest one possible. No function calls\nthis turn means we're done. Other frameworks add safety nets on top,\nlike a max iteration count, a token budget, or a wall-clock limit. You\nmight cap it at five iterations and force an answer on the last one.\nThe core is still this one flag.\n\n## Wrapping it in a function\n\nLet's wrap the loop in a function so we can reuse it. The function\ntakes the instructions and the question as parameters, and returns\nthe final answer.\n\n```python\ndef agent_loop(instructions, question, model=\"gpt-5.4-mini\") -> str:\n    messages = [\n        {\"role\": \"developer\", \"content\": instructions},\n        {\"role\": \"user\", \"content\": question}\n    ]\n\n    it = 1\n\n    while True:\n        print(f\"iteration #{it}...\")\n    ",
    "filename": "01-agentic-rag/lessons/14-agentic-loop.md"
  },
  {
    "start": 4000,
    "content": "esult.\n\nThe `result` is a `LoopResult` with `all_messages` (the full\nconversation), token counts, and `cost` (computed from token usage).\n\n## Cost and tokens\n\nLook at what the call cost:\n\n```python\nresult.cost\n```\n\nUseful while developing - especially with multi-turn agents where one\nprompt can trigger several model calls. The handwritten loop made you\ncompute this by hand. The framework keeps a running total for you.\n\nYou can also look at the full message history.\n\n```python\nresult.all_messages\n```\n\nThis is just a list - the same `messages` list we maintained by hand.\n\n## Continuing the conversation\n\nTake the messages from the previous result and pass them as\n`previous_messages` on the next `loop` call:\n\n```python\nresult2 = runner.loop(\n    prompt=\"How do I run a different model?\",\n    previous_messages=result.all_messages,\n    callback=callback,\n)\n```\n\nThe runner picks up where the last call left off, with the same agent\nloop and an extended history. The model knows \"different model\" refers\nto Ollama because it sees the previous turn in memory. Without that\nhistory, it would have no idea what we're asking about.\n\n## Interactive chat\n\nFor a chat-like workflow, run the built-in input loop:\n\n```python\nrunner.run()\n```\n\nType questions and get answers. Type \"stop\" to exit.\n\n[\u2190 The Agentic Loop](14-agentic-loop.md) | [Other Frameworks \u2192](16-other-frameworks.md)",
    "filename": "01-agentic-rag/lessons/15-frameworks.md"
  },
  {
    "start": 0,
    "content": "# Retrieval Augmented Generation\n\nVideo: [RAG Workflows](https://youtu.be/FhGZV173xrk)\n\nAI Copilot solves the context problem for flow generation. But what about workflows that need to answer questions from your own data? That's where RAG comes in.\n\n> Note: Flows 1 and 2 use `{{ secret('GEMINI_API_KEY') }}`. Flow 3 uses `{{ secret('OPENAI_API_KEY') }}` and `{{ secret('TAVILY_API_KEY') }}`. Make sure you've completed the [setup instructions](03-setup.md) to configure the relevant secrets before running them.\n\n## What is RAG?\n\nRAG (Retrieval Augmented Generation) is a technique that retrieves relevant information from your data sources, augments the AI prompt with that context, and generates a response grounded in real data. This solves the hallucination problem by ensuring the AI has access to current, accurate information at query time.\n\nFor a deeper dive into RAG concepts, see [Module 1: Intro to RAG](../../01-agentic-rag/lessons/03-rag.md). For vector search, see [Module 2: Vector Search](../../02-vector-search/lessons/04-vector-search.md).\n\n## How RAG Works in Kestra\n\nRAG has two phases. In the demo flows below they run back-to-back, but in production you'd typically schedule them separately \u2014 ingest on a cadence, query on demand.\n\n```mermaid\ngraph LR\n    subgraph Ingest [\"Ingest (run once / on schedule)\"]\n        A[Fetch Docs] --> B[Create Embeddings]\n        B --> C[Store in KV Store]\n    end\n    subgraph Query [\"Query (run on demand)\"]\n        D[User Question] --> E[Find Similar Content]\n        E --> F[Add Context to Prompt]\n        F --> G[LLM Answer]\n    end\n    C --> E\n```\n\nIngest phase (run once, or on a schedule when your data changes):\n\n1. Fetch documents: load documentation, release notes, or other data sources\n2. Create embeddings: convert text into vectors using an embedding model\n3. Store embeddings: save vectors in Kestra's KV Store\n\n> Note: The flows store embeddings in Kestra's KV Store for simplicity. This is convenient for learning and small-sc",
    "filename": "03-orchestration/lessons/05-rag.md"
  },
  {
    "start": 2000,
    "content": "s on Google Cloud or you specifically want\nGemini.\n\n## Others\n\nOther frameworks worth knowing:\n\n- CrewAI - multi-agent orchestration\n- AutoGen - multi-agent conversations from Microsoft\n- Semantic Kernel - from Microsoft, supports C# and Python\n- Smolagents - lightweight agent framework from HuggingFace\n- Anthropic Tool Use - Anthropic's native tool use API\n\nPick one that fits your stack and your needs. The hard part is\ndesigning good tools and prompts - the loop is always the same.\n\n## Avoiding agents when you can\n\nOne closing thought. You don't always need an agent, and that's fine.\nYou might assume your app needs one, but often it doesn't.\n\nAdding an agent is a real cost:\n\n- More API calls per request, since the loop can fire many tool calls\n  before the model is satisfied.\n- Higher latency, since each round-trip waits on the model.\n- More money spent, since every iteration is another billed call and\n  the full message history is re-sent each turn.\n- More moving parts, since you now monitor cost, iteration count, and\n  whether the agent is going in circles.\n- Less predictable behavior, since the LLM decides what to do and two\n  runs of the same prompt can take different paths.\n\nBefore reaching for an agent, ask whether the problem needs one. A lot\nof tasks are well served by simpler approaches.\n\nReach for one of these first:\n\n- plain RAG, with one search and one answer\n- parsing or templating a document into another form\n- a single LLM call with no tools\n\nTry the simpler approach first, and if it works, ship it. Reach for\nthe agent loop only when you've tried the simpler solution and it\ngenuinely can't handle the problem. By then you'll know the extra\ncomplexity is worth it, and you'll be ready to take it on.\n\n[\u2190 ToyAIKit](15-frameworks.md) | [Back to module \u2192](../)",
    "filename": "01-agentic-rag/lessons/16-other-frameworks.md"
  },
  {
    "start": 3000,
    "content": "we drop it.\n\nBuild a prompt that includes both the question and the context:\n\n```python\nprompt = f\"\"\"\nYour task is to answer questions from the course participants\nbased on the provided context.\n\nUse the context to find relevant information and provide accurate\nanswers. If the answer is not found in the context,\nrespond with \"I don't know.\"\n\nQuestion:\n{question}\n\nContext:\n{context}\n\"\"\"\n```\n\nInstead of sending the raw question to the LLM, we send this prompt:\n\n```python\nanswer = llm(prompt)\nprint(answer)\n```\n\nAfter that, the answer is correct: \"Yes, you can still join. If you want to\nreceive a certificate, you need to submit your project while\nsubmissions are still open.\"\n\nThis is the answer we actually want to give to our students. What we\njust did is nothing but RAG.\n\n## Retrieval plus generation\n\nRAG stands for Retrieval-Augmented Generation. Generation is the LLM\nproducing text, and retrieval is search. We retrieve relevant documents\nfrom our knowledge base and use them to augment what the LLM generates.\nThat search step is what gives the LLM the context it needs to answer\ncorrectly.\n\nWhat we just did was naive. I knew in advance which FAQ entry held the\nanswer and pasted it in by hand. What we want instead is to perform\nsearch automatically. We take the student's question, find the most\nrelevant documents, and send those to the LLM.\n\nIn code, it looks like this:\n\n```python\ndef rag(question):\n    search_results = search(question)\n    user_prompt = build_prompt(question, search_results)\n    return llm(user_prompt)\n```\n\nThat's the entire architecture. It comes down to three components.\n\nThe pieces are search, the prompt, and the LLM:\n\n- search\n- prompt\n- LLM\n\n\n```mermaid\nflowchart TD\n    U([User])\n\n    APP[Application]\n\n    DB[(DB)]\n    DOCS[[D1 ... D5]]\n\n    PROMPT[Build Prompt<br/>Question + Context]\n\n    LLM[LLM]\n\n    ANSWER([Answer])\n\n    U -->|Question| APP\n\n    APP -->|Query| DB\n    DB -->|Retrieved Data| DOCS\n    DOCS --> APP\n\n    APP --> PROMPT\n    PROMPT -",
    "filename": "01-agentic-rag/lessons/03-rag.md"
  }
]

{"query":"plain RAG versus agentic RAG course"}

[
  {
    "start": 0,
    "content": "# RAG with Vector Search\n\nVideo: [Watch this lesson](https://www.youtube.com/watch?v=-GBW3g3PVTM&list=PL3MmuxUbc_hLZFNgSad56pDBKK8KO0XIv)\n\nIn module 1, we built a RAG pipeline with three steps:\n\n```python\ndef rag(question):\n    search_results = search(question)\n    user_prompt = build_prompt(question, search_results)\n    return llm(user_prompt)\n```\n\nThe search step used keyword search. Now we swap in vector search.\nBecause RAG is modular, search is the only step we touch. Build prompt\nand the LLM call stay exactly as they were.\n\n## Using RAGBase\n\nIn [module 1](../../01-agentic-rag/) we put all the RAG logic into a\n[`RAGBase`](../../01-agentic-rag/code/rag_helper.py) helper class. It\nhas `search`, `build_prompt`, and `llm` methods, so we only need to\noverride `search`.\n\nDownload `rag_helper.py` (and `ingest.py` if you didn't get it earlier)\ninto your project:\n\n```bash\nwget https://raw.githubusercontent.com/DataTalksClub/llm-zoomcamp/main/01-agentic-rag/code/rag_helper.py\nwget https://raw.githubusercontent.com/DataTalksClub/llm-zoomcamp/main/01-agentic-rag/code/ingest.py\n```\n\nFirst, create the OpenAI client:\n\n```python\nfrom dotenv import load_dotenv\nfrom openai import OpenAI\n\nload_dotenv()\nopenai_client = OpenAI()\n```\n\nNext, download and index the data:\n\n```python\nfrom ingest import load_faq_data, build_index\n\ndocuments = load_faq_data()\nindex = build_index(documents)\n```\n\nThen use the `RAGBase` class:\n\n```python\nfrom rag_helper import RAGBase\n\nassistant = RAGBase(\n    index=index,\n    llm_client=openai_client,\n)\n```\n\nAsk it a question:\n\n```python\nquery = \"I just found out about the program, can I still sign up?\"\nassistant.rag(query)\n```\n\nThis still uses keyword search. Text search isn't bad here, so the\nanswer may already look right. Next we replace search with vector\nsearch.\n\nWe already have:\n\n- All the indexed documents `documents`\n- The embeddings matrix `X` with all these documents\n- The vector search engine `vindex`\n\nWe can't pass `vindex` to RAG as-is. Text sea",
    "filename": "02-vector-search/lessons/06-rag-vector.md"
  },
  {
    "start": 0,
    "content": "# Quick RAG Revision (Optional)\n\nVideo: [Watch this lesson](https://www.youtube.com/watch?v=gH8fB-6Emmo&list=PL3MmuxUbc_hLZFNgSad56pDBKK8KO0XIv)\n\nBefore we talk about agents, let's set up the RAG pipeline we built\nin Part 1.\n\nOur courses have a lot of participants. They ask the same questions\nover and over, so we keep a FAQ document and point students to it. RAG\ntakes that FAQ and finds the entry that matches a question. It then\nsends the entry to an LLM so it can answer. That way a student gets a\nreply right away instead of scrolling through a long document.\n\nWe'll use two helpers we defined earlier in this module:\n\n- [`rag_helper.py`](../code/rag_helper.py) - the `RAGBase` class wrapping search, prompt building, and the LLM call\n- [`ingest.py`](../code/ingest.py) - `load_faq_data` and `build_index` for loading the FAQ and building a minsearch index\n\nIf you're working through Part 2 as a standalone workshop (without\nPart 1), download them into your project:\n\n```bash\nwget https://raw.githubusercontent.com/DataTalksClub/llm-zoomcamp/main/01-agentic-rag/code/rag_helper.py\nwget https://raw.githubusercontent.com/DataTalksClub/llm-zoomcamp/main/01-agentic-rag/code/ingest.py\n```\n\n## Setting up RAG\n\nSet up the OpenAI client:\n\n```python\nfrom dotenv import load_dotenv\nfrom openai import OpenAI\n\nload_dotenv()\nopenai_client = OpenAI()\n```\n\nLoad the data and build the search index:\n\n```python\nfrom rag_helper import RAGBase\nfrom ingest import load_faq_data, build_index\n\ndocuments = load_faq_data()\nindex = build_index(documents)\n```\n\nCreate the assistant:\n\n```python\ninstructions = \"\"\"\nYou're a course teaching assistant.\nAnswer the QUESTION based on the CONTEXT from the FAQ database.\nUse only the facts from the CONTEXT when answering the QUESTION.\n\"\"\".strip()\n\nassistant = RAGBase(\n    index=index,\n    llm_client=openai_client,\n    instructions=instructions,\n)\n```\n\n## Testing it\n\nLet's try a question:\n\n```python\nassistant.rag(\"How do I run Ollama locally?\")\n```\n\nThis works fine. Th",
    "filename": "01-agentic-rag/lessons/12-rag-revision.md"
  },
  {
    "start": 0,
    "content": "# Retrieval Augmented Generation\n\nVideo: [RAG Workflows](https://youtu.be/FhGZV173xrk)\n\nAI Copilot solves the context problem for flow generation. But what about workflows that need to answer questions from your own data? That's where RAG comes in.\n\n> Note: Flows 1 and 2 use `{{ secret('GEMINI_API_KEY') }}`. Flow 3 uses `{{ secret('OPENAI_API_KEY') }}` and `{{ secret('TAVILY_API_KEY') }}`. Make sure you've completed the [setup instructions](03-setup.md) to configure the relevant secrets before running them.\n\n## What is RAG?\n\nRAG (Retrieval Augmented Generation) is a technique that retrieves relevant information from your data sources, augments the AI prompt with that context, and generates a response grounded in real data. This solves the hallucination problem by ensuring the AI has access to current, accurate information at query time.\n\nFor a deeper dive into RAG concepts, see [Module 1: Intro to RAG](../../01-agentic-rag/lessons/03-rag.md). For vector search, see [Module 2: Vector Search](../../02-vector-search/lessons/04-vector-search.md).\n\n## How RAG Works in Kestra\n\nRAG has two phases. In the demo flows below they run back-to-back, but in production you'd typically schedule them separately \u2014 ingest on a cadence, query on demand.\n\n```mermaid\ngraph LR\n    subgraph Ingest [\"Ingest (run once / on schedule)\"]\n        A[Fetch Docs] --> B[Create Embeddings]\n        B --> C[Store in KV Store]\n    end\n    subgraph Query [\"Query (run on demand)\"]\n        D[User Question] --> E[Find Similar Content]\n        E --> F[Add Context to Prompt]\n        F --> G[LLM Answer]\n    end\n    C --> E\n```\n\nIngest phase (run once, or on a schedule when your data changes):\n\n1. Fetch documents: load documentation, release notes, or other data sources\n2. Create embeddings: convert text into vectors using an embedding model\n3. Store embeddings: save vectors in Kestra's KV Store\n\n> Note: The flows store embeddings in Kestra's KV Store for simplicity. This is convenient for learning and small-sc",
    "filename": "03-orchestration/lessons/05-rag.md"
  },
  {
    "start": 1000,
    "content": "ithubusercontent.com/DataTalksClub/llm-zoomcamp/main/01-agentic-rag/code/rag_helper.py\nwget https://raw.githubusercontent.com/DataTalksClub/llm-zoomcamp/main/01-agentic-rag/code/ingest.py\n```\n\n## Setting up RAG\n\nSet up the OpenAI client:\n\n```python\nfrom dotenv import load_dotenv\nfrom openai import OpenAI\n\nload_dotenv()\nopenai_client = OpenAI()\n```\n\nLoad the data and build the search index:\n\n```python\nfrom rag_helper import RAGBase\nfrom ingest import load_faq_data, build_index\n\ndocuments = load_faq_data()\nindex = build_index(documents)\n```\n\nCreate the assistant:\n\n```python\ninstructions = \"\"\"\nYou're a course teaching assistant.\nAnswer the QUESTION based on the CONTEXT from the FAQ database.\nUse only the facts from the CONTEXT when answering the QUESTION.\n\"\"\".strip()\n\nassistant = RAGBase(\n    index=index,\n    llm_client=openai_client,\n    instructions=instructions,\n)\n```\n\n## Testing it\n\nLet's try a question:\n\n```python\nassistant.rag(\"How do I run Ollama locally?\")\n```\n\nThis works fine. The search finds relevant FAQ entries about Ollama,\nand the LLM gives a good answer.\n\nNow try something slightly different:\n\n```python\nassistant.rag(\"How do I run Olama locally?\")\n```\n\nThe word \"Olama\" doesn't match \"Ollama\" in our index. We use lexical\nsearch, so it looks for the exact word and finds nothing. The LLM\ngets these bad results and either says \"I don't know\" or answers with\nirrelevant information.\n\nThis is the limitation of a fixed pipeline. The search runs once with\nthe exact query the user typed, and there's no second chance. The\npipeline doesn't know the search failed, so it can't try again with a\ncorrected query.\n\nWe need something smarter. We need an agent.\n\n[\u2190 Agents (Part 2 intro)](11-agents-intro.md) | [Function Calling \u2192](13-function-calling.md)",
    "filename": "01-agentic-rag/lessons/12-rag-revision.md"
  },
  {
    "start": 2000,
    "content": "wrong.\n\n## The project\n\nRAG solves these problems by giving the LLM relevant documents at\nquestion time. We don't hope the model memorized the answer. We\nretrieve the right information and hand it to the LLM, and the model\ngenerates a grounded response. This lets us inject knowledge the model\nnever saw during training. That's why RAG is still the most common way\npeople use LLMs in the industry.\n\nTo make this concrete, we build a FAQ agent for our course. A student\nasks something like \"when does the course start?\" and the agent answers\nfrom the FAQ data we prepared.\n\nThis module has two parts.\n\nIn Part 1 (the next 9 lessons) we will:\n\n- Understand what RAG is and how it works\n- Build a search engine over a real FAQ dataset\n- Write a prompt that combines the user's question with search results\n- Wire it all together into a working RAG pipeline\n- Split ingestion and query into separate processes\n\nIn Part 2, we make the pipeline agentic. The LLM decides when and\nwhat to search, instead of running the same fixed flow every time.\n\nThe final code from this module is available in the\n[code/](../code/) directory.\n\n[\u2190 Back to module](../) | [Environment \u2192](02-environment.md)",
    "filename": "01-agentic-rag/lessons/01-intro.md"
  }
]