Optimización de RAG con la modalidad de visión de GPT-4o

import os
import time
# Import the Pinecone library
from pinecone.grpc import PineconeGRPC as Pinecone
from pinecone import ServerlessSpec

from dotenv import load_dotenv

load_dotenv()

api_key = os.getenv("PINECONE_API_KEY")

# Initialize a Pinecone client with your API key
pc = Pinecone(api_key)

# Create a serverless index
index_name = "my-test-index"

if not pc.has_index(index_name):
    pc.create_index(
        name=index_name,
        dimension=3072,
        metric="cosine",
        spec=ServerlessSpec(
            cloud='aws',
            region='us-east-1'
        )
    )

# Wait for the index to be ready
while not pc.describe_index(index_name).status['ready']:
    time.sleep(1)

import base64
import requests
import os
import pandas as pd
from PyPDF2 import PdfReader, PdfWriter
from pdf2image import convert_from_bytes
from io import BytesIO
from openai import OpenAI
from tqdm import tqdm

# Link to the document we will use as the example 
document_to_parse = "https://documents1.worldbank.org/curated/en/099101824180532047/pdf/BOSIB13bdde89d07f1b3711dd8e86adb477.pdf"

# OpenAI client 
oai_client = OpenAI()


# Chunk the PDF document into single page chunks 
def chunk_document(document_url):
    # Download the PDF document
    response = requests.get(document_url)
    pdf_data = response.content

    # Read the PDF data using PyPDF2
    pdf_reader = PdfReader(BytesIO(pdf_data))
    page_chunks = []

    for page_number, page in enumerate(pdf_reader.pages, start=1):
        pdf_writer = PdfWriter()
        pdf_writer.add_page(page)
        pdf_bytes_io = BytesIO()
        pdf_writer.write(pdf_bytes_io)
        pdf_bytes_io.seek(0)
        pdf_bytes = pdf_bytes_io.read()
        page_chunk = {
            'pageNumber': page_number,
            'pdfBytes': pdf_bytes
        }
        page_chunks.append(page_chunk)

    return page_chunks


# Function to encode the image
def encode_image(local_image_path):
    with open(local_image_path, "rb") as image_file:
        return base64.b64encode(image_file.read()).decode('utf-8')


# Function to convert page to image     
def convert_page_to_image(pdf_bytes, page_number):
    # Convert the PDF page to an image
    images = convert_from_bytes(pdf_bytes)
    image = images[0]  # There should be only one page

    # Define the directory to save images (relative to your script)
    images_dir = 'images'  # Use relative path here

    # Ensure the directory exists
    os.makedirs(images_dir, exist_ok=True)

    # Save the image to the images directory
    image_file_name = f"page_{page_number}.png"
    image_file_path = os.path.join(images_dir, image_file_name)
    image.save(image_file_path, 'PNG')

    # Return the relative image path
    return image_file_path


# Pass the image to the LLM for interpretation  
def get_vision_response(prompt, image_path):
    # Getting the base64 string
    base64_image = encode_image(image_path)

    response = oai_client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {
                "role": "user",
                "content": [
                    {"type": "text", "text": prompt},
                    {
                        "type": "image_url",
                        "image_url": {
                            "url": f"data:image/jpeg;base64,{base64_image}"
                        },
                    },
                ],
            }
        ],
    )
    return response


# Process document function that brings it all together 
def process_document(document_url):
    try:
        # Update document status to 'Processing'
        print("Document processing started")

        # Get per-page chunks
        page_chunks = chunk_document(document_url)
        total_pages = len(page_chunks)

        # Prepare a list to collect page data
        page_data_list = []

        # Add progress bar here
        for page_chunk in tqdm(page_chunks, total=total_pages, desc='Processing Pages'):
            page_number = page_chunk['pageNumber']
            pdf_bytes = page_chunk['pdfBytes']

            # Convert page to image
            image_path = convert_page_to_image(pdf_bytes, page_number)

            # Prepare question for vision API
            system_prompt = (
                "The user will provide you an image of a document file. Perform the following actions: "
                "1. Transcribe the text on the page. **TRANSCRIPTION OF THE TEXT:**"
                "2. If there is a chart, describe the image and include the text **DESCRIPTION OF THE IMAGE OR CHART**"
                "3. If there is a table, transcribe the table and include the text **TRANSCRIPTION OF THE TABLE**"
            )

            # Get vision API response
            vision_response = get_vision_response(system_prompt, image_path)

            # Extract text from vision response
            text = vision_response.choices[0].message.content

            # Collect page data
            page_data = {
                'PageNumber': page_number,
                'ImagePath': image_path,
                'PageText': text
            }
            page_data_list.append(page_data)

        # Create DataFrame from page data
        pdf_df = pd.DataFrame(page_data_list)
        print("Document processing completed.")
        print("DataFrame created with page data.")

        # Return the DataFrame
        return pdf_df

    except Exception as err:
        print(f"Error processing document: {err}")
        # Update document status to 'Error'


