Factorio Learning Environment

https://jackhopkins.github.io/factorio-learning-environment
Admin
Factorio Learning Environment is an open-ended automation evaluation platform for testing AI agents'...
Tokens:24,118
Snippets:342
Trust Score:8.3
Update:3 months ago
Show doc for...
Tokens:
Raw
### Quickstart FLE Installation and Execution

Source: https://jackhopkins.github.io/factorio-learning-environment

Commands to install the SDK, initialize the server cluster, and execute an evaluation run.

```bash
# 1. Install FLE with uv
uv add factorio-learning-environment

# 2. Start a Factorio server cluster
fle cluster start

# 3. Run an evaluation (with API keys in .env)
fle eval --config configs/gym_run_config.json
```

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

### Verify Installation

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/getting_started/installation.html

Start the cluster and run evaluation trajectories to confirm the setup.

```bash
# Start Factorio cluster
fle cluster start

# Run evaluation trajectories (requires [eval] dependencies)
fle eval --config configs/gym_run_config.json
```

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

### Install Core FLE SDK

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/getting_started/installation.html

Install the base package using pip or uv.

```bash
# Using pip
pip install factorio-learning-environment

# Using uv (recommended)
uv add factorio-learning-environment
```

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

### Initialize and start the MCP server

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/advanced/mcp.html

Start the MCP server to enable tool communication within the FLE environment.

```python
from fle.env.protocols.mcp import MCPServer

# Initialize MCP server
server = MCPServer()
server.start()
```

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

### Test Installation

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/getting_started/troubleshooting.html

Run verification scripts to ensure the environment is correctly configured.

```bash
# Test the gym registry
python fle/env/tests/gym_env/test_registry.py

# List available environments
python fle/env/gym_env/example_usage.py --list

# Run with detailed output
python fle/env/gym_env/example_usage.py --detail
```

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

### Install Dependencies

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/getting_started/troubleshooting.html

Install the evaluation dependencies or reinstall the package.

```bash
pip install factorio-learning-environment[eval]
```

```bash
pip install --force-reinstall factorio-learning-environment
```

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

### Start Factorio Cluster via CLI

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/getting_started/quickstart.html

Command to initialize the Factorio cluster.

```bash
# Start Factorio cluster
fle cluster start
```

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

### Manage Factorio Cluster

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/getting_started/troubleshooting.html

Start the Factorio cluster environment.

```bash
fle cluster start
```

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

### Run Interactive Setup Script

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/getting_started/installation.html

Use the provided script to configure API keys for LLM providers.

```bash
python fle/eval/infra/setup_api_keys.py
```

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

### Install Optional Features

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/getting_started/installation.html

Install specific feature sets for evaluation, MCP, or PostgreSQL support.

```bash
# For running experiments
pip install factorio-learning-environment[eval]

# For MCP protocol support
pip install factorio-learning-environment[mcp]

# For PostgreSQL support
pip install factorio-learning-environment[psql]

# Install all features
pip install factorio-learning-environment[eval,mcp,psql]

# Using uv (recommended)
uv add factorio-learning-environment[eval]
```

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

### Install FLE with MCP support

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/advanced/mcp.html

Install the necessary dependencies to enable MCP functionality in the environment.

```bash
pip install factorio-learning-environment[mcp]

# Or with uv
uv add factorio-learning-environment[mcp]
```

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

### Define Agent Documentation

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/tools/custom_tools.html

Example usage and documentation structure for the agent.md file.

```python
result = my_tool(
    entity=my_entity,
    target_position=Position(x=10, y=20),
    quantity=5
)
```

```python
entity = get_entity(Prototype.Chest, Position(x=0, y=0))
result = my_tool(entity, Position(x=5, y=5), quantity=10)
assert result['success']
```

```python
try:
    result = my_tool(entity, position)
except InvalidParameterException as e:
    print(f"Invalid parameters: {e}")
```

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

### Automate Assembling Machine Setup

Source: https://jackhopkins.github.io/factorio-learning-environment

Places and configures an assembling machine for iron gear wheels, including power connections and inserter placement. Assumes a pre-existing power network.

```python
# Need to place assembling machines away from the mining area
# Iron gear wheels need 2 iron plates each, and we need 16 per minute
# Assembling machine 2 crafts 90 iron gear wheels per 60 seconds, so 1 machine is enough

# Find a position away from the mining setup (at least 20 tiles away)
assembly_position = Position(x=15.5, y=90.0)  # 20+ tiles south of furnaces

# Define building area for assembler with space for inserters
assembly_box = BuildingBox(
    width=Prototype.AssemblingMachine2.WIDTH + 2 * Prototype.Inserter.WIDTH + 4,
    height=Prototype.AssemblingMachine2.HEIGHT + 4
)
assembly_coords = nearest_buildable(Prototype.AssemblingMachine2, assembly_box, assembly_position)

# Place assembling machine
move_to(assembly_coords.center)
assembler = place_entity(Prototype.AssemblingMachine2, position=assembly_coords.center, direction=Direction.DOWN)
print(f"Placed assembling machine at {assembler.position}")

# Set recipe to iron gear wheels
assembler = set_entity_recipe(assembler, Prototype.IronGearWheel)
print(f"Set recipe to iron gear wheels")

# Connect assembler to power
steam_engine = get_entity(Prototype.SteamEngine, Position(x=2.5, y=8.5))
poles = connect_entities(steam_engine, assembler, Prototype.MediumElectricPole)
print(f"Connected assembler to power network")

# Place input inserter on the right side
input_inserter = place_entity_next_to(Prototype.Inserter, assembler.position, direction=Direction.RIGHT, spacing=0)
input_inserter = rotate_entity(input_inserter, Direction.LEFT)
print(f"Placed input inserter at {input_inserter.position}")

# Place output inserter on the left side
output_inserter = place_entity_next_to(Prototype.Inserter, assembler.position, direction=Direction.LEFT, spacing=0)
print(f"Placed output inserter at {output_inserter.position}")

# Connect inserters to power
poles = connect_entities(steam_engine, input_inserter, Prototype.MediumElectricPole)
poles = connect_entities(steam_engine, output_inserter, Prototype.MediumElectricPole)
print(f"Connected inserters to power")
```

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

