Forge Sandbox

Fake-Daten, echtes Schema.

Eine lokale, schlüssellose Simulation des Forge Industrie-Telemetrie-Kernels. Führen Sie es auf Ihrem Laptop aus, bauen Sie Ihre Agent-Integration dagegen auf und richten Sie dann denselben Code auf die Produktions-Forge, um mit echter Ausrüstung zu sprechen.

Kein API-Schlüssel. Kein Konto. Keine Anmeldung. Nichts wird gespeichert. Die App tätigt keine ausgehenden Anrufe.

docker run -p 8000:8000 ghcr.io/foundrynet/forge-sandbox

Multi-Arch: linux/amd64 und linux/arm64. Pinnen Sie eine Version mit ghcr.io/foundrynet/forge-sandbox:1.0.0, wenn Sie nicht latest verfolgen möchten.

Port 8000 bereits belegt? docker run -p 8099:8000 ..., oder mit Compose: FORGE_SANDBOX_PORT=8099 docker compose up.

curl -X POST http://localhost:8000/v1/normalize \
  -H "Content-Type: application/json" \
  -d '{"oem": "haas", "data": {"S SPEED (RPM)": 8500, "SP_LOAD_PCT (%)": 84.7, "COOL_TEMP [°F]": 161.8}}'

{
  "normalized": {
    "spindle_speed_rpm": 8500,
    "spindle_load_pct": 84.7,
    "sensor_readings.coolant_temp": 72.1111
  },
  "coverage_pct": 100.0,
  "fields_total": 3,
  "fields_distinct_canonical": 3,
  "unit_conversions": [
    {"raw_field": "COOL_TEMP [°F]", "canonical_field": "sensor_readings.coolant_temp",
     "from": "f", "to": "c", "conversion": "fahrenheit_to_celsius",
     "raw_value": 161.8, "converted_value": 72.1111}
  ],
  "oem": "haas",
  "vertical": "cnc",
  "simulated": true
}

Wofür das gedacht ist

Industrieausrüstung von N Herstellern erzeugt Telemetrie in N inkompatiblen Formaten. Spindeldrehzahl ist S SPEED (RPM) auf einer Haas, Nist_Spindle (RPM) auf einer SINUMERIK und ACT_SP_SPEED_1/min auf einer FANUC. Ihr Agent sollte nicht alle drei lernen müssen.

Forge übersetzt jede davon in ein kanonisches Vokabular. Die Sandbox ermöglicht es Ihnen, gegen dieses Vokabular zu entwickeln, bevor Sie Ausrüstung, Anmeldedaten oder ein Budget haben.

Die Antwortstrukturen sind identisch. Das ist der Vertrag. Entwickeln Sie gegen die Sandbox, ändern Sie die Basis-URL, fügen Sie einen Authorization: Bearer-Header hinzu, und Ihr Client-Code ändert sich nicht.

Related MCP server: operational-data-mcp

Fünf Minuten

Die Sandbox enthält fünf simulierte Maschinen. Jede sendet ihre echten Hersteller-Tag-Namen – die tatsächlichen Schreibweisen, die Sie auf der Leitung treffen.

# 1. See what's here
curl -s localhost:8000/v1/machines | jq '.machines[].description'

# 2. Pull a raw reading — vendor tags, unnormalized
curl -s localhost:8000/v1/simulate/siemens | jq .data

{
  "Betriebszustand": "AUTOMATIK",
  "PROGRAMM": "WELLE_STUFE3.MPF",
  "Nist_Spindle (RPM)": 1203,
  "SPINDEL_AUSLASTUNG (%)": 62.4,
  "Kuehlmittel Temp (C)": 30.6,
  "STUECKZAHL (pcs)": 842,
  "Betriebsstunden": 14203.5
}

Ihr Agent kann nicht erraten, dass STUECKZAHL eine Stückzahl und Betriebsstunden Betriebsstunden sind. Das muss er auch nicht:

# 3. Normalize it
curl -s localhost:8000/v1/simulate/siemens \
  | jq '{oem, data}' \
  | curl -s -X POST localhost:8000/v1/normalize -H 'Content-Type: application/json' -d @- \
  | jq .normalized

{
  "execution_state": "AUTOMATIK",
  "program_name": "WELLE_STUFE3.MPF",
  "spindle_speed_rpm": 1203,
  "spindle_load_pct": 62.4,
  "sensor_readings.coolant_temp": 30.6,
  "part_count": 842,
  "operating_hours": 14203.5
}

# 4. Forecast — grab a series, ask whether it breaches
curl -s 'localhost:8000/v1/simulate/fanuc/series?field=MOTOR_TEMP&points=48' > /tmp/s.json

