### Setup Virtual Environment and Install Requirements

Source: https://github.com/apache/hamilton/blob/main/examples/prefect/README.md

Use these commands to create a virtual environment and install necessary Python packages for running the example.

```bash
python -m venv ./venv &&
. ./venv/bin/activate &&
pip install -r requirements.txt
```

--------------------------------

### Install Plugin Example

Source: https://github.com/apache/hamilton/blob/main/hamilton/plugins/README.md

Example of how to install a Hamilton plugin, such as the PySpark plugin, using pip.

```bash
hamilton[pyspark]
```

--------------------------------

### Install Kedro Example Project

Source: https://github.com/apache/hamilton/blob/main/examples/kedro/kedro-plugin/kedro_to_hamilton.ipynb

Installs the example Kedro project code. This is necessary to import Kedro pipeline modules for conversion.

```python
!pip install ../kedro-code
import warnings

warnings.filterwarnings("ignore")
```

--------------------------------

### Basic FastAPI Server Setup

Source: https://github.com/apache/hamilton/blob/main/docs/integrations/fastapi.md

Instantiate a FastAPI server and define basic GET endpoints for the root and dynamic item retrieval. Includes an example of how to run the server using uvicorn.

```python
from typing import Union
from fastapi import FastAPI

app = FastAPI()  # Instantiate the FastAPI server

@app.get("/")  # GET method with base route "/"
def read_root():
    return {"Hello": "World"}

@app.get("/items/{item_id}")  # dynamic route with variable `item_id`
def read_item(item_id: int, q: Union[str, None] = None):
    return {"item_id": item_id, "q": q}

if __name__ == "__main__":
    # launch the server with `uvicorn`
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)  # specify host and port
```

--------------------------------

### Install and Start Jupyter Notebook

Source: https://github.com/apache/hamilton/blob/main/examples/kedro/kedro-code/README.md

Installs Jupyter and starts a local notebook server for use within the Kedro project. Provides catalog, context, pipelines, and session in scope.

```bash
pip install jupyter
kedro jupyter notebook
```

--------------------------------

### Execute Hamilton UI installation script

Source: https://github.com/apache/hamilton/blob/main/docs/concepts/ui.rst

Runs the setup script to pull Docker images, start a local Postgres database, and launch the backend and frontend servers. The UI will be accessible at http://localhost:8242.

```bash
./run.sh
```

--------------------------------

### Start Local Development Server

Source: https://github.com/apache/hamilton/blob/main/contrib/docs/DEV_SETUP.md

Starts a local development server for live preview. Changes are reflected without server restart. Requires dependencies to be installed.

```bash
$ yarn start
```

--------------------------------

### Install and Start JupyterLab

Source: https://github.com/apache/hamilton/blob/main/examples/kedro/kedro-code/README.md

Installs JupyterLab and starts a local JupyterLab server for use within the Kedro project. Provides catalog, context, pipelines, and session in scope.

```bash
pip install jupyterlab
kedro jupyter lab
```

--------------------------------

### Start Jupyter Notebook

Source: https://github.com/apache/hamilton/blob/main/examples/LLM_Workflows/GraphRAG/README.md

Install Jupyter and start a notebook server to access and run notebooks like ingest_notebook.ipynb or notebook.ipynb.

```sh
pip install jupyter
jupyter notebook
```

--------------------------------

### Install Requirements

Source: https://github.com/apache/hamilton/blob/main/examples/LLM_Workflows/NER_Example/README.md

Install the necessary Python packages for the project. This is a prerequisite for running the example in a notebook or via the command line.

```bash
pip install -r requirements.txt
```

```bash
pip install jupyter
```

--------------------------------

### Run Hamilton UI Example Project

Source: https://github.com/apache/hamilton/blob/main/docs/concepts/ui.rst

Execute the example Hamilton UI project from the repository root. This requires installing dependencies and running the script with your UI email and project ID.

