Choosing the Right Embedding Model: A Multi-Agent LangGraph Selection Framework

Table of Contents

1. Introduction: The Foundation of Retrieval Quality

2. The Embedding Selection Landscape

3. Seven Critical Selection Criteria

4. Solution Architecture: The "Embedding Model Selector" Multi-Agent System

5. Technology Stack Overview

6. Step-by-Step Implementation: Backend Development

   • Defining the Embedding Selection State Schema with Memory

   • Building the Model Registry Agent

   • Implementing the Benchmark Evaluator Agent

   • Creating the Cost and Latency Analyzer Agent

   • Designing the Domain Fit Agent

   • Building the Final Recommender Agent

   • Constructing the LangGraph Workflow with Conditional Routing

7. Frontend Implementation: Interactive Selection Dashboard

8. Real-Time Use Case: Medical Literature Intelligence Platform

9. Conclusion: Embedding Selection as Strategic Infrastructure

Introduction

The embedding model is the silent foundation of every RAG system it determines whether semantically related documents are retrieved or whether the system returns irrelevant noise. Choosing poorly means building a sophisticated retrieval pipeline on a broken foundation. Yet most teams default to text-embedding-ada-002 or all-MiniLM-L6-v2 without rigorous evaluation, leaving retrieval quality on the table.

The embedding landscape has exploded: OpenAI's text-embedding-3-* family, Cohere's embed-v3, Jina's multilingual models, BGE, GTE, E5, Voyage AI, and domain-specific models like BioBERT embeddings for biomedical text. Each has distinct trade-offs across dimensions, performance, latency, cost, context length, and domain fit. This article presents an enterprise-grade multi-agent LangGraph system that acts as an "Embedding Model Selector" analyzing your use case characteristics, evaluating candidate models against quantified criteria, and recommending the optimal choice with persistent memory of past decisions.

The Embedding Selection Landscape

Modern embedding models vary dramatically along multiple axes:

• Dimensionality: 256 (Matryoshka) to 3072 (text-embedding-3-large) — affects storage, speed, and expressiveness

• Performance: MTEB leaderboard scores (retrieval, STS, classification, clustering)

• Context Length: 512 tokens (older models) to 8192 tokens (Jina v2, Voyage-3)

• Cost: $0.00 to $0.12 per million tokens

• Latency: 10ms to 500ms per 1K tokens

• Domain Specialization: General vs. biomedical vs. legal vs. code

• Multilingual Support: English-only vs. 100+ languages

• Deployment: API-only vs. self-hosted (ONNX, TensorRT)

Seven Critical Selection Criteria

Technology Tags

Python, LangGraph, LangChain, FastAPI, React, PostgreSQL, pgvector, Redis, Pydantic, OpenAI API, Cohere API, Sentence Transformers, MTEB, Hugging Face, Docker, TypeScript, TailwindCSS, NumPy, ONNX Runtime

Step-by-Step Implementation

1. Embedding Selection State Schema

from typing import List, Dict, Any, TypedDict, Optional, Literal
from langgraph.graph import StateGraph, END
from langchain_core.messages import HumanMessage
import redis
import json
from datetime import datetime

class EmbeddingModel(TypedDict):
    id: str
    name: str
    provider: str
    dimensions: int
    max_tokens: int
    mteb_retrieval_score: float
    mteb_overall_score: float
    cost_per_1m_tokens: float
    latency_ms_per_1k_tokens: float
    languages: List[str]
    domain_specialization: Optional[str]
    deployment: Literal["api", "self_hosted", "both"]
    matryoshka_dims: Optional[List[int]]

class EmbeddingSelectionState(TypedDict):
    messages: List
    conversation_id: str
    project_id: str
    # Use case characteristics
    use_case_description: str
    domain: str  # medical, legal, general, code, finance
    primary_language: str
    additional_languages: List[str]
    avg_chunk_tokens: int
    monthly_queries: int
    latency_budget_ms: int
    deployment_constraint: Literal["api", "self_hosted", "any"]
    budget_tier: Literal["low", "medium", "high"]
    # Analysis outputs
    candidate_models: List[EmbeddingModel]
    filtered_models: List[EmbeddingModel]
    model_scores: Dict[str, float]
    score_breakdown: Dict[str, Dict[str, float]]
    # Recommendation
    recommended_model: str
    runner_up: str
    reasoning: str
    trade_offs: Dict[str, List[str]]
    # Memory
    past_selections: List[Dict]

