Apply suggestions from code review

Co-authored-by: Benedikt Rollik <[email protected]>

Author: Laure-di

tutorials/how-to-implement-rag/index.mdx

@@ -11,12 +11,12 @@ categories:
 
 Retrieval-Augmented Generation (RAG) supercharges language models by enabling real-time retrieval of relevant information from external datasets. This hybrid approach boosts both the accuracy and contextual relevance of model outputs, making it essential for advanced AI applications.
 
-In this comprehensive guide, you'll learn how to implement RAG using LangChain, one of the leading frameworks for developing robust language model applications. We'll combine LangChain with ***Scaleway’s Managed Inference***, ***Scaleway’s PostgreSQL Managed Database*** (featuring pgvector for vector storage), and ***Scaleway’s Object Storage*** for seamless integration and efficient data management.
+In this comprehensive guide, you will learn how to implement RAG using LangChain, one of the leading frameworks for developing robust language model applications. We will combine LangChain with ***Scaleway’s Managed Inference***, ***Scaleway’s PostgreSQL Managed Database*** (featuring pgvector for vector storage), and ***Scaleway’s Object Storage*** for seamless integration and efficient data management.
 
 ## Why LangChain?
 LangChain simplifies the process of enhancing language models with retrieval capabilities, allowing developers to build scalable, intelligent applications that access external datasets effortlessly. By leveraging LangChain’s modular design and Scaleway’s cloud services, you can unlock the full potential of Retrieval-Augmented Generation.
 
-## What You’ll Learn
+## What you will learn
 - How to embed text using a sentence transformer using ***Scaleway Manage Inference***
 - How to store and query embeddings using ***Scaleway’s Managed PostgreSQL Database*** with pgvector
 - How to manage large datasets efficiently with ***Scaleway Object Storage***
@@ -40,7 +40,7 @@ Run the following command to install the required packages:
    ```sh
    pip install langchain psycopg2 python-dotenv
    ```
-### Step 2: Create a .env File
+### Step 2: Create a .env file
 
 Create a .env file and add the following variables. These will store your API keys, database connection details, and other configuration values.
 
@@ -71,26 +71,26 @@ Create a .env file and add the following variables. These will store your API ke
 
 ## Setting Up Managed Databases
 
-### Step 1: Connect to Your PostgreSQL Database
+### Step 1: Connect to your PostgreSQL database
 