df = process_document(document_to_parse)

Document processing started

Processing Pages: 100%|██████████| 49/49 [18:54<00:00, 23.14s/it]

Document processing completed.
DataFrame created with page data.

from IPython.display import display, HTML

# Convert the DataFrame to an HTML table and display top 5 rows 
display(HTML(df.head().to_html()))

<IPython.core.display.HTML object>

Echemos un vistazo a una página de ejemplo, como la página 21, que contiene gráficos y texto incrustados. Podemos observar que la modalidad de visión extrajo y describió eficazmente la información visual. Por ejemplo, el gráfico circular de esta página se describe con precisión como:

"FIGURE 6: MIDDLE EAST AND NORTH AFRICA IBRD AND IDA LENDING BY SECTOR - FISCAL 2024 SHARE OF TOTAL OF $4.6 BILLION" is a circular chart, resembling a pie chart, illustrating the percentage distribution of funds among different sectors. The sectors include:

# Filter and print rows where pageNumber is 21
filtered_rows = df[df['PageNumber'] == 21]
for text in filtered_rows.PageText:
    print(text)

**TRANSCRIPTION OF THE TEXT:**

We also committed $35 million in grants to support emergency relief in Gaza. Working with the World Food Programme, the World Health Organization, and the UN Children’s Fund, the grants supported the delivery of emergency food, water, and medical supplies. In the West Bank, we approved a $200 million program for the continuation of education for children, $22 million to support municipal services, and $45 million to strengthen healthcare and hospital services.

**Enabling green and resilient growth**
To help policymakers in the region advance their climate change and development goals, we published Country Climate and Development Reports for the West Bank and Gaza, Lebanon, and Tunisia. In Libya, the catastrophic flooding in September 2023 devastated eastern localities, particularly the city of Derna. The World Bank, together with the UN and the European Union, produced a Rapid Damage and Needs Assessment to inform recovery and reconstruction efforts.

We signed a new Memorandum of Understanding (MoU) with the Islamic Development Bank to promote further collaboration between our institutions. The MoU focuses on joint knowledge and operational engagements around the energy, food, and water nexus, climate impact, empowering women and youth to engage with the private sector, and advancing the digital transition and regional integration. The MoU aims to achieve a co-financing value of $6 billion through 2026, 45 percent of which has already been met.

**Expanding economic opportunities for women**
The World Bank has drawn on a variety of instruments to support Jordan’s commitment to increase female labor force participation, including through the recently approved Country Partnership Framework. Through operations, technical assistance (such as Mashreq Gender Facility; Women Entrepreneurs Finance Initiative; and the Women, Business and the Law report), and policy dialogue, we have contributed to legal reforms in Jordan that removed job restrictions on women, prohibited gender-based discrimination in the workplace, and criminalized sexual harassment in the workplace. In fiscal 2024, we approved the first women-focused Bank project in the region: the Enhancing Women’s Economic Opportunities Program for Results aims to improve workplace conditions, increase financial inclusion and entrepreneurship, make public transport safer, and increase access to affordable, quality childcare services.

**Analyzing critical infrastructure needs**
We published an Interim Damage Assessment for Gaza in partnership with the UN and with financial support from the EU. This found that a preliminary estimate of the cost of damages to critical infrastructure from the conflict in Gaza between October 2023 and the end of January 2024 was around $18.5 billion—equivalent to 97 percent of the 2022 GDP of the West Bank and Gaza combined. When the situation allows, a full-fledged Rapid Damage and Needs Assessment will be conducted.

**COUNTRY IMPACT**

Egypt: The Bank-supported Takaful and Karama social protection program has reached 4.7 million vulnerable households, benefitting approximately 20 million individuals, 75 percent of them women.

