Anistroph

Multi-Domain Predictive Analytics with AI Agent Access

What does it look like when an AI agent can discover predictive models, understand how to use them, run predictions, explain results, and analyze the underlying data?

Anistroph through Claude

What datasets and models are available in Anistroph?
Predict the 4-week material demand for `FAB_A__MAT_0001` as of `2026-07-06`. Then show me the actual demand so we can compare.
Explain the prediction. What's driving the demand forecast up or down?
Find a fab-material series that experienced a demand spike or inventory crisis, predict demand at that point, and explain what drove the spike.


Discovering datasets and models

Predicting material demand

Explaining the prediction with SHAP

Stress-testing a real inventory crisis

MCP access: Anistroph includes an MCP server that can run locally or be deployed with the application. Users can connect Claude and other MCP-compatible clients to their own Anistroph environment through stdio or Streamable HTTP.

Behind the Queries

Anistroph is a multi-domain predictive analytics architecture for structured data — connecting dataset-specific models to shared prediction, explainability, evaluation, multidimensional analysis, and AI-agent services.

Different domains can have different schemas, features, targets, preprocessing, and models without rebuilding the surrounding analytics stack.

A semiconductor manufacturing team can predict wafer yield at different process stages. A maintenance team can predict equipment failure and remaining useful life. A procurement team can forecast material demand and shortage risk. Each problem is different, but all use the same Anistroph runtime.

Explore: GitHub · Setup & Usage · Technical Architecture

Predictive Use Cases

Anistroph includes synthetic reference implementations designed to exercise different parts of the architecture.

Reference domain Predictive use cases What it demonstrates
Semiconductor Manufacturing Wafer yield, critical dimension, film thickness Multiple targets, process-stage prediction, SHAP explainability, multidimensional evaluation
Predictive Maintenance Equipment failure, remaining useful life, maintenance required Temporal sensor data, classification + regression, history-based features
Semiconductor Materials Procurement 4-week material demand, 4-week shortage risk Rolling forecasts, temporal prediction, inventory/supplier signals, multidimensional analysis
Semiconductor Memory Parametric product search, supply risk prediction Structured catalog filtering, semantic filters (range-containment), self-describing search contract, predict-on-search ranking by supply risk / lead time
Real estate Home price prediction Lightweight cross-domain regression validation

The reference datasets are not intended as production benchmarks. They provide concrete, reproducible problems for demonstrating how the same architecture behaves across different predictive domains.

Trained Reference Models

Held-out evaluation metrics for the shipped reference models:

Domain Target Task Held-out metric
Semiconductor Yield wafer_yield Regression R² = 0.81
Semiconductor CD critical_dimension_nm Regression R² = 0.89
Semiconductor Film Thickness film_thickness_nm Regression R² = 0.98
Predictive Maintenance — Failure failure_within_horizon Classification ROC-AUC = 0.85, F1 = 0.61
Predictive Maintenance — Maintenance maintenance_required Classification ROC-AUC = 1.00, F1 = 0.94
Predictive Maintenance — RUL remaining_useful_life_hours Regression MAE = 27.9h
Home Prices price Regression R² = 0.97
Procurement — Demand material_demand_next_4w Regression R² = 0.96, MAE = 14.0
Procurement — Shortage Risk shortage_risk_next_4w Classification ROC-AUC = 0.99, F1 = 0.90
Memory Supply Risk supply_risk_next_4w Classification ROC-AUC = 0.999, F1 = 0.979
Memory Supply Lead Time lead_time_next_4w_days Regression R² = 0.996, MAE = 1.1d

Models are trained on the train partition and evaluated on the held-out evaluation partition (most recent 20% for temporal datasets, random 20% for non-temporal). The two never overlap.

Note: These metrics are from synthetic reference datasets designed to exercise Anistroph’s architecture and workflows; they are not benchmarks of expected real-world model performance.

For dataset-specific prompts and worked examples, see the Setup & Usage Guide.

Core Features

The Anistroph predictive analytics pipeline — from dataset configuration through shared services to MCP, REST, and Web UI interfaces.

AI Agents as an Interface to Predictive Analytics

Anistroph exposes predictive and analytical capabilities to Claude and other AI agents through MCP stdio and Streamable HTTP.

User
 │
 ▼
Claude / AI Agent
 │
 ├── Discover datasets and models
 ├── Inspect model input requirements
 ├── Predict and explain
 ├── Evaluate model performance
 └── Analyze multidimensional populations
 │
 ▼
Anistroph Shared Runtime
 │
 ├── Registered Datasets
 ├── Feature / Preprocessing Contracts
 └── Persisted Models

Agents operate against the same runtime used by REST/OpenAPI and the Web UI rather than implementing their own prediction or analytical logic.

AI Agent Analysis & Validation

Discover → Understand → Execute → Validate

Claude and AI agents first discover the available datasets and models, then inspect the selected model’s input contract to determine required inputs, temporal requirements such as as_of, and required inference history.

The agent can then orchestrate prediction, explanation, evaluation, and analysis through MCP. These operations are executed by Anistroph’s shared services and can be independently reproduced through the Web UI or REST API when validation is required.