```bash
# we assume you're in the Apache Hamilton repository root
cd examples/hamilton_ui
# make sure you have the right python packages installed
pip install -r requirements.txt
# run the pipeline providing the email and project_id you created in the UI
python run.py --email <email> --project_id <project_id>
```

--------------------------------

### Install and Run Hamilton UI

Source: https://github.com/apache/hamilton/blob/main/README.md

Installs the necessary dependencies and starts the Apache Hamilton UI server. This is the first step to using the UI for tracking DAG executions.

```bash
hamilton ui
```

--------------------------------

### Run Materialization Example (Pandas)

Source: https://github.com/apache/hamilton/blob/main/scripts/README.md

Run the materialization example using Pandas. This requires 'openpyxl' and 'xlsxwriter' to be installed.

```bash
uv pip install openpyxl xlsxwriter
cd examples/pandas/materialization
uv run python run.py
cd ../../..
```

--------------------------------

### Run Hello World Example

Source: https://github.com/apache/hamilton/blob/main/scripts/README.md

Execute the 'Hello World' example script. This example has no additional dependencies beyond the core Hamilton package.

```bash
cd examples/hello_world
uv run python my_script.py
cd ../..
```

--------------------------------

### Run Data Quality Example with Pandera

Source: https://github.com/apache/hamilton/blob/main/scripts/README.md

Run the data quality example which requires the 'pandera' library. Ensure pandera is installed before running the script.

```bash
uv pip install pandera
cd examples/data_quality/simple
uv run python run.py
cd ../../..
```

--------------------------------

### Run Apache Hamilton Example

Source: https://github.com/apache/hamilton/blob/main/examples/hello_world/README.md

Execute the Apache Hamilton hello world example using a Python script. Ensure you have Python installed.

```bash
> python my_script.py
```

--------------------------------

### Navigate to Examples Directory

Source: https://github.com/apache/hamilton/blob/main/examples/README.md

Change your current directory to the 'examples' folder within the Hamilton project. This is the first step before building or running any examples.

```bash
cd hamilton/examples
```

--------------------------------

### Run Notebook

Source: https://github.com/apache/hamilton/blob/main/examples/LLM_Workflows/NER_Example/README.md

Start a Jupyter notebook server in the current directory to access and run the example notebook.

```bash
jupyter notebook
```

--------------------------------

### Run Function Reuse Example

Source: https://github.com/apache/hamilton/blob/main/scripts/README.md

Execute the example demonstrating function reuse. Navigate to the example directory and run the script.

```bash
cd examples/reusing_functions
uv run python run.py
cd ../..
```

--------------------------------

### Install Dependencies for DBT and Hamilton

Source: https://github.com/apache/hamilton/blob/main/examples/dbt/README.md

Install the necessary Python packages for the dbt and Hamilton example. This command should be run from the 'examples/dbt' directory.

```bash
cd examples/dbt
pip install -r requirements.txt
```

--------------------------------

### Run the Example with Bash

Source: https://github.com/apache/hamilton/blob/main/examples/scikit-learn/transformer/README.md

Execute the Python script to run the Apache Hamilton DAG and verify its output. Ensure you have Python installed.

```bash
> python run.py
```

--------------------------------

### Run Hamilton UI in Mini Mode

Source: https://github.com/apache/hamilton/blob/main/ui/BUILD.md

Installs the UI package and starts the Django development server. Access the UI at http://localhost:8241.

```bash
pip install apache-hamilton-ui
hamilton ui --port 8241

```

--------------------------------

### Setup Hamilton Notebook Environment

Source: https://github.com/apache/hamilton/blob/main/examples/caching/materializer_tutorial.ipynb

Initializes the Hamilton notebook environment by loading extensions, configuring logging, and cleaning up previous cache directories. Ensure the cache directory is removed before starting.

```python
import logging
import shutil

from hamilton import driver

CACHE_DIR = "./.materializer_and_caching_cache"

logger = logging.getLogger("hamilton.caching")
logger.setLevel(logging.INFO)
logger.addHandler(logging.StreamHandler())

shutil.rmtree(CACHE_DIR, ignore_errors=True)

# load the notebook extension
%reload_ext hamilton.plugins.jupyter_magic
```