### Example Action-Feedback Cycle

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/getting_started/quickstart.html

Illustrates the REPL pattern where an agent submits a Python script to manipulate entities and receives a structured feedback stream.

```python
# 1. Get iron patch and place mining drill
drill = place_entity(
    entity=Prototype.MiningDrill,
    position=nearest(Resource.IronOre),
    direction=Direction.NORTH
)
# 2. Add output storage
chest = place_entity_next_to(
    entity=Prototype.IronChest,
    reference_position=drill.drop_position,
    direction=Direction.SOUTH
)
# 3. Verify automation chain and observe entities
sleep(10) # Sleep for 10 seconds
assert drill.status == EntityStatus.WORKING
print(get_entities())
```

```text
>>> [ BurnerMiningDrill(fuel=Inventory({'coal': 4}),
>>>                     name='burner-mining-drill',
>>>                     direction=Direction.DOWN,
>>>                     position=Position(x=-28.0, y=-61.0),
>>>                     energy=2666.6666666667,
>>>                     tile_dimensions=TileDimensions(tile_width=2.0, tile_height=2.0),
>>>                     status=EntityStatus.WORKING,
>>>                     neighbours=[Entity(name='iron-chest', direction=DOWN, position=Position(x=-27.5 y=-59.5)],
>>>                     drop_position=Position(x=-27.5, y=-59.5),
>>>                     resources=[Ingredient(name='iron-ore', count=30000, type=None)]),
>>>   Chest(name='iron-chest',
>>>         direction=Direction.UP,
>>>         position=Position(x=-27.5, y=-59.5),
>>>         energy=0.0,
>>>         tile_dimensions=TileDimensions(tile_width=1.0, tile_height=1.0),
>>>         status=EntityStatus.NORMAL,
>>>         inventory=Inventory({'iron-ore': 75}))]
```

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

### Initiate research using set_research

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/tools/core_tools.html

Starts the research process for a specific technology, validating prerequisites automatically.

```python
# Start researching automation
research = set_research(Technology.Automation)
```

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

### Implement a transfer items tool

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/tools/custom_tools.html

A complete example showing the client-side Python class and the corresponding server-side Lua logic for transferring items between chests.

```python
from typing import Optional
from fle.env.tools.tool import Tool
from fle.env.entities import Entity

class TransferItems(Tool):
    """Transfers items between two entities."""

    def __call__(self,
                 source: Entity,
                 destination: Entity,
                 item: str,
                 quantity: int) -> dict:
        """
        Transfer items from source to destination.

        Args:
            source: Entity to take items from
            destination: Entity to place items into
            item: Item prototype name
            quantity: Number of items to transfer

        Returns:
            Dictionary with transfer results

        Raises:
            InsufficientItemsException: Not enough items in source
            InventoryFullException: Destination inventory is full
        """
        result = self.execute(
            source=source.name,
            source_position=source.position.to_dict(),
            destination=destination.name,
            destination_position=destination.position.to_dict(),
            item=item,
            quantity=quantity
        )

        return result
```

```lua
global.actions.transfer_items = function(params)
    local source = game.surfaces[1].find_entity(
        params.source,
        params.source_position
    )
    local destination = game.surfaces[1].find_entity(
        params.destination,
        params.destination_position
    )

    if not source or not destination then
        return {success = false, error = "Entity not found"}
    end

    -- Get source inventory
    local source_inv = source.get_inventory(defines.inventory.chest)
    if not source_inv then
        return {success = false, error = "No source inventory"}
    end

    -- Check if enough items
    local available = source_inv.get_item_count(params.item)
    if available < params.quantity then
        return {
            success = false,
            error = "Insufficient items",
            available = available
        }
    end

    -- Transfer items
    local removed = source_inv.remove({
        name = params.item,
        count = params.quantity
    })

    local dest_inv = destination.get_inventory(defines.inventory.chest)
    local inserted = dest_inv.insert({
        name = params.item,
        count = removed
    })

    -- Return any excess
    if inserted < removed then
        source_inv.insert({
            name = params.item,
            count = removed - inserted
        })
    end

    return {
        success = true,
        transferred = inserted,
        source = serialize_entity(source),
        destination = serialize_entity(destination)
    }
end
```

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

### Test Custom Tool

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/tools/custom_tools.html

Example test case using pytest and FactorioGymEnv to verify tool functionality.

```python
import pytest
from fle.env.gym_env import FactorioGymEnv
from fle.env.models import Position

def test_my_tool():
    env = FactorioGymEnv()
    obs = env.reset()

    # Setup test scenario
    code = """
entity = place_entity(
    Prototype.Chest,
    Position(x=0, y=0),
    Direction.NORTH
)
```

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

### Agent Action Generation

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/environment/overview.html

Example of an agent generating a Python program to place a mining drill and an output chest.

