/* 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();
  }
})();


Annotations

ℹ️ 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

Logging

From Spot Testing to Systematic Evaluation

Experiments

Overview

Datasets

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 prevent out of context information from being generated by your AI models.

Preventing Out of Context Information

Learn how to boost your AI model's performance by fully leveraging retrieved text chunks.

Maximizing Chunk Utilization

Learn how to ensure that your RAG systems provide complete answers using the Galileo completeness metric.

Completeness in RAG Systems

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

Basic Agentic AI Example

Learn how to build an Agentic System for a smart weather application in a Python-based tech stack.

🌦️ Weather Vibes Agent Cookbook

Learn how to build and monitor a LangChain AI Agent using Galileo for tracing and observability.

🔎 Monitoring LangChain Agents with Galileo

OpenAI Agent Integration

Logging via OpenTelemetry to Galileo's Observe platform; Simply modify the endpoint and headers to be up and running.

Logging using OpenTelemetry to Galileo with OpenInference in Python

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.

Experiments Overview

Running Experiments in the Galileo Console

Running Experiments with Code

Playground

Healthcheck

Get Token

Create a new Evaluate run with workflows.

Use this endpoint to create a new Evaluate run with workflows. The request body should contain the `workflows` to be ingested and evaluated.

Additionally, specify the `project_id` or `project_name` to which the workflows should be ingested. If the project does not exist, it will be created. If the project exists, the workflows will be logged to it. If both `project_id` and `project_name` are provided, `project_id` will take precedence. The `run_name` is optional and will be auto-generated (timestamp-based) if not provided.

The body is also expected to include the configuration for the scorers to be used in the evaluation. This configuration will be used to evaluate the workflows and generate the results.

Create Workflows Run

Fetch evaluation results for a specific run including rows and aggregate information.

Get Evaluate Run Results

Log workflows to an Observe project.

Use this endpoint to log workflows to an Observe project. The request body should contain the
`workflows` to be ingested.

Additionally, specify the `project_id` or `project_name` to which the workflows should be ingested.
If the project does not exist, it will be created. If the project exists, the workflows will be logged to it.
If both `project_id` and `project_name` are provided, `project_id` will take precedence.

Log Workflows

Get workflows for a specific run in an Observe project.

Get Workflows

Invoke

Log Traces

Traces Available Columns

Spans Available Columns

Query Traces

Query Spans

Get Trace

Get Span

Create Session

Query Sessions

Get Session

Sessions Available Columns

List Log Streams

Create Log Stream

Get Log Stream

Update Log Stream

Delete Log Stream

List Experiments

Create Experiment

Get Experiment

Update Experiment

Delete Experiment

Procures the column information for experiments.

Experiments Available Columns

List Feedback Templates V2

Create Feedback Template V2

Get Feedback Template V2

Delete Feedback Template

Update Feedback Template

Reorder Feedback Templates

Get Feedback Rating V2

Create Feedback Rating V2

Delete Feedback Rating V2

Apply Bulk Feedback V2

When a Protect execution completes with the status specified in the configuration, the webhook specified is
triggered with this payload.

Protect notification

Troubleshooting

TypeScript SDK Overview

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.

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

Integrations

Concepts

API Reference

References

Annotations