--------------------------------

### Install Project Dependencies

Source: https://github.com/apache/hamilton/blob/main/examples/hamilton_ui/README.md

Installs the Python dependencies required for the Hamilton UI example. Ensure you are in the correct directory before running this command.

```bash
cd hamilton/examples/hamilton_ui
pip install -r requirements.txt
```

--------------------------------

### Install Hamilton with UI support

Source: https://github.com/apache/hamilton/blob/main/examples/async/README.md

Installs the Hamilton library with optional UI support, which is necessary for visualizing the DAG execution. This command is typically run before starting the Hamilton UI server.

```bash
pip install sf-hamilton[ui]
```

--------------------------------

### Install Local Wheel and Test Version

Source: https://github.com/apache/hamilton/blob/main/scripts/README.md

Install the built wheel package locally and then print the installed Hamilton version to verify the installation.

```bash
uv pip install dist/apache_hamilton-*.whl
```

```python
import hamilton; print(hamilton.version.VERSION)
```

--------------------------------

### Activate Hamilton Environment and Run Example

Source: https://github.com/apache/hamilton/blob/main/examples/README.md

Navigate to a specific example directory (e.g., 'hello_world'), activate the 'hamilton-env' Python virtual environment, run the example script, and then deactivate the environment.

```bash
cd hamilton/examples/hello_world
source hamilton-env/bin/activate  # this will activate the right python environment
python my_script.py
deactivate # this will deactivate the virtual environment so you can activate another
```

--------------------------------

### Install Dependencies and Run Script

Source: https://github.com/apache/hamilton/blob/main/examples/decoupling_io/README.md

Use these commands to install project dependencies and view the help message for the main run script. Ensure you have Python and pip installed.

```bash
pip install -r requirements.txt
```

```bash
python run.py --help
Usage: run.py [OPTIONS] COMMAND [ARGS]...

Options:
  --help  Show this message and exit.

Commands:
  run
  visualize
```

--------------------------------

### Start Jupyter Notebook

Source: https://github.com/apache/hamilton/blob/main/examples/narwhals/README.md

Launch a Jupyter Notebook server to run the provided notebook. Ensure jupyter is installed via pip.

```bash
# cd examples/narwhals
jupyter notebook   # pip install jupyter if you don't have it
```

--------------------------------

### Run Schema Validation Example

Source: https://github.com/apache/hamilton/blob/main/scripts/README.md

Execute the schema validation example. Navigate to the example directory and run the script.

```bash
cd examples/schema
uv run python run.py
cd ../..
```

--------------------------------

### Install Project Dependencies

Source: https://github.com/apache/hamilton/blob/main/examples/LLM_Workflows/neo4j_graph_rag/README.md

Sets up a Python virtual environment and installs project dependencies from requirements.txt. Ensure Python 3.10+ is installed.

```bash
python -m venv venv
source venv/bin/activate
pip install -r requirements.txt
```

--------------------------------

### Install Dependencies and Run Notebook

Source: https://github.com/apache/hamilton/blob/main/examples/dask/community_demo/README.md

Instructions for setting up the environment and running the demo notebook. Ensure you have the necessary libraries installed.

```bash
pip install -r requirements.txt
jupyter notebook
```

--------------------------------

### Run Hamilton Example with Help

Source: https://github.com/apache/hamilton/blob/main/examples/LLM_Workflows/modular_llm_stack/README.md

Use this command to see all available options for running the example, including selecting vector databases and embedding services.

```bash
python run.py --help
```

--------------------------------

### Manual Setup Steps

Source: https://github.com/apache/hamilton/blob/main/examples/LLM_Workflows/retrieval_augmented_generation/README.md

Follow these steps for manual setup, including cloning the repository, configuring environment variables, and building Docker images. Access the Streamlit app at http://localhost:8080/.