```python
# 1. Get iron patch and place mining drill
drill = place_entity(
    entity=Prototype.MiningDrill,
    position=nearest(Resource.IronOre),
    direction=Direction.NORTH
)
# 2. Add output storage
chest = place_entity_next_to(
    entity=Prototype.IronChest,
    reference_position=drill.drop_position,
    direction=Direction.SOUTH
)
# 3. Verify automation chain and observe entities
sleep(10) # Sleep for 10 seconds
assert drill.status == EntityStatus.WORKING
print(get_entities())
```

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

### connect_entities(start, end, connection_type)

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/tools/core_tools.html

Creates connections between entities using automatic pathfinding.

```APIDOC
## connect_entities(start, end, connection_type)

### Description
Establishes a connection between two entities (e.g., belts, pipes, power) using automatic pathfinding.

### Parameters
- **start** (Position) - Required - The starting position.
- **end** (Position) - Required - The ending position.
- **connection_type** (Prototype) - Required - The type of connection to create (e.g., Prototype.TransportBelt).
```

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

### Automate Iron Mining Setup

Source: https://jackhopkins.github.io/factorio-learning-environment

Configures electric mining drills and furnaces to automate iron plate production. Requires an existing steam engine for power connectivity.

```python
# Find iron ore and setup mining
iron_pos = nearest(Resource.IronOre)
print(f"Found iron ore at {iron_pos}")

steam_engine = get_entity(Prototype.SteamEngine, Position(x=2.5, y=8.5))
# Create mining area - need 2 electric mining drills for enough iron throughput
# Iron gear wheels need 2 iron plates each, and we need 16 per minute
# So we need 32 iron plates per minute
# Electric mining drill mines 30 ore per 60 seconds, so 2 drills = 60 ore/min
drill_area_box = BuildingBox(
    width=2 * Prototype.ElectricMiningDrill.WIDTH + 2,
    height=Prototype.ElectricMiningDrill.HEIGHT + Prototype.ElectricFurnace.HEIGHT + 4
)
drill_coords = nearest_buildable(Prototype.ElectricMiningDrill, drill_area_box, iron_pos)
print(f"Found buildable area for drills at {drill_coords.center}")

move_to(drill_coords.left_top)

# Place 2 electric mining drills
drills = []
for i in range(2):
    drill_pos = Position(x=drill_coords.left_top.x + Prototype.ElectricMiningDrill.WIDTH * i, y=drill_coords.left_top.y)
    drill = place_entity(Prototype.ElectricMiningDrill, position=drill_pos, direction=Direction.DOWN)
    drills.append(drill)

    # Place furnace below each drill
    furnace = place_entity_next_to(Prototype.ElectricFurnace, drill.position, direction=Direction.DOWN)

    # Connect to power
    connect_entities(steam_engine, drill, Prototype.MediumElectricPole)
    connect_entities(steam_engine, furnace, Prototype.MediumElectricPole)
```

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

### Handle Invalid Entity Placement Exception

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/tools/overview.html

Example of an exception raised when a game constraint, such as location occupancy, is violated.

```text
InvalidEntityPlacementException: Cannot place burner-mining-drill at
Position(x=10, y=20) - location is occupied by iron-chest
```

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

### Define MCP Tool Schema

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/advanced/mcp.html

Example JSON schema for an MCP tool definition, including parameters and required fields.

```json
{
  "name": "place_entity",
  "description": "Places an entity in the world at a specified position",
  "parameters": {
    "type": "object",
    "properties": {
      "entity": {
        "type": "string",
        "description": "The entity prototype to place"
      },
      "position": {
        "type": "object",
        "properties": {
          "x": {"type": "number"},
          "y": {"type": "number"}
        }
      },
      "direction": {
        "type": "string",
        "enum": ["north", "south", "east", "west"]
      }
    },
    "required": ["entity", "position"]
  }
}
```

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

### Automate Iron Gear Wheel Production

Source: https://jackhopkins.github.io/factorio-learning-environment

Finalizes the logistics setup by removing blocking input chests and refueling the boiler to ensure continuous production.

```python
# The assembler input chest is also blocking. Let me remove it too and rethink the setup
# I need to place belts first, then the input chest on the belt line

# Remove the assembler input chest
assembler_input_chest = get_entity(Prototype.WoodenChest, Position(x=23.5, y=93.5))
move_to(assembler_input_chest.position)
pickup_entity(assembler_input_chest)
print(f"Removed input chest at {assembler_input_chest.position}")

# Now connect the furnace output inserters to the assembler input inserter with belts
output_inserter1 = get_entity(Prototype.Inserter, Position(x=15.5, y=75.5))
output_inserter2 = get_entity(Prototype.Inserter, Position(x=18.5, y=75.5))
assembler_input_inserter = get_entity(Prototype.Inserter, Position(x=22.5, y=93.5))

print(f"Connecting from inserter 1 at {output_inserter1.position} to assembler input at {assembler_input_inserter.position}")

# Connect first inserter to assembler input
belts1 = connect_entities(
    output_inserter1,
    assembler_input_inserter,
    Prototype.TransportBelt
)
print(f"Connected first furnace output to assembler input: {belts1}")

# Connect second inserter to main belt
belts2 = connect_entities(
    output_inserter2,
    belts1,
    Prototype.TransportBelt
)
print(f"Connected second furnace output to belt line: {belts2}")

# Refuel boiler
boiler = get_entity(Prototype.Boiler, Position(x=-4.0, y=3.5))
move_to(boiler.position)
boiler = insert_item(Prototype.Coal, boiler, quantity=30)
print(f"Refueled boiler")

print("Belt connections complete - waiting for iron flow")
```

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

