first commit

README.md

@@ -1,6 +1,6 @@
 ---
 title: Llama 4 RAG
-emoji: 🐢
+emoji: 🦙
 colorFrom: yellow
 colorTo: pink
 sdk: gradio

main.py

@@ -0,0 +1,510 @@
+import os
+import zipfile
+from typing import Dict, List, Optional, Union
+
+import gradio as gr
+from groq import Groq
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_core.output_parsers import StrOutputParser
+from langchain_core.prompts import PromptTemplate
+from langchain_core.runnables import RunnablePassthrough
+from langchain_groq import ChatGroq
+from langchain_huggingface import HuggingFaceEmbeddings
+from langchain_core.vectorstores import InMemoryVectorStore
+# Retrieve API key for Groq from the environment variables
+GROQ_API_KEY = os.environ.get("GROQ_API_KEY")
+
+# Initialize the Groq client
+client = Groq(api_key=GROQ_API_KEY)
+
+# Initialize the LLM
+llm = ChatGroq(model="meta-llama/llama-4-scout-17b-16e-instruct", api_key=GROQ_API_KEY)
+
+# Initialize the embedding model
+embed_model = HuggingFaceEmbeddings(model_name="mixedbread-ai/mxbai-embed-large-v1")
+
+# General constants for the UI
+TITLE = """<h1 align="center">✨ Llama 4 RAG Application</h1>"""
+AVATAR_IMAGES = (
+    None,
+    "https://huggingface.co/datasets/huggingface/brand-assets/resolve/main/hf-logo.png",
+)
+
+# List of supported text extensions (alphabetically sorted)
+TEXT_EXTENSIONS = [
+    ".bat",
+    ".c",
+    ".cfg",
+    ".conf",
+    ".cpp",
+    ".cs",
+    ".css",
+    ".docx",
+    ".go",
+    ".h",
+    ".html",
+    ".ini",
+    ".java",
+    ".js",
+    ".json",
+    ".jsx",
+    ".md",
+    ".php",
+    ".ps1",
+    ".py",
+    ".rb",
+    ".rs",
+    ".sh",
+    ".toml",
+    ".ts",
+    ".tsx",
+    ".txt",
+    ".xml",
+    ".yaml",
+    ".yml",
+]
+
+# Global variables
+EXTRACTED_FILES = {}
+VECTORSTORE = None
+RAG_CHAIN = None
+
+# Initialize the text splitter
+text_splitter = RecursiveCharacterTextSplitter(
+    chunk_size=1000, chunk_overlap=100, separators=["\n\n", "\n"]
+)
+
+# Define the RAG prompt template
+template = """You are an expert assistant tasked with answering questions based on the provided documents.
+Use only the given context to generate your answer.
+If the answer cannot be found in the context, clearly state that you do not know.
+Be detailed and precise in your response, but avoid mentioning or referencing the context itself.
+
+Context:
+{context}
+
+Question:
+{question}
+
+Answer:"""
+
+# Create the PromptTemplate
+rag_prompt = PromptTemplate.from_template(template)
+
+
+def extract_text_from_zip(zip_file_path: str) -> Dict[str, str]:
+    """
+    Extract text content from files in a ZIP archive.
+
+    Parameters:
+        zip_file_path (str): Path to the ZIP file.
+
+    Returns:
+        Dict[str, str]: Dictionary mapping filenames to their text content.
+    """
+    text_contents = {}
+
+    with zipfile.ZipFile(zip_file_path, "r") as zip_ref:
+        for file_info in zip_ref.infolist():
+            # Skip directories
+            if file_info.filename.endswith("/"):
+                continue
+
+            # Skip binary files and focus on text files
+            file_ext = os.path.splitext(file_info.filename)[1].lower()
+
+            if file_ext in TEXT_EXTENSIONS:
+                try:
+                    with zip_ref.open(file_info) as file:
+                        content = file.read().decode("utf-8", errors="replace")
+                        text_contents[file_info.filename] = content
+                except Exception as e:
+                    text_contents[file_info.filename] = (
+                        f"Error extracting file: {str(e)}"
+                    )
+
+    return text_contents
+
+
+def extract_text_from_single_file(file_path: str) -> Dict[str, str]:
+    """
+    Extract text content from a single file.
+
+    Parameters:
+        file_path (str): Path to the file.
+
+    Returns:
+        Dict[str, str]: Dictionary mapping filename to its text content.
+    """
+    text_contents = {}
+    filename = os.path.basename(file_path)
+    file_ext = os.path.splitext(filename)[1].lower()
+
+    if file_ext in TEXT_EXTENSIONS:
+        try:
+            with open(file_path, "r", encoding="utf-8", errors="replace") as file:
+                content = file.read()
+                text_contents[filename] = content
+        except Exception as e:
+            text_contents[filename] = f"Error reading file: {str(e)}"
+
+    return text_contents
+
+
+def upload_files(
+    files: Optional[List[str]], chatbot: List[Union[dict, gr.ChatMessage]]
+):
+    """
+    Process uploaded files (ZIP or single text files): extract text content and append a message to the chat.
+
+    Parameters:
+        files (Optional[List[str]]): List of file paths.
+        chatbot (List[Union[dict, gr.ChatMessage]]): The conversation history.
+
+    Returns:
+        List[Union[dict, gr.ChatMessage]]: Updated conversation history.
+    """
+    global EXTRACTED_FILES, VECTORSTORE, RAG_CHAIN
+
+    # Handle multiple file uploads
+    if len(files) > 1:
+        total_files_processed = 0
+        total_files_extracted = 0
+        file_types = set()
+
+        # Process each file
+        for file in files:
+            filename = os.path.basename(file)
+            file_ext = os.path.splitext(filename)[1].lower()
+
+            # Process based on file type
+            if file_ext == ".zip":
+                extracted_files = extract_text_from_zip(file)
+                file_types.add("zip")
+            else:
+                extracted_files = extract_text_from_single_file(file)
+                file_types.add("text")
+
+            if extracted_files:
+                total_files_extracted += len(extracted_files)
+                # Store the extracted content in the global variable
+                EXTRACTED_FILES[filename] = extracted_files
+
+            total_files_processed += 1
+
+        # Create a summary message for multiple files
+        file_types_str = (
+            "files"
+            if len(file_types) > 1
+            else ("ZIP files" if "zip" in file_types else "text files")
+        )
+
+        # Create a list of uploaded file names
+        file_list = "\n".join([f"- {os.path.basename(file)}" for file in files])
+
+        chatbot.append(
+            gr.ChatMessage(
+                role="user",
+                content=f"<p>📚 Multiple {file_types_str} uploaded ({total_files_processed} files)</p><p>Extracted {total_files_extracted} text file(s) in total</p><p>Uploaded files:</p><pre>{file_list}</pre>",
+            )
+        )
+
+    # Handle single file upload
+    elif len(files) == 1:
+        file = files[0]
+        filename = os.path.basename(file)
+        file_ext = os.path.splitext(filename)[1].lower()
+
+        # Process based on file type
+        if file_ext == ".zip":
+            extracted_files = extract_text_from_zip(file)
+            file_type_msg = "📦 ZIP file"
+        else:
+            extracted_files = extract_text_from_single_file(file)
+            file_type_msg = "📄 File"
+
+        if not extracted_files:
+            chatbot.append(
+                gr.ChatMessage(
+                    role="user",
+                    content=f"<p>{file_type_msg} uploaded: {filename}, but no text content was found or the file format is not supported.</p>",
+                )
+            )
+        else:
+            file_list = "\n".join([f"- {name}" for name in extracted_files.keys()])
+            chatbot.append(
+                gr.ChatMessage(
+                    role="user",
+                    content=f"<p>{file_type_msg} uploaded: {filename}</p><p>Extracted {len(extracted_files)} text file(s):</p><pre>{file_list}</pre>",
+                )
+            )
+
+            # Store the extracted content in the global variable
+            EXTRACTED_FILES[filename] = extracted_files
+
+    # Process the extracted files and create vector embeddings
+    if EXTRACTED_FILES:
+        # Prepare documents for processing
+        all_texts = []
+        for filename, files in EXTRACTED_FILES.items():
+            for file_path, content in files.items():
+                all_texts.append(
+                    {"page_content": content, "metadata": {"source": file_path}}
+                )
+
+        # Create document objects
+        from langchain_core.documents import Document
+
+        documents = [
+            Document(page_content=item["page_content"], metadata=item["metadata"])
+            for item in all_texts
+        ]
+
+        # Split the documents into chunks
+        chunks = text_splitter.split_documents(documents)
+
+        # Create the vector store
+        VECTORSTORE = InMemoryVectorStore.from_documents(
+            documents=chunks,
+            embedding=embed_model,
+        )
+
+        # Create the retriever
+        retriever = VECTORSTORE.as_retriever()
+
+        # Create the RAG chain
+        RAG_CHAIN = (
+            {"context": retriever, "question": RunnablePassthrough()}
+            | rag_prompt
+            | llm
+            | StrOutputParser()
+        )
+
+        # Add a confirmation message
+        chatbot.append(
+            gr.ChatMessage(
+                role="assistant",
+                content="Documents processed and indexed. You can now ask questions about the content.",
+            )
+        )
+
+    return chatbot
+
+
+def user(text_prompt: str, chatbot: List[gr.ChatMessage]):
+    """
+    Append a new user text message to the chat history.
+
+    Parameters:
+        text_prompt (str): The input text provided by the user.
+        chatbot (List[gr.ChatMessage]): The existing conversation history.
+
+    Returns:
+        Tuple[str, List[gr.ChatMessage]]: A tuple of an empty string (clearing the prompt)
+            and the updated conversation history.
+    """
+    if text_prompt:
+        chatbot.append(gr.ChatMessage(role="user", content=text_prompt))
+    return "", chatbot
+
+
+def get_message_content(msg):
+    """
+    Retrieve the content of a message that can be either a dictionary or a gr.ChatMessage.
+
+    Parameters:
+        msg (Union[dict, gr.ChatMessage]): The message object.
+
+    Returns:
+        str: The textual content of the message.
+    """
+    if isinstance(msg, dict):
+        return msg.get("content", "")
+    return msg.content
+
+
+def process_query(chatbot: List[Union[dict, gr.ChatMessage]]):
+    """
+    Process the user's query using the RAG pipeline.
+
+    Parameters:
+        chatbot (List[Union[dict, gr.ChatMessage]]): The conversation history.
+
+    Returns:
+        List[Union[dict, gr.ChatMessage]]: The updated conversation history with the response.
+    """
+    global RAG_CHAIN
+
+    if len(chatbot) == 0:
+        chatbot.append(
+            gr.ChatMessage(
+                role="assistant",
+                content="Please enter a question or upload documents to start the conversation.",
+            )
+        )
+        return chatbot
+
+    # Get the last user message as the prompt
+    user_messages = [
+        msg
+        for msg in chatbot
+        if (isinstance(msg, dict) and msg.get("role") == "user")
+        or (hasattr(msg, "role") and msg.role == "user")
+    ]
+
+    if not user_messages:
+        chatbot.append(
+            gr.ChatMessage(
+                role="assistant",
+                content="Please enter a question to start the conversation.",
+            )
+        )
+        return chatbot
+
+    last_user_msg = user_messages[-1]
+    prompt = get_message_content(last_user_msg)
+
+    # Skip if the last message was about uploading a file
+    if (
+        "📦 ZIP file uploaded:" in prompt
+        or "📄 File uploaded:" in prompt
+        or "📚 Multiple files uploaded" in prompt
+    ):
+        return chatbot
+
+    # Check if RAG chain is available
+    if RAG_CHAIN is None:
+        chatbot.append(
+            gr.ChatMessage(
+                role="assistant",
+                content="Please upload documents first to enable question answering.",
+            )
+        )
+        return chatbot
+
+    # Append a placeholder for the assistant's response
+    chatbot.append(gr.ChatMessage(role="assistant", content="Thinking..."))
+
+    try:
+        # Process the query through the RAG chain
+        response = RAG_CHAIN.invoke(prompt)
+
+        # Update the placeholder with the actual response
+        chatbot[-1].content = response
+    except Exception as e:
+        # Handle any errors
+        chatbot[-1].content = f"Error processing your query: {str(e)}"
+
+    return chatbot
+
+
+def reset_app(chatbot):
+    """
+    Reset the app by clearing the chat context and removing any uploaded files.
+
+    Parameters:
+        chatbot (List[Union[dict, gr.ChatMessage]]): The conversation history.
+
+    Returns:
+        List[Union[dict, gr.ChatMessage]]: A fresh conversation history.
+    """
+    global EXTRACTED_FILES, VECTORSTORE, RAG_CHAIN
+
+    # Clear the global variables
+    EXTRACTED_FILES = {}
+    VECTORSTORE = None
+    RAG_CHAIN = None
+
+    # Reset the chatbot with a welcome message
+    return [
+        gr.ChatMessage(
+            role="assistant",
+            content="App has been reset. You can start a new conversation or upload new documents.",
+        )
+    ]
+
+
+# Define the Gradio UI components
+chatbot_component = gr.Chatbot(
+    label="Llama 4 RAG",
+    type="messages",
+    bubble_full_width=False,
+    avatar_images=AVATAR_IMAGES,
+    scale=2,
+    height=350,
+)
+text_prompt_component = gr.Textbox(
+    placeholder="Ask a question about your documents...",
+    show_label=False,
+    autofocus=True,
+    scale=28,
+)
+upload_files_button_component = gr.UploadButton(
+    label="Upload",
+    file_count="multiple",
+    file_types=[".zip", ".docx"] + TEXT_EXTENSIONS,
+    scale=1,
+    min_width=80,
+)
+send_button_component = gr.Button(
+    value="Send", variant="primary", scale=1, min_width=80
+)
+reset_button_component = gr.Button(value="Reset", variant="stop", scale=1, min_width=80)
+
+# Define input lists for button chaining
+user_inputs = [text_prompt_component, chatbot_component]
+
+with gr.Blocks(theme=gr.themes.Ocean()) as demo:
+    gr.HTML(TITLE)
+    with gr.Column():
+        chatbot_component.render()
+        with gr.Row(equal_height=True):
+            text_prompt_component.render()
+            send_button_component.render()
+            upload_files_button_component.render()
+            reset_button_component.render()
+
+    # When the Send button is clicked, first process the user text then process the query
+    send_button_component.click(
+        fn=user,
+        inputs=user_inputs,
+        outputs=[text_prompt_component, chatbot_component],
+        queue=False,
+    ).then(
+        fn=process_query,
+        inputs=[chatbot_component],
+        outputs=[chatbot_component],
+        api_name="process_query",
+    )
+
+    # Allow submission using the Enter key
+    text_prompt_component.submit(
+        fn=user,
+        inputs=user_inputs,
+        outputs=[text_prompt_component, chatbot_component],
+        queue=False,
+    ).then(
+        fn=process_query,
+        inputs=[chatbot_component],
+        outputs=[chatbot_component],
+        api_name="process_query_submit",
+    )
+
+    # Handle file uploads
+    upload_files_button_component.upload(
+        fn=upload_files,
+        inputs=[upload_files_button_component, chatbot_component],
+        outputs=[chatbot_component],
+        queue=False,
+    )
+
+    # Handle Reset button clicks
+    reset_button_component.click(
+        fn=reset_app,
+        inputs=[chatbot_component],
+        outputs=[chatbot_component],
+        queue=False,
+    )
+
+# Launch the demo interface
+demo.queue().launch()

