/* 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,
h5[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: 0.3rem;
  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();
  }
})();


Delete Experiment

Location

Message

Error Type

ValidationError

APIKeyHeader

OAuth2PasswordBearer

HTTPBasic

HTTPValidationError

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

Recent updates and enhancements to Galileo

Release Notes

Get Started with Galileo

Logging

From Spot Testing to Systematic Evaluation

Experiments

Overview

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

Log Using the OpenAI Wrapper

Learn how to use the Galileo log decorator to log functions to traces

Log Using the Log Decorator

Learn how to create log traces and spans manually in your AI apps

Create Traces and Spans

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

Basic Agentic AI Example

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 evaluate metrics cheaper and faster using the Luna-2 model

Evaluate Metrics with the Luna-2 Model

Learn how to use Luna-2 metrics when running experiments in code

Use Luna-2 in Your Experiments

Learn how to create a local metric in Python to use in your experiments

Create a Local Metric

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

Monitor LangChain Agents with Galileo

Learn how to add evaluations to a multi-agent LangGraph chat bot using Galileo

Add Evaluations to a Multi-Agent LangGraph Application

Learn how to create custom LLM-as-a-Judge metrics to evaluate domain-specific applications within Galileo

Add Domain-Specific Custom Metrics to your Application

Guide to using MongoDB Atlas Vector Search with LangGraph agents logging to Galileo

MongoDB Atlas Integration for Retrieval-Augmented Generation (RAG)

Guide to using Elasticsearch with LangGraph for the Chatbot RAG app, logging to Galileo

Build a RAG Application with Elasticsearch, LangGraph, and Galileo

Get hands on integrating Galileo into an agentic app using the OpenAI Agents SDK

OpenAI Agent Integration

This guide explains how to send OpenTelemetry (OTel) traces to Galileo using OpenInference. Configure the endpoint and headers to get started quickly.

Logging Using OpenTelemetry and OpenInference

Learn how to connect your self-hosted NVIDIA NIM (NVIDIA Inference Microservices) to Galileo for comprehensive LLM performance assessment, playground experimentation, and enhanced generative AI model capabilities

Integrating NVIDIA NIM with Galileo

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

Metrics Overview

Explore Galileo's comprehensive out-of-the-box metrics for evaluating and improving AI system performance across multiple dimensions

Metrics Comparison

Learn how to customize your LLM-powered metrics with Continuous Learning via Human Feedback

Customizing Your LLM-Powered Metrics via CLHF

Discover Galileo's Luna-2 Evaluation model, reducing the latency and cost for metric evaluations

Luna-2 Overview

Understand the requirements and process for fine-tuning Luna-2 models based off your real-world scenarios

Fine-Tuning Luna Models

Projects

Log Streams

Learn how to configure metrics for Log streams, including managing sampling rates

Log Stream Metrics

Traces

Spans

Annotations Overview

Adding Annotations

Learn how to use datasets and experiments to improve your application

Experiments Overview

Learn about datasets, the data driving your experiments

Datasets

Run Experiments in the Galileo Console

Learn about running experiments in Galileo using code

Run Experiments with Code

Learn how to compare multiple experiment runs in Galileo

Compare Experiments

Playground

Learn the basics of logging using the Galileo SDKs

Logging Basics

Get granular control over logging with the GalileoLogger class

Galileo Logger

Easily capture function inputs and outputs as spans in your traces

Log Decorator

Manage trace context and control logging behavior with the Galileo Context Manager

Galileo Context

Learn the basics of running experiments with multiple data points using datasets and prompt templates using the Galileo SDKs

Experiments Basics

Learn how to create and manage datasets for use in your experiments with our SDKs

Learn how to create and use prompt templates in experiments

Prompts

Learn how to run experiments in Galileo using the Galileo SDKs

Run Experiments

A quick lookup for integrating and interpreting metrics in your workflows

Metrics

Learn about the Galileo integrations with third-party SDKs to automatically log your applications

Third-Party Integrations Overview

Learn about the Galileo OpenAI integration

OpenAI SDK

Learn how to send traces from the OpenAI Agents SDK to Galileo for evaluation

OpenAI Agents SDK

Learn about the Galileo LangChain and LangGraph integration

LangChain and LangGraph

Get started using the Galileo TypeScript SDK

Common Errors Guide

Where Do I Find My Project Keys?

Troubleshooting

What is Galileo?

Getting Started with Galileo

How to Use Galileo

Running Experiments in the Galileo Console

Running Experiments with Code

Python SDK Reference

TypeScript SDK Overview

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.

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

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

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

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 implement a basic agentic AI system using Galileo and OpenAI.

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.

Improve Agent Decision Making

Agents

Chatbot

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

Overview

Get Started

How-to Guides

Cookbooks

Integrations

Concepts

SDK/API Reference

References

Delete Experiment

Authorizations

Path Parameters

Response