-To perform these actions, you'll need to connect to your PostgreSQL database. You can use any PostgreSQL client, such as [psql](https://www.postgresql.org/docs/current/app-psql.html). The following steps will guide you through setting up your database to handle vector storage and document tracking.
+To perform these actions, you will need to connect to your PostgreSQL database. You can use any PostgreSQL client, such as [psql](https://www.postgresql.org/docs/current/app-psql.html). The following steps will guide you through setting up your database to handle vector storage and document tracking.
 
-### Step 2: Install the pgvector Extension
+### Step 2: Install the pgvector extension
 
 [pgvector](https://github.com/pgvector/pgvector) is essential for storing and indexing high-dimensional vectors, which are critical for retrieval-augmented generation (RAG) systems. Ensure that it is installed by executing the following SQL command:
 
 ```sql
    CREATE EXTENSION IF NOT EXISTS vector;
 ```
-### Step 3: Create a Table to Track Processed Documents
+### Step 3: Create a table to track processed documents
 
 To prevent reprocessing documents that have already been loaded and vectorized, you should create a table to keep track of them. This will ensure that new documents added to your object storage bucket are only processed once, avoiding duplicate downloads and redundant vectorization:
 
 ```sql
  CREATE TABLE IF NOT EXISTS object_loaded (id SERIAL PRIMARY KEY, object_key TEXT);
 ```
 
-### Step 4: Connect to PostgreSQL Programmatically
+### Step 4: Connect to PostgreSQL programmatically
 
 Connect to your PostgreSQL instance and perform tasks programmatically.
 
@@ -143,7 +143,7 @@ embeddings = OpenAIEmbeddings(
             )
 ```
 
-#### Key Parameters:
+#### Key parameters:
 - `openai_api_key`: This is your API key for accessing the OpenAI-powered embeddings service, in this case, deployed via Scaleway’s Managed Inference.
 - `openai_api_base`: This is the base URL that points to your deployment of the sentence-transformers/sentence-t5-xxl model on Scaleway's Managed Inference. This URL serves as the entry point to make API calls for generating embeddings.
 - `model="sentence-transformers/sentence-t5-xxl"`: This defines the specific model being used for text embeddings. sentence-transformers/sentence-t5-xxl is a powerful model optimized for generating high-quality sentence embeddings, making it ideal for tasks like document retrieval in RAG systems.
@@ -159,7 +159,7 @@ In the context of using Scaleway’s Managed Inference and the `sentence-t5-xxl`
 Moreover, leaving `tiktoken_enabled` as `True` causes issues when sending data to Scaleway’s API because it results in tokenized vectors being sent instead of raw text. Since Scaleway's endpoint expects text and not pre-tokenized data, this mismatch can lead to errors or incorrect behavior.
 By setting `tiktoken_enabled=False`, you ensure that raw text is sent to Scaleway's Managed Inference endpoint, which is what the sentence-transformers model expects to process. This guarantees that the embedding generation process works smoothly with Scaleway's infrastructure.
 
-### Step 3: Create a PGVector Store
+### Step 3: Create a PGVector store
 
 Configure the connection string for your PostgreSQL instance and create a PGVector store to store these embeddings.
 
@@ -172,11 +172,11 @@ vector_store = PGVector(connection=connection_string, embeddings=embeddings)
 
 PGVector: This creates the vector store in your PostgreSQL database to store the embeddings.
 
-## Load and Process Documents
+## Load and process documents
 
 Use the [`S3FileLoader`](https://api.python.langchain.com/en/latest/document_loaders/langchain_community.document_loaders.s3_file.S3FileLoader.html) to load documents and split them into chunks. Then, embed and store them in your PostgreSQL database.
 
-### Step 1: Import Required Modules
+### Step 1: Import required modules
 
 ```python
 #rag.py
@@ -188,9 +188,9 @@ from langchain_openai import OpenAIEmbeddings
 
 ```
 
-### Step 2: Load Metadata for Improved Efficiency
+### Step 2: Load metadata for improved efficiency
 
-Load Metadata for Improved Efficiency: By loading the metadata for all objects in your bucket, you can speed up the process significantly. This allows you to quickly check if a document has already been embedded without the need to load the entire document.
+Load metadata for improved efficiency: By loading the metadata for all objects in your bucket, you can speed up the process significantly. This allows you to quickly check if a document has already been embedded without the need to load the entire document.
 
 ```python
 # rag.py
@@ -205,14 +205,14 @@ page_iterator = paginator.paginate(Bucket=BUCKET_NAME)
 ```
 
 In this code sample we:
-- Set Up a Boto3 Session: We initialize a Boto3 session, which is the AWS SDK for Python, fully compatible with Scaleway Object Storage. This session manages configuration, including credentials and settings, that Boto3 uses for API requests.
-- Create an S3 Client: We establish an S3 client to interact with the Scaleway Object storage service.
-- Set Up Pagination for Listing Objects: We prepare pagination to handle potentially large lists of objects efficiently.
-- Iterate Through the Bucket: This initiates the pagination process, allowing us to list all objects within the specified Scaleway Object bucket seamlessly.
+- Set up a Boto3 session: We initialize a Boto3 session, which is the AWS SDK for Python, fully compatible with Scaleway Object Storage. This session manages configuration, including credentials and settings, that Boto3 uses for API requests.
+- Create an S3 client: We establish an S3 client to interact with the Scaleway Object Storage service.
+- Set up pagination for listing objects: We prepare pagination to handle potentially large lists of objects efficiently.
+- Iterate through the bucket: This initiates the pagination process, allowing us to list all objects within the specified Scaleway Object bucket seamlessly.
 
-### Step 3: Iterate Through Metadata
+### Step 3: Iterate through metadata
 
-Iterate Through Metadata: Next, we will iterate through the metadata to determine if each object has already been embedded. If an object hasn’t been processed yet, we will embed it and load it into the database.
+Iterate through metadata: Next, we will iterate through the metadata to determine if each object has already been embedded. If an object hasn’t been processed yet, we will embed it and load it into the database.
 
 ```python
 # rag.py
@@ -245,9 +245,9 @@ conn.commit()
 
 - S3FileLoader: The S3FileLoader loads each file individually from your ***Scaleway Object Storage bucket*** using the file's object_key (extracted from the file's metadata). It ensures that only the specific file is loaded from the bucket, minimizing the amount of data being retrieved at any given time.
 - RecursiveCharacterTextSplitter: The RecursiveCharacterTextSplitter breaks each document into smaller chunks of text. This is crucial because embeddings models, like those used in Retrieval-Augmented Generation (RAG), typically have a limited context window (the number of tokens they can process at once).
-- Embedding the Chunks: For each document, the text is split into smaller chunks using the text splitter, and an embedding is generated for each chunk using the embeddings.embed_query(chunk) function. This function transforms each chunk into a vector representation that can later be used for similarity search.
-- Embedding Storage: After generating the embeddings for each chunk, they are stored in a vector database (e.g., PostgreSQL with pgvector) using the vector_store.add_embeddings(embedding, chunk) method. Each embedding is stored alongside its corresponding text chunk, enabling retrieval during a query.
-- Avoiding Redundant Processing: The script checks the object_loaded table in PostgreSQL to see if a document has already been processed (i.e., the object_key exists in the table). If it has, the file is skipped, avoiding redundant downloads, vectorization, and database inserts. This ensures that only new or modified documents are processed, reducing the system's computational load and saving both time and resources.
+- Embedding the chunks: For each document, the text is split into smaller chunks using the text splitter, and an embedding is generated for each chunk using the embeddings.embed_query(chunk) function. This function transforms each chunk into a vector representation that can later be used for similarity search.
+- Embedding storage: After generating the embeddings for each chunk, they are stored in a vector database (e.g., PostgreSQL with pgvector) using the vector_store.add_embeddings(embedding, chunk) method. Each embedding is stored alongside its corresponding text chunk, enabling retrieval during a query.
+- Avoiding redundant processing: The script checks the object_loaded table in PostgreSQL to see if a document has already been processed (i.e., the object_key exists in the table). If it has, the file is skipped, avoiding redundant downloads, vectorization, and database inserts. This ensures that only new or modified documents are processed, reducing the system's computational load and saving both time and resources.
 
 #### Why 500 characters?
 
@@ -262,7 +262,7 @@ When a query is made, the RAG system will retrieve the most relevant embeddings,
 
 ### Query the RAG System with a pre-defined prompt template
 
-### Step 1: Import Required Modules
+### Step 1: Import required modules
 
 ```python
 #rag.py
@@ -273,7 +273,7 @@ from langchain_core.runnables import RunnablePassthrough
 
 ```
 
-### Step 2: Setup LLM for Querying
+### Step 2: Setup LLM for querying
 
 Now, set up the RAG system to handle queries
 
@@ -301,15 +301,15 @@ for r in rag_chain.stream("Your question"):
     print(r, end="", flush=True)
     time.sleep(0.1)
 ```
-- LLM Initialization: We initialize the ChatOpenAI instance using the endpoint and API key from the environment variables, along with the specified model name.
+- LLM initialization: We initialize the ChatOpenAI instance using the endpoint and API key from the environment variables, along with the specified model name.
 
-- Prompt Setup: The prompt is pulled from the hub using a pre-defined template, ensuring consistent query formatting.
+- Prompt setup: The prompt is pulled from the hub using a pre-defined template, ensuring consistent query formatting.
 
-- Retriever Configuration: We set up the retriever to access the vector store, allowing the RAG system to retrieve relevant information based on the query.
+- Retriever configuration: We set up the retriever to access the vector store, allowing the RAG system to retrieve relevant information based on the query.
 
-- RAG Chain Construction: We create the RAG chain, which connects the retriever, prompt, LLM, and output parser in a streamlined workflow.
+- RAG chain construction: We create the RAG chain, which connects the retriever, prompt, LLM, and output parser in a streamlined workflow.
 
-- Query Execution: Finally, we stream the output of the RAG chain for a specified question, printing each response with a slight delay for better readability.
+- Query execution: Finally, we stream the output of the RAG chain for a specified question, printing each response with a slight delay for better readability.
 
 ### Query the RAG system with you own prompt template
 
@@ -339,22 +339,22 @@ for r in custom_rag_chain.stream({"question":"your question", "context": context
     time.sleep(0.1)
 ```
 
-- Prompt Template: The prompt template is meticulously crafted to direct the model's responses. It clearly instructs the model on how to leverage the provided context and emphasizes the importance of honesty in cases where it lacks information.
+- Prompt template: The prompt template is meticulously crafted to direct the model's responses. It clearly instructs the model on how to leverage the provided context and emphasizes the importance of honesty in cases where it lacks information.
 To make the responses more engaging, consider adding a light-hearted conclusion or a personalized touch. For example, you might modify the closing line to say, "Thank you for asking! I'm here to help with anything else you need!"
-Retrieving Context:
+Retrieving context:
 - The retriever.invoke(new_message) method fetches relevant information from your vector store based on the user’s query. It's essential that this step retrieves high-quality context to ensure that the model's responses are accurate and helpful.
 You can enhance the quality of the context by fine-tuning your embeddings and ensuring that the documents in your vector store are relevant and well-structured.
-Creating the RAG Chain:
+Creating the RAG chain:
 - The create_stuff_documents_chain function connects the language model with your custom prompt. This integration allows the model to process the retrieved context effectively and formulate a coherent and context-aware response.
 Consider experimenting with different chain configurations to see how they affect the output. For instance, using a different chain type may yield varied responses.
-Streaming Responses:
+Streaming responses:
 - The loop that streams responses from the custom_rag_chain provides a dynamic user experience. Instead of waiting for the entire output, users can see responses as they are generated, enhancing interactivity.
 You can customize the streaming behavior further, such as implementing progress indicators or more sophisticated UI elements for applications.
 
-#### Example Use Cases
-- Customer Support: Use a custom prompt to answer customer queries effectively, making the interactions feel more personalized and engaging.
-- Research Assistance: Tailor prompts to provide concise summaries or detailed explanations on specific topics, enhancing your research capabilities.
-- Content Generation: Personalize prompts for creative writing, generating responses that align with specific themes or tones.
+#### Example use cases
+- Customer support: Use a custom prompt to answer customer queries effectively, making the interactions feel more personalized and engaging.
+- Research assistance: Tailor prompts to provide concise summaries or detailed explanations on specific topics, enhancing your research capabilities.
+- Content generation: Personalize prompts for creative writing, generating responses that align with specific themes or tones.
 
 ### Conclusion