2. Model Registry Agent

from langchain_openai import ChatOpenAI

class ModelRegistryAgent:
    """Maintains a curated registry of embedding models with metadata"""
    
    REGISTRY: List[EmbeddingModel] = [
        {
            "id": "openai-3-small", "name": "text-embedding-3-small",
            "provider": "OpenAI", "dimensions": 1536, "max_tokens": 8191,
            "mteb_retrieval_score": 0.63, "mteb_overall_score": 0.62,
            "cost_per_1m_tokens": 0.02, "latency_ms_per_1k_tokens": 45,
            "languages": ["en"], "domain_specialization": None,
            "deployment": "api", "matryoshka_dims": [512, 1536]
        },
        {
            "id": "openai-3-large", "name": "text-embedding-3-large",
            "provider": "OpenAI", "dimensions": 3072, "max_tokens": 8191,
            "mteb_retrieval_score": 0.67, "mteb_overall_score": 0.65,
            "cost_per_1m_tokens": 0.13, "latency_ms_per_1k_tokens": 85,
            "languages": ["en"], "domain_specialization": None,
            "deployment": "api", "matryoshka_dims": [256, 512, 1024, 3072]
        },
        {
            "id": "cohere-v3", "name": "embed-english-v3.0",
            "provider": "Cohere", "dimensions": 1024, "max_tokens": 512,
            "mteb_retrieval_score": 0.65, "mteb_overall_score": 0.64,
            "cost_per_1m_tokens": 0.10, "latency_ms_per_1k_tokens": 60,
            "languages": ["en", "fr", "de", "es", "it", "pt", "ja", "ko", "zh"],
            "domain_specialization": None,
            "deployment": "api", "matryoshka_dims": None
        },
        {
            "id": "bge-large", "name": "bge-large-en-v1.5",
            "provider": "BAAI", "dimensions": 1024, "max_tokens": 512,
            "mteb_retrieval_score": 0.64, "mteb_overall_score": 0.63,
            "cost_per_1m_tokens": 0.0, "latency_ms_per_1k_tokens": 35,
            "languages": ["en"], "domain_specialization": None,
            "deployment": "self_hosted", "matryoshka_dims": None
        },
        {
            "id": "jina-v2", "name": "jina-embeddings-v2-base-en",
            "provider": "Jina AI", "dimensions": 768, "max_tokens": 8192,
            "mteb_retrieval_score": 0.61, "mteb_overall_score": 0.60,
            "cost_per_1m_tokens": 0.02, "latency_ms_per_1k_tokens": 55,
            "languages": ["en"], "domain_specialization": None,
            "deployment": "both", "matryoshka_dims": None
        },
        {
            "id": "voyage-3", "name": "voyage-3",
            "provider": "Voyage AI", "dimensions": 1024, "max_tokens": 32000,
            "mteb_retrieval_score": 0.70, "mteb_overall_score": 0.68,
            "cost_per_1m_tokens": 0.06, "latency_ms_per_1k_tokens": 70,
            "languages": ["en"], "domain_specialization": None,
            "deployment": "api", "matryoshka_dims": None
        },
        {
            "id": "voyage-3-lite", "name": "voyage-3-lite",
            "provider": "Voyage AI", "dimensions": 512, "max_tokens": 32000,
            "mteb_retrieval_score": 0.65, "mteb_overall_score": 0.63,
            "cost_per_1m_tokens": 0.02, "latency_ms_per_1k_tokens": 40,
            "languages": ["en"], "domain_specialization": None,
            "deployment": "api", "matryoshka_dims": None
        },
        {
            "id": "gte-qwen2", "name": "gte-Qwen2-7B-instruct",
            "provider": "Alibaba", "dimensions": 3584, "max_tokens": 32768,
            "mteb_retrieval_score": 0.69, "mteb_overall_score": 0.67,
            "cost_per_1m_tokens": 0.0, "latency_ms_per_1k_tokens": 200,
            "languages": ["en", "zh", "ja", "ko"], "domain_specialization": None,
            "deployment": "self_hosted", "matryoshka_dims": None
        },
        {
            "id": "sap-bge-medical", "name": "sap-bge-large-en-medical",
            "provider": "SAP", "dimensions": 1024, "max_tokens": 512,
            "mteb_retrieval_score": 0.62, "mteb_overall_score": 0.60,
            "cost_per_1m_tokens": 0.0, "latency_ms_per_1k_tokens": 40,
            "languages": ["en"], "domain_specialization": "medical",
            "deployment": "self_hosted", "matryoshka_dims": None
        },
        {
            "id": "multilingual-e5", "name": "multilingual-e5-large-instruct",
            "provider": "Microsoft", "dimensions": 1024, "max_tokens": 8192,
            "mteb_retrieval_score": 0.60, "mteb_overall_score": 0.59,
            "cost_per_1m_tokens": 0.0, "latency_ms_per_1k_tokens": 50,
            "languages": ["en", "fr", "de", "es", "it", "pt", "ja", "ko", "zh", "ar", "ru", "hi"],
            "domain_specialization": None,
            "deployment": "self_hosted", "matryoshka_dims": None
        }
    ]
    
    def register(self, state: EmbeddingSelectionState) -> EmbeddingSelectionState:
        state["candidate_models"] = self.REGISTRY.copy()
        return state