Lebanon: A roads project has rehabilitated over 500 km of roads in 25 districts across the country and generated 1.3 million labor days for Lebanese workers and Syrian refugees.

Morocco: Our programs have benefited more than 400,000 people directly and more than 33 million people indirectly, through more than 230 disaster risk reduction projects.

**DESCRIPTION OF THE IMAGE OR CHART:**

The image is a pie chart titled "FIGURE 6: MIDDLE EAST AND NORTH AFRICA IBRD AND IDA LENDING BY SECTOR - FISCAL 2024 SHARE OF TOTAL OF $4.6 BILLION." The chart breaks down the sectors as follows:
- Public Administration: 24%
- Social Protection: 13%
- Health: 13%
- Education: 17%
- Agriculture, Fishing, and Forestry: 8%
- Water, Sanitation, and Waste Management: 8%
- Transportation: 5%
- Energy and Extractives: 3%
- Financial Sector: 1%
- Industry, Trade, and Services: 2%
- Information and Communications Technologies: 6%

**TRANSCRIPTION OF THE TABLE:**

TABLE 13: MIDDLE EAST AND NORTH AFRICA REGIONAL SNAPSHOT

| INDICATOR                                                | 2000   | 2012     | CURRENT DATA* |
|----------------------------------------------------------|--------|----------|---------------|
| Total population (millions)                              | 283.9  | 356.2    | 430.9         |
| Population growth (annual %)                             | 2.0    | 1.8      | 1.5           |
| GNI per capita (Atlas method, current US$)               | 1,595.5| 4,600.4  | 3,968.1       |
| GDP per capita growth (annual %)                         | 4.0    | 1.7      | 1.2           |
| Population living below $2.15 a day (millions)           | 9.7    | 8.2      | 19.1          |
| Life expectancy at birth, females (years)                | 70.8   | 73.9     | 74.8          |
| Life expectancy at birth, males (years)                  | 66.5   | 69.6     | 69.9          |
| Carbon dioxide emissions (megatons)                      | 813.2  | 1,297.7  | 1,370.9       |
| Extreme poverty (% of population below $2.15 a day, 2017 PPP)| 3.4 | 2.3      | 4.7           |
| Debt service as a proportion of exports of goods, services, and primary income | 15.1   | 5.2      | 12.4   |
| Ratio of female to male labor force participation rate (%) (modeled ILO estimate) | 24.5   | 26.2     | 23.2   |
| Vulnerable employment, total (% of total employment) (modeled ILO estimate) | 35.4   | 31.7     | 31.4   |
| Under-5 mortality rate per 1,000 live births             | 46.7   | 29.0     | 20.9          |
| Primary completion rate (% of relevant age group)        | 81.4   | 88.9     | 86.7          |
| Individuals using the Internet (% of population)         | 0.9    | 26.0     | 73.4          |
| Access to electricity (% of population)                  | 91.4   | 94.7     | 96.9          |
| Renewable energy consumption (% of total final energy consumption) | 3.0 | 3.6      | 2.9    |
| People using at least basic drinking water services (% of population) | 86.5   | 90.6     | 93.7   |
| People using at least basic sanitation services (% of population) | 79.4   | 86.2     | 90.4   |

