/* Adjust space between sidebar sections */
.sidebar > .section {
    margin-bottom: 0px; /* Adjust spacing as needed */
}

/* Adjust space between pages within a section */
.sidebar .page {
    margin-bottom: 0px; /* Adjust spacing as needed */
}

/* Adjust padding inside each page link */
.sidebar .page a {
    padding: 0px 0px; /* Adjust top/bottom and left/right padding */
}

/* Section highlight animation when targeted through anchor links */
:target,
h2[id]:target,
h3[id]:target,
h4[id]:target,
div[id]:target {
    position: relative;
    background: linear-gradient(to right, rgba(74, 47, 249, 0.1), rgba(2, 255, 187, 0.1));
    animation: highlight-section 3s ease-in-out;
    scroll-margin-top: 80px;
    padding: 1rem;
    margin: -1rem;
    border-radius: 8px;
    border-left: 4px solid #4a2ff9;
}

@keyframes highlight-section {
    0% {
        background: linear-gradient(to right, rgba(74, 47, 249, 0.2), rgba(2, 255, 187, 0.2));
    }
    50% {
        background: linear-gradient(to right, rgba(74, 47, 249, 0.2), rgba(2, 255, 187, 0.2));
    }
    100% {
        background: linear-gradient(to right, rgba(74, 47, 249, 0.1), rgba(2, 255, 187, 0.1));
    }
}


#banner {
  background-color: #fef1d7;

  p {
    color: #383645;
  }

  a {
    color: #383645;
    border-bottom: 1px solid #383645;
  }

  button {
    color: #9b98ae;
  }
}


// REO script
!(function () {
  var e, t, n;
  (e = "638190bf025179e"),
    (t = function () {
      Reo.init({ clientID: "638190bf025179e" });
    }),
    ((n = document.createElement("script")).src = "https://static.reo.dev/" + e + "/reo.js"),
    (n.async = !0),
    (n.onload = t),
    document.head.appendChild(n);
})();

// Hubspot script
const script = document.createElement("script");
script.type = "text/javascript";
script.id = "hs-script-loader";
script.async = true;
script.defer = true;
script.src = "//js.hs-scripts.com/23114811.js";
document.head.appendChild(script);

// RB2B script.
!(function () {
  var reb2b = (window.reb2b = window.reb2b || []);
  if (reb2b.invoked) return;
  reb2b.invoked = true;
  reb2b.methods = ["identify", "collect"];
  reb2b.factory = function (method) {
    return function () {
      var args = Array.prototype.slice.call(arguments);
      args.unshift(method);
      reb2b.push(args);
      return reb2b;
    };
  };
  for (var i = 0; i < reb2b.methods.length; i++) {
    var key = reb2b.methods[i];
    reb2b[key] = reb2b.factory(key);
  }
  reb2b.load = function (key) {
    var script = document.createElement("script");
    script.type = "text/javascript";
    script.async = true;
    script.src = "https://s3-us-west-2.amazonaws.com/b2bjsstore/b/" + key + "/8XOE9GH5EDOM.js.gz";
    var first = document.getElementsByTagName("script")[0];
    first.parentNode.insertBefore(script, first);
  };
  reb2b.SNIPPET_VERSION = "1.0.1";
  reb2b.load("8XOE9GH5EDOM");
})();

