search-r3-reasoning

name	search-r3-reasoning
title	Search-R3: Unifying Reasoning and Embedding Generation for Retrieval
version	0.0.2
engine	skillxiv-v0.0.2-claude-opus-4.6
license	MIT
url	https://arxiv.org/abs/2510.07048
keywords	["retrieval-augmented-generation","reasoning","embedding-generation","post-training","knowledge-intensive-tasks"]
description	Unify LLM reasoning with embedding generation by training models to output embeddings as direct outputs of step-by-step reasoning. Trigger: improve performance on complex retrieval tasks requiring deep reasoning.

Search-R3: Reasoning + Retrieval Integration

Core Concept

Search-R3 addresses a critical gap: Large language models excel at reasoning but have been underutilized for retrieval tasks. Current systems treat reasoning and retrieval as separate pipelines. Search-R3 unifies these by training LLMs to generate search embeddings as direct outputs of their reasoning process. Through combined supervised learning and RL, models learn to produce embeddings that simultaneously capture both reasoning depth and retrieval relevance, improving performance on knowledge-intensive tasks requiring complex reasoning.

The key insight: Embeddings are not fixed representations; they can be outputs of reasoning, making retrieval and reasoning co-dependent and co-optimized.

Architecture Overview

• Unified Post-Training: Combines supervised learning + RL in single framework
• Reasoning-Driven Embeddings: Embeddings are outputs of chain-of-thought
• Specialized RL Environment: Efficiently handles dynamic corpus representations
• Two-Stage Learning: Supervised embedding generation → RL optimization
• No Corpus Re-encoding: Embeddings computed once during training

Implementation Steps

1. Understand Reasoning-Based Embedding Generation

Define how embeddings emerge from reasoning.

class ReasoningEmbeddingGenerator:
    """
    Generate embeddings through explicit reasoning steps.
    """
    def __init__(self, model, embedding_dim=768):
        self.model = model
        self.embedding_dim = embedding_dim

    def generate_reasoning_and_embedding(self, query):
        """
        Chain-of-thought reasoning that concludes with embedding generation.

        Args:
            query: Query string or question

        Returns:
            (reasoning_trace, embedding_vector)
        """
        # Step 1: Generate reasoning
        reasoning_prompt = (
            f"Query: {query}\n\n"
            f"Think through this step-by-step:\n"
            
            
            
            
        )

        reasoning = .model.generate(
            reasoning_prompt,
            max_tokens=,
            temperature=
        )

        
        embedding_prompt = (
            
            
            
            
        )

        embedding_text = .model.generate(
            embedding_prompt,
            max_tokens=,
            temperature=
        )

        
        embedding = .parse_embedding_output(embedding_text)

         reasoning, embedding

     ():
        
        
         re
        numbers = re.findall(, embedding_text)

         (numbers) >= .embedding_dim:
            embedding = torch.tensor([(n)  n  numbers[:.embedding_dim]])
        :
            
            embedding = torch.zeros(.embedding_dim)
             i, num  (numbers):
                embedding[i] = (num)

        
        embedding = embedding / (torch.norm(embedding) + )

         embedding

     ():
        
        
        doc_embeddings = .model.encode_documents(relevant_docs)

        similarities = []
         doc_emb  doc_embeddings:
            sim = torch.dot(embedding, doc_emb) / (
                torch.norm(embedding) * torch.norm(doc_emb) + 
            )
            similarities.append(sim.item())

        
        recall_at_1 =   (similarities) >   
        mean_similarity = np.mean(similarities)

         {
            : recall_at_1,
            : mean_similarity,
            : recall_at_1 *  + mean_similarity * 
        }