*Note: ILO = International Labour Organization. PPP = purchasing power parity. a. The most current data available between 2018 and 2023; visit [https://data.worldbank.org](https://data.worldbank.org) for data updates.

For more information, visit [www.worldbank.org/mena](http://www.worldbank.org/mena).

Paso 3: Generación de Embeddings:

En esta sección, nos enfocamos en transformar el contenido textual extraído de cada página del documento en embeddings vectoriales. Estos embeddings capturan el significado semántico del texto, lo que permite búsquedas de similitud eficientes y diversas tareas de Procesamiento de Lenguaje Natural (NLP). También identificamos páginas que contienen elementos visuales, como imágenes, gráficos o tablas, y las marcamos para un manejo especial.

Desglose del paso:

1. Añadir un indicador para contenido visual

Para procesar páginas que contienen información visual, en el Paso 2 utilizamos la modalidad de visión para extraer contenido de gráficos, tablas e imágenes. Al incluir instrucciones específicas en nuestro prompt, nos aseguramos de que el modelo añada marcadores como DESCRIPTION OF THE IMAGE OR CHART o TRANSCRIPTION OF THE TABLE al describir contenido visual. En este paso, si se detecta dicho marcador, establecemos el indicador Visual_Input_Processed en 'Y'; de lo contrario, permanece en 'N'.

Aunque la modalidad de visión captura la mayoría de la información visual de manera efectiva, algunos detalles —particularmente en elementos visuales complejos como dibujos de ingeniería— pueden perderse en la traducción. En el Paso 6, utilizaremos este indicador para determinar cuándo pasar la imagen de la página a GPT-4 Vision como contexto adicional. Esta es una mejora opcional que puede aumentar significativamente la efectividad de una solución RAG.

2. Generación de Embeddings con el Modelo de Embeddings de OpenAI

Utilizamos el modelo de embeddings de OpenAI, text-embedding-3-large, para generar embeddings de alta dimensión que representan el contenido semántico de cada página.

Nota: Es crucial asegurar que las dimensiones del modelo de embeddings que utilizas sean consistentes con la configuración de tu almacén de vectores de Pinecone. En nuestro caso, configuramos la base de datos de Pinecone con 3072 dimensiones para que coincida con las dimensiones predeterminadas de text-embedding-3-large.

# Add a column to flag pages with visual content
df['Visual_Input_Processed'] = df['PageText'].apply(
    lambda x: 'Y' if 'DESCRIPTION OF THE IMAGE OR CHART' in x or 'TRANSCRIPTION OF THE TABLE' in x else 'N'
)


# Function to get embeddings
def get_embedding(text_input):
    response = oai_client.embeddings.create(
        input=text_input,
        model="text-embedding-3-large"
    )
    return response.data[0].embedding


# Generate embeddings with a progress bar
embeddings = []
for text in tqdm(df['PageText'], desc='Generating Embeddings'):
    embedding = get_embedding(text)
    embeddings.append(embedding)

# Add the embeddings to the DataFrame
df['Embeddings'] = embeddings

Generating Embeddings: 100%|██████████| 49/49 [00:18<00:00,  2.61it/s]

Podemos verificar que nuestra lógica marcó correctamente las páginas que requieren entrada visual. Por ejemplo, la página 21, que examinamos previamente, tiene el indicador Visual_Input_Needed establecido en "Y".

# Display the flag for page 21 
filtered_rows = df[df['PageNumber'] == 21]
print(filtered_rows.Visual_Input_Processed)

20    Y
Name: Visual_Input_Processed, dtype: object

Paso 4: Subir embeddings a Pinecone:

En esta sección, subiremos los embeddings que hemos generado para cada página de nuestro documento a Pinecone. Junto con los embeddings, incluiremos etiquetas de metadatos relevantes que describen cada página, como el número de página, el contenido del texto, las rutas de las imágenes y si la página incluye gráficos.

Desglose del paso:

1. Crear campos de metadatos:
Los metadatos mejoran nuestra capacidad para realizar búsquedas más granulares, encontrar el texto o la imagen asociada con el vector y permiten el filtrado dentro de la base de datos vectorial.

• pageId: Combina el document_id y pageNumber para crear un identificador único para cada página. Lo usaremos como identificador único para nuestros embeddings.
• pageNumber: El número de página numérico dentro del documento.
• text: El contenido de texto extraído de la página.
• ImagePath: La ruta del archivo de la imagen asociada con la página.
• GraphicIncluded: Un booleano o indicador que señala si la página incluye elementos gráficos que pueden requerir procesamiento visual.

2. Subir embeddings:
Utilizaremos la API de Pinecone en la función upsert_vector para "upsertar" los valores:

• Un identificador único
• Embeddings
• Metadatos como se definieron anteriormente

Nota: "Upsert" es una combinación de las palabras "update" (actualizar) e "insert" (insertar). En operaciones de bases de datos, un upsert es una operación atómica que actualiza un registro existente si este existe, o inserta un nuevo registro si no existe. Esto es particularmente útil cuando quieres asegurar que tu base de datos tenga los datos más recientes sin tener que realizar verificaciones separadas para inserción o actualización.

# reload the index from Pinecone 
index = pc.Index(index_name)

# Create a document ID prefix 
document_id = 'WB_Report'


# Define the async function correctly
def upsert_vector(identifier, embedding, metadata):
    try:
        index.upsert([
            {
                'id': identifier,
                'values': embedding,
                'metadata': metadata
            }
        ])
    except Exception as e:
        print(f"Error upserting vector with ID {identifier}: {e}")
        raise


for idx, row in tqdm(df.iterrows(), total=df.shape[0], desc='Uploading to Pinecone'):
    pageNumber = row['PageNumber']

    # Create meta-data tags to be added to Pinecone 
    metadata = {
        'pageId': f"{document_id}-{pageNumber}",
        'pageNumber': pageNumber,
        'text': row['PageText'],
        'ImagePath': row['ImagePath'],
        'GraphicIncluded': row['Visual_Input_Processed']
    }

    upsert_vector(metadata['pageId'], row['Embeddings'], metadata)

Uploading to Pinecone: 100%|██████████| 49/49 [00:08<00:00,  5.93it/s]

Navega a la lista de índices en Pinecone y deberías poder ver los vectores "upsertados" en la base de datos con metadatos.

Paso 5: Realizar una búsqueda semántica de páginas relevantes:

En esta sección, implementamos una búsqueda semántica para encontrar las páginas más relevantes en nuestro documento que respondan a la pregunta de un usuario. Este enfoque utiliza los embeddings almacenados en la base de datos vectorial de Pinecone para recuperar páginas basándose en la similitud semántica de su contenido con la consulta del usuario. Al hacerlo, podemos buscar contenido textual de manera efectiva y proporcionarlo como contexto a GPT-4o para responder la pregunta del usuario.

Desglose del paso:

1. Generar un Embedding para la Pregunta del Usuario

• Utilizamos el modelo de embeddings de OpenAI para generar una representación vectorial de alta dimensión de la pregunta del usuario.
• Este vector captura el significado semántico de la pregunta, lo que nos permite realizar una búsqueda de similitud eficiente contra nuestros embeddings almacenados.
• El embedding es crucial para asegurar que la consulta de búsqueda esté semánticamente alineada con el contenido del documento, incluso si las palabras exactas no coinciden.

2. Consultar el Índice de Pinecone para Páginas Relevantes

• Utilizando el embedding generado, consultamos el índice de Pinecone para encontrar las páginas más relevantes.
• Pinecone realiza una búsqueda de similitud comparando el embedding de la pregunta con los embeddings almacenados en la base de datos vectorial utilizando la similitud cosine. Si recuerdas, establecimos esto como el parámetro metric en el Paso 1 cuando creamos nuestra base de datos de Pinecone.
• Especificamos el número de coincidencias principales a recuperar, típicamente basándonos en un equilibrio entre cobertura y relevancia. Por ejemplo, recuperar las 3-5 páginas principales suele ser suficiente para proporcionar una respuesta completa sin abrumar al modelo con demasiado contexto.

3. Compilar los Metadatos de las Páginas Coincidentes para Proporcionar Contexto

• Una vez que se identifican los embeddings relevantes, recopilamos sus metadatos asociados, incluyendo el texto extraído y el número de página.
• Estos metadatos son esenciales para estructurar el contexto proporcionado a GPT-4o.
• También formateamos la información compilada como un JSON para facilitar su interpretación por parte del LLM.

4. Usar el Modelo GPT-4o para Generar una Respuesta

• Finalmente, pasamos el contexto compilado a GPT-4o.
• El modelo utiliza el contexto para generar una respuesta informativa, coherente y contextualmente relevante a la pregunta del usuario.
• El contexto recuperado ayuda al LLM a responder preguntas con mayor precisión, ya que tiene acceso a información relevante del documento.

import json


# Function to get response to a user's question 
def get_response_to_question(user_question, pc_index):
    # Get embedding of the question to find the relevant page with the information 
    question_embedding = get_embedding(user_question)

    # get response vector embeddings 
    response = pc_index.query(
        vector=question_embedding,
        top_k=2,
        include_values=True,
        include_metadata=True
    )

    # Collect the metadata from the matches
    context_metadata = [match['metadata'] for match in response['matches']]

    # Convert the list of metadata dictionaries to prompt a JSON string
    context_json = json.dumps(context_metadata, indent=3)

    prompt = f"""You are a helpful assistant. Use the following context and images to answer the question. In the answer, include the reference to the document, and page number you found the information on between <source></source> tags. If you don't find the information, you can say "I couldn't find the information"

    question: {user_question}
    
    <SOURCES>
    {context_json}
    </SOURCES>
    """

    # Call completions end point with the prompt 
    completion = oai_client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {"role": "system", "content": prompt}
        ]
    )

    return completion.choices[0].message.content