3. Benchmark Evaluator Agent

class BenchmarkEvaluatorAgent:
    """Filters models by hard constraints and scores on task performance"""
    
    def evaluate(self, state: EmbeddingSelectionState) -> EmbeddingSelectionState:
        filtered = []
        for model in state["candidate_models"]:
            # Hard constraint: context length must accommodate chunks
            if model["max_tokens"] < state["avg_chunk_tokens"]:
                continue
            # Hard constraint: deployment compatibility
            if state["deployment_constraint"] != "any":
                if state["deployment_constraint"] == "api" and model["deployment"] == "self_hosted":
                    continue
                if state["deployment_constraint"] == "self_hosted" and model["deployment"] == "api":
                    continue
            # Hard constraint: language support
            required_langs = [state["primary_language"]] + state["additional_languages"]
            if not all(lang in model["languages"] for lang in required_langs):
                continue
            filtered.append(model)
        
        state["filtered_models"] = filtered
        
        # Score each model on MTEB retrieval performance
        scores = {}
        breakdown = {}
        for model in filtered:
            task_score = model["mteb_retrieval_score"] * 100
            scores[model["id"]] = task_score
            breakdown[model["id"]] = {"task_performance": task_score}
        
        state["model_scores"] = scores
        state["score_breakdown"] = breakdown
        return state

4. Cost and Latency Analyzer Agent

class CostLatencyAnalyzerAgent:
    """Scores models on cost and latency at projected scale"""
    
    def analyze(self, state: EmbeddingSelectionState) -> EmbeddingSelectionState:
        monthly_tokens = state["monthly_queries"] * state["avg_chunk_tokens"] * 2  # query + retrieved
        monthly_tokens_millions = monthly_tokens / 1_000_000
        
        for model in state["filtered_models"]:
            monthly_cost = model["cost_per_1m_tokens"] * monthly_tokens_millions
            per_query_latency = (state["avg_chunk_tokens"] / 1000) * model["latency_ms_per_1k_tokens"]
            
            # Cost score: lower is better, normalize against max
            max_cost = max(m["cost_per_1m_tokens"] for m in state["filtered_models"]) or 0.01
            cost_score = (1 - model["cost_per_1m_tokens"] / max_cost) * 100 if max_cost > 0 else 100
            
            # Latency score: lower is better, must meet budget
            max_latency = max(m["latency_ms_per_1k_tokens"] for m in state["filtered_models"]) or 1
            latency_score = (1 - model["latency_ms_per_1k_tokens"] / max_latency) * 100
            
            # Bonus if under budget
            if per_query_latency <= state["latency_budget_ms"]:
                latency_score = min(100, latency_score + 20)
            else:
                latency_score *= 0.5
            
            state["score_breakdown"][model["id"]]["cost"] = cost_score
            state["score_breakdown"][model["id"]]["latency"] = latency_score
            state["score_breakdown"][model["id"]]["monthly_cost_usd"] = round(monthly_cost, 2)
            state["score_breakdown"][model["id"]]["per_query_latency_ms"] = round(per_query_latency, 1)
        
        return state

