11 Models · Python 3.11+

tollama

Ollama for Time Series.
Run TSFMs and neural baselines with a single API.

Time series forecasting is still fragmented across incompatible runtimes, conflicting dependencies, and per-model wrappers. tollama now unifies 7 TSFMs and 4 neural baselines behind one daemon, one SDK, one REST API, and first-class agent pathways.

Star on GitHub Quick Start →
Why another tool?

Every TSFM ships its own install, its own API, and its own dependency tree. Building on top of them means fighting fragmentation at every layer.

01 / FRAGMENTATION
Every model ships its own install.
Chronos needs torch, TimesFM needs JAX, Moirai needs einops. Installing multiple models in one environment leads to version hell.
02 / INCONSISTENT APIs
No common interface across models.
Different function signatures, parameter names, and output formats per family. Comparing models means writing adapters for each one.
03 / DEPENDENCY CONFLICTS
Models can't coexist.
torch 2.x and JAX fight over GPU memory allocation. Different CUDA requirements per family make unified environments impossible without isolation.
04 / AGENT FRICTION
LLMs can't call forecast models.
No standard tool interface for AI agents to discover, invoke, and chain time series forecasts. MCP, LangChain, A2A integrations must be built per model.
tollama — bash
# Start the forecasting daemon
$ tollama serve
✓ Daemon running at http://127.0.0.1:11435

# Pull a model from the registry
$ tollama pull chronos2
Pulling chronos2 from Hugging Face... ████████████ 100%

# Run a forecast
$ tollama run chronos2 --input request.json
{"forecast": [[12.4, 13.1, 11.8, 14.2, 13.6, 12.9, 14.8]]}
Quickstart

Install tollama, start the daemon, and run the built-in pull plus forecast demo in under five minutes.

1) Install
python -m pip install tollama

# optional dashboard extras:
python -m pip install "tollama[tui]"

# from source (dev):
python -m pip install -e ".[dev]"
2) Start the daemon
# terminal 1
tollama serve

# check health + diagnostics
curl http://localhost:11435/api/version
tollama doctor
tollama info --json
3) Run the guided demo
# terminal 2
tollama quickstart

# or pull and run manually
tollama pull chronos2
tollama run chronos2 --input examples/chronos2_request.json

# stable API route
curl -s http://localhost:11435/v1/forecast \
  -H 'content-type: application/json' \
  -d @examples/chronos2_request.json

Human-friendly progress is enabled automatically on interactive terminals. Full setup, models, troubleshooting, and API docs live in the upstream repo: README.md.

// Developer Interfaces
4 ways to access.
One unified platform.

Python SDK, REST API, CLI, and dashboards all sit on the same daemon and canonical forecast contract.

Python SDK
from tollama import Tollama

with Tollama() as sdk:
    flow = (
        sdk.workflow(series={"target": [10, 11, 12, 13, 14], "freq": "D"})
        .analyze()
        .auto_forecast(horizon=3)
    )

print(flow.auto_forecast_result.selection.chosen_model)

The upstream SDK now exposes 16 methods, DataFrame conversion, chained workflows, and follow-on helpers like then_compare().

HTTP API · 42 endpoints
curl -s http://localhost:11435/v1/forecast \
  -H 'content-type: application/json' \
  -d '{
    "model": "chronos2",
    "series": [{"target": [120, 135, 142], "freq": "D"}],
    "horizon": 7
  }'

Beyond forecasting, the current API surface covers analyze, generate, compare, report, what-if, counterfactual, scenario-tree, modelfiles, ingest, A2A, and dashboard bootstrap routes.

CLI
tollama serve
tollama quickstart
tollama explain chronos2
tollama runtime install --all
tollama modelfile list
tollama config keys

Recent CLI additions include doctor, open, dashboard, runtime, modelfile, and dev scaffold.

Dashboards
# Web dashboard (browser)
tollama serve
tollama open
# → http://127.0.0.1:11435/dashboard

# Terminal TUI
python -m pip install "tollama[tui]"
tollama dashboard

The bundled dashboard now ships with packaged static assets, auth-aware API routes, and an aggregated /api/dashboard/state bootstrap endpoint.

// Model Registry
11 forecasting backends.
One unified API.

The current upstream registry spans 7 TSFMs and 4 neural baselines. They all share the same CLI, SDK, HTTP, MCP, and A2A surface, while family runtimes stay isolated under ~/.tollama/runtimes/.

PASSING
chronos2
Amazon · Chronos-2
past-numeric past-categorical known-future
PASSING
granite-ttm-r2
IBM · Granite TTM
past-numeric known-future-numeric
PASSING
timesfm-2.5-200m
Google · TimesFM 2.5
past-numeric xreg-support xreg-mode
PASSING
moirai-2.0-R-small
Salesforce · Uni2TS
past-numeric known-future-numeric
PASSING
sundial-base-128m
THUML · Sundial
target-only freq-agnostic
PASSING
toto-open-base-1.0
Datadog · Toto
past-numeric open-base
PASSING
lag-llama
TSFM Community · Lag-Llama
target-only zero-shot
BASELINE
patchtst
IBM Granite · PatchTST
neural-baseline target-only
BASELINE
tide
Unit8 / Darts · TiDE
neural-baseline past-numeric known-future
BASELINE
n-hits
Nixtla / NeuralForecast · N-HiTS
neural-baseline target-only auto-fit
BASELINE
n-beatsx
Nixtla / NeuralForecast · N-BEATSx
neural-baseline target-only auto-fit
Model Family Past Numeric Past Categorical Known-Future Numeric Known-Future Categorical
Chronos-2
Granite TTM
TimesFM 2.5
Uni2TS / Moirai
Sundial
Toto Open Base
Lag-Llama
PatchTST
TiDE
N-HiTS / N-BEATSx
// AI Agent Integrations
Built for agents.
5 integration pathways.