```bash
git clone https://github.com/apache/hamilton.git
cd hamilton/examples/LLM_Workflows/retrieval_augmented_generation
```

```bash
cp .env.template .env
```

```bash
docker compose up -d --build
```

```bash
docker compose down
```

```bash
docker compose logs -f
```

--------------------------------

### Run Split/Apply/Combine Example

Source: https://github.com/apache/hamilton/blob/main/examples/pandas/split-apply-combine/README.md

Instructions on how to run the split-apply-combine example using Python scripts or Jupyter notebooks.

```bash
# cd examples/pandas/split-apply-combine/
python my_script.py
```

```bash
# cd examples/pandas/split-apply-combine/
jupyter notebook   # pip install jupyter if you don't have it
```

--------------------------------

### Install Hamilton Contrib Package

Source: https://github.com/apache/hamilton/blob/main/examples/contrib/notebook.ipynb

Installs the sf-hamilton-contrib package, which may contain additional utilities or examples.

```python
# !pip install sf-hamilton-contrib
```

--------------------------------

### Install Dependencies for Apache Hamilton on Ray

Source: https://github.com/apache/hamilton/blob/main/examples/data_quality/simple/README.md

Installs the Python dependencies needed for running the example with Apache Hamilton and Ray.

```bash
pip install -r requirements-ray.txt
```

--------------------------------

### Install Dependencies for Apache Hamilton on Dask

Source: https://github.com/apache/hamilton/blob/main/examples/data_quality/simple/README.md

Installs the Python dependencies required for running the example with Apache Hamilton and Dask.

```bash
pip install -r requirements-dask.txt
```

--------------------------------

### Install Hamilton, Pandas, and DuckDB

Source: https://github.com/apache/hamilton/blob/main/examples/data_loaders/data_loaders.ipynb

Installs necessary libraries for data loading, including Hamilton, Pandas, and a specific version of DuckDB. Ensure these are installed before running data loading examples.

```python
# %pip install sf-hamilton[visualization] pandas duckdb==0.5.0
```

--------------------------------

### Initialize Clients and Application Variables

Source: https://github.com/apache/hamilton/blob/main/examples/LLM_Workflows/GraphRAG/notebook.ipynb

Sets up the necessary clients and variables for the application, including OpenAI client, FalkorDB connection, graph name, and a unique application run ID.

```python
# define our clients / connections / IDs
openai_client = openai.OpenAI()
db_client = FalkorDB(host="localhost", port=6379)
graph_name = "UFC"
application_run_id = str(uuid.uuid4())
```

--------------------------------

### Running the Fine-tuning Code

Source: https://github.com/apache/hamilton/blob/main/contrib/hamilton/contrib/user/skrawcz/fine_tuning/README.md

Instantiate the driver with `{"start": "base"}` to use a raw base LLM. Specify the model ID, e.g., `"model_id":"google/mt5-small"`, and provide the data path and key names as inputs.

```python
# Example of how to run the code:
# python your_script.py \
#     --config '{"start": "base"}' \
#     --model_id "google/mt5-small" \
#     --data_path PATH_TO_YOUR_DATA.json \
#     --input_text_key "question" \
#     --output_text_key "reply"
```

--------------------------------

### Install Dependencies for Apache Hamilton on Pandas on Spark

Source: https://github.com/apache/hamilton/blob/main/examples/data_quality/simple/README.md

Installs the Python dependencies required for running the example with Apache Hamilton and Pandas on Spark.

```bash
pip install -r requirements-spark.txt
```

--------------------------------

### Run application.py with help

Source: https://github.com/apache/hamilton/blob/main/examples/LLM_Workflows/image_telephone/README.md

Execute this command to view the command-line options for the application.py script.

```bash
python application.py --help
```

--------------------------------

### Colab Environment Setup

Source: https://github.com/apache/hamilton/blob/main/examples/dask/hello_world/notebook.ipynb

Optional setup for Google Colab to mount Google Drive, clone the Hamilton repository, and install requirements. This ensures modifications are saved and persistent.