5. Domain Fit Agent

class DomainFitAgent:
    """Evaluates domain specialization and multilingual coverage"""
    
    def evaluate(self, state: EmbeddingSelectionState) -> EmbeddingSelectionState:
        for model in state["filtered_models"]:
            domain_score = 50.0  # baseline
            
            # Domain specialization bonus
            if model["domain_specialization"] == state["domain"]:
                domain_score = 95.0
            elif model["domain_specialization"] is not None:
                domain_score = 30.0  # wrong domain = penalty
            
            # Multilingual coverage bonus
            required_langs = len([state["primary_language"]] + state["additional_languages"])
            lang_coverage = len([l for l in model["languages"] if l in [state["primary_language"]] + state["additional_languages"]])
            lang_score = (lang_coverage / required_langs) * 100 if required_langs > 0 else 100
            
            state["score_breakdown"][model["id"]]["domain_fit"] = domain_score
            state["score_breakdown"][model["id"]]["multilingual"] = lang_score
        
        return state

6. Final Recommender Agent

class RecommenderAgent:
    """Computes weighted final score and recommends top model"""
    
    WEIGHTS = {
        "task_performance": 0.30,
        "domain_fit": 0.20,
        "multilingual": 0.10,
        "cost": 0.10,
        "latency": 0.10
    }
    
    def __init__(self):
        self.llm = ChatOpenAI(model="gpt-4", temperature=0.1)
    
    def recommend(self, state: EmbeddingSelectionState) -> EmbeddingSelectionState:
        # Compute weighted final scores
        final_scores = {}
        for model_id, breakdown in state["score_breakdown"].items():
            score = sum(
                self.WEIGHTS.get(k, 0) * v
                for k, v in breakdown.items()
                if isinstance(v, (int, float))
            )
            final_scores[model_id] = score
        
        state["model_scores"] = final_scores
        
        # Rank models
        ranked = sorted(final_scores.items(), key=lambda x: x[1], reverse=True)
        state["recommended_model"] = ranked[0][0] if ranked else ""
        state["runner_up"] = ranked[1][0] if len(ranked) > 1 else ""
        
        # Generate reasoning
        rec_model = next((m for m in state["filtered_models"] if m["id"] == state["recommended_model"]), None)
        runner_model = next((m for m in state["filtered_models"] if m["id"] == state["runner_up"]), None)
        
        prompt = f"""Explain the embedding model recommendation.

Use case: {state['use_case_description']}
Domain: {state['domain']}
Primary language: {state['primary_language']}
Avg chunk size: {state['avg_chunk_tokens']} tokens
Monthly queries: {state['monthly_queries']:,}
Latency budget: {state['latency_budget_ms']}ms
Deployment: {state['deployment_constraint']}

Recommended: {rec_model['name'] if rec_model else 'None'} (score: {ranked[0][1]:.1f})
Runner-up: {runner_model['name'] if runner_model else 'None'} (score: {ranked[1][1]:.1f if len(ranked)>1 else 0})

Score breakdown for recommended: {state['score_breakdown'].get(state['recommended_model'], {})}

Provide 3-4 sentence reasoning explaining why this model wins and key trade-offs."""
        response = self.llm.invoke(prompt)
        state["reasoning"] = response.content
        
        # Trade-offs
        state["trade_offs"] = {
            state["recommended_model"]: [
                f"Higher cost (${state['score_breakdown'][state['recommended_model']].get('monthly_cost_usd', 0)}/mo)" if state['score_breakdown'][state['recommended_model']].get('cost', 100) < 50 else "Cost-efficient",
                f"Latency: {state['score_breakdown'][state['recommended_model']].get('per_query_latency_ms', 0)}ms per query",
                f"Dimensions: {rec_model['dimensions'] if rec_model else 'N/A'}"
            ]
        }
        
        return state

7. LangGraph Workflow with Memory

