Spaces:

redis
/

ai-research-redis

Running

File size: 32,268 Bytes

<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml" lang="en" xml:lang="en"><head>

<meta charset="utf-8">
<meta name="generator" content="quarto-1.8.27">

<meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes">

<meta name="author" content="Radoslav Ralev">
<meta name="dcterms.date" content="2026-03-25">
<meta name="description" content="A specialized embedding model for semantic caching that improves intent matching while reducing latency, memory use, and deployment cost.">

<title>Introducing langcache-embed-v3-small – AI Research @Redis</title>
<style>
code{white-space: pre-wrap;}
span.smallcaps{font-variant: small-caps;}
div.columns{display: flex; gap: min(4vw, 1.5em);}
div.column{flex: auto; overflow-x: auto;}
div.hanging-indent{margin-left: 1.5em; text-indent: -1.5em;}
ul.task-list{list-style: none;}
ul.task-list li input[type="checkbox"] {
  width: 0.8em;
  margin: 0 0.8em 0.2em -1em; /* quarto-specific, see https://github.com/quarto-dev/quarto-cli/issues/4556 */ 
  vertical-align: middle;
}
</style>


<script src="../site_libs/quarto-nav/quarto-nav.js"></script>
<script src="../site_libs/quarto-nav/headroom.min.js"></script>
<script src="../site_libs/clipboard/clipboard.min.js"></script>
<script src="../site_libs/quarto-search/autocomplete.umd.js"></script>
<script src="../site_libs/quarto-search/fuse.min.js"></script>
<script src="../site_libs/quarto-search/quarto-search.js"></script>
<meta name="quarto:offset" content="../">
<script src="../site_libs/quarto-html/quarto.js" type="module"></script>
<script src="../site_libs/quarto-html/tabsets/tabsets.js" type="module"></script>
<script src="../site_libs/quarto-html/axe/axe-check.js" type="module"></script>
<script src="../site_libs/quarto-html/popper.min.js"></script>
<script src="../site_libs/quarto-html/tippy.umd.min.js"></script>
<script src="../site_libs/quarto-html/anchor.min.js"></script>
<link href="../site_libs/quarto-html/tippy.css" rel="stylesheet">
<link href="../site_libs/quarto-html/quarto-syntax-highlighting-ed96de9b727972fe78a7b5d16c58bf87.css" rel="stylesheet" id="quarto-text-highlighting-styles">
<script src="../site_libs/bootstrap/bootstrap.min.js"></script>
<link href="../site_libs/bootstrap/bootstrap-icons.css" rel="stylesheet">
<link href="../site_libs/bootstrap/bootstrap-a8976c3e89df70b272bdfba3d2fda974.min.css" rel="stylesheet" append-hash="true" id="quarto-bootstrap" data-mode="light">
<script id="quarto-search-options" type="application/json">{
  "location": "navbar",
  "copy-button": false,
  "collapse-after": 3,
  "panel-placement": "end",
  "type": "overlay",
  "limit": 50,
  "keyboard-shortcut": [
    "f",
    "/",
    "s"
  ],
  "show-item-context": false,
  "language": {
    "search-no-results-text": "No results",
    "search-matching-documents-text": "matching documents",
    "search-copy-link-title": "Copy link to search",
    "search-hide-matches-text": "Hide additional matches",
    "search-more-match-text": "more match in this document",
    "search-more-matches-text": "more matches in this document",
    "search-clear-button-title": "Clear",
    "search-text-placeholder": "",
    "search-detached-cancel-button-title": "Cancel",
    "search-submit-button-title": "Submit",
    "search-label": "Search"
  }
}</script>
<script defer="" src="https://cloud.umami.is/script.js" data-website-id="6c45a91a-0956-45db-8248-dadff3c2d36d"></script>


</head>

<body class="nav-fixed quarto-light">