### Run Command-Line Tools

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/environment/gym_registry.html

Execute the example_usage.py script to interact with environments, list available options, or search for specific configurations.

```bash
# Run interactive examples
python fle/env/gym_env/example_usage.py

# List all environments
python fle/env/gym_env/example_usage.py --list

# Show detailed information
python fle/env/gym_env/example_usage.py --detail

# Search for specific environments
python fle/env/gym_env/example_usage.py --search iron

# Output in gym.make() format
python fle/env/gym_env/example_usage.py --gym-format
```

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

### Basic Gym Interface Usage

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/getting_started/quickstart.html

Demonstrates initializing the environment, resetting, executing an action, and closing the session.

```python
import gym
from fle.env.gym_env.action import Action

# Create an environment
env = gym.make("iron_ore_throughput")

# Reset the environment
obs = env.reset(options={'game_state': None})

# Take an action
action = Action(
    agent_idx=0,  # Which agent takes the action
    code='print("Hello Factorio!")',  # Python code to execute
    game_state=None  # Optional: game state to reset to before running code
)

# Execute the action
obs, reward, terminated, truncated, info = env.step(action)

# Clean up
env.close()
```

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

### Initialize PostgreSQL Database Manually

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/advanced/database.html

SQL commands to create the database, user, and grant necessary permissions.

```sql
CREATE DATABASE fle_database;
CREATE USER fle_user WITH PASSWORD 'fle123';
GRANT ALL PRIVILEGES ON DATABASE fle_database TO fle_user;
```

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

### Accessing the Database

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/advanced/database.html

Initialize the database client and perform basic queries for trajectories and steps.

```python
from fle.commons.db_client import get_db_client

# Get database client (auto-detects type from .env)
db = get_db_client()

# Query trajectories
trajectories = db.get_all_trajectories()

# Get specific trajectory
trajectory = db.get_trajectory(trajectory_id)

# Get steps for a trajectory
steps = db.get_trajectory_steps(trajectory_id)
```

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

### Get Entities

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/tools/core_tools.html

Finds multiple entities within an area, with optional filtering by prototype type.

```python
# Get all entities
entities = get_entities()

# Get entities by type
drills = get_entities(prototype=Prototype.BurnerMiningDrill)
```

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

### Create Tool Directory

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/tools/custom_tools.html

Command to initialize the directory for a new tool.

```bash
mkdir fle/env/tools/agent/my_tool
```

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

### Build documentation

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/project_structure.html

Command to generate HTML documentation using Sphinx.

```bash
cd docs/sphinx && python -m sphinx -b html source build/html
```

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

### Execute Complete Workflow

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/getting_started/quickstart.html

Demonstrates the full lifecycle of an environment, from listing and initialization to taking actions and cleanup.

```python
import gym
from fle.env.gym_env.registry import list_available_environments, get_environment_info
from fle.env.gym_env.action import Action

# 1. List available environments
env_ids = list_available_environments()
print(f"Found {len(env_ids)} environments")

# 2. Get information about a specific environment
info = get_environment_info("iron_ore_throughput")
print(f"Description: {info['description']}")

# 3. Create the environment
env = gym.make("iron_ore_throughput")

# 4. Use the environment
obs = env.reset(options={'game_state': None})
print(f"Initial observation keys: {list(obs.keys())}")

# 5. Take actions
current_state = None
for step in range(5):
    action = Action(
        agent_idx=0,
        game_state=current_state,
        code=f'print("Step {step}: Hello Factorio!")'
    )
    obs, reward, terminated, truncated, info = env.step(action)
    done = terminated or truncated
    current_state = info['output_game_state']
    print(f"Step {step}: Reward={reward}, Done={done}")

    if done:
        break

# 6. Clean up
env.close()
```

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

### Get Entity

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/tools/core_tools.html

Retrieves a typed entity object at a specific position. Useful for updating stale references.

```python
# Get a chest at a specific position
chest = get_entity(Prototype.IronChest, Position(x=10, y=20))
```

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

### Create an Environment

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/environment/gym_registry.html

Instantiate a specific Factorio environment using the standard gym.make() method.

```python
import gym

# Create any available environment
env = gym.make("iron_ore_throughput")
```

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

### Environment Creation

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/environment/gym_registry.html

Standard interface for instantiating a Factorio gym environment.

```python
# Creates a Factorio gym environment
gym.make(env_id: str, **kwargs) -> FactorioGymEnv
```

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

### gym.make(env_id: str, **kwargs)

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/environment/gym_registry.html

Creates and returns a Factorio gym environment instance.

```APIDOC
## gym.make(env_id: str, **kwargs)

### Description
Creates a Factorio gym environment.

### Parameters
- **env_id** (str) - Required - The ID of the environment to create.
- **kwargs** (dict) - Optional - Additional configuration arguments.

### Returns
- **FactorioGymEnv** - An instance of the Factorio gym environment.
```

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

### Test a custom tool

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/tools/custom_tools.html

Demonstrates how to invoke a tool and verify the output using the environment's step function.

```python
result = my_tool(
    entity=entity,
    target_position=Position(x=5, y=5),
    quantity=10
)

print(result)
assert result['success']
"""

    action = Action(agent_idx=0, code=code)
    obs, reward, done, truncated, info = env.step(action)

    # Verify results
    assert "success" in obs['raw_text']
    env.close()
```

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

### Visual Observation Data Structure

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/advanced/sprites.html

Example of the observation dictionary format containing base64 encoded map images and entity sprites.