class EmbeddingSelectionMemory:
    def __init__(self, redis_client: redis.Redis):
        self.redis = redis_client
    
    def save_selection(self, state: EmbeddingSelectionState):
        record = {
            "project_id": state["project_id"],
            "domain": state["domain"],
            "recommended": state["recommended_model"],
            "runner_up": state["runner_up"],
            "scores": {k: round(v, 2) for k, v in state["model_scores"].items()},
            "timestamp": datetime.now().isoformat()
        }
        key = f"embedding_selections:{state['domain']}"
        history = json.loads(self.redis.get(key) or "[]")
        history.append(record)
        self.redis.set(key, json.dumps(history[-30:]))
    
    def load_history(self, domain: str) -> List[Dict]:
        return json.loads(self.redis.get(f"embedding_selections:{domain}") or "[]")

def build_embedding_selector():
    workflow = StateGraph(EmbeddingSelectionState)
    
    registry = ModelRegistryAgent()
    evaluator = BenchmarkEvaluatorAgent()
    cost_analyzer = CostLatencyAnalyzerAgent()
    domain_fit = DomainFitAgent()
    recommender = RecommenderAgent()
    
    workflow.add_node("register_models", registry.register)
    workflow.add_node("evaluate_benchmarks", evaluator.evaluate)
    workflow.add_node("analyze_cost_latency", cost_analyzer.analyze)
    workflow.add_node("evaluate_domain_fit", domain_fit.evaluate)
    workflow.add_node("recommend", recommender.recommend)
    
    workflow.set_entry_point("register_models")
    workflow.add_edge("register_models", "evaluate_benchmarks")
    workflow.add_edge("evaluate_benchmarks", "analyze_cost_latency")
    workflow.add_edge("analyze_cost_latency", "evaluate_domain_fit")
    workflow.add_edge("evaluate_domain_fit", "recommend")
    workflow.add_edge("recommend", END)
    
    return workflow.compile()

8. FastAPI Backend

from fastapi import FastAPI
from fastapi.middleware.cors import CORSMiddleware
from pydantic import BaseModel

app = FastAPI(title="Embedding Model Selector API")
app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_methods=["*"], allow_headers=["*"])

graph = build_embedding_selector()
memory = EmbeddingSelectionMemory(redis.Redis())

class SelectionRequest(BaseModel):
    project_id: str
    use_case_description: str
    domain: str
    primary_language: str = "en"
    additional_languages: List[str] = []
    avg_chunk_tokens: int = 512
    monthly_queries: int = 100000
    latency_budget_ms: int = 200
    deployment_constraint: Literal["api", "self_hosted", "any"] = "any"
    budget_tier: Literal["low", "medium", "high"] = "medium"

@app.post("/select_embedding")
async def select_embedding(req: SelectionRequest):
    history = memory.load_history(req.domain)
    
    initial_state = EmbeddingSelectionState(
        messages=[HumanMessage(content=f"Select embedding for {req.domain}")],
        conversation_id=f"conv_{req.project_id}",
        project_id=req.project_id,
        use_case_description=req.use_case_description,
        domain=req.domain,
        primary_language=req.primary_language,
        additional_languages=req.additional_languages,
        avg_chunk_tokens=req.avg_chunk_tokens,
        monthly_queries=req.monthly_queries,
        latency_budget_ms=req.latency_budget_ms,
        deployment_constraint=req.deployment_constraint,
        budget_tier=req.budget_tier,
        candidate_models=[],
        filtered_models=[],
        model_scores={},
        score_breakdown={},
        recommended_model="",
        runner_up="",
        reasoning="",
        trade_offs={},
        past_selections=history
    )
    
    result = graph.invoke(initial_state)
    memory.save_selection(result)
    
    # Build model details
    model_details = {}
    for m in result["filtered_models"]:
        model_details[m["id"]] = {
            "name": m["name"],
            "provider": m["provider"],
            "dimensions": m["dimensions"],
            "max_tokens": m["max_tokens"],
            "final_score": round(result["model_scores"].get(m["id"], 0), 2),
            "breakdown": result["score_breakdown"].get(m["id"], {})
        }
    
    return {
        "recommended_model": result["recommended_model"],
        "runner_up": result["runner_up"],
        "reasoning": result["reasoning"],
        "all_models": model_details,
        "trade_offs": result["trade_offs"],
        "candidates_evaluated": len(result["filtered_models"]),
        "historical_picks": history[-5:]
    }

