Two-Stage Retrieval: Cross-Encoder Reranking with Laravel 13 AI SDK

On my recent deep dives into Vespa's Multi-Stage Ranking Engine and Scaling pgvector Ingestion in Laravel 13, we explored how to store millions of multi-dimensional embeddings and query them at scale. But as applications move from prototypes into production, a glaring issue often surfaces: the actual ordering of the top 5 vector search results can feel completely disorganized.

You search a documentation base for "How to clear application cache in a background job," and your vector database correctly pulls 50 relevant chunks. However, the absolute top-ranked result might be a generic paragraph about background job configurations, while the exact snippet containing the code example is buried down at position #7.

Pure semantic vector closeness often fails to evaluate fine-grained word overlaps, negation, or specific technical modifiers. To fix this, production-grade systems use a Two-Stage Retrieval Pipeline. Let's build one natively in PHP using the first-party Laravel 13 AI SDK.

Bi-Encoders vs. Cross-Encoders: The Two-Stage Paradigm

To understand why your current search feels clumsy, you have to look at the underlying model architectures:

1. Bi-Encoders (Your Vector Store): Your embedding model turns your query and your database documents into vectors completely independently of each other. The database compares them using fast mathematical dot products. This is ultra-fast and handles Recall beautifully—instantly filtering millions of rows down to 50 candidates.
2. Cross-Encoders (The Re-Ranker): A Cross-Encoder doesn't look at pre-computed vectors. Instead, it feeds the user's query and a document text string together into the attention window of a transformer network. It analyzes exact term intersections and linguistic modifiers on the fly. This process is highly accurate for Precision, but computationally expensive.

[Millions of Rows] ───( pgvector / Bi-Encoder )───> [Top 50 Candidates] ───( Cross-Encoder )───> [Perfect Top 5 Results]

By combining both into a two-stage pipeline, you achieve the best of both worlds: sub-10ms scalability over giant tables, paired with near-perfect ranking precision.

Step 1: Executing Fast First-Stage Recall with pgvector

We begin by querying our primary PostgreSQL database using our existing AI-Native Eloquent query patterns. Instead of returning only 3 or 5 records to the end-user, we widen our target window to capture a robust pool of 50 candidate records.

PHP

use App\Models\DocumentChunk;

// Stage 1: High-speed semantic recall over millions of items
$candidates = DocumentChunk::query()
    ->whereVectorSimilarTo('embedding', $userQuery)
    ->limit(50) 
    ->get();

At this stage, our pgvector HNSW graph filter has eliminated 99.9% of the irrelevant data in our database effortlessly.

Step 2: Precision Re-Ranking via the Laravel AI SDK

Now, we take those 50 candidate records and feed them into the Laravel AI SDK's native Reranking manager. The SDK maps seamlessly to top enterprise reranking backends like Cohere, Jina, or local endpoints running lightweight models.

PHP

use Laravel\Ai\Reranking;

// Stage 2: Deep joint-attention scoring across the candidate pool
$rerankedCollection = Reranking::of($candidates)
    ->limit(5) // Narrow our final output to the absolute best top 5
    ->rerank($userQuery);

// Extract the sorted documents
$finalResults = $rerankedCollection->map(fn($item) => $item->document);

Behind the scenes, the Cross-Encoder scores every individual text string directly against the literal semantics of your query and resort-orders your collection based on the output weights.

Step 3: Streamlining with the Collection Macro

Because Laravel is built with developer convenience in mind, the AI SDK injects a helpful macro directly into the base framework Collection class out of the box. This lets you collapse your entire two-stage code implementation into a single fluid, readable statement:

PHP

$finalResults = DocumentChunk::query()
    ->whereVectorSimilarTo('embedding', $userQuery)
    ->limit(50)
    ->get()
    ->rerank('content', $userQuery) // Pass target column and query
    ->take(5);

This structural elegance keeps your controllers highly maintainable while implementing an elite search topology behind the scenes.

Infrastructure Trade-offs: Latency vs. Re-Ranking Depth

As a Solution Architect, I must emphasize that precision comes with a minor latency cost. While a vector lookup in pgvector takes mere milliseconds, pushing text across a Cross-Encoder network adds a brief calculation window per item.

• If you rerank the top 20 items, your processing overhead is practically imperceptible (<30ms).
• If you attempt to rerank the top 200 items, your system latency can spike past 400ms, defeating the purpose of an optimized search layout.

For the vast majority of user-facing RAG platforms, capping your first-stage recall pool at 40 to 50 candidates strikes the perfect balance between highly accurate relevance and snappy page load performance.

FAQ: Common Questions on Laravel AI Reranking

Q: Can I use open-source rerankers like BGE-Reranker locally? Yes. By pointing your AI configuration backend (config/ai.php) to a local Ollama instance or a private Hugging Face Text Embeddings Inference (TEI) container, you can run open models like bge-reranker-v2-m3 completely free of cloud costs.

Q: Does re-ranking replace traditional keyword matching (BM25)? No, it complements it. The industry gold standard for search engine layouts is a Hybrid Architecture: execute a combined text and vector query, merge the results using Reciprocal Rank Fusion, and then pass that consolidated group to a Cross-Encoder to finalize the top results.