Ahora, planteemos una pregunta que requiera información de un diagrama. En este caso, los detalles relevantes se encuentran dentro de un gráfico circular.

question = "What percentage was allocated to social protections in Western and Central Africa?"
answer = get_response_to_question(question, index)

print(answer)

Social protection was allocated 8% of the total lending in Western and Central Africa in fiscal 2024. <source>WB_Report-13, page 13</source>

Hagámoslo más desafiante haciendo una pregunta que requiera la interpretación de información presentada en una tabla. En nuestro Paso 2, extrajimos esta información utilizando la modalidad de visión de GPT-4o.

question = "What was the increase in access to electricity between 2000 and 2012 in Western and Central Africa?"
answer = get_response_to_question(question, index)

print(answer)

The increase in access to electricity between 2000 and 2012 in Western and Central Africa was from 34.1% to 44.1%, which is an increase of 10 percentage points. 

<source>WB_Report-13, page 13</source>

Este enfoque funcionó bien. Sin embargo, puede haber casos en los que la información esté incrustada en imágenes o gráficos que pierden fidelidad al traducirse a texto, como dibujos de ingeniería complejos.

Al utilizar la modalidad de visión de GPT-4o, podemos pasar la imagen de la página directamente al modelo como contexto. En la siguiente sección, exploraremos cómo mejorar la precisión de las respuestas del modelo utilizando entradas de imagen.

