mihuman is a small, dependency-light Python library that rewrites AI-generated text so it reads like a human wrote it. Everything runs against a local Ollama server — no external API calls, no data leaves your box.

The library ships two things:

1. A humanize() function that streams a rewrite from Ollama and runs a deterministic post-processing pipeline over the output (em-dash stripping, AI-lexicon substitution, burstiness enforcement, optional error injection).
2. A Config dataclass and load_config() helper so you can drive the whole thing from a TOML file instead of threading a dozen keyword arguments through your code.

Install

pip install mihuman

You also need Ollama running locally with at least one model pulled:

ollama pull mistral-nemo:12b   # or llama3.1:8b, gemma2:9b, whatever you like

Quick start

from mihuman import humanize

result = humanize(
    text="The utilization of innovative paradigms facilitates a robust framework...",
    model="llama3.1:8b",
    style="stealth",
    intensity="aggressive",
)

print(result.text)

Driving it from a config file

Drop a mihuman.toml in your project (or at ~/.config/mihuman/config.toml):

model = "llama3.1:8b"
base_url = "http://localhost:11434"
style = "stealth"
intensity = "aggressive"
burstiness = true
error_level = 0
temperature = 0.85
top_p = 0.97
timeout = 300
# seed = 42

Then load it:

from mihuman import humanize, load_config

cfg = load_config()                         # auto-discovers
# cfg = load_config("path/to/mihuman.toml") # or pass an explicit path

result = humanize(text=my_text, **cfg.to_kwargs())
print(result.text)

Config search order (first match wins):

1. Explicit path passed to load_config(path=...)
2. $MIHUMAN_CONFIG env var
3. ./mihuman.toml (current working directory)
4. $XDG_CONFIG_HOME/mihuman/config.toml (fallback: ~/.config/mihuman/config.toml)

Unknown keys raise ConfigError so typos surface at load time, not months later.

An annotated starter config lives at examples/mihuman.toml.

Options

Styles

Intensity

Error injection

Pipeline

Input text
    │
    ▼
Smart chunking          ~800-word, paragraph-aware chunks
    │
    ▼
Ollama /api/chat        streamed rewrite per chunk (system prompt = style overlay)
    │
    ▼
Post-processing         preamble strip → em-dash strip → AI-lexicon sub
                        → contractions → capitalize → burstiness → whitespace
                        → optional human-error injection
    │
    ▼
Output

The LLM does the heavy rewriting; the post-processor cleans up AI-specific tells the model tends to leave behind.

Public API

from mihuman import (
    humanize, HumanizeResult, OllamaError, list_models,
    Config, load_config, ConfigError,
    STYLES, DEFAULT_MODEL, DEFAULT_OLLAMA_URL,
    postprocess, make_rng, build_system_prompt,
    __version__,
)

• humanize(text, *, style, model, intensity, base_url, temperature, top_p, timeout, burstiness, error_level, seed, writing_sample, on_progress, on_token, on_chunk_done) -> HumanizeResult
• list_models(base_url=...) -> list[str] — enumerate installed Ollama models
• postprocess(text, intensity, rng, burstiness, error_level) -> str — run just the post-processor on already-rewritten text

Pass callbacks (on_token, on_chunk_done, on_progress) if you want to stream output into a UI.

Requirements

• Python 3.10+
• Ollama running locally (or somewhere reachable)

Runtime deps: none on Python 3.11+; tomli on 3.10 only.

License

MIT — see LICENSE.