Getting Started | Galileo Observe

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"

from galileo_observe import ObserveWorkflows

observe_logger = ObserveWorkflows(project_name="my_first_project")

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

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

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

// 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));

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

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

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

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