<div id="quarto-search-results"></div>
  <header id="quarto-header" class="headroom fixed-top">
    <nav class="navbar navbar-expand-lg " data-bs-theme="dark">
      <div class="navbar-container container-fluid">
      <div class="navbar-brand-container mx-auto">
    <a href="../index.html" class="navbar-brand navbar-brand-logo">
    <img src="../assets/redis-logo.svg" alt="Redis" class="navbar-logo light-content">
    <img src="../assets/redis-logo.svg" alt="Redis" class="navbar-logo dark-content">
    </a>
    <a class="navbar-brand" href="../index.html">
    <span class="navbar-title">AI Research <span class="citation" data-cites="Redis">@Redis</span></span>
    </a>
  </div>
            <div id="quarto-search" class="" title="Search"></div>
          <button class="navbar-toggler" type="button" data-bs-toggle="collapse" data-bs-target="#navbarCollapse" aria-controls="navbarCollapse" role="menu" aria-expanded="false" aria-label="Toggle navigation" onclick="if (window.quartoToggleHeadroom) { window.quartoToggleHeadroom(); }">
  <span class="navbar-toggler-icon"></span>
</button>
          <div class="collapse navbar-collapse" id="navbarCollapse">
            <ul class="navbar-nav navbar-nav-scroll me-auto">
  <li class="nav-item">
    <a class="nav-link" href="../index.html"> 
<span class="menu-text">Home</span></a>
  </li>  
  <li class="nav-item">
    <a class="nav-link" href="../about.html"> 
<span class="menu-text">About</span></a>
  </li>  
</ul>
          </div> <!-- /navcollapse -->
            <div class="quarto-navbar-tools">
</div>
      </div> <!-- /container-fluid -->
    </nav>
</header>
<!-- content -->
<div id="quarto-content" class="quarto-container page-columns page-rows-contents page-layout-article page-navbar">
<!-- sidebar -->
<!-- margin-sidebar -->
    <div id="quarto-margin-sidebar" class="sidebar margin-sidebar">
        <nav id="TOC" role="doc-toc" class="toc-active">
    <h2 id="toc-title">On this page</h2>
   
  <ul>
  <li><a href="#why-generic-embedding-models-fall-short" id="toc-why-generic-embedding-models-fall-short" class="nav-link active" data-scroll-target="#why-generic-embedding-models-fall-short">Why generic embedding models fall short</a></li>
  <li><a href="#what-changed-in-v3-small" id="toc-what-changed-in-v3-small" class="nav-link" data-scroll-target="#what-changed-in-v3-small">What changed in v3-small</a>
  <ul class="collapse">
  <li><a href="#much-larger-training-data" id="toc-much-larger-training-data" class="nav-link" data-scroll-target="#much-larger-training-data">Much larger training data</a></li>
  <li><a href="#better-task-specific-training" id="toc-better-task-specific-training" class="nav-link" data-scroll-target="#better-task-specific-training">Better task-specific training</a></li>
  </ul></li>
  <li><a href="#why-small-is-a-feature" id="toc-why-small-is-a-feature" class="nav-link" data-scroll-target="#why-small-is-a-feature">Why “small” is a feature</a></li>
  <li><a href="#what-this-improves-in-practice" id="toc-what-this-improves-in-practice" class="nav-link" data-scroll-target="#what-this-improves-in-practice">What this improves in practice</a></li>
  <li><a href="#why-this-matters-for-langcache" id="toc-why-this-matters-for-langcache" class="nav-link" data-scroll-target="#why-this-matters-for-langcache">Why this matters for LangCache</a></li>
  <li><a href="#source" id="toc-source" class="nav-link" data-scroll-target="#source">Source</a></li>
  </ul>
</nav>
    </div>
<!-- main -->
<main class="content" id="quarto-document-content">

<header id="title-block-header" class="quarto-title-block default">
<div class="quarto-title">
<h1 class="title">Introducing langcache-embed-v3-small</h1>
  <div class="quarto-categories">
    <div class="quarto-category">langcache</div>
    <div class="quarto-category">semantic-caching</div>
    <div class="quarto-category">embeddings</div>
    <div class="quarto-category">models</div>
  </div>
  </div>

<div>
  <div class="description">
    A specialized embedding model for semantic caching that improves intent matching while reducing latency, memory use, and deployment cost.
  </div>
</div>


<div class="quarto-title-meta">

    <div>
    <div class="quarto-title-meta-heading">Author</div>
    <div class="quarto-title-meta-contents">
             <p>Radoslav Ralev </p>
          </div>
  </div>
    
    <div>
    <div class="quarto-title-meta-heading">Published</div>
    <div class="quarto-title-meta-contents">
      <p class="date">March 25, 2026</p>
    </div>
  </div>
  
    
  </div>
  


</header>