```json
{
    'raw_text': '...',
    'entities': [...],
    'map_image': 'data:image/png;base64,...',
    'sprites': {
        'burner-mining-drill': 'data:image/png;base64,...',
        'iron-chest': 'data:image/png;base64,...'
    }
}
```

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

### Configure PostgreSQL Environment Variables

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/advanced/database.html

Set connection parameters for PostgreSQL in the .env file.

```text
# Database Configuration - Set to postgres to use PostgreSQL
FLE_DB_TYPE="postgres"

# PostgreSQL Configuration
SKILLS_DB_HOST=localhost
SKILLS_DB_PORT=5432
SKILLS_DB_NAME=fle_database
SKILLS_DB_USER=fle_user
SKILLS_DB_PASSWORD=fle123
```

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

### Manual API Key Configuration

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/getting_started/installation.html

Add API keys directly to the .env file.

```text
# OpenAI
OPENAI_API_KEY=sk-...

# Anthropic
ANTHROPIC_API_KEY=sk-ant-...

# Additional providers as needed
```

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

### Create Factorio Environments

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/getting_started/quickstart.html

Instantiate specific throughput or open play environments using the gym.make interface.

```python
import gym

# Create throughput environments
env = gym.make("iron_plate_throughput")
env = gym.make("automation_science_pack_throughput")
env = gym.make("crude_oil_throughput")

# Create open play environment
env = gym.make("open_play")
```

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

### Run the registry test suite

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/environment/gym_registry.html

Execute the test suite to verify that the registry is functioning correctly.

```bash
python fle/env/tests/gym_env/test_registry.py
```

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

### env.step(action)

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/environment/overview.html

Executes an action in the environment and returns the next state.

```APIDOC
## env.step(action)

### Description
Advances the environment by one step using the provided action.

### Parameters
- **action** (Action) - Required - The action to perform, containing agent_idx, optional game_state, and code.

### Returns
- **obs** (Dict[str, Any]) - The new observation.
- **reward** (float) - The reward received from the step.
- **terminated** (bool) - Whether the episode has ended.
- **truncated** (bool) - Whether the episode was truncated.
- **info** (Dict[str, Any]) - Additional diagnostic information.
```

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

### Configure SQLite Database Type

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/advanced/database.html

Set the database backend to SQLite in the .env file.

```text
FLE_DB_TYPE="sqlite"
```

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

### Invoke Tools and Manage Entities

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/tools/overview.html

Demonstrates calling a tool to locate resources, placing an entity, and accessing its attributes.

```python
# Find nearest iron ore
iron_position = nearest(Resource.IronOre)

# Place a mining drill
drill = place_entity(
    entity=Prototype.MiningDrill,
    position=iron_position,
    direction=Direction.NORTH
)

# Check the drill's status
print(f"Drill status: {drill.status}")

# Store result for later use
my_first_drill = drill
```

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

### gym.make(env_id)

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/environment/gym_registry.html

Instantiates a specific Factorio environment by its identifier string.

```APIDOC
## gym.make(env_id)

### Description
Creates and returns an instance of a Factorio environment. The `env_id` corresponds to specific throughput tasks or the open play mode.

### Parameters
- **env_id** (string) - Required - The identifier of the environment to create (e.g., "iron_plate_throughput", "open_play").

### Usage Example
```python
import gym

# Create a throughput environment
env = gym.make("iron_plate_throughput")

# Create the open play environment
env = gym.make("open_play")
```
```

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

### Implement Lua Server Logic

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/tools/custom_tools.html

Register the tool action in the global actions table and implement the game logic using the Factorio API.

```lua
-- Register the tool action
global.actions.my_tool = function(params)
    -- Extract parameters
    local entity_name = params.entity
    local position = params.position
    local quantity = params.quantity or 1

    -- Validate parameters
    if not entity_name or not position then
        return {
            success = false,
            error = "Missing required parameters"
        }
    end

    -- Find the entity
    local entity = game.surfaces[1].find_entity(entity_name, position)
    if not entity then
        return {
            success = false,
            error = "Entity not found at position"
        }
    end

    -- Perform the action using Factorio API
    local result = entity.some_action(quantity)

    -- Return serialized result
    return {
        success = true,
        entity = serialize_entity(entity),
        result = result
    }
end
```

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

### Verify Environment Variables

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/getting_started/troubleshooting.html

Python script to verify that the .env file is loaded correctly.

```python
import os
from dotenv import load_dotenv

load_dotenv()
print(os.getenv('OPENAI_API_KEY'))  # Should show your API key (masked)
print(os.getenv('FLE_DB_TYPE'))     # Should show sqlite or postgres
```

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

### register_all_environments()

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/environment/gym_registry.html

Manually triggers the discovery and registration process for all environments.

```APIDOC
## register_all_environments()

### Description
Manually trigger environment discovery and registration.
```

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

### Discover available tools via MCP

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/advanced/mcp.html

Retrieve and iterate through tools exposed by the MCP server.

```python
# List all available tools
tools = server.list_tools()

for tool in tools:
    print(f"Tool: {tool.name}")
    print(f"Description: {tool.description}")
    print(f"Parameters: {tool.parameters}")
```

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

### Project Directory Layout

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/project_structure.html

The root directory structure of the Factorio Learning Environment project.

