Getting Started | Galileo Observe

Getting started with Galileo Observe is really easy. It involves 3 steps:

Create a project

Go to your Galileo Console. Click on the big + icon on the top left, and follow the steps to create your Observe project.

Integrate Galileo in your code

Galileo Observe can integrate via Langchain callbacks, our Python Logger, or via RESTful APIs.

Choose your Guardrail metrics

Turn on the metrics you want to monitor your system on, select from our Guardrail Metric store or register your own.

Install the Galileo Client

Install the python client via pip install galileo-observe

Open a TypeScript project where you want to install Galileo
Install the client via npm with npm install @rungalileo/galileo

If you are not using Observe Callback features you can use the --no-optional flag to avoid extraneous dependencies.

Add your console URL (GALILEO_CONSOLE_URL) and API key (GALILEO_API_KEY) to your environment variables in your .env file.

GALILEO_CONSOLE_URL="https://console.galileo.yourcompany.com"
GALILEO_API_KEY="Your API Key"

# Alternatively, you can also use username/password.
GALILEO_USERNAME="Your Username"
GALILEO_PASSWORD="Your Password"

Getting an API Key

To create an API key:

Go to your Galileo Console settings and select API Keys

Select Create a new key

Give your key a distinct name and hit Create

Logging via Client

If you’re not using LangChain, you can use our Python or TypeScript Logger to log your data to Galileo.

First you can create your ObserveWorkflows object with your existing project.

from galileo_observe import ObserveWorkflows

observe_logger = ObserveWorkflows(project_name="my_first_project")

Next you can log your workflow.

from openai import OpenAI

client = OpenAI()

prompt = "Tell me a joke about Large Language Models"
model = "gpt-4o-mini"
temperature = 0.3

# Create your workflow to log to Galileo.
wf = observe_logger.add_workflow(input={"input": prompt}, name="CustomWorkflow")

# Initiate the chat call
chat_completion = client.chat.completions.create(
    model=model,
    messages=[{"role": "user", "content": prompt}],
    temperature=temperature,
)
output_message = chat_completion.choices[0].message


# Log your llm call step to Galileo.
wf.add_llm(
    input=[{"role": "user", "content": prompt}],
    output=output_message.model_dump(mode="json"),
    model=model,
    input_tokens=chat_completion.usage.prompt_tokens,
    output_tokens=chat_completion.usage.completion_tokens,
    total_tokens=chat_completion.usage.total_tokens,
    metadata={"env": "production"},
    name="ChatOpenAI",
)

# Conclude the workflow.
wf.conclude(output={"output": output_message.content})
# Log the workflow to Galileo.
observe_logger.upload_workflows()

First you can create your ObserveWorkflows object with your existing project.

from galileo_observe import ObserveWorkflows

observe_logger = ObserveWorkflows(project_name="my_first_project")

Next you can log your workflow.

from openai import OpenAI

client = OpenAI()

prompt = "Tell me a joke about Large Language Models"
model = "gpt-4o-mini"
temperature = 0.3

# Create your workflow to log to Galileo.
wf = observe_logger.add_workflow(input={"input": prompt}, name="CustomWorkflow")

# Initiate the chat call
chat_completion = client.chat.completions.create(
    model=model,
    messages=[{"role": "user", "content": prompt}],
    temperature=temperature,
)
output_message = chat_completion.choices[0].message


# Log your llm call step to Galileo.
wf.add_llm(
    input=[{"role": "user", "content": prompt}],
    output=output_message.model_dump(mode="json"),
    model=model,
    input_tokens=chat_completion.usage.prompt_tokens,
    output_tokens=chat_completion.usage.completion_tokens,
    total_tokens=chat_completion.usage.total_tokens,
    metadata={"env": "production"},
    name="ChatOpenAI",
)

# Conclude the workflow.
wf.conclude(output={"output": output_message.content})
# Log the workflow to Galileo.
observe_logger.upload_workflows()

Initialize client and create or select your project

import { GalileoObserveWorkflow } from "@rungalileo/galileo";

// Initialize and create project
const observeWorkflow = new GalileoObserveWorkflow("Observe Project"); // Project Name
await observeWorkflow.init();

Log your workflows