<p>Semantic caching looks deceptively simple. The system only needs to answer one question: does this new query mean the same thing as something we have already answered?</p>
<p>In practice, that is harder than standard retrieval. Two user questions can share a lot of words but require different answers, while two questions with very different wording can still express the same intent. That makes semantic caching a poor fit for many generic retrieval embeddings, even when those same models work well for RAG.</p>
<p><code>langcache-embed-v3-small</code> is designed for that narrower task. Instead of optimizing for query-to-document retrieval, it is built for low-latency question-to-question matching in semantic cache pipelines.</p>
<section id="why-generic-embedding-models-fall-short" class="level2">
<h2 class="anchored" data-anchor-id="why-generic-embedding-models-fall-short">Why generic embedding models fall short</h2>
<p>Most embedding models are trained for a classic retrieval setup: short user queries matched against long documents. That is useful for finding relevant passages, but semantic caching has a stricter requirement.</p>
<p>Here the model needs to distinguish between:</p>
<ul>
<li>questions that look similar but should not share an answer</li>
<li>questions that are phrased differently but should reuse the same answer</li>
</ul>
<p>For example, “How do I reset my password?” and “How can I change my password?” may be close enough to reuse an answer, while “How do I reset my password?” and “How do I recover my account if I forgot my password?” may require different flows.</p>
<p>That distinction is exactly where a specialized semantic-caching model matters.</p>
</section>
<section id="what-changed-in-v3-small" class="level2">
<h2 class="anchored" data-anchor-id="what-changed-in-v3-small">What changed in v3-small</h2>
<p>Compared with the earlier <code>langcache-embed-v1</code>, the new model changes the data scale, training setup, and model size.</p>
<section id="much-larger-training-data" class="level3">
<h3 class="anchored" data-anchor-id="much-larger-training-data">Much larger training data</h3>
<p>The earlier version was trained on roughly <code>323,000</code> question pairs. <code>v3-small</code> is trained on more than <code>8 million</code> labeled pairs from the public <code>sentencepairs-v2</code> dataset.</p>
<p>That larger training set gives the model much broader exposure to:</p>
<ul>
<li>paraphrases that should collapse together</li>
<li>near-matches that should stay apart</li>
<li>the kinds of short-query ambiguity that are common in cache reuse decisions</li>
</ul>
</section>
<section id="better-task-specific-training" class="level3">
<h3 class="anchored" data-anchor-id="better-task-specific-training">Better task-specific training</h3>
<p>The model is also trained to make finer distinctions across many examples in the same step, rather than learning only from isolated positive pairs. That pushes truly equivalent questions closer together while separating misleading near-neighbors.</p>
<p>The goal is not just higher semantic similarity in the abstract. It is better cache behavior under realistic thresholding.</p>
</section>
</section>
<section id="why-small-is-a-feature" class="level2">
<h2 class="anchored" data-anchor-id="why-small-is-a-feature">Why “small” is a feature</h2>
<p>In semantic caching, speed matters as much as quality. The cache check runs before downstream generation or retrieval, so every millisecond saved improves the overall request path.</p>
<p><code>langcache-embed-v3-small</code> is intentionally compact:</p>
<ul>
<li>about <code>20M</code> parameters instead of roughly <code>149M</code> in <code>v1</code></li>
<li>a <code>128</code>-token context window sized for user queries rather than long documents</li>
</ul>
<p>That smaller footprint reduces inference cost, lowers memory requirements, and makes the model easier to deploy in latency-sensitive systems.</p>
</section>
<section id="what-this-improves-in-practice" class="level2">
<h2 class="anchored" data-anchor-id="what-this-improves-in-practice">What this improves in practice</h2>
<p>The Redis writeup positions <code>v3-small</code> as stronger on the outcomes that matter for semantic caching:</p>
<ul>
<li>more correct grouping of queries with the same intent</li>
<li>fewer false cache hits on similar-looking but meaningfully different questions</li>
<li>better latency and efficiency for online cache checks</li>
</ul>
<p>That combination matters because semantic caching is only useful when it improves cost and latency without creating too many incorrect answer reuses.</p>
<div class="quarto-figure quarto-figure-center">
<figure class="figure">
<p><img src="assets/introducing-langcache-embed-v3-small/langcache-embed-v3-small-benchmark.jpg" class="img-fluid figure-img"></p>
<figcaption>Benchmark comparison for langcache-embed-v3-small.</figcaption>
</figure>
</div>
</section>
<section id="why-this-matters-for-langcache" class="level2">
<h2 class="anchored" data-anchor-id="why-this-matters-for-langcache">Why this matters for LangCache</h2>
<p>This release reflects a broader shift from general-purpose embedding models toward task-specific models for semantic caching. If your system repeatedly sees similar user questions, the right embedding model can raise cache hit rate and reduce downstream compute, but only if it can separate true semantic equivalence from superficial wording overlap.</p>
<p><code>langcache-embed-v3-small</code> is built around that requirement.</p>
</section>
<section id="source" class="level2">
<h2 class="anchored" data-anchor-id="source">Source</h2>
<ul>
<li>Original Redis post: <code>https://redis.io/blog/introducing-langcache-embed-v3-small/</code></li>
</ul>


