ColPali bypasses OCR by treating document pages as raw images

Traditional Retrieval-Augmented Generation (RAG) pipelines rely on a fractured architecture. To process a complex PDF, you must first disassemble it: text is stripped into strings, tables are reconstructed through OCR, and images are isolated into sub-directories. This process, while standard, destroys the spatial context of the document. When we segregate these entities, we lose the relationship between a figure and its caption, or the alignment of data in a non-standard table. It is like disassembling a family and expecting a stranger to identify they belong together.

ColPali represents a fundamental shift by treating every document page as an image rather than a collection of characters. Instead of running expensive and often error-prone OCR passes, we generate embeddings directly from the visual representation of the page. This approach is particularly effective for convoluted data like insurance policies, government forms, or technical manuals where text is often embedded within graphics. By keeping the document whole, we preserve the visual semantics that human readers use to navigate complex information.

ColPali architecture and the mechanics of late interaction

At the heart of this vision-based retrieval is the concept of late interaction. Unlike traditional models that compress an entire chunk of text into a single vector, ColPali breaks a page into a grid of patches—typically 32x32. Each patch is processed through a vision-based encoder to generate its own embedding vector. If a document has 10 pages and each page has 15 patches, the system manages 150 vectors.

When a user submits a text query, the model tokenizes the text and generates vectors for each token. The "late interaction" occurs when we perform a dot product between every query token vector and every image patch vector stored in the database. We calculate a maximum similarity score for each token against the patches, then sum these maximums to derive a total similarity score for the page. This ensures that a page is retrieved only if all parts of the user's question find strong matches across the various patches of that image. It effectively solves the problem of finding specific information buried in a sea of similar terms across a large corpus.

Setting up the environment and vector storage

To implement this, we require a vector database that supports multi-vector configurations and specific comparators. Qdrant is uniquely suited for this task because it allows us to define a collection with a multivector_config using the max_sim (maximum similarity) comparator. This is essential for executing the late interaction logic during search.

Prerequisites and libraries

To follow this implementation, you will need Python 3.10+ and Docker to run the Qdrant instance locally. The primary libraries used include:

• ColPali-engine: For loading the pre-trained vision-retrieval models.
• Qdrant-client: To interface with the vector database.
• Pillow (PIL): For image processing and RGB conversion.
• Strands Agent: A lightweight framework to orchestrate the agentic workflow.

from colpali_engine.models import ColPali
from qdrant_client import QdrantClient, models

# Initialize Qdrant local instance
client = QdrantClient(host="localhost", port=6333)

# Create a collection with MaxSim comparator
client.create_collection(
    collection_name="document_vision",
    vectors_config=models.VectorParams(
        size=128, 
        distance=models.Distance.COSINE,
        multivector_config=models.MultiVectorConfig(
            comparator=models.MultiVectorComparator.MAX_SIM
        )
    )
)

Logical code walkthrough for vision-based RAG

The implementation follows a three-stage pipeline: data ingestion, semantic retrieval, and agentic response generation.

Stage 1: Document to image conversion

Before embedding, we must convert PDF pages into a standard image format. This step ensures that the vision model receives consistent input regardless of the original document's source. We store these images in a list with metadata including page_number and document_id to allow for easy reconstruction after retrieval.

def convert_pdf_to_images(pdf_path):
    # Uses pdf2image to transform pages into RGB tensors
    images = [] 
    # ... logic to iterate pages ...
    return images

Stage 2: Embedding and ingestion

We pass these images through the ColPali pre-processor and model. Note that the batch size should be kept small—typically 2 to 4—if running on a consumer-grade laptop to avoid memory crashes. The resulting embeddings are then upserted into Qdrant.

Stage 3: Retrieval and multimodal response

When a query is received, we generate its multi-vector representation and query Qdrant. The database returns the top 'k' most relevant images. Because these are images, we cannot use a standard text-based LLM for the final answer. We need a multimodal model like Claude 3.5 Sonnet via Amazon Bedrock or a local model via Ollama to interpret the visual chunks and generate a response.

Creating agentic workflows with Strands

To make this system interactive, we wrap the retrieval and generation logic into an agent using the Strands Agent framework. Strands Agent is a model-first SDK that prioritizes reasoning over complex prompt engineering. It treats an agent as a combination of a model and a set of tools. By defining our retrieval logic as a custom tool, we allow the agent to decide when and how to search the vector database.

from strands import Agent, tool

@tool
def retrieve_documents(query: str):
    # Logic to search Qdrant and return image paths
    return matched_image_paths

# Initialize the agent with Bedrock and tools
agent = Agent(
    model_id="anthropic.claude-3-5-sonnet-20241022-v2:0",
    tools=[retrieve_documents, image_reader, speak]
)

In this setup, the image_reader tool handles the multimodal interpretation, while the speak tool provides the final voice synthesis. This turns a standard search query into a conversational experience where the agent "looks" at the document and "speaks" the findings back to the user.

Practical applications and performance considerations

While ColPali is powerful, it is not a universal replacement for traditional RAG. It is computationally heavy during the ingestion phase because storing 32x32 vectors per page requires more storage than a single text embedding. However, the retrieval speed remains high due to optimized indexing techniques like Hierarchical Navigable Small World (HNSW), which prunes the search space effectively.

This architecture shines in industries like insurance and aerospace. For instance, IKEA assembly manuals contain almost no text, relying instead on emojis and diagrams. A traditional RAG system would find zero matches for a text query about a specific screw in an IKEA PDF. A vision-based system, however, can find the visual pattern of that screw across the patches and identify the correct page. Start with cost-effective text-based RAG for simple documents, but switch to vision-based retrieval when the context is visual or the data is highly convoluted.