```text
factorio-learning-environment/
├── .github/                        # GitHub workflows and CI/CD
├── .fle/                           # Runtime data (saves, scenarios, trajectory logs)
├── docs/                           # Documentation and website
├── examples/                       # Example agent implementations
├── fle/                            # Main codebase
│   ├── agents/                     # Agent implementations
│   ├── cluster/                    # Docker orchestration and scenarios
│   ├── commons/                    # Shared utilities and models
│   ├── configs/                    # Configuration files
│   ├── data/                       # Data files and replays
│   ├── env/                        # Core environment
│   ├── eval/                       # Evaluation framework
│   ├── run.py                      # CLI entry point
│   └── server.py                   # RCON server
├── tests/                          # Test suite
├── .example.env                    # Environment variables template
├── BUILD.md                        # Build instructions
├── CONTRIBUTING.md                 # Contribution guidelines
├── pyproject.toml                  # Python project config
└── uv.lock                         # Dependency lock file
```

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

### Run PostgreSQL via Docker

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/advanced/database.html

Deploy a PostgreSQL instance using Docker for development or testing.

```bash
docker run --name fle-postgres \
  -e POSTGRES_PASSWORD=fle123 \
  -e POSTGRES_USER=fle_user \
  -e POSTGRES_DB=fle_database \
  -p 5432:5432 \
  -d postgres:15
```

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

### System Architecture Diagram

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/environment/overview.html

Visual representation of the interaction between the Agent, Learning Environment, and Factorio Server.

```text
┌─────────────────┐
│     Agent       │
│ (Synthesizes    │
│  Python Code)   │
└────────┬────────┘
         │
         ▼
┌─────────────────────────────┐
│  Learning Environment       │
│  ┌─────────────────────┐   │
│  │   Interpreter       │   │
│  │   - Executes code   │   │
│  │   - Manages         │   │
│  │     namespace       │   │
│  └──────┬──────────────┘   │
│         │                   │
│  ┌──────▼──────────────┐   │
│  │   client.py         │   │
│  │   (Tool Interface)  │   │
│  └──────┬──────────────┘   │
└─────────┼──────────────────┘
          │ Remote TCP Call
          ▼
┌─────────────────────────────┐
│   Factorio Server           │
│  ┌─────────────────────┐   │
│  │   server.lua        │   │
│  │   (Game Logic)      │   │
│  └──────┬──────────────┘   │
│         │                   │
│  ┌──────▼──────────────┐   │
│  │  Factorio Engine    │   │
│  │  (Game Simulation)  │   │
│  └─────────────────────┘   │
└─────────────────────────────┘
```

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

### Environment Methods

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/environment/gym_registry.html

Core methods for managing the environment lifecycle, including resetting, stepping, and closing.

```python
# Reset the environment
reset(options: Dict[str, Any], seed: Optional[int] = None) -> Dict[str, Any]

# Take a step
step(action: Action) -> Tuple[Dict[str, Any], float, bool, bool, Dict[str, Any]]

# Clean up
close() -> None
```

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

### Standard Gym Interface Methods

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/environment/overview.html

Standard methods for interacting with the environment, including resetting, stepping, and closing.

```python
# Reset the environment
obs = env.reset(options: Dict[str, Any], seed: Optional[int] = None) -> Dict[str, Any]

# Take a step
obs, reward, terminated, truncated, info = env.step(action: Action)

# Clean up
env.close()
```

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

### Build Power Infrastructure in Factorio

Source: https://jackhopkins.github.io/factorio-learning-environment

This script automates the placement of an offshore pump, boiler, and steam engine, connects them with pipes, and verifies power generation.

```python
# Step 1: Find water and set up power generation
water_pos = nearest(Resource.Water)
print(f"Found water at {water_pos}")

# Move to water and place offshore pump
move_to(water_pos)
offshore_pump = place_entity(Prototype.OffshorePump, position=water_pos)
print(f"Placed offshore pump at {offshore_pump.position}")

# Find buildable area for boiler (away from water)
boiler_box = BuildingBox(width=Prototype.Boiler.WIDTH + 4, height=Prototype.Boiler.HEIGHT + 4)
boiler_coords = nearest_buildable(Prototype.Boiler, boiler_box, offshore_pump.position)
move_to(boiler_coords.center)
boiler = place_entity(Prototype.Boiler, position=boiler_coords.center, direction=Direction.LEFT)
print(f"Placed boiler at {boiler.position}")

# Add coal to boiler
boiler = insert_item(Prototype.Coal, boiler, quantity=20)

# Find buildable area for steam engine
engine_box = BuildingBox(width=Prototype.SteamEngine.WIDTH + 4, height=Prototype.SteamEngine.HEIGHT + 4)
engine_coords = nearest_buildable(Prototype.SteamEngine, engine_box, boiler.position)
move_to(engine_coords.center)
steam_engine = place_entity(Prototype.SteamEngine, position=engine_coords.center, direction=Direction.LEFT)
print(f"Placed steam engine at {steam_engine.position}")

# Connect water flow
water_pipes = connect_entities(offshore_pump, boiler, Prototype.Pipe)
print(f"Connected offshore pump to boiler with pipes")
steam_pipes = connect_entities(boiler, steam_engine, Prototype.Pipe)
print(f"Connected boiler to steam engine with pipes")

# Wait and verify power generation
sleep(5)
steam_engine = get_entity(Prototype.SteamEngine, steam_engine.position)
assert steam_engine.energy > 0, "Steam engine not generating power"
print(f"Power generation verified! Steam engine producing {steam_engine.energy} energy")
```

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

### Configure SQLite File Path

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/advanced/database.html

Define the file system path for the SQLite database file.

```text
SQLITE_DB_FILE=".fle/data.db"
```

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

### Configure MCP Client Integration

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/advanced/mcp.html