9. Frontend: Interactive Selection Dashboard

// components/EmbeddingSelector.tsx
import React, { useState } from 'react';

export const EmbeddingSelector: React.FC = () => {
  const [formData, setFormData] = useState({
    project_id: 'medical-rag-v1',
    use_case_description: 'Retrieval system for medical research papers and clinical guidelines',
    domain: 'medical',
    primary_language: 'en',
    additional_languages: [] as string[],
    avg_chunk_tokens: 512,
    monthly_queries: 500000,
    latency_budget_ms: 150,
    deployment_constraint: 'any' as const,
    budget_tier: 'medium' as const
  });
  const [result, setResult] = useState<any>(null);

  const handleSubmit = async () => {
    const response = await fetch('http://localhost:8000/select_embedding', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(formData)
    });
    setResult(await response.json());
  };

  return (
    <div className="p-6 max-w-6xl mx-auto bg-gray-50 min-h-screen">
      <h1 className="text-3xl font-bold mb-2">🎯 Embedding Model Selector</h1>
      <p className="text-gray-600 mb-6">Data-driven selection based on your use case</p>

      <div className="grid grid-cols-3 gap-6">
        <div className="bg-white p-4 rounded-lg shadow">
          <h2 className="font-bold mb-3">Use Case Configuration</h2>
          <textarea
            className="w-full p-2 border rounded mb-3 text-sm"
            rows={3}
            value={formData.use_case_description}
            onChange={e => setFormData({...formData, use_case_description: e.target.value})}
          />
          <label className="text-sm block mb-1">Domain:</label>
          <select className="w-full p-2 border rounded mb-3"
            value={formData.domain}
            onChange={e => setFormData({...formData, domain: e.target.value})}>
            <option value="medical">Medical/Biomedical</option>
            <option value="legal">Legal</option>
            <option value="finance">Finance</option>
            <option value="code">Code/Technical</option>
            <option value="general">General</option>
          </select>
          <label className="text-sm block mb-1">Avg Chunk Size (tokens):</label>
          <input type="number" className="w-full p-2 border rounded mb-3"
            value={formData.avg_chunk_tokens}
            onChange={e => setFormData({...formData, avg_chunk_tokens: +e.target.value})} />
          <label className="text-sm block mb-1">Monthly Queries:</label>
          <input type="number" className="w-full p-2 border rounded mb-3"
            value={formData.monthly_queries}
            onChange={e => setFormData({...formData, monthly_queries: +e.target.value})} />
          <label className="text-sm block mb-1">Deployment:</label>
          <select className="w-full p-2 border rounded mb-3"
            value={formData.deployment_constraint}
            onChange={e => setFormData({...formData, deployment_constraint: e.target.value as any})}>
            <option value="any">Any</option>
            <option value="api">API Only</option>
            <option value="self_hosted">Self-Hosted Only</option>
          </select>
          <button onClick={handleSubmit} className="w-full bg-blue-600 text-white px-6 py-2 rounded">
            Find Optimal Embedding
          </button>
        </div>

        {result && (
          <div className="col-span-2 space-y-4">
            <div className="bg-gradient-to-r from-green-600 to-emerald-600 text-white p-6 rounded-lg shadow">
              <div className="text-sm opacity-90">RECOMMENDED</div>
              <h2 className="text-2xl font-bold mt-1">
                {result.all_models[result.recommended_model]?.name}
              </h2>
              <div className="text-sm opacity-90 mt-1">
                by {result.all_models[result.recommended_model]?.provider} • 
                Score: {result.all_models[result.recommended_model]?.final_score}/100
              </div>
              <p className="mt-3 text-sm">{result.reasoning}</p>
            </div>

            <div className="bg-white p-4 rounded-lg shadow">
              <h3 className="font-bold mb-3">All Candidates Ranked</h3>
              <div className="space-y-2">
                {Object.entries(result.all_models)
                  .sort(([, a]: any, [, b]: any) => b.final_score - a.final_score)
                  .map(([id, m]: any, i: number) => (
                    <div key={id} className={`flex items-center gap-3 p-2 rounded ${
                      id === result.recommended_model ? 'bg-green-50 border border-green-300' :
                      id === result.runner_up ? 'bg-yellow-50 border border-yellow-300' : 'bg-gray-50'
                    }`}>
                      <span className="text-sm font-mono w-6">{i+1}.</span>
                      <div className="flex-1">
                        <div className="font-semibold text-sm">{m.name}</div>
                        <div className="text-xs text-gray-500">
                          {m.dimensions}D • {m.max_tokens} tokens • {m.breakdown.monthly_cost_usd || 0}$/mo
                        </div>
                      </div>
                      <div className="w-32">
                        <div className="bg-gray-200 rounded-full h-2">
                          <div className="bg-blue-500 h-2 rounded-full" style={{width: `${m.final_score}%`}} />
                        </div>
                        <div className="text-xs text-right mt-1">{m.final_score}</div>
                      </div>
                    </div>
                  ))}
              </div>
            </div>

            <div className="bg-white p-4 rounded-lg shadow">
              <h3 className="font-bold mb-2">Score Breakdown — {result.all_models[result.recommended_model]?.name}</h3>
              <div className="grid grid-cols-2 gap-3 text-sm">
                {Object.entries(result.all_models[result.recommended_model]?.breakdown || {})
                  .filter(([, v]) => typeof v === 'number')
                  .map(([k, v]: any) => (
                    <div key={k}>
                      <div className="flex justify-between">
                        <span className="capitalize">{k.replace(/_/g, ' ')}</span>
                        <span className="font-mono">{v.toFixed(1)}</span>
                      </div>
                      <div className="bg-gray-200 rounded-full h-1.5 mt-1">
                        <div className="bg-purple-500 h-1.5 rounded-full" style={{width: `${v}%`}} />
                      </div>
                    </div>
                  ))}
              </div>
            </div>
          </div>
        )}
      </div>
    </div>
  );
};

