Base120 Source SDK

source checkout v2.0.0  ·  Python 3.11+  ·  stdlib-only  ·  not published on PyPI as base120 or hummbl-base120  ·  Apache 2.0  ·  148 tests  ·  score 100/100

Install

$git clone https://github.com/hummbl-dev/base120.git && cd base120 && pip install -e .
stdlib-only air-gap ready Python 3.11+ Apache 2.0 157 tests source install

Zero third-party runtime dependencies. The canonical package name is base120. PyPI publication is not live yet, so install from the GitHub source checkout until a package distribution exists.

6 transformation families

120 models organized into six families. Each model has a code (P1, IN6, SY13), definition, usage guidance, and worked examples.

P
Perspective / Identity
Frame and anchor point of view. Define what something is.
IN
Inversion
Reverse assumptions. Examine opposites, edges, negations.
CO
Composition
Combine parts into coherent wholes.
DE
Decomposition
Break complex systems into constituent parts.
RE
Recursion
Apply operations iteratively; outputs become inputs.
SY
Systems
Understand systems of systems; coordination and emergence.

Engine.get()

Retrieve an operator by code. Returns the full operator object with name, transformation family, definition, and prompt support.

Import

from base120 import Engine

Signature

Engine.get(code: str) -> Operator | None

Example

from base120 import Engine

engine = Engine()
operator = engine.get("P6")
if operator:
    print(operator.name)        # "Point-of-View Anchoring"
    print(operator.definition)

# Iterate a transformation family
p_operators = engine.list(family="P")
for op in p_operators:
    print(op.code, op.name)

Engine.prompt()

Generate an operator-specific prompt for a problem statement.

Signature

Engine.prompt(code: str, problem: str) -> str

Example

from base120 import Engine

engine = Engine()
prompt = engine.prompt(
    "DE1",
    "Our deployment pipeline takes 45 minutes",
)
print(prompt)

Engine.select()

Given a freeform problem statement, returns ranked operator suggestions. Uses local keyword heuristics; no external API call required.

Signature

Engine.recommend(
    problem: str,
    n: int = 5,
) -> list[tuple[Operator, float]]

Example

from base120 import Engine

engine = Engine()
matches = engine.select(
    problem="How do I prioritize features for my MVP?",
    n=3,
)

for operator, score in matches:
    print(f"{operator.code}: {operator.name} (score={score:.2f})")

Model object

The Operator dataclass returned by Engine methods:

class Operator:
    code: str             # "P1", "IN6", "DE7", etc.
    name: str             # Human-readable name
    transformation: str   # "P", "IN", "CO", "DE", "RE", or "SY"
    definition: str       # What this operator is
    aliases: tuple[str, ...]
    prompts: tuple[str, ...]
The full model catalog (120 models) is accessible at the Explorer or via the REST API at GET /v1/models. The Python package reads the bundled operator data locally after source install.

Krineia Ledger — overview

Krineia (formerly named VERUM, renamed 2026-05-04 per HUMMBL namespace audit) is the append-only audit layer inside base120. It records which reasoning operators were applied, when, and in what sequence — creating a provable governance trace without feeding back into the inference loop. Note: Python module path base120 and the verum-overview HTML anchor are retained as intentional migration debt; the public name is Krineia.

Four node fields per entry: id (who/what), time (when), state (current condition), drift (deviation from setpoint).

Three operators: append(), project(), cut(). The ledger grows; it never shrinks. External tools inspect it; the system never reads its own log.

Krineia Ledger — API

Import

from base120 import Ledger

Constructor

Ledger(
    path: Path | str | None = None,  # defaults to ~/.base120/ledger.jsonl
)

Key methods

Method Returns Notes
append(model_code, context, state, drift) None Records an operator application
cut(threshold) list[OperatorTuple] Returns entries where drift exceeds threshold

Example

from pathlib import Path
from base120 import Engine, Ledger

engine = Engine()
result = engine.record(
    "DE1",
    "Reduce release risk.",
    "Split blockers by owner.",
    0.9,
)

ledger = Ledger(Path("_state/reasoning.jsonl"))
ledger.append(result.to_tuple())

for entry in ledger.cut(0.5):
    print(entry.id, entry.time, entry.drift)

CLI

The package ships a CLI for quick lookups and prompt generation. Available after source install:

# Get a model by code
base120 get P1

# Recommend models for a problem
base120 recommend "how do I scale a database"

# List all models in a transformation family
base120 list --transformation DE

# List all 120 models as JSON
base120 list --json

MCP Server

The source package exposes an MCP server for Claude Desktop, Cursor, and other MCP clients. A standalone npm package is also available for Node.js environments.

Python MCP server (bundled)

# Start the MCP server locally
base120-mcp

# Add to claude_desktop_config.json:
{
  "mcpServers": {
    "hummbl": {
      "command": "base120-mcp",
      "args": []
    }
  }
}

npm MCP server (standalone)

npm install -g @hummbl/mcp-server

# claude_desktop_config.json:
{
  "mcpServers": {
    "hummbl": {
      "command": "npx",
      "args": ["-y", "@hummbl/mcp-server"]
    }
  }
}

Available MCP tools

Tool Description
get_model Get a specific model by code
list_all_models List all available mental models
search_models Search models by query or category
recommend_models Select appropriate mental models for a problem

REST API

The REST API is an alternative to the Python SDK — no install required. Free, no auth, sub-50ms latency on Cloudflare edge.

# Base URL
https://api.hummbl.io

# Get a model
GET /v1/models/P1

# List all models
GET /v1/models

# Recommend
POST /v1/recommend
{"problem": "How do I reduce churn?", "limit": 5}

# List transformations
GET /v1/transformations

Full REST API reference: HUMMBL Docs →