AP02_Retrieval_Augmented_Generation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "4cf56921",
   "metadata": {},
   "source": [
    "# Arbeitspaket (AP) 2: Retrieval Augmented Generation"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0f7fb22f",
   "metadata": {},
   "source": [
    "### Persönliche Angaben (bitte ergänzen)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "94d35a25",
   "metadata": {},
   "source": [
    "<table>\n",
    "  <tr>\n",
    "    <td>Vorname:</td>\n",
    "    <td></td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td>Nachname:</td>\n",
    "    <td></td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td>Immatrikulationsnummer:</td>\n",
    "    <td></td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td>Modul:</td>\n",
    "    <td>Data Science</td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td>Prüfungsdatum / Raum / Zeit:</td>\n",
    "    <td>16.12.2024 / Raum: SF O3.54 / 8:00 – 12:30</td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td>Erlaubte Hilfsmittel:</td>\n",
    "    <td>w.MA.XX.DS.24HS (Data Science)<br>Open Book, Eigener Computer, Internet-Zugang</td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "  <td>Nicht erlaubt:</td>\n",
    "  <td>Nicht erlaubt ist der Einsatz beliebiger Formen von generativer KI (z.B. Copilot, ChatGPT) <br> sowie beliebige Formen von Kommunikation oder Kollaboration mit anderen Menschen.</td>\n",
    "</tr>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "61847f62",
   "metadata": {},
   "source": [
    "## Bewertungskriterien\n",
    "\n",
    "### <b style=\"color: gray;\">(max. erreichbare Punkte: 48)</b>\n",
    "\n",
    "<table>\n",
    "  <thead>\n",
    "    <tr>\n",
    "      <th>Kategorie</th>\n",
    "      <th>Beschreibung</th>\n",
    "      <th>Punkteverteilung</th>\n",
    "    </tr>\n",
    "  </thead>\n",
    "  <tbody>\n",
    "    <tr>\n",
    "      <td>Code nicht lauffähig oder Ergebnisse nicht sinnvoll</td>\n",
    "      <td>Der Code enthält Fehler, die verhindern, dass er ausgeführt werden kann (z.B. Syntaxfehler) oder es werden Ergebnisse ausgegeben, welche nicht zur Fragestellung passen.</td>\n",
    "      <td>0 Punkte</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "      <td>Code lauffähig, aber mit gravierenden Mängeln</td>\n",
    "      <td>Der Code läuft, aber die Ergebnisse sind aufgrund wesentlicher Fehler unvollständig (z.B. grundlegende Fehler beim Einlesen der Daten). Nur geringer Fortschritt erkennbar.</td>\n",
    "      <td>25% der max. erreichbaren Punkte</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "      <td>Code lauffähig, aber mit mittleren Mängeln</td>\n",
    "      <td>Der Code läuft und liefert teilweise korrekte Ergebnisse, aber es gibt grössere Fehler (z.B. die Datentypen der eingelesenen Daten entsprechen nicht den Anforderungen gemäss Fragestellung). Die Ergebnisse sind nachvollziehbar, aber unvollständig oder ungenau.</td>\n",
    "      <td>50% der max. erreichbaren Punkte</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "      <td>Code lauffähig, aber mit minimalen Mängeln</td>\n",
    "      <td>Der Code läuft und liefert ein weitgehend korrektes Ergebnis, aber kleinere Fehler (z.B. Spaltenname falsch geschrieben, TimeStamp nicht korrekt formatiert) beeinträchtigen die Vollständigkeit des Ergebnisses.</td>\n",
    "      <td>75% der max. erreichbaren Punkte</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "      <td>Code lauffähig und korrekt</td>\n",
    "      <td>Der Code läuft einwandfrei und liefert das korrekte Ergebnis ohne Mängel.</td>\n",
    "      <td>100% der max. erreichbaren Punkte</td>\n",
    "    </tr>\n",
    "  </tbody>\n",
    "</table>\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b8df3dd",
   "metadata": {},
   "source": [
    "## Python Libraries und Settings"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aac9011e",
   "metadata": {},
   "source": [
    "## <b>Vorbereitung (Dieser Teil wird <u>nicht</u> bewertet!)</b>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e253f40",
   "metadata": {},
   "source": [
    "#### <b>1.) Starten Sie eine GitHub Codespaces Instanz auf Basis Ihres Forks von diesem Github Repository</b>\n",
    "#### <b>2.) Führen Sie bitte die untenstehenden 2 Code Zellen aus sobald der Codespace gestartet ist und die libraries installiert hat</b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "b027d889",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os  # For interacting with the operating system, e.g., file paths\n",
    "import glob  # For working with file patterns\n",
    "import asyncio  # For managing asynchronous tasks\n",
    "import json  # For working with JSON data\n",
    "import random  # For generating random data\n",
    "\n",
    "from dotenv import load_dotenv  # For loading environment variables from a .env file\n",
    "from PyPDF2 import PdfReader  # For reading PDF files\n",
    "from tqdm import tqdm  # For displaying progress bars in loops\n",
    "import pandas as pd  # For data manipulation and analysis\n",
    "\n",
    "from langchain.text_splitter import RecursiveCharacterTextSplitter  # For splitting text into manageable chunks\n",
    "from langchain.prompts import PromptTemplate  # For defining and managing prompt templates\n",
    "from langchain_core.output_parsers import StrOutputParser  # For parsing string outputs from models\n",
    "from langchain.chains.combine_documents import create_stuff_documents_chain  # For combining retrieved documents into a coherent chain\n",
    "from langchain.globals import set_debug  # For enabling debug mode in LangChain\n",
    "\n",
    "from langchain.text_splitter import RecursiveCharacterTextSplitter  # For splitting text into manageable chunks\n",
    "from langchain.prompts import PromptTemplate  # For defining and managing prompt templates\n",
    "from langchain.chains.combine_documents import create_stuff_documents_chain  # For combining retrieved documents into a coherent chain\n",
    "from langchain.globals import set_debug  # For enabling debug mode in LangChain\n",
    "\n",
    "from langchain_google_genai import GoogleGenerativeAIEmbeddings, ChatGoogleGenerativeAI  # For Google Generative AI integrations\n",
    "from langchain_huggingface import HuggingFaceEmbeddings  # For generating embeddings using Hugging Face models\n",
    "from langchain_openai import ChatOpenAI  # For OpenAI chat models\n",
    "from langchain_groq import ChatGroq  # For Groq-based models\n",
    "\n",
    "from langchain_community.vectorstores import FAISS, Chroma  # For storing and retrieving embeddings using FAISS and Chroma\n",
    "\n",
    "import openai\n",
    "from openai import OpenAI  # For OpenAI API access\n",
    "from huggingface_hub import InferenceClient  # For Hugging Face Hub integrations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "f4b53272",
   "metadata": {},
   "outputs": [],
   "source": [
    "load_dotenv()\n",
    "groq_key = os.getenv(\"GROQ_API_KEY\")\n",
    "openai.api_key = os.getenv(\"OPENAI_API_KEY\")\n",
    "google_key = os.getenv(\"GOOGLE_API_KEY\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e5c27b72",
   "metadata": {},
   "source": [
    "## <b>Aufgaben (Dieser Teil wird bewertet!)</b>\n",
    "### Hinweise zum folgenden Arbeitspaket:\n",
    "\n",
    "Im Rahmen dieses Arbeitspakets sollen Sie einen Retrieval-Augmented Generation (RAG)-Prozess erstellen, der medizinische Informationen aus Beipackzetteln gängiger Medikamente effizient abruft. Stellen Sie sich vor, Sie entwickeln ein System für Apotheker*innen oder medizinisches Personal, um schnell und präzise Fragen zu Medikamenten zu beantworten. Die folgenden fünf Beipackzettel stehen Ihnen als Datenquelle zur Verfügung:\n",
    "\n",
    "- [data/Amoxicillin.pdf](data/Amoxicillin.pdf)\n",
    "- [data/bisoprolol.pdf](data/bisoprolol.pdf)\n",
    "- [data/citalopram.pdf](data/citalopram.pdf)\n",
    "- [data/metformin.pdf](data/metformin.pdf)\n",
    "- [data/paracetamol.pdf](data/paracetamol.pdf)\n",
    "\n",
    "Ihre Aufgabe ist es, eine RAG-Pipeline zu implementieren, die relevante Informationen aus den Beipackzetteln abruft und in den Antwortprozess integriert. Nutzen Sie dabei die bereitgestellten Beschreibungen und Ihre Kenntnisse aus den Übungen.\n",
    "\n",
    "### Erwartetes Ergebnis:\n",
    "\n",
    "1. Lesen Sie die bereitgestellten Beipackzettel ein und extrahieren Sie den gesamten Text.\n",
    "2. Zerlegen Sie den extrahierten Text in handhabbare Abschnitte mithilfe eines Text-Splitters (z. B. `RecursiveCharacterTextSplitter`).\n",
    "3. Erstellen Sie Embeddings für die Textabschnitte mit einem vorgegebenen Modell.\n",
    "4. Indexieren Sie die Embeddings in einem Vektorspeicher (z. B. FAISS).\n",
    "5. Erarbeiten Sie einen passenden Prompt.\n",
    "6. Bauen Sie die Chain zusammen,\n",
    "7. Erstellen Sie eine Lsite mit Testfragen\n",
    "8. Lassen Sie die 10 Fragen von ihrem RAG beantworten.\n",
    "\n",
    "### Einreichungsdokumente:\n",
    "\n",
    "Die Einreichung dieser Aufgabe sollte Folgendes umfassen:\n",
    "- Das von Ihnen bearbeitete Notebook (dieses File).\n",
    "\n",
    "\n",
    "<b style=\"color:blue;\">Hinweise zu den folgenden Aufgabenstellungen:</b>\n",
    "<ul style=\"color:blue;\">\n",
    "  <li>Beachten Sie auch die zu jeder Aufgabenstellung zugehörenden Details zur Aufgabenstellung.</li>\n",
    "  <li>Lösen Sie jede Aufgabe mit Hilfe von Python Code. Integrieren Sie den Python Code in die Code-Zellen der jeweiligen Aufgabe.</li>\n",
    "  <li>Stellen Sie die Lösung(en) jeder Aufgabe so dar wie un der Aufgabe verlangt.</li>\n",
    "  <li>Verwenden Sie als Unterstützung die Langchain Dokumentation, sowie die API Dokumentation der verwendeten Languge Models.</li>\n",
    "</ul>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6033f466",
   "metadata": {},
   "source": [
    "#### <b>Aufgabe (1): Lesen sie alle 5 PDFs aus dem Ordner data ein und speichern sie deren Inhalt als String ab</b>\n",
    "<b>Details zur Aufgabenstellung:</b>\n",
    "- Sie finden die Files im Order 'data'.\n",
    "- Speichern Sie die Inhalte aller 5 PDFs in einem einzigen String.\n",
    "- Zeigen Sie mit Hilfe eines geeigneten Python Befehls die Dimension des Strings an (wie viele Zeichen?).\n",
    "- Stellen Sie die ersten 100 Zeichen im Jupyter notebook dar.\n",
    "<b style=\"color: gray;\">(max. erreichbare Punkte: 6)</b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "fdfcb555",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Einlesen der PDFs als String\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "07233c5f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Anzeigen der Anzal Zeichen im String\n",
    "\n",
    "\n",
    "# Anzeigen der ersten 100 Zeichen im String\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c31d4887",
   "metadata": {},
   "source": [
    "#### <b>Aufgabe (2): Splitten Sie die Texte in Chunks von einer Länge von 1000 Zeichen. Geben sie ebenfalls einen overlap an.</b>\n",
    "<b>Details zur Aufgabenstellung:</b>\n",
    "- Verwenden Sie dazu den String, den sie in der vorherigen Aufgabe erstellt haben.\n",
    "- Hinweis: In den Übungen haben wir den `RecursiveCharacterTextSplitter` verwendet.\n",
    "- Stellen Sie die Menge aller Chunks im Jupyter Notebook dar.\n",
    "- Stellen Sie die Länge des ersten Chunks im Jupyter Notenbook dar.\n",
    "\n",
    "<b style=\"color: gray;\">(max. erreichbare Punkte: 6)</b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "93aad8fd",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Spliting in Chunks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "9e4a316e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Darstellen der Menge aller Chunks\n",
    "\n",
    "# Darstellen der Länge des ersten Chunks\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "acc3fec8",
   "metadata": {},
   "source": [
    "#### <b>Aufgabe (3): Initialisieren sie ein Embedding Model</b>\n",
    "<b>Details zur Aufgabenstellung:</b>\n",
    "- Wählen sie ein geeignetes Embedding Modell von Huggingface aus.\n",
    "- [Huggigface Modelle](https://huggingface.co/spaces/mteb/leaderboard).\n",
    "- Beachten Sie die grösse des Modells. Das Modell sollte in ihrem Codespace ausführbar sein.\n",
    "- Beachten Sie auch, dass unser Datensatz in deutscher Spracher verfasst ist.\n",
    "\n",
    "<b style=\"color: gray;\">(max. erreichbare Punkte: 2)</b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "ed99968e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialisieren des Modells\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b80dc61",
   "metadata": {},
   "source": [
    "#### <b>Aufgabe (4): Erstellen sie mit Hilfe der Chunks und Embeddings einen Vector Store und einen Retriever.</b>\n",
    "<b>Details zur Aufgabenstellung:</b>\n",
    "- Erstellen sie einen Vector Store\n",
    "- Erstellen sie daraus einen Retriever\n",
    "- Definieren sie selber die Anzahl Dokumente, welche der Retriever zurückgeben soll.\n",
    "- Testen sie den Retriever mit der folgenden Anfrage: `\"Welche Dosierung von Amoxicillin Axapharm wird für die Behandlung einer Endokarditis-Prophylaxe bei Erwachsenen empfohlen?\"`\n",
    "- Speichern Sie die Chunks in einer Variable, damit Sie diese wiederverwenden können.\n",
    "- Falls die erhaltenen Chunks nicht relevant sind, erhöhen sie gegebenfalls die Anzahl Chunks die gesucht werden soll und führen Sie die Abfrage erneut durch. \n",
    "- Es muss nicht perfekt sein und falls sich nichts verbessert, fahren Sie weiter mit dem aktuellen Ergebnis.\n",
    "<b style=\"color: gray;\">(max. erreichbare Punkte: 6)</b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "077a187d-05be-4c30-a367-a4e1a19d4466",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Erstellen des Vector Stores\n",
    "\n",
    "# Erstellen des Retrievers\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ef402de2",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Testen des retrievers\n",
    "docs = ...\n",
    "print(docs)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1620f7aa",
   "metadata": {},
   "source": [
    "#### <b>Aufgabe (5): Prompt Engineering.</b>\n",
    "<b>Details zur Aufgabenstellung:</b>\n",
    "- Erstellen Sie ein an die Situation angepasstes PromptTemplate, in welches die erhaltenen Chunks und eine Frage eingefügt werden können.\n",
    "- Das PromptTemplate soll zwei`input_variables` enthalten. Eine für die Frage und eine für die Dokumente.\n",
    "- Inspiration zum Prompt Engineering: Es richtet sich an medizisches Fachpersonal, gegebenfalls Antwortlänge, was soll mit den eingefügten Texten passierent.\n",
    "- Beachten Sie die Sprache der Texte.\n",
    "<br><br>\n",
    "\n",
    "\n",
    "<b style=\"color: gray;\">(max. erreichbare Punkte: 6)</b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "e7a62839",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Erstellen sie einen Prompt\n",
    "\n",
    "# Erzeugen sie daraus ein Prompt Template\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ba5b3943",
   "metadata": {},
   "source": [
    "#### <b>Aufgabe (6): Setzen sie die Chain zusammen</b>\n",
    "<b>Details zur Aufgabenstellung:</b>\n",
    "- Kombinieren Sie die bisher erstellten Komponenten in einer Retrieval-Augmented-Generation (RAG)-Chain.\n",
    "- Die Chain sollte mindestens folgende Schritte enthalten:\n",
    "  - Einen Retriever, der relevante Textchunks basierend auf der Eingabefrage abruft.\n",
    "  - Ein Language Model (LLM), das basierend auf den abgerufenen Chunks eine Antwort generiert.\n",
    "  - einen Outputparser\n",
    "- Testen Sie Ihre Chain mit folgender Frage: \n",
    "`Welche Dosierung von Amoxicillin Axapharm wird für die Behandlung einer Endokarditis-Prophylaxe bei Erwachsenen empfohlen?`\n",
    "<br><br>\n",
    "\n",
    "<b style=\"color: gray;\">(max. erreichbare Punkte: 6)</b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "ae8ae141",
   "metadata": {},
   "outputs": [],
   "source": [
    "# set language model and output parser\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "c4ffd3b6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# define complete chain (3 parts)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "c380d27f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Test query\n",
    "query = \"Welche Dosierung von Amoxicillin Axapharm wird für die Behandlung einer Endokarditis-Prophylaxe bei Erwachsenen empfohlen?\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "fa1a3d91",
   "metadata": {},
   "outputs": [],
   "source": [
    "# print result of test query with your chain (hint: input is a dictionary)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ba422771",
   "metadata": {},
   "source": [
    "### <b>Aufgabe (7): Reusable Function für die RAG-Pipeline</b>\n",
    "<b>Details zur Aufgabenstellung:</b>\n",
    "- Schreiben Sie eine Funktion `get_answer_and_documents`, die eine Frage mit Hilfe der RAG-Pipeline beantwortet.\n",
    "- Die Funktion sollte:\n",
    "  - Einen Parameter für die Frage (`question`), die RAG-Chain (`rag_chain`), und den Retriever (`retriever`) enthalten.\n",
    "  - Dokumente mit dem Retriever abrufen und als Kontext an die Chain übergeben.\n",
    "  - Die Antwort und die verwendeten Dokumente zurückgeben.\n",
    "- Testen Sie die Funktion mit der Frage: `Welche Dosierung von Amoxicillin Axapharm wird für die Behandlung einer Endokarditis-Prophylaxe bei Erwachsenen empfohlen?`\n",
    "\n",
    "<b style=\"color: gray;\">(max. erreichbare Punkte: 4)</b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "28f98d3d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# function get_answer_and_documents\n",
    "def get_answer_and_documents(..., ..., ...,):\n",
    "   \n",
    "    return reply, retrieved_documents"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "02216dbb",
   "metadata": {},
   "outputs": [],
   "source": [
    "query2 = \"Ab welcher Kreatinin-Clearance ist die Einnahme von Metformin kontraindiziert?\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1317543b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# test your function with query2\n",
    "answer, documents = get_answer_and_documents()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a92c9ed7",
   "metadata": {},
   "outputs": [],
   "source": [
    "# this should now print the answer and the documents, as you return a touple of answer and documents\n",
    "print(\"retrieved answer: \" + answer)\n",
    "print(\"retrieved documents: \" + str(documents))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d2572817",
   "metadata": {},
   "source": [
    "Als Untersützung: So erhalten sie die Antwort au"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "08bd20f4",
   "metadata": {},
   "source": [
    "#### <b>Aufgabe (7): Erstellen sie eine Liste mit Testfragen.</b>\n",
    "<b>Details zur Aufgabenstellung:</b>\n",
    "- Erstellen sie eine Python Liste mit 10 Fragen, zu diesen Medikatementen.\n",
    "- Sie Können die Fragen mit einem Sprachmodell generieren lassen und in einer Liste abspeichern.\n",
    "- Dazu brauchen sie einen geegineten Prompt und eine Schleife um mehrere Anfragen an das Modell zu senden.\n",
    "- Notfalls kann die Liste von Hand erstellt werden oder über mehrere Zeilen Hinweg.\n",
    "- Sie können dazu Chunks aus den Packungsbeilagen verwenden, müssen aber nicht.\n",
    "- geben sie am Ende die Liste ihrer Fragen aus\n",
    "\n",
    "<b style=\"color: gray;\">(max. erreichbare Punkte: 6)</b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "504ca399",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Generieren der Testfragen (Hinweis: Es kann hilfreich sein, die Fragen in einer Liste zu speichern)\n",
    "# Sie dürfen auch Hilfslisten verwenden, wie zum Beispiel die Namen der Medikamente, oder ähnliches."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "e76e6700",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Augabe aller Test Fragen"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d67e3225",
   "metadata": {},
   "source": [
    "#### <b>Aufgabe (8): Lassen sie 10 die Fragen von ihrem Retriever Beantworten.</b>\n",
    "<b>Details zur Aufgabenstellung:</b>\n",
    "- Verwenden sie die 10 generierten Fragen und lassen sie diese von ihrer Chain beantworten\n",
    "- Geben Sie dazu Dokumente und Antwort aus.\n",
    "- Geben sie selbst eine Einschätzung ab, ob ihre Chain funktionert oder nicht.\n",
    "- Geben sie dazu ein Beispiel was gut ging und was nicht.\n",
    "\n",
    "<b style=\"color: gray;\">(max. erreichbare Punkte: 6</b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "909478da",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Beantwortung der 10 generierten Fragen\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e0e8e4d8",
   "metadata": {},
   "source": [
    "#### Ihre Einschätzung zur Qualität (mit Doppelklick auf die Zelle können sie reinschreiben):"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "ff525b1e",
   "metadata": {},
   "source": [
    "### Jupyter notebook --footer info-- (please always provide this at the end of each notebook)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e6cae5b2",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import platform\n",
    "import socket\n",
    "from platform import python_version\n",
    "from datetime import datetime\n",
    "\n",
    "print('-----------------------------------')\n",
    "print(os.name.upper())\n",
    "print(platform.system(), '|', platform.release())\n",
    "print('Datetime:', datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\"))\n",
    "print('Python Version:', python_version())\n",
    "print('IP Address:', socket.gethostbyname(socket.gethostname()))\n",
    "print('-----------------------------------')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "3.12.2",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}