jq '{time_series: .values, threshold: 75.0, canonical_field: .canonical_field}' /tmp/s.json \
  | curl -s -X POST localhost:8000/v1/predict_breach -H 'Content-Type: application/json' -d @- \
  | jq '{will_breach, estimated_steps_to_breach, confidence, breach_window}'

Die fünf Maschinen

Fügen Sie ?seed=N zu jedem simulate-Aufruf hinzu, um ihn wiederholbar zu machen.

Endpunkte

Endpunkte, die in der Produktion existieren, aber dauerhaften Zustand benötigen – /v1/history, /v1/identify, /v1/guardrails, /v1/triggers, /v1/attest, /v1/billing/usage – geben 501 mit dem Grund zurück, nicht ein bloßes 404, sodass Sie unterscheiden können zwischen „nicht in der Sandbox" und „falsch getippt".

MCP

Die Sandbox ist auch ein MCP-Server. Richten Sie Claude Desktop, Claude Code oder einen beliebigen MCP-Client auf http://localhost:8000/mcp aus.

{
  "mcpServers": {
    "forge-sandbox": {
      "type": "http",
      "url": "http://localhost:8000/mcp"
    }
  }
}

Claude Code:

claude mcp add --scope user --transport http forge-sandbox http://localhost:8000/mcp

--scope user ist wichtig. Ohne es registriert claude mcp add den Server lokal für das aktuelle Verzeichnis, sodass er dort und nirgendwo sonst aufgelöst wird – führen Sie claude mcp get forge-sandbox aus dem Projekt aus, in dem Sie ihn tatsächlich verwenden möchten, und Sie erhalten „No MCP server named forge-sandbox". Benutzerbereich macht ihn überall verfügbar. Um ihn wieder zu entfernen:

claude mcp remove forge-sandbox -s user

Acht Tools. Die fünf, die in der Produktion existieren, tragen die Tool-Beschreibungen der Produktion wörtlich, weil die Beschreibung die Schnittstelle ist, über die Ihr Agent nachdenkt – wenn sie hier anders lautet, wird das Prompt-Verhalten, das Sie gegen die Sandbox abstimmen, nicht übertragen.

Jede Tool-Beschreibung endet mit einem SANDBOX:-Hinweis, sodass ein Agent, der die Tool-Liste liest, darauf hingewiesen wird, dass die Daten simuliert sind, bevor er auf etwas reagiert.

Produktions-Forge stellt 32 Tools unter https://mcp.foundrynet.io/mcp bereit. Die anderen 24 benötigen dauerhafte Identität, Verlauf, Schutzmaßnahmen, Trigger, Abrechnung oder On-Chain-Attestierung.

Wie die Auflösung hier tatsächlich funktioniert

Die Produktion löst ein Tag über fünf Ebenen auf. Die Sandbox enthält die drei, die keine Modellgewichte, kein Netzwerk und keine proprietären Daten benötigen.

Ein Tag, das zu nichts aufgelöst wird, behält seinen rohen Namen und Wert in der Ausgabe. Nichts wird stillschweigend verworfen, und es zählt nicht zur Abdeckung.

coverage_pct ist unterschiedliche kanonische Felder ÷ Gesamtzahl der Tags. Zehn Schreibweisen einer Menge sind ein abgedecktes Feld, nicht zehn. (Die Produktion hatte genau diesen Fehler und meldete 100% Abdeckung auf einem ungesehten Korpus.)

Die Sandbox erfindet nie einen kanonischen Namen. Jeder Name, den sie ausgibt, stammt aus dem mitgelieferten Wörterbuch, und die Ziele des Klassifikators werden beim Start gegen dieses Wörterbuch validiert – ein Tippfehler lässt den Container fehlschlagen, er liefert kein plausibel aussehendes falsches Feld.

Was NICHT in diesem Image ist

Bewusst, und klar gesagt, damit nichts hier mit dem echten Ding verwechselt wird:

• Der Produktions-Zuordnungskorpus. 16.908 kuratierte Zuordnungen mit Konfidenzwerten und Herkunft. Die Sandbox enthält 1.515 Zuordnungen, die nur aus bereits öffentlichen Quellen zusammengestellt wurden: das MIT-lizenzierte kanonische Schema (haas, fanuc, siemens, octoprint), das mitgelieferte BACnet/IP-Vertikalpaket plus Carrier i-Vu-Objektnamen und die Marlin M105/M114-Feldnamen, die jede Prusa über seriell sendet. tools/build_packs.py zeigt genau, woher jede Zeile stammt.

• Die Embedding-Ebene. Die Produktion bettet unbekannte Tags ein und gleicht sie nach Ähnlichkeit ab. Keine Modellgewichte hier.

• LLM-Feldrecherche. Die Produktion sendet wirklich neuartige Tags an ein Modell, speichert die Antwort zwischen, bestätigt sie bei 5 Verwendungen und packt sie bei 10. Nicht hier.