Configuration block for adding the Factorio MCP server to an MCP-compatible client.

```json
{
  "mcpServers": {
    "factorio": {
      "command": "python",
      "args": ["-m", "fle.env.protocols.mcp.server"],
      "env": {
        "FLE_CLUSTER_HOST": "localhost",
        "FLE_CLUSTER_PORT": "34197"
      }
    }
  }
}
```

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

### Handle placement errors

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/tools/core_tools.html

Wrap tool calls in try-except blocks to catch and handle placement exceptions gracefully.

```python
try:
    drill = place_entity(...)
except InvalidEntityPlacementException as e:
    print(f"Placement failed: {e}")
```

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

### Environment Directory Layout

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/project_structure.html

Detailed structure of the fle/env/ directory containing the core environment implementation.

```text
env/
├── gym_env/                # OpenAI Gym interface
│   ├── action.py           # Action definitions
│   ├── observation.py      # Observation space
│   ├── registry.py         # Environment registry
│   └── gym_env.py          # Main gym environment
├── tools/                  # Agent-accessible tools
│   ├── agent/              # Agent tools
│   └── admin/              # Admin tools
├── protocols/              # Communication protocols
│   ├── _mcp/               # Model Context Protocol
│   └── a2a/                # Agent-to-Agent protocol
├── exceptions/             # Custom exceptions
├── entities.py             # Entity definitions
├── instance.py             # Game instance management
└── namespace.py            # Python namespace management
```

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

### PostgreSQL Backup and Restore Commands

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/advanced/database.html

Standard pg_dump and psql commands for backing up and restoring PostgreSQL databases.

```bash
# Dump database
pg_dump -h localhost -U fle_user fle_database > backup.sql

# Restore database
psql -h localhost -U fle_user fle_database < backup.sql
```

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

### Registry Functions

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/environment/gym_registry.html

Functions for discovering and retrieving metadata about available Factorio gym environments.

```python
# Returns a list of all registered environment IDs
list_available_environments() -> List[str]

# Returns detailed information about a specific environment
get_environment_info(env_id: str) -> Optional[Dict[str, Any]]

# Manually trigger environment discovery and registration
register_all_environments() -> None
```

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

### SQLite Backup Commands

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/advanced/database.html

Methods for backing up SQLite databases via file system copy or sqlite3 utility.

```bash
# Simple file copy
cp .fle/data.db .fle/data.db.backup

# Or use SQLite command
sqlite3 .fle/data.db ".backup '.fle/data.db.backup'"
```

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

### step(action)

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/environment/gym_registry.html

Advances the environment by one step using the provided action.

```APIDOC
## step(action: Action) -> Tuple[Dict[str, Any], float, bool, bool, Dict[str, Any]]

### Description
Executes an action in the environment and returns the new observation, reward, termination status, truncation status, and info dictionary.

### Parameters
- **action** (Action) - Required - The action to be performed by the agent.
```

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

### Debug state with print

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/tools/core_tools.html

Use print statements to inspect the current environment state and inventory contents.

```python
print(f"Entities: {get_entities()}")
print(f"Inventory: {inspect_inventory()}")
```

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

### Download and Extract Sprites via CLI

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/advanced/sprites.html

Basic command to download and extract game sprites.

```bash
# Download and extract sprites
fle sprites
```

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

### Import Data into PostgreSQL

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/advanced/database.html

Initializes a PostgreSQL client and imports previously exported trajectory data.

```python
from fle.commons.db_client import PostgreSQLClient

pg_db = PostgreSQLClient(
    host='localhost',
    port=5432,
    database='fle_database',
    user='fle_user',
    password='fle123'
)
pg_db.import_all(trajectories)
```

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

### Invoke tools through the MCP interface

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/advanced/mcp.html

Execute specific tools by name with structured parameters.

```python
# Invoke a tool
result = server.invoke_tool(
    tool_name="place_entity",
    parameters={
        "entity": "burner-mining-drill",
        "position": {"x": 10, "y": 20},
        "direction": "north"
    }
)

print(f"Result: {result}")
```

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

### Database Query Methods

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/advanced/database.html

Methods for retrieving checkpoints and verifying trajectory status.

```python
# Get latest checkpoint
checkpoint = db.get_latest_checkpoint(trajectory_id)

# Get checkpoint at specific step
checkpoint = db.get_checkpoint(trajectory_id, step_number)

# Count steps in trajectory
count = db.count_steps(trajectory_id)

# Check if trajectory exists
exists = db.trajectory_exists(trajectory_id)
```

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

### Initialize SpriteManager

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/advanced/sprites.html

Configures the SpriteManager with custom directory paths for spritemaps and sprites.

```python
sprite_manager = SpriteManager(
    spritemap_dir='/custom/path/spritemaps',
    sprite_dir='/custom/path/sprites'
)
```

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

### Interact with the Environment

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/environment/gym_registry.html

Perform environment reset, execute actions using the Action class, and clean up resources.

```python
from fle.env.gym_env.action import Action

# Reset the environment
obs = env.reset(options={'game_state': None})

# Take an action
action = Action(
    agent_idx=0,  # Which agent takes the action
    code='print("Hello Factorio!")',  # Python code to execute
    game_state=None  # Optional: game state to reset to before running code
)

# Execute the action
obs, reward, terminated, truncated, info = env.step(action)

# Clean up
env.close()
```

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

### List Available Environments

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/getting_started/quickstart.html

Retrieve and display all registered environment IDs using the Python API or command-line interface.

