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


Enumeration: AgentType

classifier

default

judge

planner

react

reflection

router

supervisor

Enumeration Members

AgentType

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

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

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

A quick lookup for integrating and interpreting metrics in your workflows.

Metrics SDK Reference

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

Traces

Spans

Datasets

Annotations Overview

Adding Annotations

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

Experiments Overview

Run Experiments in the Galileo Console

Run Experiments with Code

Learn how to compare multiple experiment runs in Galileo.

Compare experiments

Playground

Run experiments with multiple data points

Prompts

An overview of the Galileo TypeScript SDK.

Troubleshooting

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

Basic OpenAI Integration

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

Get Started

How-to Guides

Cookbooks

Integrations

Concepts

SDK/API Reference

References

AgentType

Enumeration: AgentType

Enumeration Members

classifier

default

judge

planner

react

reflection

router

supervisor

Overview

Get Started

How-to Guides

Cookbooks

Integrations

Concepts

SDK/API Reference

References

​Enumeration: AgentType

​Enumeration Members

​classifier

​default

​judge

​planner

​react

​reflection

​router

​supervisor

Enumeration: AgentType

Enumeration Members

classifier

default

judge

planner

react

reflection

router

supervisor