Paso 6: Manejo de páginas con contenido visual (Paso opcional):

Cuando los metadatos indican la presencia de una imagen, un gráfico o una tabla, podemos pasar la imagen como contexto a GPT-4o en lugar del texto extraído. Este enfoque puede ser útil en casos donde la descripción textual de la información visual no es suficiente para transmitir el contexto. Puede ser el caso de gráficos complejos como dibujos de ingeniería o diagramas complejos.

Desglose del paso:

La diferencia entre este Paso y el Paso 5 es que hemos añadido lógica adicional para identificar cuándo el indicador Visual_Input_Processed está activado para un embedding. En ese caso, en lugar de pasar el texto como contexto, pasamos la imagen de la página utilizando la modalidad de visión de GPT-4o como contexto.

Nota: Este enfoque aumenta tanto la latencia como el costo, ya que el procesamiento de entradas de imagen consume más recursos y es más caro. Por lo tanto, solo debe usarse si los resultados deseados no se pueden lograr con la modalidad de solo texto como se describe en el Paso 5 anterior.

import base64
import json


def get_response_to_question_with_images(user_question, pc_index):
    # Get embedding of the question to find the relevant page with the information 
    question_embedding = get_embedding(user_question)

    # Get response vector embeddings 
    response = pc_index.query(
        vector=question_embedding,
        top_k=3,
        include_values=True,
        include_metadata=True
    )

    # Collect the metadata from the matches
    context_metadata = [match['metadata'] for match in response['matches']]

    # Build the message content
    message_content = []

    # Add the initial prompt
    initial_prompt = f"""You are a helpful assistant. Use the text and images provided by the user to answer the question. You must include the reference to the page number or title of the section you the answer where you found the information. If you don't find the information, you can say "I couldn't find the information"

    question: {user_question}
    """
    
    message_content.append({"role": "system", "content": initial_prompt})
    
    context_messages = []

    # Process each metadata item to include text or images based on 'Visual_Input_Processed'
    for metadata in context_metadata:
        visual_flag = metadata.get('GraphicIncluded')
        page_number = metadata.get('pageNumber')
        page_text = metadata.get('text')
        message =""

        if visual_flag =='Y':
            # Include the image
            print(f"Adding page number {page_number} as an image to context")
            image_path = metadata.get('ImagePath', None)
            try:
                base64_image = encode_image(image_path)
                image_type = 'jpeg'
                # Prepare the messages for the API call
                context_messages.append({
                    "type": "image_url",
                    "image_url": {
                        "url": f"data:image/{image_type};base64,{base64_image}"
                    },
                })
            except Exception as e:
                print(f"Error encoding image at {image_path}: {e}")
        else:
            # Include the text
            print(f"Adding page number {page_number} as text to context")
            context_messages.append({
                    "type": "text",
                    "text": f"Page {page_number} - {page_text}",
                })
        
                # Prepare the messages for the API call
        messages =  {
                "role": "user",
                "content": context_messages
        }
    
    message_content.append(messages)

    completion = oai_client.chat.completions.create(
    model="gpt-4o",
    messages=message_content
    )

    return completion.choices[0].message.content