notebook.ipynb

@@ -0,0 +1,444 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "7bfc3afd-0868-4938-9b45-19b2cba1a149",
+   "metadata": {},
+   "source": [
+    "## Setting Up"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d102db92-a346-447d-8c61-3be8292adec7",
+   "metadata": {
+    "executionCancelledAt": null,
+    "executionTime": 22644,
+    "lastExecutedAt": 1744298182897,
+    "lastExecutedByKernel": "b0791251-777d-414c-b5cc-636b4f317d9a",
+    "lastScheduledRunId": null,
+    "lastSuccessfullyExecutedCode": "%%capture\n%pip install langchain\n%pip install langchain-community \n%pip install langchainhub \n%pip install langchain-chroma \n%pip install langchain-groq\n%pip install langchain-huggingface\n%pip install unstructured[docx]"
+   },
+   "outputs": [],
+   "source": [
+    "%%capture\n",
+    "%pip install langchain\n",
+    "%pip install langchain-community \n",
+    "%pip install langchainhub \n",
+    "%pip install langchain-chroma \n",
+    "%pip install langchain-groq\n",
+    "%pip install langchain-huggingface\n",
+    "%pip install unstructured[docx]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "356e4c03-5642-4d21-8ee4-bc32b14e98ec",
+   "metadata": {},
+   "source": [
+    "## Groq Python API"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "4e8b89b9-f5bc-466b-a30f-db8e97828826",
+   "metadata": {
+    "executionCancelledAt": null,
+    "executionTime": 3176,
+    "lastExecutedAt": 1744298186074,
+    "lastExecutedByKernel": "b0791251-777d-414c-b5cc-636b4f317d9a",
+    "lastScheduledRunId": null,
+    "lastSuccessfullyExecutedCode": "import os\nfrom groq import Groq\n\ngroq_api_key = os.environ.get(\"GROQ_API_KEY\")\n\nclient = Groq(\n   api_key=groq_api_key,\n)\n\n\nchat_streaming = client.chat.completions.create(\n    messages=[\n       {\"role\": \"system\", \"content\": \"You are a professional Data Engineer.\"},\n       {\"role\": \"user\", \"content\": \"Can you explain how the data lake works?\"},\n    ],\n    model=\"meta-llama/llama-4-scout-17b-16e-instruct\",\n    temperature=0.3,\n    max_tokens=1200,\n    top_p=1,\n    stop=None,\n    stream=True,\n)\n\nfor chunk in chat_streaming:\n    print(chunk.choices[0].delta.content, end=\"\")",
+    "outputsMetadata": {
+     "0": {
+      "height": 469,
+      "type": "stream"
+     }
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "As a Data Engineer, I'd be happy to explain how a data lake works.\n",
+      "\n",
+      "**What is a Data Lake?**\n",
+      "\n",
+      "A data lake is a centralized repository that stores raw, unprocessed data in its native format. It's a scalable and flexible storage solution that allows you to store and process large amounts of structured, semi-structured, and unstructured data. The data lake is often used as a precursor to data warehousing, data analytics, and machine learning.\n",
+      "\n",
+      "**Key Components of a Data Lake**\n",
+      "\n",
+      "1. **Storage**: The storage layer is the foundation of a data lake. It's typically a distributed file system, such as Hadoop Distributed File System (HDFS), Amazon S3, Azure Data Lake Storage (ADLS), or Google Cloud Storage (GCS). This layer stores raw data in its native format, without any transformation or processing.\n",
+      "2. **Data Ingestion**: Data ingestion is the process of collecting data from various sources and loading it into the data lake. This can be done through various methods, such as batch processing, streaming, or manual uploads.\n",
+      "3. **Data Processing**: The data processing layer is responsible for transforming and processing the raw data into a usable format. This can be done using various processing frameworks, such as Apache Spark, Apache Flink, or Azure Databricks.\n",
+      "4. **Metadata Management**: Metadata management is critical in a data lake, as it provides context and meaning to the stored data. This includes information such as data schema, data lineage, and data quality.\n",
+      "\n",
+      "**How a Data Lake Works**\n",
+      "\n",
+      "Here's a step-by-step overview of how a data lake works:\n",
+      "\n",
+      "1. **Data Ingestion**: Data is collected from various sources, such as databases, applications, IoT devices, or social media platforms.\n",
+      "2. **Data Landing**: The ingested data is landed in the data lake's storage layer, where it's stored in its native format.\n",
+      "3. **Data Processing**: The raw data is processed and transformed into a usable format using various processing frameworks.\n",
+      "4. **Data Cataloging**: The processed data is cataloged, which involves creating metadata that describes the data, such as its schema, format, and quality.\n",
+      "5. **Data Analysis**: The processed and cataloged data is made available for analysis, reporting, and machine learning.\n",
+      "\n",
+      "**Benefits of a Data Lake**\n",
+      "\n",
+      "The data lake offers several benefits, including:\n",
+      "\n",
+      "1. **Scalability**: Data lakes can store large amounts of data and scale horizontally as needed.\n",
+      "2. **Flexibility**: Data lakes can store various types of data, including structured, semi-structured, and unstructured data.\n",
+      "3. **Cost-Effective**: Data lakes can be more cost-effective than traditional data warehousing solutions.\n",
+      "4. **Improved Data Quality**: Data lakes provide a single source of truth for data, which improves data quality and reduces data duplication.\n",
+      "\n",
+      "**Common Use Cases for a Data Lake**\n",
+      "\n",
+      "1. **Data Warehousing**: Data lakes can be used as a precursor to data warehousing, providing a centralized repository for data before it's loaded into a data warehouse.\n",
+      "2. **Big Data Analytics**: Data lakes can be used for big data analytics, providing a scalable and flexible storage solution for large datasets.\n",
+      "3. **Machine Learning**: Data lakes can be used as a data source for machine learning models, providing a large and diverse dataset for training and testing.\n",
+      "4. **Data Archiving**: Data lakes can be used for data archiving, providing a cost-effective solution for storing historical data.\n",
+      "\n",
+      "I hope this helps! Do you have any specific questions about data lakes or would you like me to elaborate on any of these points?None"
+     ]
+    }
+   ],
+   "source": [
+    "import os\n",
+    "from groq import Groq\n",
+    "\n",
+    "groq_api_key = os.environ.get(\"GROQ_API_KEY\")\n",
+    "\n",
+    "client = Groq(\n",
+    "   api_key=groq_api_key,\n",
+    ")\n",
+    "\n",
+    "\n",
+    "chat_streaming = client.chat.completions.create(\n",
+    "    messages=[\n",
+    "       {\"role\": \"system\", \"content\": \"You are a professional Data Engineer.\"},\n",
+    "       {\"role\": \"user\", \"content\": \"Can you explain how the data lake works?\"},\n",
+    "    ],\n",
+    "    model=\"meta-llama/llama-4-scout-17b-16e-instruct\",\n",
+    "    temperature=0.3,\n",
+    "    max_tokens=1200,\n",
+    "    top_p=1,\n",
+    "    stop=None,\n",
+    "    stream=True,\n",
+    ")\n",
+    "\n",
+    "for chunk in chat_streaming:\n",
+    "    print(chunk.choices[0].delta.content, end=\"\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b1849fe7-4641-44c4-a91f-27976d2c1918",
+   "metadata": {},
+   "source": [
+    "## Initiating LLM and Embedding"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "65583358-ce96-4657-9b4b-fabc5a2f195e",
+   "metadata": {
+    "executionCancelledAt": null,
+    "executionTime": 560,
+    "lastExecutedAt": 1744298186634,
+    "lastExecutedByKernel": "b0791251-777d-414c-b5cc-636b4f317d9a",
+    "lastScheduledRunId": null,
+    "lastSuccessfullyExecutedCode": "from langchain_groq import ChatGroq\n\nllm = ChatGroq(model=\"meta-llama/llama-4-scout-17b-16e-instruct\", api_key=groq_api_key)"
+   },
+   "outputs": [],
+   "source": [
+    "from langchain_groq import ChatGroq\n",
+    "\n",
+    "llm = ChatGroq(model=\"meta-llama/llama-4-scout-17b-16e-instruct\", api_key=groq_api_key)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "70675683-6a4f-4331-b8b5-6c4e348fa389",
+   "metadata": {
+    "executionCancelledAt": null,
+    "executionTime": 661,
+    "lastExecutedAt": 1744298599903,
+    "lastExecutedByKernel": "b0791251-777d-414c-b5cc-636b4f317d9a",
+    "lastScheduledRunId": null,
+    "lastSuccessfullyExecutedCode": "from langchain_huggingface import HuggingFaceEmbeddings\nembed_model = HuggingFaceEmbeddings(model_name=\"mixedbread-ai/mxbai-embed-large-v1\")",
+    "outputsMetadata": {
+     "0": {
+      "height": 437,
+      "type": "stream"
+     }
+    }
+   },
+   "outputs": [],
+   "source": [
+    "from langchain_huggingface import HuggingFaceEmbeddings\n",
+    "embed_model = HuggingFaceEmbeddings(model_name=\"mixedbread-ai/mxbai-embed-large-v1\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ff2b277e-dc31-4801-bd05-ffda3265523b",
+   "metadata": {},
+   "source": [
+    "## Loading and spliting the data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "12390e24-2c8f-4690-8060-69eea3c224a0",
+   "metadata": {
+    "executionCancelledAt": null,
+    "executionTime": 1932,
+    "lastExecutedAt": 1744298196669,
+    "lastExecutedByKernel": "b0791251-777d-414c-b5cc-636b4f317d9a",
+    "lastScheduledRunId": null,
+    "lastSuccessfullyExecutedCode": "from langchain_community.document_loaders import DirectoryLoader\nfrom langchain.text_splitter import RecursiveCharacterTextSplitter\n\n# Initialize the text splitter\ntext_splitter = RecursiveCharacterTextSplitter(\n    chunk_size=500,\n    chunk_overlap=50,\n    separators=[\"\\n\\n\", \"\\n\"]\n)\n\n# Load the .docx files\nloader = DirectoryLoader(\"./\", glob=\"*.docx\", use_multithreading=True)\ndocuments = loader.load()\n\n# Split the documents into chunks\nchunks = text_splitter.split_documents(documents)\n\n# Print the number of chunks\nprint(len(chunks))\n"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "29\n"
+     ]
+    }
+   ],
+   "source": [
+    "from langchain_community.document_loaders import DirectoryLoader\n",
+    "from langchain.text_splitter import RecursiveCharacterTextSplitter\n",
+    "\n",
+    "# Initialize the text splitter\n",
+    "text_splitter = RecursiveCharacterTextSplitter(\n",
+    "    chunk_size=1000,\n",
+    "    chunk_overlap=100,\n",
+    "    separators=[\"\\n\\n\", \"\\n\"]\n",
+    ")\n",
+    "\n",
+    "# Load the .docx files\n",
+    "loader = DirectoryLoader(\"./\", glob=\"*.docx\", use_multithreading=True)\n",
+    "documents = loader.load()\n",
+    "\n",
+    "# Split the documents into chunks\n",
+    "chunks = text_splitter.split_documents(documents)\n",
+    "\n",
+    "# Print the number of chunks\n",
+    "print(len(chunks))\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "26085a16-42c8-4c6c-958f-9c1e2cc62b23",
+   "metadata": {},
+   "source": [
+    "## Creating the Vector Store"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "b27426d6-a218-4a44-9067-a9d4509e59c4",
+   "metadata": {
+    "executionCancelledAt": null,
+    "executionTime": 8773,
+    "lastExecutedAt": 1744298205442,
+    "lastExecutedByKernel": "b0791251-777d-414c-b5cc-636b4f317d9a",
+    "lastScheduledRunId": null,
+    "lastSuccessfullyExecutedCode": "from langchain_chroma import Chroma\n\nvectorstore = Chroma.from_documents(\n    documents=chunks,\n    embedding=embed_model,\n    persist_directory=\"./Vectordb\",\n)",
+    "outputsMetadata": {
+     "0": {
+      "height": 101,
+      "type": "stream"
+     }
+    }
+   },
+   "outputs": [],
+   "source": [
+    "from langchain_chroma import Chroma\n",
+    "\n",
+    "vectorstore = Chroma.from_documents(\n",
+    "    documents=chunks,\n",
+    "    embedding=embed_model,\n",
+    "    persist_directory=\"./Vectordb\",\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "633bbbfa-36ac-426e-8599-0f3bfb3b80ea",
+   "metadata": {
+    "executionCancelledAt": null,
+    "executionTime": 166,
+    "lastExecutedAt": 1744298366376,
+    "lastExecutedByKernel": "b0791251-777d-414c-b5cc-636b4f317d9a",
+    "lastScheduledRunId": null,
+    "lastSuccessfullyExecutedCode": "query = \"What this tutorial about?\"\ndocs = vectorstore.similarity_search(query)\nprint(docs[0].page_content)",
+    "outputsMetadata": {
+     "0": {
+      "height": 122,
+      "type": "stream"
+     }
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Learn how to Fine-tune Stable Diffusion XL with DreamBooth and LoRA on your personal images. \n",
+      "\n",
+      "Let’s try another prompt:\n",
+      "\n",
+      "Prompt:\n"
+     ]
+    }
+   ],
+   "source": [
+    "query = \"What this tutorial about?\"\n",
+    "docs = vectorstore.similarity_search(query)\n",
+    "print(docs[0].page_content)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "304a6177-9f74-40a5-bac9-eb2df32a8bff",
+   "metadata": {},
+   "source": [
+    "## Creating the RAG pipeline"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "5e3cd149-3009-4a12-98ed-8873d3bf9ab5",
+   "metadata": {
+    "executionCancelledAt": null,
+    "executionTime": 49,
+    "lastExecutedAt": 1744298865976,
+    "lastExecutedByKernel": "b0791251-777d-414c-b5cc-636b4f317d9a",
+    "lastScheduledRunId": null,
+    "lastSuccessfullyExecutedCode": "# Create retriever\nretriever = vectorstore.as_retriever()\n\n# Import PromptTemplate\nfrom langchain_core.prompts import PromptTemplate\n\n# Define a clearer, more professional prompt template\ntemplate = \"\"\"You are an expert assistant tasked with answering questions based on the provided documents.\nUse only the given context to generate your answer.\nIf the answer cannot be found in the context, clearly state that you do not know.\nBe detailed and precise in your response, but avoid mentioning or referencing the context itself.\n\nContext:\n{context}\n\nQuestion:\n{question}\n\nAnswer:\"\"\"\n\n# Create the PromptTemplate\nrag_prompt = PromptTemplate.from_template(template)\n"
+   },
+   "outputs": [],
+   "source": [
+    "# Create retriever\n",
+    "retriever = vectorstore.as_retriever()\n",
+    "\n",
+    "# Import PromptTemplate\n",
+    "from langchain_core.prompts import PromptTemplate\n",
+    "\n",
+    "# Define a clearer, more professional prompt template\n",
+    "template = \"\"\"You are an expert assistant tasked with answering questions based on the provided documents.\n",
+    "Use only the given context to generate your answer.\n",
+    "If the answer cannot be found in the context, clearly state that you do not know.\n",
+    "Be detailed and precise in your response, but avoid mentioning or referencing the context itself.\n",
+    "\n",
+    "Context:\n",
+    "{context}\n",
+    "\n",
+    "Question:\n",
+    "{question}\n",
+    "\n",
+    "Answer:\"\"\"\n",
+    "\n",
+    "# Create the PromptTemplate\n",
+    "rag_prompt = PromptTemplate.from_template(template)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "889685f6-3e5e-4abb-8391-084bdb6b7d4d",
+   "metadata": {
+    "executionCancelledAt": null,
+    "executionTime": 48,
+    "lastExecutedAt": 1744298875804,
+    "lastExecutedByKernel": "b0791251-777d-414c-b5cc-636b4f317d9a",
+    "lastScheduledRunId": null,
+    "lastSuccessfullyExecutedCode": "from langchain_core.output_parsers import StrOutputParser\nfrom langchain_core.runnables import RunnablePassthrough\n\nrag_chain = (\n    {\"context\": retriever, \"question\": RunnablePassthrough()}\n    | rag_prompt\n    | llm\n    | StrOutputParser()\n)"
+   },
+   "outputs": [],
+   "source": [
+    "from langchain_core.output_parsers import StrOutputParser\n",
+    "from langchain_core.runnables import RunnablePassthrough\n",
+    "\n",
+    "rag_chain = (\n",
+    "    {\"context\": retriever, \"question\": RunnablePassthrough()}\n",
+    "    | rag_prompt\n",
+    "    | llm\n",
+    "    | StrOutputParser()\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "ee406271-90d6-453b-a2aa-4753f08d30e5",
+   "metadata": {
+    "executionCancelledAt": null,
+    "executionTime": 888,
+    "lastExecutedAt": 1744298897317,
+    "lastExecutedByKernel": "b0791251-777d-414c-b5cc-636b4f317d9a",
+    "lastScheduledRunId": null,
+    "lastSuccessfullyExecutedCode": "from IPython.display import display, Markdown\n\nresponse = rag_chain.invoke(\"What this tutorial about?\")\nMarkdown(response)"
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/markdown": [
+       "This tutorial is about setting up and using the Janus project, specifically Janus Pro, a multimodal model that can understand images and generate images from text prompts, and building a local solution to use the model privately on a laptop GPU. It covers learning about the Janus Series, setting up the Janus project, building a Docker container to run the model locally, and testing its capabilities with various image and text prompts."
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from IPython.display import display, Markdown\n",
+    "\n",
+    "response = rag_chain.invoke(\"What this tutorial about?\")\n",
+    "Markdown(response)"
+   ]
+  }
+ ],
+ "metadata": {
+  "colab": {
+   "name": "Welcome to DataCamp Workspaces.ipynb",
+   "provenance": []
+  },
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "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.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

requirements.txt

@@ -0,0 +1,6 @@
+langchain
+langchain-community 
+langchainhub 
+langchain-groq
+langchain-huggingface
+unstructured[docx]