// Observe dataset
const observeSet = [
  "What are hallucinations?",
  "What are intrinsic hallucinations?",
  "What are extrinsic hallucinations?"
]

// Add workflows
const myLlmApp = (input) => {
    const template = "Given the following context answer the question. \n Context: {context} \n Question: {question}"

    // Add workflow
    observeWorkflow.addWorkflow({ input });

    // Get context from Retriever
    // Pseudo-code, replace with your Retriever call
    const retrieverCall = () => 'You're an AI assistant helping a user with hallucinations.';
    const context = retrieverCall()

    // Log Retriever Step
    observeWorkflow.addRetrieverStep({
      input: template,
      output: context
    })

    // Get response from your LLM
    // Pseudo-code, replace with your LLM call
    const prompt = template.replace('{context}', context).replace('{question}', input)
    const llmCall = (_prompt) => 'An LLM response…';
    const llmResponse = llmCall(prompt);

    // Log LLM step
    observeWorkflow.addLlmStep({
        durationNs: parseInt((Math.random() * 3) * 1000000000),
        input: prompt,
        output: llmResponse,
    })

    // Conclude workflow
    observeWorkflow.concludeWorkflow(llmResponse);
}

observeSet.forEach((input) => myLlmApp(input));

Log your Evaluate run to Galileo

  // Upload workflows to Galileo
  await observeWorkflow.uploadWorkflows();

Integrating with Langchain

We support integrating into both Python-based and Typescript-based Langchain systems:

Integrating into your Python-based Langchain application is the easiest and recommended route. You can just add GalileoObserveCallback(project_name="YOUR_PROJECT_NAME") to the callbacks of your chain invocation.

from galileo_observe import GalileoObserveCallback
from langchain.chat_models import ChatOpenAI

prompt = ChatPromptTemplate.from_template("tell me a joke about {foo}")
model = ChatOpenAI()
chain = prompt | model

monitor_handler = GalileoObserveCallback(project_name="YOUR_PROJECT_NAME")
chain.invoke({'foo':'bears'},
            config(dict(callbacks=[monitor_handler])))

The GalileoObserveCallback logs your input, output, and relevant statistics back to Galileo, where additional evaluation metrics are computed.

from galileo_observe import GalileoObserveCallback
from langchain.chat_models import ChatOpenAI

prompt = ChatPromptTemplate.from_template("tell me a joke about {foo}")
model = ChatOpenAI()
chain = prompt | model

monitor_handler = GalileoObserveCallback(project_name="YOUR_PROJECT_NAME")
chain.invoke({'foo':'bears'},
            config(dict(callbacks=[monitor_handler])))

The GalileoObserveCallback logs your input, output, and relevant statistics back to Galileo, where additional evaluation metrics are computed.

Integrating into your Typescript-based Langchain application is a very simple process. You can just add aGalileoObserveCallback object to the callbacks of your chain invocation.

import { GalileoObserveCallback } from "@rungalileo/galileo";
const observe_callback = new GalileoObserveCallback("observe_example", "app_v1")
await observe_callback.init();

Add the callback {callbacks: [observe_callback]} in the invoke step of your application:

const result = await chain.invoke(
    { question: "What is the powerhouse of the cell?"},
    {callbacks: [observe_callback]});

The GalileoObserveCallback callback logs your input, output, and relevant statistics back to Galileo, where additional evaluation metrics are computed.

Logging through our REST APIs

If you are looking to log directly using our REST APIs, you can do so with our public APIs. More instructions on using those can be found here.

What’s next

Once you’ve integrated Galileo into your production app code, you can choose your Guardrail metrics.

Introduction

Evaluate

Observe

Protect

Galileo Guardrail Metrics

Fine Tune

Galileo NLP Studio

Getting Started | Galileo Observe

Install the Galileo Client

Getting an API Key

Logging via Client

Integrating with Langchain

Logging through our REST APIs

What’s next

Introduction

Evaluate

Observe

Protect

Galileo Guardrail Metrics

Fine Tune

Galileo NLP Studio

​Install the Galileo Client

​Getting an API Key

​Logging via Client

​Integrating with Langchain

​Logging through our REST APIs

​What’s next

Install the Galileo Client

Getting an API Key

Logging via Client

Integrating with Langchain

Logging through our REST APIs

What’s next