// Universal CodeGroup tab synchronization
(function() {
  // Store the last selected language to sync across all CodeGroups
  let lastSelectedLanguage = null;
  
  // Function to initialize the script
  function init() {
    console.log("Universal CodeGroup tab sync initialized");
    
    // Set up the click event listener on the document (event delegation)
    document.addEventListener('click', handleDocumentClick);
    
    // Set up a MutationObserver to detect when new CodeGroups are added
    setupMutationObserver();
    
    // Initial scan for CodeGroups
    syncAllCodeGroups();
  }
  
  // Handle clicks anywhere in the document
  function handleDocumentClick(event) {
    // Find if the click was on a CodeGroup tab
    let target = event.target;
    
    // Traverse up the DOM to find if we clicked on a tab
    while (target && target !== document) {
      if (target.getAttribute && target.getAttribute('role') === 'tab' && 
          target.id && target.id.startsWith('headlessui-tabs-tab-')) {
        
        // We found a tab click
        const tabDiv = target.querySelector('div');
        if (tabDiv) {
          const language = tabDiv.textContent.trim();
          console.log(`Tab clicked: ${language}`);
          
          // Store the selected language
          lastSelectedLanguage = language;
          
          // Sync all other CodeGroups to this language (after a small delay)
          setTimeout(() => {
            syncAllCodeGroups();
          }, 10);
        }
        break;
      }
      target = target.parentNode;
    }
  }
  
  // Function to sync all CodeGroups to the last selected language
  function syncAllCodeGroups() {
    if (!lastSelectedLanguage) {
      // If no language has been selected yet, find the first selected tab
      const selectedTab = document.querySelector('[role="tab"][aria-selected="true"]');
      if (selectedTab) {
        const tabDiv = selectedTab.querySelector('div');
        if (tabDiv) {
          lastSelectedLanguage = tabDiv.textContent.trim();
          console.log(`Initial language detected: ${lastSelectedLanguage}`);
        }
      }
    }
    
    if (!lastSelectedLanguage) {
      console.log("No language selected yet");
      return;
    }
    
    // Find all tab containers
    const tabLists = document.querySelectorAll('[role="tablist"][aria-orientation="horizontal"]');
    console.log(`Found ${tabLists.length} CodeGroup containers`);
    
    // For each container, find and click the tab with the matching language
    tabLists.forEach(tabList => {
      const tabs = tabList.querySelectorAll('[role="tab"]');
      
      // Find the tab with the matching language
      let matchingTab = null;
      tabs.forEach(tab => {
        const tabDiv = tab.querySelector('div');
        if (tabDiv) {
          const tabLanguage = tabDiv.textContent.trim();
          if (tabLanguage === lastSelectedLanguage && tab.getAttribute('aria-selected') !== 'true') {
            matchingTab = tab;
          }
        }
      });
      
      // Click the matching tab if found and not already selected
      if (matchingTab) {
        console.log(`Syncing tab to ${lastSelectedLanguage}`);
        matchingTab.click();
      }
    });
  }
  
  // Set up a MutationObserver to detect when new CodeGroups are added
  function setupMutationObserver() {
    const observer = new MutationObserver(mutations => {
      let shouldSync = false;
      
      mutations.forEach(mutation => {
        if (mutation.addedNodes && mutation.addedNodes.length) {
          // Check if any of the added nodes are or contain CodeGroup elements
          for (let i = 0; i < mutation.addedNodes.length; i++) {
            const node = mutation.addedNodes[i];
            if (node.nodeType === 1) {  // Element node
              if (node.getAttribute && node.getAttribute('role') === 'tablist' ||
                  node.querySelector && node.querySelector('[role="tablist"]')) {
                shouldSync = true;
                break;
              }
            }
          }
        }
      });
      
      if (shouldSync) {
        console.log("New CodeGroup detected, syncing...");
        setTimeout(syncAllCodeGroups, 100);  // Delay to ensure the DOM is fully updated
      }
    });
    
    // Start observing the entire document
    observer.observe(document.documentElement, {
      childList: true,
      subtree: true
    });
    
    console.log("MutationObserver set up");
  }
  
  // Start the script when the DOM is ready
  if (document.readyState === 'loading') {
    document.addEventListener('DOMContentLoaded', init);
  } else {
    init();
  }
})();




Failure Mode Detection

ℹ️ These docs are for the free version of Galileo. Documentation for current customers can be found [here](https://docs.galileo.ai/galileo).

Galileo

What is Galileo?

Getting Started with Galileo

How to Use Galileo

From Spot Testing to Systematic Evaluation

Overview

Datasets

Running Experiments with Code

Experiments

Prompts

Python SDK Reference

Typescript SDK Reference

Learn how to integrate and use OpenAI's API with Galileo's wrapper client.

Basic OpenAI Integration

Learn how to handle ignored instructions and ensure that your AI models follow your instructions.

Handling Ignored Instructions

Learn how to identify and address hallucinations and factual errors in your AI models

Fixing Hallucinations and Factual Errors

Learn how to reduce hesitation and uncertainty in your AI models.

Reducing Hesitation and Uncertainty

Learn how to implement a basic Retrieval-Augmented Generation (RAG) system using Galileo and OpenAI.

Basic RAG Example

Learn how to implement a basic agentic AI system using Galileo and OpenAI.

Basic Agentic AI Example

Explore Galileo's comprehensive metrics framework for evaluating and improving AI system performance across multiple dimensions.

Metrics Overview

Projects

Log Streams

Traces

Spans

Learn how to use datasets and experiments to improve your application.

Playground

Running Experiments in the Galileo Console

TypeScript SDK Overview

Learn how to prevent out of context information from being generated by your AI models.

Preventing Out of Context Information

Learn how to ensure that your AI models use all the retrieved data.

Ensuring Complete Use of Retrieved Data

Learn how to maximize the utilization of retrieved chunks by your AI models.

Maximizing Chunk Utilization

Fixing Irrelevant Retrievals

Learn how to optimize multi-step task execution and ensure that agents follow a logical sequence of actions.

Optimizing Multi-Step Task Execution

Learn how to fix issues when AI models ignore your instructions and how to design better prompts for reliable responses.

Ensuring Agents Follow Instructions

Learn how to improve agent decision making and ensure that agents make the right choices.

Overview

Getting Started

SDK/API

How-to Guides

Cookbooks

Concepts

Failure Mode Detection