modules:
  - class: modules::state::StateModule
    config:
      adapter:
        class: modules::state::adapters::KvStore
        config:
          store_method: file_based  # Options: in_memory, file_based
          file_path: ./data/state_store.db  # required for file_based

</Tab>
<Tab title="Python">
```python title="state_writer.py"
import os
import uuid

from iii import Logger, register_worker

iii = register_worker(os.environ.get("III_URL", "ws://localhost:49134"))


def create_user(input):
    logger = Logger()
    user_id = str(uuid.uuid4())
    user = {"id": user_id, "name": input["name"], "email": input["email"]}

    iii.trigger({
        "function_id": "state::set",
        "payload": {"scope": "users", "key": user_id, "value": user},
    })

    logger.info("User saved to state", {"userId": user_id})
    return {"userId": user_id}


iii.register_function({"id": "users::create"}, create_user)

# Then call from another function or worker
result = iii.trigger({
    "function_id": "users::create",
    "payload": {"name": "Alice", "email": "[email protected]"},
})
print("Created user:", result["userId"])

let iii_clone = iii.clone();
iii.register_function(
    RegisterFunctionMessage {
        id: "users::create".to_string(),
        description: None,
        request_format: None,
        response_format: None,
        metadata: None,
        invocation: None,
    },
    move |input| {
        let iii = iii_clone.clone();
        async move {
            let logger = Logger::new();
            let user_id = uuid::Uuid::new_v4().to_string();
            let name = input["name"].as_str().unwrap_or("");
            let email = input["email"].as_str().unwrap_or("");

            iii.trigger(TriggerRequest {
                function_id: "state::set".into(),
                payload: json!({
                    "scope": "users",
                    "key": user_id,
                    "value": { "id": user_id, "name": name, "email": email },
                }),
                action: None,
                timeout_ms: None,
            }).await?;

            logger.info("User saved to state", Some(json!({ "userId": user_id })));
            Ok(json!({ "userId": user_id }))
        }
    },
);

signal::ctrl_c().await?;
Ok(())

</Tab>
</Tabs>

### 3. Read state

<Tabs>
<Tab title="Node / TypeScript">
```typescript title="state-reader.ts"
iii.registerFunction({ id: 'users::get' }, async (input) => {
  const logger = new Logger()

  const user = await iii.trigger({
    function_id: 'state::get',
    payload: { scope: 'users', key: input.userId },
  })

  logger.info('User retrieved', { userId: input.userId })
  return user
})

// Then call from another function or worker
const user = await iii.trigger({
  function_id: 'users::get',
  payload: { userId: 'some-user-id' },
})
logger.info('Retrieved user', user)

user = iii.trigger({
    "function_id": "state::get",
    "payload": {"scope": "users", "key": input["userId"]},
})

logger.info("User retrieved", {"userId": input["userId"]})
return user

</Tab>
<Tab title="Rust">
```rust title="state_reader.rs"
let iii_clone = iii.clone();
iii.register_function(
    RegisterFunctionMessage {
        id: "users::get".to_string(),
        description: None,
        request_format: None,
        response_format: None,
        metadata: None,
        invocation: None,
    },
    move |input| {
        let iii = iii_clone.clone();
        async move {
            let logger = Logger::new();
            let user_id = input["userId"].as_str().unwrap_or("");

            let user = iii.trigger(TriggerRequest {
                function_id: "state::get".into(),
                payload: json!({
                    "scope": "users",
                    "key": user_id,
                }),
                action: None,
                timeout_ms: None,
            }).await?;

            logger.info("User retrieved", Some(json!({ "userId": user_id })));
            Ok(user)
        }
    },
);

// Then call from another function or worker
let user = iii
    .trigger(TriggerRequest {
        function_id: "users::get".into(),
        payload: json!({ "userId": "some-user-id" }),
        action: None,
        timeout_ms: None,
    })
    .await?;
println!("Retrieved user: {:?}", user);

</Tab>
<Tab title="Python">
```python title="state_update.py"
from datetime import datetime, timezone


def record_login(input):
    logger = Logger()

    iii.trigger({
        "function_id": "state::update",
        "payload": {
            "scope": "users",
            "key": input["userId"],
            "ops": [
                {"type": "set", "path": "lastLogin", "value": datetime.now(timezone.utc).isoformat()},
                {"type": "increment", "path": "loginCount", "by": 1},
            ],
        },
    })

    logger.info("User login recorded", {"userId": input["userId"]})
    return {"updated": True}


iii.register_function({"id": "users::record-login"}, record_login)

# Then call from another function or worker
iii.trigger({
    "function_id": "users::record-login",
    "payload": {"userId": "some-user-id"},
})
print("Login recorded")

        iii.trigger(TriggerRequest {
            function_id: "state::update".into(),
            payload: json!({
                "scope": "users",
                "key": user_id,
                "ops": [
                    { "type": "set", "path": "lastLogin", "value": chrono::Utc::now().to_rfc3339() },
                    { "type": "increment", "path": "loginCount", "by": 1 },
                ],
            }),
            action: None,
            timeout_ms: None,
        }).await?;

        logger.info("User login recorded", Some(json!({ "userId": user_id })));
        Ok(json!({ "updated": true }))
    }
},

</Tab>
</Tabs>

## Result

State is shared across all Functions in the system. Any Function can read or write to any scope/key pair. The Engine handles consistency and persistence based on the configured adapter.
{/* <Info title="Production adapters">
  The default `file_based` adapter works for single-instance use. For production with multiple replicas, use a persistent adapter like Redis. See the [State module reference](/modules/module-state).
</Info> */}