```python
## 1. Mount google drive
# from google.colab import drive
# drive.mount('/content/drive')
## 2. Change directory to google drive.
# %cd /content/drive/MyDrive
## 3. Make a directory "hamilton-tutorials"
# !mkdir hamilton-tutorials
## 4. Change directory to it.
# %cd hamilton-tutorials
## 5. Clone this repository to your google drive
# !git clone https://github.com/apache/hamilton/
## 6. Move your current directory to the hello_world example
# %cd hamilton/examples/hello_world
## 7. Install requirements.
# %pip install -r requirements.txt
# clear_output()  # optionally clear outputs
# To check your current working directory you can type `!pwd` in a cell and run it.
```

--------------------------------

### Set up Hamilton Driver and Input Data

Source: https://github.com/apache/hamilton/blob/main/examples/scikit-learn/transformer/hamilton_notebook.ipynb

Initializes a Pandas DataFrame with sample data and defines the desired output columns. Then, it sets up the Hamilton Driver with specified modules and calculations.

```python
# Set up the driver, input and output columns
initial_df = pd.DataFrame(
    {"signups": [1, 10, 50, 100, 200, 400], "spend": [10, 10, 20, 40, 40, 50]}
)

output_columns = [
    "spend",
    "signups",
    "avg_3wk_spend",
    "spend_per_signup",
    "spend_zero_mean_unit_variance",
]


dr = driver.Driver({}, spend_calculations, spend_statistics)
```

--------------------------------

### Start Hamilton UI with PostgreSQL 18 (Fresh Install)

Source: https://github.com/apache/hamilton/blob/main/ui/UPGRADE.md

This command starts the Hamilton UI Docker containers with PostgreSQL 18, rebuilding the images if necessary. This option is recommended for development or testing environments where data preservation is not required, as it will delete all existing data.

```bash
cd hamilton/ui

# Start with PostgreSQL 18
./run.sh --build
```

--------------------------------

### Scaffold a Hamilton Data Pipeline

Source: https://github.com/apache/hamilton/blob/main/docs/ecosystem/mcp-server.md

Use hamilton_scaffold to generate a starting point for a data pipeline, tailored to preferred libraries. This example scaffolds a basic data pipeline for pandas.

```python
Tool call: hamilton_scaffold(pattern="data_pipeline", preferred_libraries=["pandas"])
Response:
"""Hamilton data pipeline: ingest -> clean -> transform -> aggregate."""
import pandas as pd

def raw_data(raw_data_input: pd.DataFrame) -> pd.DataFrame:
    """Ingest raw data."""
    return raw_data_input

def cleaned_data(raw_data: pd.DataFrame) -> pd.DataFrame:
    """Remove nulls and duplicates."""
    return raw_data.dropna().drop_duplicates()
...
```

--------------------------------

### Manual Build Process for Mini Mode

Source: https://github.com/apache/hamilton/blob/main/ui/BUILD.md

Manually builds the frontend, copies assets to the backend, builds the Python package, and optionally uploads to PyPI.

```bash
# 1. Build frontend
cd ui/frontend
npm install
npm run build

# 2. Copy to backend
rm -rf ../backend/server/build
mkdir -p ../backend/server/build
cp -a build/. ../backend/server/build/

# 3. Build Python package
cd ../backend
python -m build

# 4. Verify package contents
tar -tzf dist/apache-hamilton-ui-*.tar.gz | grep build/

# 5. Publish (optional)
python -m twine upload --repository testpypi dist/*

```

--------------------------------

### Building Hamilton UI Docker Containers from Scratch

Source: https://github.com/apache/hamilton/blob/main/examples/LLM_Workflows/RAG_document_extract_chunk_embed/simple_pipeline.ipynb

Instructions for building the Docker containers for the Hamilton UI from scratch. This is an alternative to using pre-built images.

```bash
# from the hamilton/ui directory
./deployment/build.sh
```

--------------------------------

### Object Prototype Extension for Hamilton