This makes the source-feature inputs, selected model, and analytical operation portable across interfaces. An agent-driven workflow can therefore be inspected or reproduced independently without changing the underlying model execution path.

One Architecture, Different Prediction Problems

Multi-Domain Datasets

Each dataset retains its own schema, features, targets, preprocessing, and model artifacts. Shared services remain independent of semiconductor, maintenance, procurement, real estate, or future domain concepts.

Semiconductor ──→ Yield / CD / Film Models ──────┐
Maintenance ────→ Failure / RUL Models ──────────┤
Procurement ────→ Demand / Shortage Models ──────┼─→ Shared Runtime
Real Estate ────→ Price Model ───────────────────┤
Future Domains ─→ Domain-Specific Models ────────┘
                                                   │
                                  Predict • Explain • Evaluate • Analyze
                                                   │
                                      MCP • REST/OpenAPI • Web UI

Declarative Dataset and Model Contracts

Dataset YAML defines what is unique to a prediction problem:

The shared services consume these contracts rather than embedding domain-specific rules into the runtime. To add your own dataset, author a dataset.yaml and register it — see Adding a Dataset in the README and the Dataset Configuration reference in the Setup & Usage Guide for the full YAML schema, transform table, and worked examples.

Multiple Targets

One source dataset can support independent predictive outcomes. Semiconductor manufacturing, for example, uses separate models for wafer yield, critical dimension, and film thickness while sharing the same underlying source data.

Process-Stage Prediction

Anistroph can train separate models for different points in a process using only the information available at each stage.

Before Etch ──→ After Etch ──→ Deposition / Lithography ──→ Final Test
     │               │                         │
     ▼               ▼                         ▼
 Early Model     Mid-Process Model        Later-Stage Model

This supports progressively better-informed predictions without introducing future-process information into earlier-stage models.

Temporal Prediction

Temporal prediction separates the trained model from the changing history used to construct its current inputs.

Entity History through as_of
            │
            ▼
   Rolling / Current Features
            │
            ▼
      Persisted Model
            │
            ▼
       Future Outcome

The longest configured rolling window determines how much entity history is needed. The forecast target determines what future period is being predicted.

Source-Level Explainability

Model preprocessing can expand one business/source feature into several engineered model features. Anistroph normalizes explanation output back to the original source feature so users and agents do not need to reason about one-hot encoded columns.

Multidimensional Analysis and Evaluation

Anistroph distinguishes between two related questions:

For example, a wafer-yield model can be evaluated overall and then across Product, Product × Tool, and Product × Tool × Chamber populations.

How the System Fits Together

Each dataset follows a common predictive lifecycle:

Dataset → define prediction targets → select and transform source features → prepare training data → train models → evaluate persisted models

Once trained, models enter the shared runtime:

Dataset-Specific Layer
Schema • Features • Target • Preprocessing • Model
                         │
                         ▼
                  SHARED RUNTIME
          Predict • Explain • Evaluate • Analyze
                         │
          ┌──────────────┼───────────────┐
          ▼              ▼               ▼
         MCP        REST / OpenAPI      Web UI
          │
   Claude / AI Agents

The separation allows new datasets and models to be introduced without rebuilding the runtime services or agent interfaces.

For Developers

Anistroph is implemented as a modular Python architecture with thin interfaces over a shared service layer.

Layer Technology Role
Language Python Core services, data preparation, ML orchestration
API / Service FastAPI + Uvicorn REST/OpenAPI and Web UI service layer
Data processing Polars + DuckDB Columnar transformations, querying, analytical slicing
Persistence Parquet Dataset and partition storage
Configuration YAML Dataset schemas, features, targets, and split strategy
ML XGBoost + scikit-learn Regression and classification models
Explainability SHAP TreeExplainer Per-prediction XGBoost explanations
Model artifacts joblib Model persistence and reload
Agent access MCP SDK Domain-agnostic tools over stdio and Streamable HTTP
Testing pytest Unit, integration, MCP, and end-to-end coverage

No database, message queue, or vector store is required by the current reference implementation.

Runtime Interfaces

Training and dataset administration are intentionally excluded from the MCP agent tool surface.

External A2A Integration

For this reference implementation, Aina-Veris is used as the technical research system. The relevant datasheets and technical documents are uploaded and indexed into its semiconductor knowledge domain, providing domain-specific retrieval, grounded responses and source citations.

Aina-Veris is not a dependency of Anistroph. Another RAG or technical-document research system can be used instead, provided it exposes an interface that Anistroph can invoke, such as MCP or A2A. The external system and endpoint are configured through Anistroph’s external tool registry.

Extending Anistroph

The architecture is designed to extend along several dimensions:

The current implementation supports regression and binary classification. Multiclass classification, specialized forecasting models, anomaly detection, model versioning/promotion, and monitoring/drift detection are natural extension paths.

Explore the Project

License

Anistroph is available under the GNU GPLv3.

Commercial licensing is also available — ai-musings99@gmail.com