```python
from fle.env.gym_env.registry import list_available_environments

# Get all available environment IDs
env_ids = list_available_environments()
print(f"Available environments: {env_ids}")
```

```bash
python fle/env/gym_env/example_usage.py --list
```

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

### Core Database Client Methods

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/advanced/database.html

Basic CRUD operations for managing trajectories and steps within the database.

```python
# Create new trajectory
trajectory_id = db.create_trajectory(task_id, metadata)

# Save step
db.save_step(trajectory_id, step_data)

# Get trajectory
trajectory = db.get_trajectory(trajectory_id)

# Get all trajectories for a task
trajectories = db.get_task_trajectories(task_id)

# Delete trajectory
db.delete_trajectory(trajectory_id)
```

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

### CLI Sprite Options

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/advanced/sprites.html

Configuration options for sprite management including force re-download, custom directory paths, and worker count for parallel processing.

```bash
# Force re-download
fle sprites --force

# Custom directories
fle sprites --spritemap-dir /path/to/spritemaps --sprite-dir /path/to/sprites

# Parallel processing (default: 4 workers)
fle sprites --workers 8
```

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

### Checkpoint Management

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/advanced/database.html

Methods for saving and loading game state checkpoints to support training persistence.

```APIDOC
## save_checkpoint(trajectory_id, step_number, agent_code, environment_feedback, game_state)

### Description
Saves a new checkpoint for a specific trajectory and step, including agent code, feedback, and the serialized game state.

## get_checkpoint(trajectory_id, step_number)

### Description
Retrieves a previously saved checkpoint for a given trajectory and step number.
```

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

### env.reset(options, seed)

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/environment/overview.html

Resets the environment to an initial state.

```APIDOC
## env.reset(options, seed)

### Description
Resets the environment to an initial state and returns the initial observation.

### Parameters
- **options** (Dict[str, Any]) - Required - Configuration options for the reset.
- **seed** (Optional[int]) - Optional - Random seed for environment initialization.

### Returns
- **obs** (Dict[str, Any]) - The initial observation from the environment.
```

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

### Retrieve recipes using get_prototype_recipe

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/tools/core_tools.html

Fetches a Recipe object containing ingredient and timing data for a given prototype.

```python
# Get recipe for electronic circuits
recipe = get_prototype_recipe(Prototype.ElectronicCircuit)
print(f"Ingredients: {recipe.ingredients}")
print(f"Crafting time: {recipe.energy}")
```

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

### Implement Python Client Interface

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/tools/custom_tools.html

Define the tool class inheriting from Tool and implementing the __call__ method to invoke server-side logic.

```python
from typing import Optional
from fle.env.tools.tool import Tool
from fle.env.entities import Entity
from fle.env.models import Position

class MyTool(Tool):
    """
    Brief description of what your tool does.
    """

    def __call__(self,
                 entity: Entity,
                 target_position: Position,
                 quantity: Optional[int] = None) -> dict:
        """
        Detailed description of the tool's functionality.

        Args:
            entity: The entity to operate on
            target_position: Where to perform the action
            quantity: Optional quantity parameter

        Returns:
            Dictionary containing result information

        Raises:
            InvalidParameterException: If parameters are invalid
            EntityNotFoundException: If entity doesn't exist
        """
        # Call server-side implementation
        result = self.execute(
            entity=entity.name,
            position=target_position.to_dict(),
            quantity=quantity
        )

        return result
```

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

### Enable Verbose Logging

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/getting_started/troubleshooting.html

Set the environment variable to increase log verbosity.

```bash
export FLE_LOG_LEVEL=DEBUG
```

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

### Optimize SQLite Performance

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/advanced/database.html

Enable Write-Ahead Logging (WAL) mode and increase the cache size to improve concurrency and read/write performance.

```sql
# Use WAL mode for better concurrency
db.execute("PRAGMA journal_mode=WAL")

# Increase cache size
db.execute("PRAGMA cache_size=-64000")  # 64MB
```

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

### Debug Docker Logs

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/getting_started/troubleshooting.html

Commands for listing containers and viewing or following logs.

```bash
# List running containers
docker ps

# View logs for a specific container
docker logs <container_id>

# Follow logs in real-time
docker logs -f <container_id>
```

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

### Calculate connection requirements

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/tools/core_tools.html

Determine the number of items required to create a connection between two positions.

```python
# Calculate how many belts are needed
amount = get_connection_amount(
    start_position=drill.drop_position,
    end_position=chest.position,
    connection_type=Prototype.TransportBelt
)
print(f"Need {amount} belts")
```

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

### Run project tests

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/project_structure.html

Commands to execute the test suite using pytest with various options.

```bash
# Run all tests
pytest tests/

# Run specific test file
pytest tests/actions/test_place_entity.py

# Run with coverage
pytest --cov=fle tests/
```

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

### list_available_environments()

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/environment/gym_registry.html

Returns a list of all registered environment IDs available in the system.

```APIDOC
## list_available_environments()

### Description
Returns a list of all registered environment IDs.

### Returns
- **List[str]** - A list of strings representing the IDs of available environments.
```

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

### Resuming from Checkpoint

Source: https://jackhopkins.github.io/factorio-learning-environment/sphinx/build/html/advanced/database.html

Retrieve a saved checkpoint and restore the environment state to continue execution.

```python
# Load checkpoint
checkpoint = db.get_checkpoint(trajectory_id, step_number)

# Resume environment from checkpoint
env.load_state(checkpoint['game_state'])

# Continue execution
obs, reward, done, truncated, info = env.step(next_action)
```
Tokens:
Raw