</section>

</main> <!-- /main -->
<script>
(function () {
  try {
    var inIframe = window.top !== window.self;
    if (!inIframe) return;

    function ensureNoopener(a) {
      var rel = (a.getAttribute("rel") || "").trim();
      if (!rel) {
        a.setAttribute("rel", "noopener");
        return;
      }
      if (!rel.split(/\s+/).includes("noopener")) {
        a.setAttribute("rel", (rel + " noopener").trim());
      }
    }

    function isInternalLink(href) {
      if (!href) return false;
      if (href.startsWith("#")) return false;
      if (href.startsWith("mailto:")) return false;
      if (href.startsWith("javascript:")) return false;
      if (href.startsWith("/")) return true;
      if (href.startsWith("http://") || href.startsWith("https://")) {
        try {
          var u = new URL(href, window.location.href);
          return u.origin === window.location.origin;
        } catch (e) {
          return false;
        }
      }
      // relative
      return true;
    }

    function retargetInternalLinks() {
      var links = document.querySelectorAll("a[href]");
      for (var i = 0; i < links.length; i++) {
        var a = links[i];
        var href = a.getAttribute("href");
        if (!isInternalLink(href)) continue;
        a.setAttribute("target", "_top");
        ensureNoopener(a);
      }
    }

    function insertShareableLinkNotice() {
      var main = document.querySelector("main.content");
      if (!main) return;
      if (document.getElementById("hf-embed-notice")) return;

      var wrap = document.createElement("div");
      wrap.id = "hf-embed-notice";
      wrap.style.cssText =
        "border:1px solid #e5e7eb;border-radius:10px;padding:10px 12px;" +
        "background:#f9fafb;color:#111827;margin:0 0 16px 0;font-size:0.95rem;";

      var a = document.createElement("a");
      a.href = window.location.href;
      a.target = "_top";
      a.rel = "noopener";
      a.textContent = "Open this page directly";
      a.style.cssText = "font-weight:600;text-decoration:underline;";

      wrap.appendChild(
        document.createTextNode(
          "You are viewing this site embedded in the Hugging Face Space page. " +
            "The address bar won\u2019t change as you navigate. "
        )
      );
      wrap.appendChild(a);
      wrap.appendChild(document.createTextNode(" for a shareable URL."));

      main.insertBefore(wrap, main.firstChild);
    }

    retargetInternalLinks();
    insertShareableLinkNotice();
    window.addEventListener("DOMContentLoaded", function () {
      retargetInternalLinks();
      insertShareableLinkNotice();
    });
  } catch (e) {
    // no-op
  }
})();
</script>
<script id="quarto-html-after-body" type="application/javascript">
  window.document.addEventListener("DOMContentLoaded", function (event) {
    const icon = "";
    const anchorJS = new window.AnchorJS();
    anchorJS.options = {
      placement: 'right',
      icon: icon
    };
    anchorJS.add('.anchored');
    const isCodeAnnotation = (el) => {
      for (const clz of el.classList) {
        if (clz.startsWith('code-annotation-')) {                     
          return true;
        }
      }
      return false;
    }
    const onCopySuccess = function(e) {
      // button target
      const button = e.trigger;
      // don't keep focus
      button.blur();
      // flash "checked"
      button.classList.add('code-copy-button-checked');
      var currentTitle = button.getAttribute("title");
      button.setAttribute("title", "Copied!");
      let tooltip;
      if (window.bootstrap) {
        button.setAttribute("data-bs-toggle", "tooltip");
        button.setAttribute("data-bs-placement", "left");
        button.setAttribute("data-bs-title", "Copied!");
        tooltip = new bootstrap.Tooltip(button, 
          { trigger: "manual", 
            customClass: "code-copy-button-tooltip",
            offset: [0, -8]});
        tooltip.show();    
      }
      setTimeout(function() {
        if (tooltip) {
          tooltip.hide();
          button.removeAttribute("data-bs-title");
          button.removeAttribute("data-bs-toggle");
          button.removeAttribute("data-bs-placement");
        }
        button.setAttribute("title", currentTitle);
        button.classList.remove('code-copy-button-checked');
      }, 1000);
      // clear code selection
      e.clearSelection();
    }
    const getTextToCopy = function(trigger) {
      const outerScaffold = trigger.parentElement.cloneNode(true);
      const codeEl = outerScaffold.querySelector('code');
      for (const childEl of codeEl.children) {
        if (isCodeAnnotation(childEl)) {
          childEl.remove();
        }
      }
      return codeEl.innerText;
    }
    const clipboard = new window.ClipboardJS('.code-copy-button:not([data-in-quarto-modal])', {
      text: getTextToCopy
    });
    clipboard.on('success', onCopySuccess);
    if (window.document.getElementById('quarto-embedded-source-code-modal')) {
      const clipboardModal = new window.ClipboardJS('.code-copy-button[data-in-quarto-modal]', {
        text: getTextToCopy,
        container: window.document.getElementById('quarto-embedded-source-code-modal')
      });
      clipboardModal.on('success', onCopySuccess);
    }
      var localhostRegex = new RegExp(/^(?:http|https):\/\/localhost\:?[0-9]*\//);
      var mailtoRegex = new RegExp(/^mailto:/);
        var filterRegex = new RegExp("https:\/\/redis-ai-research-redis\.static\.hf\.space");
      var isInternal = (href) => {
          return filterRegex.test(href) || localhostRegex.test(href) || mailtoRegex.test(href);
      }
      // Inspect non-navigation links and adorn them if external
     var links = window.document.querySelectorAll('a[href]:not(.nav-link):not(.navbar-brand):not(.toc-action):not(.sidebar-link):not(.sidebar-item-toggle):not(.pagination-link):not(.no-external):not([aria-hidden]):not(.dropdown-item):not(.quarto-navigation-tool):not(.about-link)');
      for (var i=0; i<links.length; i++) {
        const link = links[i];
        if (!isInternal(link.href)) {
          // undo the damage that might have been done by quarto-nav.js in the case of
          // links that we want to consider external
          if (link.dataset.originalHref !== undefined) {
            link.href = link.dataset.originalHref;
          }
        }
      }
    function tippyHover(el, contentFn, onTriggerFn, onUntriggerFn) {
      const config = {
        allowHTML: true,
        maxWidth: 500,
        delay: 100,
        arrow: false,
        appendTo: function(el) {
            return el.parentElement;
        },
        interactive: true,
        interactiveBorder: 10,
        theme: 'quarto',
        placement: 'bottom-start',
      };
      if (contentFn) {
        config.content = contentFn;
      }
      if (onTriggerFn) {
        config.onTrigger = onTriggerFn;
      }
      if (onUntriggerFn) {
        config.onUntrigger = onUntriggerFn;
      }
      window.tippy(el, config); 
    }
    const noterefs = window.document.querySelectorAll('a[role="doc-noteref"]');
    for (var i=0; i<noterefs.length; i++) {
      const ref = noterefs[i];
      tippyHover(ref, function() {
        // use id or data attribute instead here
        let href = ref.getAttribute('data-footnote-href') || ref.getAttribute('href');
        try { href = new URL(href).hash; } catch {}
        const id = href.replace(/^#\/?/, "");
        const note = window.document.getElementById(id);
        if (note) {
          return note.innerHTML;
        } else {
          return "";
        }
      });
    }
    const xrefs = window.document.querySelectorAll('a.quarto-xref');
    const processXRef = (id, note) => {
      // Strip column container classes
      const stripColumnClz = (el) => {
        el.classList.remove("page-full", "page-columns");
        if (el.children) {
          for (const child of el.children) {
            stripColumnClz(child);
          }
        }
      }
      stripColumnClz(note)
      if (id === null || id.startsWith('sec-')) {
        // Special case sections, only their first couple elements
        const container = document.createElement("div");
        if (note.children && note.children.length > 2) {
          container.appendChild(note.children[0].cloneNode(true));
          for (let i = 1; i < note.children.length; i++) {
            const child = note.children[i];
            if (child.tagName === "P" && child.innerText === "") {
              continue;
            } else {
              container.appendChild(child.cloneNode(true));
              break;
            }
          }
          if (window.Quarto?.typesetMath) {
            window.Quarto.typesetMath(container);
          }
          return container.innerHTML
        } else {
          if (window.Quarto?.typesetMath) {
            window.Quarto.typesetMath(note);
          }
          return note.innerHTML;
        }
      } else {
        // Remove any anchor links if they are present
        const anchorLink = note.querySelector('a.anchorjs-link');
        if (anchorLink) {
          anchorLink.remove();
        }
        if (window.Quarto?.typesetMath) {
          window.Quarto.typesetMath(note);
        }
        if (note.classList.contains("callout")) {
          return note.outerHTML;
        } else {
          return note.innerHTML;
        }
      }
    }
    for (var i=0; i<xrefs.length; i++) {
      const xref = xrefs[i];
      tippyHover(xref, undefined, function(instance) {
        instance.disable();
        let url = xref.getAttribute('href');
        let hash = undefined; 
        if (url.startsWith('#')) {
          hash = url;
        } else {
          try { hash = new URL(url).hash; } catch {}
        }
        if (hash) {
          const id = hash.replace(/^#\/?/, "");
          const note = window.document.getElementById(id);
          if (note !== null) {
            try {
              const html = processXRef(id, note.cloneNode(true));
              instance.setContent(html);
            } finally {
              instance.enable();
              instance.show();
            }
          } else {
            // See if we can fetch this
            fetch(url.split('#')[0])
            .then(res => res.text())
            .then(html => {
              const parser = new DOMParser();
              const htmlDoc = parser.parseFromString(html, "text/html");
              const note = htmlDoc.getElementById(id);
              if (note !== null) {
                const html = processXRef(id, note);
                instance.setContent(html);
              } 
            }).finally(() => {
              instance.enable();
              instance.show();
            });
          }
        } else {
          // See if we can fetch a full url (with no hash to target)
          // This is a special case and we should probably do some content thinning / targeting
          fetch(url)
          .then(res => res.text())
          .then(html => {
            const parser = new DOMParser();
            const htmlDoc = parser.parseFromString(html, "text/html");
            const note = htmlDoc.querySelector('main.content');
            if (note !== null) {
              // This should only happen for chapter cross references
              // (since there is no id in the URL)
              // remove the first header
              if (note.children.length > 0 && note.children[0].tagName === "HEADER") {
                note.children[0].remove();
              }
              const html = processXRef(null, note);
              instance.setContent(html);
            } 
          }).finally(() => {
            instance.enable();
            instance.show();
          });
        }
      }, function(instance) {
      });
    }
        let selectedAnnoteEl;
        const selectorForAnnotation = ( cell, annotation) => {
          let cellAttr = 'data-code-cell="' + cell + '"';
          let lineAttr = 'data-code-annotation="' +  annotation + '"';
          const selector = 'span[' + cellAttr + '][' + lineAttr + ']';
          return selector;
        }
        const selectCodeLines = (annoteEl) => {
          const doc = window.document;
          const targetCell = annoteEl.getAttribute("data-target-cell");
          const targetAnnotation = annoteEl.getAttribute("data-target-annotation");
          const annoteSpan = window.document.querySelector(selectorForAnnotation(targetCell, targetAnnotation));
          const lines = annoteSpan.getAttribute("data-code-lines").split(",");
          const lineIds = lines.map((line) => {
            return targetCell + "-" + line;
          })
          let top = null;
          let height = null;
          let parent = null;
          if (lineIds.length > 0) {
              //compute the position of the single el (top and bottom and make a div)
              const el = window.document.getElementById(lineIds[0]);
              top = el.offsetTop;
              height = el.offsetHeight;
              parent = el.parentElement.parentElement;
            if (lineIds.length > 1) {
              const lastEl = window.document.getElementById(lineIds[lineIds.length - 1]);
              const bottom = lastEl.offsetTop + lastEl.offsetHeight;
              height = bottom - top;
            }
            if (top !== null && height !== null && parent !== null) {
              // cook up a div (if necessary) and position it 
              let div = window.document.getElementById("code-annotation-line-highlight");
              if (div === null) {
                div = window.document.createElement("div");
                div.setAttribute("id", "code-annotation-line-highlight");
                div.style.position = 'absolute';
                parent.appendChild(div);
              }
              div.style.top = top - 2 + "px";
              div.style.height = height + 4 + "px";
              div.style.left = 0;
              let gutterDiv = window.document.getElementById("code-annotation-line-highlight-gutter");
              if (gutterDiv === null) {
                gutterDiv = window.document.createElement("div");
                gutterDiv.setAttribute("id", "code-annotation-line-highlight-gutter");
                gutterDiv.style.position = 'absolute';
                const codeCell = window.document.getElementById(targetCell);
                const gutter = codeCell.querySelector('.code-annotation-gutter');
                gutter.appendChild(gutterDiv);
              }
              gutterDiv.style.top = top - 2 + "px";
              gutterDiv.style.height = height + 4 + "px";
            }
            selectedAnnoteEl = annoteEl;
          }
        };
        const unselectCodeLines = () => {
          const elementsIds = ["code-annotation-line-highlight", "code-annotation-line-highlight-gutter"];
          elementsIds.forEach((elId) => {
            const div = window.document.getElementById(elId);
            if (div) {
              div.remove();
            }
          });
          selectedAnnoteEl = undefined;
        };
          // Handle positioning of the toggle
      window.addEventListener(
        "resize",
        throttle(() => {
          elRect = undefined;
          if (selectedAnnoteEl) {
            selectCodeLines(selectedAnnoteEl);
          }
        }, 10)
      );
      function throttle(fn, ms) {
      let throttle = false;
      let timer;
        return (...args) => {
          if(!throttle) { // first call gets through
              fn.apply(this, args);
              throttle = true;
          } else { // all the others get throttled
              if(timer) clearTimeout(timer); // cancel #2
              timer = setTimeout(() => {
                fn.apply(this, args);
                timer = throttle = false;
              }, ms);
          }
        };
      }
        // Attach click handler to the DT
        const annoteDls = window.document.querySelectorAll('dt[data-target-cell]');
        for (const annoteDlNode of annoteDls) {
          annoteDlNode.addEventListener('click', (event) => {
            const clickedEl = event.target;
            if (clickedEl !== selectedAnnoteEl) {
              unselectCodeLines();
              const activeEl = window.document.querySelector('dt[data-target-cell].code-annotation-active');
              if (activeEl) {
                activeEl.classList.remove('code-annotation-active');
              }
              selectCodeLines(clickedEl);
              clickedEl.classList.add('code-annotation-active');
            } else {
              // Unselect the line
              unselectCodeLines();
              clickedEl.classList.remove('code-annotation-active');
            }
          });
        }
    const findCites = (el) => {
      const parentEl = el.parentElement;
      if (parentEl) {
        const cites = parentEl.dataset.cites;
        if (cites) {
          return {
            el,
            cites: cites.split(' ')
          };
        } else {
          return findCites(el.parentElement)
        }
      } else {
        return undefined;
      }
    };
    var bibliorefs = window.document.querySelectorAll('a[role="doc-biblioref"]');
    for (var i=0; i<bibliorefs.length; i++) {
      const ref = bibliorefs[i];
      const citeInfo = findCites(ref);
      if (citeInfo) {
        tippyHover(citeInfo.el, function() {
          var popup = window.document.createElement('div');
          citeInfo.cites.forEach(function(cite) {
            var citeDiv = window.document.createElement('div');
            citeDiv.classList.add('hanging-indent');
            citeDiv.classList.add('csl-entry');
            var biblioDiv = window.document.getElementById('ref-' + cite);
            if (biblioDiv) {
              citeDiv.innerHTML = biblioDiv.innerHTML;
            }
            popup.appendChild(citeDiv);
          });
          return popup.innerHTML;
        });
      }
    }
  });
  </script>
</div> <!-- /content -->
<footer class="footer">
  <div class="nav-footer">
    <div class="nav-footer-left">
<p>Discover this project on Hugging Face Spaces: https://huggingface.co/spaces/redis/ai-research-redis</p>
</div>   
    <div class="nav-footer-center">
      &nbsp;
    </div>
    <div class="nav-footer-right">
      &nbsp;
    </div>
  </div>
</footer>




</body></html>