The upstream project explicitly targets both developers and AI agents: forecasts, analysis, comparison, and planning can all be invoked as tools over MCP, A2A, LangChain, or framework adapters.

15 MCP Tools
13 LangChain Tools
5+ Agent Pathways
42 REST Endpoints
🔌
MCP Server (15 tools)

Register tollama-mcp as an MCP server. AI assistants discover and call 15 forecasting tools — forecast, auto-forecast, pipeline, what-if, model management, and data ingest.

🦜
LangChain (13 tools)

First-party LangChain toolkit with 13 tools wrapping the full API surface. Compose forecast chains, embed in ReAct agents, or use with LangGraph workflows.

🤖
CrewAI / AutoGen / smolagents

Framework adapters now ship directly in the package: CrewAI tools, AutoGen tool specs plus function maps, and smolagents-compatible tool wrappers.

🧩
OpenClaw Skills

Skill package at skills/tollama-forecast/ with health, models, forecast, pull, rm, and info wrappers. E2E validated with contract-first error handling.

🤝
A2A Protocol (JSON-RPC)

Authenticated discovery plus task lifecycle support via POST /a2a and /.well-known/agent-card.json, including message/stream, tasks/get, tasks/query, and tasks/cancel.

A daemon that
manages everything.

The tollamad daemon supervises worker-per-family runtimes, keeps the public contract stable, and auto-bootstrap installs isolated venvs per backend when needed.

  • tollamad Public daemon for forecast, analysis, pipeline, and lifecycle requests
  • runtimes/ Per-family isolated venvs with auto-bootstrap under ~/.tollama/runtimes/
  • JSON-lines stdio RPC between daemon and runners
  • SQLite Per-key usage metering at /api/usage
  • SSE Progressive forecasts and daemon events via /api/events
  • API keys Optional auth for daemon, docs, dashboard, and A2A
tollama daemon
(tollamad)
FastAPI 42 endpoints SSE Dashboard
venv
chronos2
venv
timesfm
venv
moirai
venv
lag-llama
venv
+ baselines
JSON-lines stdio protocol
// Advanced Features
Beyond basic forecasting.
🧠
Structured Intelligence

Combined analysis, recommendation, and forecast in a single call via /api/report, with optional narrative blocks.

📡
Progressive Forecasting

Real-time forecast refinement and daemon event feeds over SSE via /api/forecast/progressive and /api/events.

🧪
Analyze + Generate

Model-free descriptive analysis at /api/analyze and synthetic series generation at /api/generate.

📥
Upload + Ingest

Forecast directly from CSV or Parquet using data_url, /api/forecast/upload, or /api/ingest/upload.

🔗
Workflow + Compare

Chain benchmarks, comparisons, and end-to-end plans through /api/compare and /api/pipeline.

🔮
What-if + Counterfactual + Trees

Explore alternative futures with /api/what-if, /api/counterfactual, and /api/scenario-tree.

⚖️
Auto-Forecast + Ensemble

Zero-config model selection via /api/auto-forecast, with ensemble mean and median strategies available today.

📄
TSModelfiles + Config

Create named forecast profiles with tollama modelfile and manage pull or routing defaults with tollama config.

🔒
Auth + Metrics + Diagnostics

Optional API-key auth, docs protection, usage metering at /api/usage, Prometheus at /metrics, and full diagnostics at /api/info.

42 endpoints.
One daemon.

The current endpoint inventory spans system diagnostics, model lifecycle, upload plus ingest, stable v1 routes, structured analysis, scenario workflows, TSModelfiles, observability, and A2A discovery.

json · /api/forecast POST
{
  "model": "timesfm-2.5-200m",
  "horizon": 2,
  "series": [{
    "id": "store_001",
    "freq": "D",
    "target": [120, 135, 142],
    "actuals": [141, 145],
    "past_covariates": {
      "promo": [0, 1, 0]
    },
    "future_covariates": {
      "promo": [1, 0]
    }
  }],
  "parameters": {
    "covariates_mode": "best_effort",
    "metrics": {
      "names": ["mape", "mase", "mae", "rmse", "smape"],
      "mase_seasonality": 1
    }
  }
}
System
/api/version
/api/info
/v1/health
Forecasting
/api/validate
/api/forecast
/api/forecast/progressive
/v1/forecast
/api/auto-forecast
Structured Analysis
/api/analyze
/api/generate
/api/compare
/api/report
/api/pipeline
Model Management
/api/tags
/api/show
/api/pull
/api/delete
/api/ps
/v1/models
Upload + Profiles
/api/ingest/upload
/api/forecast/upload
/api/modelfiles
/api/modelfiles/{name}
Observability + Agents
/api/usage
/api/events
/metrics
/.well-known/agent-card.json
/a2a
// Roadmap
What's next.

The upstream roadmap is now implementation-aware and explicitly tracks what is shipped versus what remains for v1 hardening.

COMPLETED
Auto Model Comparison
Basic auto model comparison and selection are shipped, including ensemble mean and median strategies.
COMPLETED
Auto Data Preprocessing
Basic preprocessing is now implemented with validation, spline interpolation, smoothing, train-fit scaling, and sliding-window generation in tollama.preprocess.
IN PROGRESS
Runtime Hardening
Current TODOs center on VRAM reclaim policy, idle strategy, crash recovery behavior, and stronger runner lifecycle controls.
PLANNED
Local + Cloud Execution
The project remains local-first for v1; future packaging work is focused on better Docker and cloud deployment guidance rather than distributed training.
// Get Started

Forecast, compare,
and serve simply.

Runtime management, analysis, ingest, dashboards, and agent integration all ship in the same platform.

View on GitHub ↗ API Reference →