Source: https://github.com/apache/hamilton/blob/main/examples/plotly/interactive.html

Extends Object.prototype with methods like get, has, set, and delete for use with Hamilton's internal mechanisms. This is typically part of the library's internal setup.

```javascript
Object.prototype,{"get":{"value":function(t,e){return this.get__(t,e)},"writable":!0,"configurable":!0},"has":{"value":function(t){return this.has__(t)},"writable":!0,"configurable":!0},"set":{"value":function(t,e){return this.set__(t,e)},"writable":!0,"configurable":!0},"delete":{"value":function(t){return this.delete__(t)},"writable":!0,"configurable":!0}}
```

--------------------------------

### Install sf-hamilton with Ray

Source: https://github.com/apache/hamilton/blob/main/examples/LLM_Workflows/scraping_and_chunking/spark/requirements.txt

Install the sf-hamilton library with Ray support. This is an optional installation for distributed computing.

```bash
# sf-hamilton[ray]
```

--------------------------------

### Install Claude Code CLI

Source: https://github.com/apache/hamilton/blob/main/docs/ecosystem/claude-code-plugin.md

Installs the Claude Code CLI tool. Ensure you have curl installed.

```bash
curl -fsSL https://cli.claude.ai/install.sh | sh
```

--------------------------------

### Run Slack Notification Example

Source: https://github.com/apache/hamilton/blob/main/examples/slack/README.md

To run this example, fill in the details in `slack_notification_example.py` and execute it using Python. Ensure you have the necessary Slack API credentials configured.

```python
python slack_notification_example.py
```

--------------------------------

### Initialize Rendering System

Source: https://github.com/apache/hamilton/blob/main/examples/plotly/interactive.html

Initializes the rendering system with various buffers and shaders. Sets up the core rendering pipeline.

```javascript
t.exports=function(t){var e=t.gl,r=m(e),n=b(e),s=x(e),l=_(e),u=i(e),c=a(e,[{buffer:u,size:4,stride:w,offset:0},{buffer:u,size:3,stride:w,offset:16},{buffer:u,size:3,stride:w,offset:28}]),f=i(e),h=a(e,[{buffer:f,size:4,stride:20,offset:0},{buffer:f,size:1,stride:20,offset:16}]),p=i(e),d=a(e,[{buffer:p,size:2,type:e.FLOAT}]),v=o(e,1,S,e.RGBA,e.UNSIGNED_BYTE);v.minFilter=e.LINEAR,v.magFilter=e.LINEAR;var g=new E(e,[0,0],[[0,0,0],[0,0,0]],r,n,u,c,v,s,l,f,h,p,d,[0,0,0]),y={levels:[[],[],[]]};for(var T in t)y[T]=t[T];return y.colormap=y.colormap||"jet",g.update(y),g}
```

--------------------------------

### Install Apache Hamilton CLI

Source: https://github.com/apache/hamilton/blob/main/docs/how-tos/cli-reference.md

Installs the Apache Hamilton CLI and its dependencies. Ensure you have Python and pip installed.

```console
pip install sf-hamilton[cli]
```

--------------------------------

### Install sf-hamilton-contrib Package

Source: https://github.com/apache/hamilton/blob/main/contrib/README.md

Use this command to install the package for static installation. Ensure you have the necessary Python dependencies.

```bash
pip install sf-hamilton-contrib --upgrade
```

--------------------------------

### Building Hamilton UI Docker Containers

Source: https://github.com/apache/hamilton/blob/main/examples/LLM_Workflows/RAG_document_extract_chunk_embed/simple_pipeline.ipynb

Instructions for building the Hamilton UI Docker containers from scratch. This is an alternative to using the pre-built script and may be necessary in certain environments.

```bash
# from the hamilton/ui directory
./deployment/build.sh

```

--------------------------------

### Initialize and Configure Hamilton

Source: https://github.com/apache/hamilton/blob/main/examples/plotly/interactive.html

This snippet shows how to initialize and configure the Hamilton framework. It demonstrates setting up the dependency injection container and applying configuration settings.

