> ## Documentation Index
> Fetch the complete documentation index at: https://docs.galileo.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Overview

> An overview of the Galileo SDKs

{/*<!-- markdownlint-enable MD044 -->*/}

The Galileo SDKs provide a comprehensive set of tools for logging, evaluating, and experimenting with LLM applications. Regardless of how you go about logging your AI application, you will still need to install the Galileo SDK and initialize your API keys by following the steps below.

<CardGroup cols={2}>
  <Card title="Python SDK" icon="python" horizontal href="https://pypi.org/project/galileo/">
    The Galileo Python SDK on PyPI.
  </Card>

  <Card title="TypeScript SDK" icon="js" horizontal href="https://www.npmjs.com/package/galileo">
    The Galileo TypeScript SDK on npm.
  </Card>
</CardGroup>

## Installation

<CodeGroup>
  ```bash Pip theme={null}
  pip install galileo
  ```

  ```bash uv theme={null}
  uv pip install galileo
  ```

  ```bash Poetry theme={null}
  poetry add galileo
  ```

  ```bash npm theme={null}
  npm install galileo
  ```

  ```bash Yarn theme={null}
  yarn add galileo
  ```

  ```bash pnpm theme={null}
  pnpm add galileo
  ```
</CodeGroup>

If you want to use the OpenAI wrapper in Python, you need to install with the optional OpenAI dependencies.

<CodeGroup>
  ```bash Pip theme={null}
  pip install "galileo[openai]"
  ```

  ```bash uv theme={null}
  uv pip install "galileo[openai]"
  ```

  ```bash Poetry theme={null}
  poetry add "galileo[openai]"
  ```
</CodeGroup>

## Initialization and authentication

You need a [Galileo API key](/references/faqs/find-keys#galileo-api-key) set as an environment variable called `GALILEO_API_KEY`. The Galileo SDK will automatically pick this up from the environment variable at run time.

You can also optionally set the following environment variables to define the project, Log stream, and console URL that Galileo should use.

| Environment variable  | Description                                                                                                                                                                                                |
| :-------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `GALILEO_PROJECT`     | The [Galileo project](/concepts/projects) to log to. If this is not set, you will need to pass the project name in code.                                                                                   |
| `GALILEO_LOG_STREAM`  | The [default Log stream](/sdk-api/logging/logging-basics) to log to. If this is not set, you will need to pass the Log stream name in code.                                                                |
| `GALILEO_CONSOLE_URL` | For custom Galileo deployments only, set this to the URL of your Galileo Console to log to. If this is not set, it will default to the hosted Galileo version at [app.galileo.ai](https://app.galileo.ai). |

<Note>
  If you are using the free version of Galileo, [app.galileo.ai](https://app.galileo.ai), there is no need to set the `GALILEO_CONSOLE_URL` environment variable.
</Note>

When developing your application, you should use a `.env` file. Create or update a `.env` file with the following values as required:

<CodeGroup>
  ```ini .env theme={null}
  # Your Galileo API key
  GALILEO_API_KEY="your-galileo-api-key"

  # Your Galileo project name
  GALILEO_PROJECT="your-galileo-project-name"

  # The name of the Log stream you want to use for logging
  GALILEO_LOG_STREAM="your-galileo-log-stream "

  # Provide the console url below if you are using a
  # custom deployment, and not using the free tier, or app.galileo.ai.
  # This will look something like “console.galileo.yourcompany.com”.
  # GALILEO_CONSOLE_URL="your-galileo-console-url"
  ```
</CodeGroup>

You can then load the environment variables from this file:

<CodeGroup>
  ```python Python theme={null}
  from dotenv import load_dotenv
  load_dotenv()
  ```

  ```typescript TypeScript theme={null}
  import { config } from "dotenv";
  config();
  ```
</CodeGroup>

For Python, you will need to install `python-dotenv` if you haven't already.

<CodeGroup>
  ```bash Pip theme={null}
  pip install python-dotenv
  ```

  ```bash uv theme={null}
  uv pip install python-dotenv
  ```

  ```bash Poetry theme={null}
  poetry add python-dotenv
  ```
</CodeGroup>

## Logging

The Galileo SDKs allow you to log all prompts, responses, and statistics around your LLM usage. There are three main ways to log your application:

1. **Use a third-party integration** - use wrappers that integrate with common SDKs to automatically log LLM calls or agentic workflows.
2. **Use a decorator** - by decorating a function that calls an LLM with the `@log` decorator or `log` wrapper, the Galileo SDK logs all AI prompts within.
3. **Directly using the `GalileoLogger` class** - For more control over your logging, you can use the `GalileoLogger` directly. This allows you to manually create sessions, start traces, and log spans. This can be mixed with the other methods, for example accessing the logger directly inside a decorated function call to manually add spans.

### Log experiments

Experiments are logged automatically when they are run, but you can use these same SDK concepts inside the code being run by your experiment for greater control and additional logging. This allows you to not only create distinct experiments, such as in notebooks, but to also add experiments to your production application code.

See our [run experiments with code documentation](/sdk-api/experiments/running-experiments) for more details.

## Next steps

### Logging with the SDKs

<CardGroup cols={2}>
  <Card title="Learn how to log experiments" icon="flask" horizontal href="/sdk-api/experiments">
    Learn how to run experiments with multiple data points using datasets and prompt templates
  </Card>

  <Card title="Galileo logger" icon="code" horizontal href="/sdk-api/logging/galileo-logger">
    Log with full control over sessions, traces, and spans using the Galileo logger.
  </Card>

  <Card title="Log decorator" icon="code" horizontal href="/sdk-api/logging/log-decorator/log-decorator">
    Quickly add logging to your code with the log decorator and wrapper.
  </Card>

  <Card title="Galileo context" icon="code" horizontal href="/sdk-api/logging/galileo-context">
    Manage logging using the Galileo context manager.
  </Card>
</CardGroup>

### How-to guides

<CardGroup cols={2}>
  <Card title="Log Using the OpenAI Wrapper" href="/how-to-guides/basics/basic-example" horizontal>
    Learn how to integrate and use OpenAI's API with Galileo's wrapper client.

    <br />

    **Python**
  </Card>

  <Card title="Log Using the @log Decorator" href="/how-to-guides/basics/basic-logging-with-decorator/basic-logging-with-decorator" horizontal>
    Learn how to use the Galileo @log decorator to log functions to traces

    <br />

    **Python**
  </Card>

  <Card title="Create Traces and Spans" href="/how-to-guides/basics/manual-span-creation/manual-span-creation" horizontal>
    Learn how to create log traces and spans manually in your AI apps

    <br />

    **Python**
  </Card>
</CardGroup>

### SDK reference

<CardGroup cols={2}>
  <Card title="Python SDK Reference" icon="python" horizontal href="/sdk-api/python/sdk-reference">
    The Galileo Python SDK reference.
  </Card>

  <Card title="TypeScript SDK Reference" icon="js" horizontal href="/sdk-api/typescript/sdk-reference">
    The Galileo TypeScript SDK reference.
  </Card>
</CardGroup>