• Physik-Validatoren und Lesezeit-Validatoren. Änderungsrate, festgefahrener Sensor, Ausfall, Betriebsmodus, Korrelation, Konfidenzabfall. Nicht hier.

• TimesFM. Die Produktion prognostiziert mit einem 200M-Parameter-Zeitreihen-Basismodell. Die Sandbox verwendet kleinste Quadrate mit einem residual-skalierten Quantilband. Jede Vorhersage ist mit "model": "sandbox-ols-v1" und "simulated": true gestempelt.

• Persistenz, Identität, Verlauf, Trigger, Schutzmaßnahmen, Abrechnung, Attestierung. Alles zustandsbehaftet, alles serverseitig.

• Jede Verbindung zur Produktion. Die Anwendung importiert keinen HTTP-Client und keine Socket-API, sodass sie keine ausgehenden Anrufe tätigt – grep -rE "httpx|requests|urllib|socket" app/ kommt leer zurück. docker-compose.yml führt sie zusätzlich read_only mit allen Capabilities entfernt aus. Beachten Sie, dass dies das Dateisystem härtet, nicht das Netzwerk: Das Standard-Bridge von Docker erlaubt weiterhin ausgehenden Verkehr. Wenn Sie also benötigen, dass dies durchgesetzt wird und nicht nur wahr ist, führen Sie es in einem internal-Netzwerk aus.

Jede Antwort trägt "simulated": true und einen X-Forge-Sandbox: true-Header. Wenn Sie diese jemals gegen einen echten Endpunkt sehen, ist etwas falsch geroutet.

Zwei Dinge, die die Sandbox besser macht als die Produktion

Beides sind bekannte Produktionsprobleme, hier behoben, weil eine Sandbox, die Ihnen die falsche Form beibringt, schlimmer ist als keine Sandbox.

1. PWM-Skala ist deklariert. Marlin's @:-Heizfeld ist ein 0–127-Pflichtbyte, kein Prozentsatz. Der Produktionskorpus gibt dafür unit: null aus, sodass ein Messwert von 95 als „95%, nahe Maximum" interpretiert wird, obwohl es tatsächlich etwa 75% sind. Die Sandbox deklariert unit: "pwm_0_127".

2. Null-Einheiten werden aus Feldnamen nachgefüllt. Der veröffentlichte Korpus deklariert eine Einheit für nur 58 von 366 Feldern. Wo der Feldname die Einheit angibt (_temperature_c, _pressure_bar, _rpm), füllt die Sandbox sie aus und markiert sie mit unit_source: "sandbox_inferred_from_name".

Lokale Entwicklung

docker compose up --build          # build and run your local changes
docker build --target test .       # run the suite inside the shipping image

Ohne Docker:

python3 -m venv .venv && source .venv/bin/activate
pip install -r requirements-dev.txt
python -m pytest tests/ -q
uvicorn app.main:app --reload --port 8000

Regenerieren Sie die Zuordnungspakete aus der Quelle (benötigt das ausgecheckte canonical-schema-Repository):

python3 tools/build_packs.py

forge-sandbox/
  app/
    main.py        FastAPI surface — the production response envelopes
    corpus.py      tag → canonical resolution, unit conversion, collisions
    simulate.py    the five machines
    predict.py     deterministic forecasting, production's response contract
    mcp_tools.py   MCP server, production tool descriptions
    packs/         generated mapping packs + the canonical dictionary
  tools/
    build_packs.py regenerates packs from the public sources
  tests/
    test_sandbox.py

Upgrade auf Produktion

Zwei Änderungen:

- BASE_URL = "http://localhost:8000"
- headers = {}
+ BASE_URL = "https://forge.foundrynet.io"
+ headers = {"Authorization": f"Bearer {FORGE_API_KEY}"}

Für MCP tauschen Sie http://localhost:8000/mcp gegen https://mcp.foundrynet.io/mcp.

Was sich darunter ändert:

• Tags, die die Sandbox als unknown meldete, werden durch die Embedding-Ebene, den LLM-Recherchepfad oder die Vertikalpakete aufgelöst.

• Vorhersagen kommen von TimesFM statt von einer geraden Linie.

• Messwerte werden gespeichert, sodass Verlauf, Trigger und Schutzmaßnahmen funktionieren.

• /v1/identify stellt eine dauerhafte Maschinenidentität aus.

• Vorhersagen können attestiert werden.

Holen Sie sich einen Schlüssel: foundrynet.io

Sandbox:     fake data, real schema
Production:  real data, real schema, real predictions

Upgrade:     foundrynet.io

Lizenz

MIT. Die Mapping-Packs sind aus dem MIT-lizenzierten FoundryNet canonical schema; tools/build_packs.py dokumentiert die Herkunft jedes Packs.

Forge von Foundry Labs · forge@foundrynet.io