```java
public static void main(String[] args) {
    Hamilton.bootstrap(new Module() {
        @Override
        protected void configure() {
            install(new MyConfigurationModule());
            bind(MyService.class).to(MyServiceImpl.class);
        }
    });
}
```

--------------------------------

### Install Hamilton Plugin (Combined Command)

Source: https://github.com/apache/hamilton/blob/main/docs/ecosystem/claude-code-plugin.md

A combined command to install the Hamilton plugin, equivalent to adding the marketplace and then installing.

```bash
claude plugin install hamilton@apache/hamilton --scope user
```

--------------------------------

### Install Hamilton UI and run locally

Source: https://github.com/apache/hamilton/blob/main/docs/concepts/ui.rst

Installs the necessary Hamilton packages for the UI and launches the UI in local mode. Access the UI at localhost:8241. Suitable for small production workflows.

```bash
pip install "sf-hamilton[ui,sdk]"
hamilton ui
# python -m hamilton.cli.__main__ ui # on windows
```

--------------------------------

### Install Hamilton with Visualization

Source: https://github.com/apache/hamilton/blob/main/README.md

Installs Apache Hamilton with optional visualization dependencies. Requires Graphviz to be installed separately on your system.

```bash
pip install "sf-hamilton[visualization]"
```

--------------------------------

### Initialize Hamilton Driver with Configuration

Source: https://github.com/apache/hamilton/blob/main/examples/LLM_Workflows/RAG_document_extract_chunk_embed/simple_pipeline.ipynb

Demonstrates how to initialize a Hamilton driver, apply configuration, and integrate adapters and trackers. This is useful for setting up custom dataflow execution environments.

```python
from hamilton_sdk import adapters

tracker = adapters.get_default_tracker()
driver = driver.Builder()
    .with_config(your_config)
    .with_adapters(tracker)
    .build()

```

--------------------------------

### Starting Hamilton UI Server

Source: https://github.com/apache/hamilton/blob/main/examples/LLM_Workflows/RAG_document_extract_chunk_embed/simple_pipeline.ipynb

Command to start the Hamilton UI server. Ensure you are in the correct directory within the Hamilton repository before running this command.

```bash
# we assume you're in the Hamilton repository
# you might need to adjust the path to the script
python -m hamilton.ui.server --email <email> --project_id <project_id>

```

--------------------------------

### Start Experiment Server

Source: https://github.com/apache/hamilton/blob/main/examples/experiment_management/README.md

Launch the local FastAPI server for the experiment manager. This server reads the run metadata cache and mounts the base directory for exploration.

```bash
h_experiments
```

--------------------------------

### Install Slack Notifier

Source: https://github.com/apache/hamilton/blob/main/docs/reference/lifecycle-hooks/SlackNotifierHook.rst

Install the Slack notifier for Apache Hamilton. Ensure `slack_sdk` is installed. Use quotes if using zsh.

```bash
pip install sf-hamilton[slack]
```

--------------------------------

### Navigate to Project Directory

Source: https://github.com/apache/hamilton/blob/main/examples/LLM_Workflows/pdf_summarizer/README.md

Change into the specific project directory after cloning.

```bash
cd hamilton/examples/LLM_Workflows/pdf_summarizer
```

--------------------------------

### Install Hamilton with conda

Source: https://github.com/apache/hamilton/blob/main/docs/get-started/install.md

Install Apache Hamilton using the conda package manager. This command installs the package from the hamilton-opensource channel.

```bash
conda install -c hamilton-opensource sf-hamilton
```

--------------------------------

### Install Hamilton SDK

Source: https://github.com/apache/hamilton/blob/main/ui/sdk/README.md

Install the Apache Hamilton SDK package using pip. This command also validates the installation by importing a module.

```bash
# install the package & cli into your favorite python environment.
pip install "sf-hamilton[sdk]"

# And validate -- this should not error.
python -c "from hamilton_sdk import adapters"
```