Installation & environment¶

What to install, what to set, and where datafast looks for it.

Install¶

pip install datafast

Datafast needs Python 3.11 or newer. Datafast supports every Python version that still gets security fixes.

The base install is deliberately small. It carries every step, every provider factory, and the JSONL, CSV and in-memory sinks — five runtime dependencies, all of them imported at module scope:

There is no provider SDK in that list. LiteLLM reaches OpenAI, Anthropic, Gemini and the rest over its own HTTP transport, so installing datafast does not install four vendor libraries you will never import.

Extras¶

Anything that needs a heavier dependency ships as an extra:

pip install "datafast[all]"

Reach for one of these steps without its extra and datafast raises an ImportError naming the extra to install, so you will not have to guess which package is missing.

Environment variables¶

Provider API keys¶

Each provider factory reads one variable. You only need keys for the providers you actually call — there is no configuration step that requires all of them.

Two factories need no key at all: ollama() talks to a local daemon, and openai_compatible() takes whatever api_key= you pass it, since a self-hosted server may want none.

You can always pass api_key= directly to a factory, which takes precedence over the environment. An empty variable counts as unset rather than being sent as an empty string.

Other variables¶

Set DATAFAST_LITELLM_SUPPRESS_DEBUG_INFO to 0, false, no or off to let LiteLLM's own diagnostics through — useful when a provider call fails for a reason datafast cannot explain.

Using a .env file¶

Put the variables in a .env file in your working directory and datafast picks them up:

OPENAI_API_KEY=sk-...
ANTHROPIC_API_KEY=sk-ant-...
HF_TOKEN=hf_...

Two details worth knowing:

• It is loaded once, the first time you construct a served model — not at import, and not again afterwards. Writing to .env after that point has no effect on the running process.
• Real environment variables win. The file never overrides a variable that is already set, so an exported key beats the file.

Langfuse tracing¶

Install the extra and set the key pair:

pip install "datafast[langfuse]"

LANGFUSE_PUBLIC_KEY=pk-lf-...
LANGFUSE_SECRET_KEY=sk-lf-...
LANGFUSE_HOST=https://cloud.langfuse.com

Tracing then switches itself on when you build a served model. Both keys are required: with only one set, the automatic path stays quietly off, while an explicit configure_langfuse_tracing() call raises ValueError and tells you which pair it wants. Calling it with enabled=False turns tracing off. See Langfuse Tracing for the full surface.

Verifying the install¶

import datafast

print(datafast.get_version())

Building a served model does not verify the key. Construction resolves whatever it can find and stores None if there is nothing, so a missing key surfaces on the first actual call, not at startup:

from datafast import openai

model = openai()
print(model.api_key is None)  # True when OPENAI_API_KEY is unset

That is worth checking before a long run, since the pipeline will otherwise seed, expand and reach the LLM step before anything complains.

Logging¶

Datafast logs through loguru and reports per-step progress at INFO. Change the level globally:

from datafast import configure_logger

configure_logger(level="WARNING")

Logging is process-wide, so there is no per-run logging setting — RunConfig exposes only what the runner actually reads.