Real-Time Use Case: Medical Literature Intelligence Platform

A hospital research team is building a RAG system to answer clinical questions from PubMed articles, clinical guidelines, and internal research reports. They need an embedding model that handles medical terminology accurately.

Configuration:

• Domain: medical

• Avg chunk size: 512 tokens

• Monthly queries: 500,000

• Latency budget: 150ms

• Deployment: any

The multi-agent selector analyzes:

1. Model Registry loads 10 candidate models including sap-bge-large-en-medical, voyage-3, openai-3-large, bge-large, etc.

2. Benchmark Evaluator filters out models with insufficient context length or missing language support. 8 models remain.

3. Cost/Latency Analyzer computes monthly costs:

   • openai-3-large: $65/mo at 500K queries

   • voyage-3: $30/mo

   • sap-bge-large-en-medical: $0/mo (self-hosted)

4. Domain Fit Agent gives sap-bge-large-en-medical a 95/100 domain score (specialized for medical text), while general models get 50/100.

5. Recommender computes weighted final scores:

   • sap-bge-large-en-medical: 87.5 (wins on domain fit + cost)

   • voyage-3: 78.2 (best MTEB score but no domain specialization)

   • openai-3-large: 71.4 (expensive, no domain fit)

Recommendation: sap-bge-large-en-medical domain-specialized embeddings capture medical terminology (drug names, gene symbols, clinical phrases) that general models miss. The team saves $65/month while achieving better retrieval on clinical queries.

The system stores this decision in Redis. Six months later, when the team expands to include Spanish-language patient education materials, they re-run the selector with additional_languages: ["es"]. The system now recommends multilingual-e5-large-instruct demonstrating how the framework adapts to evolving requirements while maintaining institutional memory.

Conclusion

Choosing an embedding model is not a one-time decision it's a strategic infrastructure choice that directly impacts retrieval quality, operational costs, and system scalability. By encoding selection expertise into a multi-agent LangGraph framework, enterprises can make data-driven decisions that balance task performance, domain fit, cost, latency, and deployment constraints. The persistent memory layer ensures that lessons from past selections inform future decisions, creating a continuously improving selection process. As the embedding landscape evolves with new models releasing monthly, this systematic approach prevents teams from defaulting to familiar choices and instead surfaces the optimal model for each unique use case turning what is often a guess into a defensible, quantified architectural decision.