Examinemos las mismas preguntas que hicimos para la búsqueda semántica solo de texto en el Paso 5. Notamos que el modelo GPT-4o puede identificar el diagrama que tiene información relevante para responder la pregunta.

question = "What percentage was allocated to social protections in Western and Central Africa?"
answer = get_response_to_question_with_images(question, index)

print(answer)

Adding page number 13.0 as an image to context
Adding page number 12.0 as an image to context
Adding page number 11.0 as an image to context
The percentage allocated to social protection in Western and Central Africa is 8% (Figure 2: Western and Central Africa; IBRD and IDA Lending by Sector).

Ahora, hagamos una pregunta que posiblemente no pueda ser respondida por la modalidad de solo texto, como encontrar una imagen relevante en el documento y describirla.

question = "Can you find the image associated with digital improvements and describe what you see in the images?"
answer = get_response_to_question_with_images(question, index)

print(answer)

Adding page number 32.0 as an image to context
Adding page number 10.0 as an image to context
Adding page number 4.0 as an image to context
### Image Descriptions

1. **Page 60-61 (Digital Section)**:
   - **Left Side**: A person is sitting and working on a laptop, holding a smartphone. The setting seems informal, possibly in a small office or a cafe.
   - **Text**: Discussion on scaling digital development, thought leadership, partnerships, and establishment of a Digital Vice Presidency unit for digital transformation efforts.

2. **Page 16-17 (Eastern and Southern Africa Section)**:
   - **Right Side**: A group of people standing on a paved street, some using mobile phones. It seems to be a casual, evening setting.
   - **Text**: Information about improving access to electricity in Rwanda and efforts for education and other services in Eastern and Southern Africa.

3. **Page 4-5 (Driving Action, Measuring Results)**:
   - **Images**: Various circular images and icons accompany text highlights such as feeding people, providing schooling, access to clean water, transport, and energy.
   - **Text**: Summary of key development results achieved by the World Bank Group in fiscal 2024.

These images illustrate the initiatives and impacts of the World Bank's projects and activities in various sectors.

Conclusión

En este manual, nos embarcamos en un viaje para mejorar los sistemas de Generación Aumentada por Recuperación (RAG) para documentos ricos en imágenes, gráficos y tablas. Los modelos RAG tradicionales, aunque competentes con datos textuales, a menudo pasan por alto la gran cantidad de información transmitida a través de elementos visuales. Al integrar modelos de visión y aprovechar el etiquetado de metadatos, hemos cerrado esta brecha, permitiendo que la IA interprete y utilice el contenido visual de manera efectiva.

Comenzamos configurando un almacén de vectores utilizando Pinecone, estableciendo una base para el almacenamiento y la recuperación eficientes de embeddings vectoriales. El análisis de PDF y la extracción de información visual utilizando la modalidad de visión de GPT-4o nos permitieron convertir las páginas del documento en texto relevante. Al generar embeddings y marcar las páginas con contenido visual, creamos un sistema robusto de filtrado de metadatos dentro de nuestro almacén de vectores.

La carga de estos embeddings a Pinecone facilitó una integración perfecta con nuestro flujo de trabajo de procesamiento RAG. A través de la búsqueda semántica, recuperamos páginas relevantes que coincidían con las consultas de los usuarios, asegurando que tanto la información textual como la visual fueran consideradas. El manejo de páginas con contenido visual pasándolas a modelos de visión mejoró la precisión y la profundidad de las respuestas, particularmente para consultas que dependían de imágenes o tablas.

Utilizando el informe A Better Bank for a Better World: Annual Report 2024 del Banco Mundial como nuestro ejemplo guía, demostramos cómo estas técnicas se unen para procesar e interpretar documentos complejos. Este enfoque no solo enriquece la información proporcionada a los usuarios, sino que también mejora significativamente la satisfacción y el compromiso del usuario al ofrecer respuestas más completas y precisas.

Siguiendo los conceptos descritos en este manual, ahora estás equipado para construir sistemas RAG capaces de procesar e interpretar documentos con elementos visuales intrincados. Este avance abre nuevas posibilidades para las aplicaciones de IA en varios dominios donde los datos visuales desempeñan un papel fundamental.