Kshana: die Marke, ein Kompass-Fadenkreuz, das den genauen Augenblick markiert, neben dem Wortzeichen kshana

kshana-mcp: Fragen Sie Ihren KI-Assistenten, und die Engine antwortet

kshana-mcp ist ein Model-Context-Protocol-Server (MCP) für Kshana, den quelloffenen Simulator für die Resilienz von PNT (Positionierung, Navigation und Zeitgebung). Er lässt einen KI-Assistenten (künstliche Intelligenz) die echte Engine ausführen und deren JSON (JavaScript Object Notation) zurücklesen, statt die Mathematik zu raten. Er spricht über stdio (Standardeingabe und -ausgabe) mit jedem MCP-kompatiblen Client, darunter Cursor und JetBrains AI Assistant / Junie.

Die Mathematik, für die Kshana validiert ist, ist genau dort, wo ein Sprachmodell schlecht rät: SGP4 (Simplified General Perturbations 4) Bahnpropagation, Bezugssysteme der IAU (Internationale Astronomische Union), Allan-Abweichungen, GNSS-Verfügbarkeit (Global Navigation Satellite System) und DOP (Dilution of Precision), ARAIM-Schutzgrenzen (advanced receiver autonomous integrity monitoring), GNSS- und INS-Fusion (inertial navigation system) und Quantensensor-Modelle. Stellen Sie eine Frage; der Assistent führt ein echtes Szenario aus und erhält Gütemaße mit ihrer Herkunft und ihrer Kennzeichnung VALIDATED oder MODELLED.

Eine offene Engine in der Mitte, mit dem MCP-Server als einer ihrer Oberflächen neben der Befehlszeile, der Rust-Bibliothek, Python, WebAssembly und Kshana Studio, dem Docker-Image und dem JetBrains-Plugin; jede Oberfläche führt dieselbe Engine aus, und Kshana Pro hängt von ihr ab, ohne sie zu forken

Werkzeuge#

Werkzeug	Was es tut
`run_scenario`	Führt ein Szenario aus einer TOML-Definition (Tom's Obvious, Minimal Language) aus; gibt die Zusammenfassung + das vollständige Ergebnis-JSON zurück (JavaScript Object Notation: Gütemaße, Kurven). Optional gibt `include_chart` das Diagramm als SVG (Scalable Vector Graphics) zurück.
`list_scenario_kinds`	Die 92 eingebauten Szenarioarten mit Beschreibungen + Pflicht- und optionalen Feldern, damit der Agent ein gültiges Szenario aufbauen kann.
`validate_scenario`	Vorabprüfung: das TOML parsen und seine Art erkennen, ohne es auszuführen.
`list_example_scenarios`	Die mitgelieferten Referenzszenarien als JSON: jeweils `name`, ihre `kind` und ein Satz dazu, was sie zeigen. Optionaler Filter `kind`. Jedes Beispiel läuft so, wie es ist, daher ist dies der schnellste Weg zu einem gültigen TOML für eine Art.
`get_example_scenario`	Der TOML-Text eines mitgelieferten Referenzszenarios, Byte für Byte die Datei unter `scenarios/`.
`report_scenario`	Führt ein Szenario aus und gibt seinen Bericht zurück: Kurzfassung, Eingaben, jeder Wert mit seiner Einheit und seiner Kennzeichnung VALIDATED oder MODELLED, Ereignisse, die genutzten Fähigkeiten und ein Reproduzierbarkeitsprotokoll. `format` ist `json` (Standard) oder `html` (die druckbare Einzeldatei-Seite).
`animate_scenario`	Führt ein Szenario aus und gibt seine Zeitreihen als Animation zurück: `svg` (Standard), `html` (ein in sich geschlossener Player) oder `frames` (höchstens 120 in einer Antwort). Das erste Inhaltselement ist eine JSON-Zusammenfassung dessen, was gezeichnet wurde; die Dateien folgen. Eine Art ohne abgetastete Zeitachse wird mit Angabe des Grundes abgelehnt.
`list_export_formats`	Welche Interoperabilitätsformate für ein Szenario gelten (`czml`, `kml`, `geojson`, `stk`, `sigmf`), der Grund, wenn eines nicht gilt, und die Spezifikation, der jeder Writer folgt. Führt das Szenario nicht aus.
`export_interop`	Exportiert ein Szenario als CZML (Cesium Language), KML (Keyhole Markup Language), GeoJSON, STK-Ephemeride (Systems Tool Kit) `.e` oder SigMF (Signal Metadata Format, für ein Szenario `spectrum` mit einem Block `[iq]`). Das erste Inhaltselement ist ein JSON-Index der Dateien (Suffix, Größe, Kodierung und der SHA-256-Digest, der 256-Bit-Secure-Hash-Algorithm); die Dateien folgen, die binäre SigMF-Sampledatei als Base64.
`import_route`	Schreibt eine GeoJSON-Route `LineString` in ein Szenario, das einer Wegpunktspur folgt (`terrain-nav`, `terrain-slam`, `gravity-map`, `combined-altpnt`), und gibt das neue TOML zurück.
`export_sp3`	Exportiert die Konstellation eines Szenarios `orbit` als präzise SP3-c-Ephemeride (Standard Product 3, Revision c).
`export_omm`	Exportiert die Elemente eines Szenarios `orbit` als CCSDS-502.0-B-2-OMM-Katalog (Consultative Committee for Space Data Systems; Orbit Mean-elements Message).
`export_oem`	Exportiert die Zustandsreihe eines Szenarios `orbit` als CCSDS-OEM-Ephemeride (Orbit Ephemeris Message) 2,0 — die TEME-Positions- (true equator, mean equinox) und Geschwindigkeitsreihe, die Flugdynamik-Werkzeuge (GMAT, das General Mission Analysis Tool; Orekit; STK, das Systems Tool Kit) lesen; das geschwindigkeitstragende Gegenstück zum nur positionsbezogenen `export_sp3`.
`export_table_csv`	Führt ein Szenario aus und gibt seine Reproduzierbarkeitstabelle als CSV (comma-separated values) zurück — die bytestabile Tabelle, die die CLI (Befehlszeilenschnittstelle) als `<scenario>.table.csv` schreibt. Nur `realtime-frame-eop`, `lunar-time-budget`, `lunar-jamming`, `telecom-timing`, `leo-navmsg` (seine Analyse `encode-decode` an einem Nachrichtenmodell `kepler16` oder `kepler-rac`) und `moonlight-service-volume` mit gesetztem `export_site_lat_deg` + `export_site_lon_deg` geben eine aus; jede andere Art liefert einen Fehler, der diese nennt.
`sky_geometry`	Himmelsgeometrie unter einer azimutabhängigen Skyline: von einem Standort, einer Zeit und Konstellations-Voreinstellungen, Two-Line-Element-Sätzen (`tle`, per SGP4 auf eine UTC-`epoch` propagiert) oder Satelliten als Azimut/Elevation oder ECEF, die sichtbaren Satelliten und die von der Skyline verdeckten, GDOP/PDOP/HDOP/VDOP/TDOP aus dem durch gnss_lib_py geprüften DOP-Kernel, der Ost-Nord-Oben-Kofaktor und die Kovarianz (eine Uhr je System oder eine gemeinsame) und die horizontale Fehlerellipse; mit `skyline_preset` statt `request` eine REPRESENTATIVE-Voreinstellung mit ihrer Herkunft und ihrem Schnitt jedes Grad. MODELLED; trägt den Hinweis; keine Monte-Carlo-Simulation über MCP. Siehe `docs/SKYLINE.md`.
`assess_receiver_log`	Bewertet ein echtes GNSS-Empfänger-Log (Global Navigation Satellite System) auf Vertrauen. Das TOML nennt das `format` des Logs (`ubx`, `rinex`, `android`, `nmea` oder `sbf`) und gibt dessen Bytes inline als `text` oder `base64` an; das Werkzeug führt die Vertrauensmonitore aus (Abfall der Träger-Rausch-Dichte, Verlust der Verriegelung, AGC (automatic gain control), Jamming-Indikator, Positionssprung und, mit RINEX plus Rundsende-Navigation, RAIM (receiver autonomous integrity monitoring) und ein uhrgestützter Monitor) und gibt zurück, wann und warum die Lösung aufhörte, vertrauenswürdig zu sein. Optionale Abschnitte `[[events]]` und `[compare]` bewerten angegebene Ereignisse und vorhergesagte C/N0-Abfälle gegen angegebene Toleranzen. Eine Tabelle `[platform] kind = "vessel"` wählt die maritimen Monitore aus und fügt je Epoche einen Vertrauenswert von 0-100 hinzu, mit den Monitoren, die abgezogen haben (beratend; MODELLED). Das Log kommt inline als `text` oder `base64` (höchstens 4 MiB). Diagramm und CSV je Epoche auf Anfrage. Siehe `docs/RECEIVER-TRUST.md`.
`assess_vessel_stream`	Bewertet einen begrenzten NMEA-0183-Auszug (höchstens 2 MiB und 20.000 Epochen; er muss das Kalibrierungsfenster enthalten) so, wie `kshana receiver-trust live` ihn bewertet: Vertrauenszustand und Wert von 0-100 je Epoche mit den Monitoren, die abgezogen haben, eine Zusammenfassung und das letzte `$PKSHT`. Die begrenzte Form des Live-Befehls: Es wird kein Socket geöffnet und nichts auf einen Port geschrieben; das Gate, `--listen` und die Telemetrie-Exporter (Prometheus, OTLP, syslog) gibt es nur in der Befehlszeile. Nur beratend; MODELLED. Siehe `docs/MARITIME-TRUST.md`.
`assess_vessel_log`	Das NMEA-0183-Log eines Schiffes (höchstens 4 MiB) als Batch-Lauf, mit dem Sitzungs-TOML, das die Grenzen des Schiffes angibt: das Wertmodell und der Wert von 0-100 jeder Epoche mit ihren Abzügen (die Antwort behält Zählungen nach Zustand und die ersten 200 Epochen mit degraded oder untrusted). Nur beratend; MODELLED.
`jammertest_import`	Liest den veröffentlichten Jammertest-Testkatalog und Sendeplan (NPRA/jammertest-plan, MIT) als geplante Wahrheit (`kshana jammertest import`): Die Slots eines Testgebiets werden zu Empfängervertrauens-Ereignissen mit der Katalogkennung und dem Jahr in jeder Bezeichnung. Geplante Slots, keine aufgezeichneten Sendezeiten; kein Kontaktfeld des Plans wird gelesen. MODELLED. Siehe `docs/JAMMERTEST.md`.
`jammertest_score`	Bewertet ein Empfänger-Log gegen diesen Zeitplan (`kshana jammertest score`): je Test die Erkennungslatenz, verpasste Alarme und die Zeit bis zur Erholung sowie die Fehlalarme außerhalb jedes Slots. Textlogs als `log`, binäre (`ubx`, `sbf`) als `log_base64`. Ein signiertes Paket braucht einen Schlüssel: Befehlszeile. Nur beratend; MODELLED.
`create_evidence_pack`	Ein signiertes Nachweispaket für ein Fenster des Logs eines Schiffes (`kshana receiver-trust evidence`): die rohen Log-Bytes für das Fenster, Konfiguration, Ergebnisse und Gründe je Epoche, eine Zusammenfassungsseite und ein Manifest mit jedem SHA-256 und einer Hash-Kette, signiert mit Ed25519. Der Signatur-Seed wird nie zurückgegeben oder protokolliert; ohne einen wird ein Einmalschlüssel verwendet, sodass das Paket Integrität beweist, nicht Identität. Eine technische Aufzeichnung, keine Rechtsauskunft. Siehe `docs/EVIDENCE-PACKS.md`.
`attach_evidence_timestamp`	Bindet ein RFC-3161-Zeitstempel-Token (Base64 der `.tsr`-Bytes) im Speicher an ein Paket (`kshana evidence attach-timestamp`); das Paket mit dem Token muss weiterhin verifizieren. Die Signatur der Zeitstempelautorität wird nicht geprüft: Verwenden Sie `openssl ts -verify`.
`verify_evidence_pack`	Verifiziert ein Paket (`kshana evidence verify`): jeden Hash, die Kette, die Signatur und, mit dem öffentlichen Schlüssel des Signierers und dem vollständigen Log, wer es signiert hat und dass der Ausschnitt aus diesem Log stammt. Nennt jeden Fehler und jede Datei. Das `verdict` ist `verified` (Signierer festgelegt), `intact-signer-not-pinned` (alles stimmt, aber es wurde kein öffentlicher Schlüssel angegeben, sodass der Signierer nicht festgestellt ist) oder `failed`; `require_timestamp` lässt ein Paket ohne Zeitstempel-Token durchfallen.
`generate_training_nmea`	Synthetisches Brücken-NMEA 0183 für die Crew-Ausbildung aus einem TOML `nmea-scenario` (Jamming, Wegziehen der Position, Zeit-Spoofing, Replay-Verzögerung) mit dem Ausbilder-Log (`kshana-nmea-training/1`); deterministisch je Seed. Nur Text: Nichts wird auf HF- oder IQ-Ebene synthetisiert, und nichts wird gesendet; nie für die Live-Navigationssysteme eines Schiffes. Die Antwort trägt die ersten 2000 Zeilen.
`build_interference_map`	Eine GNSS-Störungskarte aus ADS-B- oder AIS-Positionsmeldungen als CSV-Text (höchstens 4 MiB): ein GeoJSON `kshana-interference-map/v1` je UTC-Tag, nur aggregiert (keine Kennungen, Zellen mit unter 5 verschiedenen Luftfahrzeugen oder Schiffen zurückgehalten), mit eingebetteter Lizenz des Datensatzes. Eine degraded-Zelle identifiziert Störung nicht als Ursache; keine Vorhersage. MODELLED. Siehe `docs/INTERFERENCE-MAP.md`.
`export_test_bench`	Die Fahrzeugbewegung und Ereignisse eines Szenarios für einen GNSS-Simulator im Labor (`kshana bench-export`): Bewegungs-CSV und -JSON, NMEA, Wegpunkte und Ereignisse als Text, nichts wird auf die Platte geschrieben. Arten `gnss-ins`, `jamming`, `gnss-sim`. Kein Signal: Nichts Exportiertes ist ein Hochfrequenz- oder Basisbandsignal, modelliert eines oder steuert eines; der Simulator und sein Betreiber liefern die Signale. Siehe `docs/TEST-BENCH.md`.
`create_round_trip_pack`	Das signierte Labor-Rundlauf-Paket (`kshana evidence round-trip`): das Szenario, das Dokument `kshana.test-conditions/1` des Labors, das Empfänger-Log und seine Bewertung gegen die angegebenen Ereignisse, per Hash verknüpft. Lehnt Bedingungen und Bewertungsereignisse ab, die einander widersprechen. Kein Signal; eine technische Aufzeichnung, keine Zertifizierung.
`iq_sweep`	Spielt eine IQ-Aufzeichnung im Arbeitsverzeichnis über mehrere Tracking-Schleifen-Entwürfe ab (`kshana iq sweep`): je Entwurf und PRN den eingeschwungenen Phasen- und Codejitter, Verriegelungsanteile und mittleres C/N0. Höchstens 256 Kanäle (Entwurf, PRN) je Aufruf; die Zeitspanne muss in das Sample-Budget passen.
`iq_monitor`	Führt die Störungs- und Spoofing-Erkennungsmonitore über eine IQ-Aufzeichnung im Arbeitsverzeichnis aus (`kshana iq monitor`): Breitband-Leistungs- und Spektralmonitore sowie C/N0- und Signalqualitätsmonitore je Satellit gegen eine gelernte Basislinie. Reihennamen und -längen und bis zu 200 Ereignisse in der Antwort; der ganze Bericht auf Anfrage als Dateien. Ein Ereignis sagt, dass eine gemessene Größe ihre Basislinie verlassen hat, nicht warum. MODELLED.
`iq_labfit`	Passt das Verlust-der-Verriegelung-Modell der Tracking-Schleife an Laborläufe an (`kshana iq labfit`), aus einem Szenario `iq-labfit`, dessen Logs inline vorliegen (`text` oder `base64`; ein `path` wird abgelehnt). Liest und schreibt keine Datei. MODELLED.
`iq_test_conditions`	Validiert eine als Text gegebene Datei `kshana.test-conditions/1` und gibt die aufgelösten Bedingungen mit ihrem Hash zurück. Nur inline.
`compliance_report`	Die Zuordnung zu öffentlichen Rahmenwerken, aus als Text gegebenen Ergebnisdokumenten befüllt (`kshana compliance-report`): für welche Zeilen von sechs Resilienz-Rahmenwerken und -Standards (US DHS Resilient PNT framework v2.0, IMO ships, EASA aviation, NIS2 Article 21, EN 16803, NIST IR 8323r1) die Läufe Belege liefern, für welche nicht, und die Lücke jeder Zeile. Nimmt `runs` von `{label, result, scenario?}` (höchstens 64, insgesamt 4 MiB). Ein Status besagt, dass die Läufe Belege für die Fähigkeiten der Zeile liefern; er ist keine Feststellung, dass ein Rahmenwerk erfüllt ist, und keine Bewertung oder Zulassung eines Produkts. Die `statement` wird mit jedem Bericht zurückgegeben; zeigen Sie sie wörtlich. MODELLED. Siehe `docs/compliance/`.
`compliance_mapping`	Die statischen Zuordnungstabellen (oder, mit `sources`, die Quelldokumente, die sie zitieren, mit Versionen und URLs) als Markdown, angeführt von derselben Aussage. Braucht keine Läufe.
`trust_telemetry`	Ein Vertrauensstrom (JSON-Zeilen) oder ein Ergebnis `receiver-trust`, dargestellt als Prometheus-Text, CEF- oder LEEF-Syslog-Zeilen, eine OTLP-JSON-Nutzlast oder Home-Assistant-MQTT-Discovery- und -Zustandszeilen, mit den Encodern `kshana trust-telemetry`. Text in der Antwort: Nichts wird gesendet oder bereitgestellt, und keine Uhr wird gelesen. Nur beratend.
`fit_imu_log`	Beschleunigungsmesser- und Gyroskop-Parameter der Szenarien `hybrid` und `fusion`, aus einem Log einer ruhenden IMU (CSV oder EuRoC) per Allan-Abweichung angepasst, mit einer zum Einfügen fertigen Tabelle `[accel_classical]` und dem SHA-256 des Logs (`kshana imu-fit`). Text hinein, JSON heraus; MODELLED.
`list_standards_packs`	Die Standards-Pakete (`kshana standards-pack list`): bewertete Szenariosätze für die Testprofile des DHS Resilient PNT framework (Stufen 1 bis 4), IMO MSC.1/Circ.1575 und ICAO Doc 9849 Appendix F.
`run_standards_pack`	Ein Paketlauf gegen seine vor dem Lauf angegebenen Zielwerte (`kshana standards-pack run`): jeder Test `MET`, `NOT MET` oder `NEEDS INPUT`, mit gemessenen und erwarteten Werten; geben Sie den Bericht an `compliance_report`, um die Zeilen zu sehen. MODELLED; bewertet kein Produkt.
`lunanet_afs_check`	Das LunaNet Augmented Forward Signal, geprüft gegen LNIS V5 AD1 Volume A (LSIS-AFS V1.0, 29. Januar 2025): `spec` (die Implementierung gegen die gedruckten Codetabellen und Rechenbeispiele des Dokuments), `symbols` (ein Symbolstrom: Sync-Muster, SB1, FID, TOI-Kontinuität) oder `generate` (ein Teststrom). LDPC und CRC-24Q der Unterrahmen 2 bis 4 werden nicht verifiziert; es wird kein Signal geschrieben.
`score_benchmark`	Eine Einreichung für kshana-bench, gegen eine Wahrheitsdatei bewertet, beide als JSON-Text (`kshana bench score`, `bench/SPEC.md`): die Ergebnisdatei mit der Spezifikationsversion, Aufteilung, Eingabe-Hashes und den Kennzahlen der Aufgabe. MODELLED; beschreibt ein Log oder einen Korpus, nie ein Produkt.
`render_leaderboard`	kshana-bench-Ergebnisdateien, als statische Bestenlisten-Seite (HTML-Text) dargestellt, jede zuvor validiert.
`trust_telemetry`	Ein Vertrauensstrom (JSON-Zeilen) oder ein Ergebnis `receiver-trust`, dargestellt als Prometheus-Text, CEF- oder LEEF-Syslog-Zeilen oder eine OTLP-JSON-Nutzlast, mit den Encodern `kshana trust-telemetry`. Text in der Antwort: Nichts wird gesendet oder bereitgestellt, und keine Uhr wird gelesen. Nur beratend.
`route_exposure`	Der Anteil der Länge einer Route in degraded-, nicht-degraded-, nicht bewerteten und nicht beobachteten Zellen einer oder mehrerer Störungskarten, optional innerhalb eines Datumsbereichs. Unbeobachtete Zellen sind kein Beleg für eine freie Route.
`iq_signals`	Die Einrichtung der GNSS-IQ-Schicht: die Signalnamen, die die IQ-Werkzeuge akzeptieren, ob die IQ-Dateiwerkzeuge aktiv sind, das Arbeitsverzeichnis und das Sample-Budget je Aufruf. Rufen Sie es zuerst auf.
`iq_info`	Beschreibt eine IQ-Aufzeichnung (In-Phase und Quadratur) im Arbeitsverzeichnis, ohne sie zu verarbeiten: Format, Abtastrate, Mittenfrequenz, Samples, Dauer, Datendateien und Größen (`kshana iq info`).
`iq_scene`	Erzeugt eine GNSS-IQ-Szene mit mehreren Satelliten im Arbeitsverzeichnis (`kshana iq scene`): angegebene Doppler/C/N0-Profile oder echte Rundsende-Ephemeriden-Geometrie aus einer RINEX-Navigationsdatei, mit einem optionalen Ausbreitungskanal auf Signalebene. Antwortet mit den geschriebenen Dateien und ihren Byte-Zahlen und der ersten Epoche der Wahrheit je Satellit.
`iq_acquire`	FFT-Erfassung (schnelle Fourier-Transformation) eines oder mehrerer PRNs (Pseudozufallsrauschen-Codes) über eine Aufzeichnung (`kshana iq acquire`), optional hinter Front-End-Stufen: je PRN erfasst oder nicht, Doppler, Codephase, Spitzenstatistik und Schwellenwert; `surface_out` (ein PRN) behält die gesamte Korrelationsfläche aus Doppler × Codephase mit Fein-Doppler-Verfeinerungen.
`iq_track`	Erfassen, dann mit der DLL/PLL/FLL-Bank (delay-, phase- und frequency-locked loop) verfolgen (`kshana iq track`), mit den Schleifen aus einer TOML-Datei `kshana.loop-design/1` im Arbeitsverzeichnis (`design`) oder dem eingebauten Entwurf und optionaler Wiedererfassung (`reacquire`): je Kanal Epochen, finaler Doppler, finales und mittleres C/N0, Phasen- und Code-Verriegelungsanteile, am Ende verriegelt, der finale Verriegelungszustand, Falschverriegelungen und Wiedererfassungen, dazu Name und Hash des Entwurfs. Das Tracking streamt in begrenztem Speicher; die Ausgabe je Epoche geht nur in Dateien (`epochs_out`: E/P/L, Diskriminatoren, Schleifenzustände, C/N0, Verriegelungszustand als .csv/.jsonl/.bin; `events_out`).
`iq_frontend`	Wendet Empfänger-Front-End- und Störminderungs-DSP (digitale Signalverarbeitung: Bandpass, Notch, Blanking, Excision, AGC, Quantisierer) auf eine Aufzeichnung an und schreibt eine neue (`kshana iq frontend`).
`iq_campaign`	Führt eine Laborwiedergabe-Kampagne aus (`kshana iq campaign`): Aufzeichnungen, jeweils mit einer Testbedingungsdatei, die die bekannte Wahrheit des Labors angibt, × Front-End-Ketten × Schleifenentwürfe. Jede Zelle wird bewertet nach Zeit bis zum Verlust der Verriegelung, Wiedererfassungszeit, C/N0-Verschlechterung gegenüber dem angegebenen J/S (neben einer analytischen Referenz, gekennzeichnet MODELLED), Falschverriegelungsrate, PLL/DLL-Jitter und Verfügbarkeit. Inkrementell und fortsetzbar: Jeder Aufruf führt die ausstehenden Zellen aus, die in das Sample-Budget passen (oder `max_cells`).
`iq_campaign_status`	Der Fortschritt eines Kampagnen-Ausgabeordners: erledigte und ausstehende Zellen und der Digest, sobald vollständig. Liest nur Dateien.

Jedes Werkzeug ist ein dünner, getreuer Wrapper um eine öffentliche Funktion der Bibliothek kshana — hier lebt keine neue Simulationslogik, sodass ein Agent genau die validierte Engine ausführt.

Die GNSS-IQ-Werkzeuge: Dateien hinein, kompaktes JSON heraus#

IQ-Aufzeichnungen reichen bis in Gigabyte, daher leiten die Werkzeuge iq_* Samples nie durch das Protokoll. Sie folgen einem Vertrag:

Ein Arbeitsverzeichnis. Der Server liest und schreibt IQ-Dateien nur innerhalb des Ordners, den KSHANA_MCP_IQ_DIR nennt. Jedes Pfadargument ist relativ dazu (ein absoluter Pfad muss innerhalb davon auflösen); Eingaben werden vor der Prüfung über Symlinks aufgelöst, der Ordner einer Ausgabe muss darin bereits existieren, und eine vorhandene Ausgabe wird nur mit overwrite: true ersetzt. Ist es nicht gesetzt, sind die IQ-Dateiwerkzeuge aus und sagen, wie man sie aktiviert; jedes andere Werkzeug ist unberührt.
Ein Sample-Budget. Ein Aufruf erzeugt oder verarbeitet höchstens KSHANA_MCP_IQ_MAX_SAMPLES komplexe Samples (Standard 50.000.000). In Bytes sind das 400 MB als cf32_le (8 Bytes je komplexem Sample), 200 MB als ci16_le (4 Bytes) und 100 MB als ci8 (2 Bytes); eine Szene wird als cf32_le geschrieben, sofern format nichts anderes sagt. Die Prüfung läuft vor jeder Arbeit, und die Ablehnung nennt die Dauer oder max_seconds, die passt.
Kompakte Antworten. Jedes Werkzeug antwortet mit einer JSON-Zusammenfassung: Erfassungsspitzen, C/N0, Verriegelungszustand und jede geschriebene Datei mit Pfad und Byte-Zahl. Tabellen je Epoche gehen in die Dateien json_out / csv_out, die Sie benennen.
Unbekannte Argumente werden abgelehnt, nicht ignoriert, sodass eine falsch geschriebene Option ein Fehler ist.

Jedes Werkzeug läuft über denselben Codepfad wie kshana iq in der Befehlszeile, im selben Prozess. Die Schicht ist reine Software: Sie schreibt Dateien für Software-Empfänger und steuert keine Funkhardware. Die IQ-Schicht fügt keine Störungs- oder Spoofer-Synthese hinzu, und nichts wird je gesendet. (Die separate Szenarioart spectrum kann analytische Störsender-IQ-Schnappschüsse in eine Datei schreiben.)

{
  "mcpServers": {
    "kshana": {
      "command": "/Users/you/.cargo/bin/kshana-mcp",
      "env": { "KSHANA_MCP_IQ_DIR": "/Users/you/iq" }
    }
  }
}

Mit dem Docker-Image binden Sie den Ordner ein und lassen die Variable darauf zeigen: docker run --rm -i -v "$PWD/iq:/iq" -e KSHANA_MCP_IQ_DIR=/iq ghcr.io/ashfordeou/kshana-mcp.

Jede Art ist erreichbar#

run_scenario verteilt nach der kind des Szenarios, sodass jede Art, die list_scenario_kinds nennt, darüber läuft. Das schließt die neueren Familien ein, jeweils mit mitgelieferten Beispielen, die ein Agent abrufen kann:

Fähigkeit	Arten	Ein Beispiel als Ausgangspunkt
Spektrum und Wasserfall	`spectrum`	`l-band-waterfall-jamming`
Das Sonnensystem	`solar-system`	`solar-system-tour`
Konstellationen um jeden Körper	`constellation-design`, `body-pnt`	`lunar-relay-constellation`, `europa-surface-pnt`
Kampagnen: verkettete Phasen, Sweeps, Monte Carlo (gesetzte zufällige Ensembles), Komposition	`campaign`	`campaign-sweep-jammer-power`
Navigation im niedrigen Erdorbit (LEO): Signalentwurf	`leo-signal`	`leo-band-trade`
LEO-Navigation: Link-Budget je Überflug	`leo-pass`	`leo-pass-iridium`
LEO-Navigation: Navigationsnachricht	`leo-navmsg`	`leo-navmsg-encode-decode`
LEO-Navigation: fusionierte Positionierung und Zeitgebung	`leo-pvt`, `leo-ppp`, `ntn-positioning`, `leo-pnt-chain`	`leo-doppler-positioning`, `leo-pnt-end-to-end`

list_example_scenarios mit einer kind nennt jedes mitgelieferte Beispiel dieser Art. Animationen, Berichte und Interoperabilitäts-Exporte sind keine Arten: Sie sind Ansichten eines Laufs, und animate_scenario, report_scenario und export_interop liefern sie für jedes Szenario, auf das sie zutreffen.

Nicht bereitgestellt: Studiensuiten (kshana --study <suite.toml>), weil eine Suite benachbarte Szenariodateien auf der Platte benennt und die Szenariowerkzeuge keine Datei lesen. Führen Sie jedes Mitglied mit run_scenario aus. (Die IQ-Werkzeuge lesen und schreiben Dateien, nur innerhalb ihres Arbeitsverzeichnisses.)

Den MCP-Server installieren#

Beratend, keine typzugelassene Navigationsausrüstung: Der Betreiber bleibt für die Navigation verantwortlich. Der Server läuft auf Ihrem Computer; es wird nichts an Ashforde OÜ gesendet.

Eine Passage, die KI-Clients von Drittanbietern nennt, ist hier weggelassen; sie steht in mcp/kshana-mcp/README.md auf GitHub.

Kanal	Befehl oder Schaltfläche	Voraussetzung	Festgelegte Form
Cursor (ein Klick)	npx (Node) · Docker	Node oder Docker	`kshana-mcp@0.40.0` / `ghcr.io/ashfordeou/kshana-mcp:0.40.0`
VS Code (ein Klick)	npx (Node) · Docker · Insiders (npx)	Node oder Docker	`kshana-mcp@0.40.0` / `ghcr.io/ashfordeou/kshana-mcp:0.40.0`
npx	`npx -y kshana-mcp@0.40.0`	Node 18+	`kshana-mcp@0.40.0`
uvx / pipx	`uvx kshana-mcp==0.40.0` · `pipx run kshana-mcp==0.40.0`	Python 3,9+ mit uv oder pipx	`kshana-mcp==0.40.0`
Docker	`docker run -i --rm ghcr.io/ashfordeou/kshana-mcp:0.40.0`	Docker	`ghcr.io/ashfordeou/kshana-mcp:0.40.0`
Homebrew	`brew install ashfordeOU/tap/kshana-mcp`	brew	Formel für v0.40.0
Scoop	`scoop bucket add ashforde https://github.com/ashfordeOU/scoop-bucket`, dann `scoop install kshana-mcp`	Scoop (Windows)	Manifest für v0.40.0
winget	`winget install AshfordeOU.KshanaMcp`	winget (Windows)	`--version 0.40.0`
cargo	`cargo install kshana-mcp --version 0.40.0`	Rust 1,88+	`kshana-mcp 0.40.0`
Vorkompilierte Binärdatei	die Release-Seite: `kshana-mcp` (Linux x86-64), `kshana-mcp-<target>[.exe]`, geprüft mit `SHA256SUMS` und `gh attestation verify`	keine	v0.40.0
MCP-Register	`io.github.ashfordeOU/kshana-mcp` (von registrierungsfähigen Clients gefunden)	ein registrierungsfähiger Client	`0.40.0`
Remote (Streamable HTTP)	`kshana-mcp --http 127.0.0.1:8080`, selbst gehostet: siehe https://github.com/ashfordeOU/kshana/blob/main/docs/deploy/mcp-http.md	Ihr eigener Host	v0.40.0

Aus einem Checkout oder git (Entwicklung):

cd mcp/kshana-mcp && cargo install --path .
cargo install --git https://github.com/AshfordeOU/kshana kshana-mcp

HTTP-Modus (selbst gehostet)#

kshana-mcp --http 127.0.0.1:8080 stellt dieselben Werkzeuge über Streamable HTTP unter /mcp bereit. Es bindet nur an Loopback; eine Nicht-Loopback-Adresse braucht --allow-remote und ein Bearer-Token in KSHANA_MCP_HTTP_TOKEN; die IQ-Dateiwerkzeuge sind aus; Anfragegröße, Zeit und Nebenläufigkeit sind begrenzt; es wird kein CORS-Header gesendet. Kshana hostet keinen Endpunkt: Sie hosten ihn selbst. Siehe docs/deploy/mcp-http.md.

cargo install legt kshana-mcp in Ihren PATH (typischerweise ~/.cargo/bin/kshana-mcp). Der Server spricht JSON-RPC (JSON remote procedure call) über stdio; Logs gehen nach stderr. Das Bauen aus dem Quelltext braucht eine Rust-Toolchain ≥ 1,88 (das gepatchte SDK rmcp 2.x braucht sie, ebenso die Bibliothek kshana); das Docker-Image braucht keine.

Bei einem Client registrieren#

Praktisch jeder MCP-Client verwendet denselben Konfigurationsblock mcpServers — registrieren Sie die Binärdatei kshana-mcp über den absoluten Pfad:

{
  "mcpServers": {
    "kshana": {
      "command": "/Users/you/.cargo/bin/kshana-mcp",
      "args": [],
      "env": {}
    }
  }
}

Oder, mit dem Docker-Image statt einer lokalen Binärdatei (kein PATH nötig):

{
  "mcpServers": {
    "kshana": {
      "command": "docker",
      "args": ["run", "--rm", "-i", "ghcr.io/ashfordeou/kshana-mcp"]
    }
  }
}

Wo dieser Block liegt, hängt vom Client ab:

Cursor — ~/.cursor/mcp.json (global) oder .cursor/mcp.json (je Projekt).
JetBrains AI Assistant / Junie — Settings → Tools → AI Assistant → Model Context Protocol → Add → As JSON, den Block einfügen, dann die IDE (integrierte Entwicklungsumgebung) vollständig neu starten.
Desktop-Assistenten — die meisten verwenden eine …_config.json mit derselben Form mcpServers; prüfen Sie die Dokumentation Ihres Clients für den Speicherort der Datei.
CLI-Agenten — viele akzeptieren dasselbe JSON über einen Mechanismus mcp add / mcp.json.

Verwenden Sie immer einen absoluten Pfad zur Binärdatei. Setzen Sie RUST_LOG=debug in env, um Probleme zu untersuchen (Diagnosen gehen nach stderr; stdout ist dem JSON-RPC-Protokoll vorbehalten).

Ausprobieren#

Sobald registriert, fragen Sie Ihren Assistenten Dinge wie:

"Liste die Szenarioarten von Kshana auf." → list_scenario_kinds
"Zeige mir ein Kshana-Beispiel für spectrum und führe es aus." → list_example_scenarios, get_example_scenario, run_scenario
"Führe das Kshana-Szenario für Uhren-Holdover mit einem Schwellenwert von 20 ns und einem GNSS-Ausfall von 2 Stunden aus; wie groß ist das Holdover von Quantenuhr gegenüber klassischer Uhr?" → run_scenario
"Exportiere diese GPS-Konstellation (Global Positioning System) als SP3." → export_sp3
"Gib mir die Tabelle realtime-frame-eop als CSV." → export_table_csv
"Zeige diesen Iridium-Überflug auf einem Cesium-Globus." → list_export_formats, export_interop
"Animiere die Jamming-Kampagne." → animate_scenario
"Gib mir den Bericht zu diesem Lauf, mit seinem Reproduzierbarkeitsprotokoll." → report_scenario
"Erzeuge eine GPS-L1-Szene von einer Sekunde mit den PRNs 3 und 17, dann erfasse und verfolge sie." → iq_signals, iq_scene, iq_acquire, iq_track

Entwurfsnotiz — warum ein eigenes Crate#

Der Server ist ein eigenständiges, vom Workspace ausgeschlossenes Crate mit eigener Cargo.lock, sodass das offizielle Rust-MCP-SDK (Software Development Kit) rmcp und seine asynchrone Laufzeit nie in den Abhängigkeitsgraphen des veröffentlichten Crates kshana gelangen: Ein Bibliotheks- oder Python-Nutzer kompiliert keinen Server, den er nicht betreibt. (Es wurde zuerst abgetrennt, weil rmcp Edition 2024 ist und rustc ≥ 1,85 braucht, während das Haupt-Crate damals 1,75 zusagte. Die Bibliothek und dieser Server erklären jetzt beide 1,88, die Untergrenze des sicherheitsgepatchten rmcp 2.x und der aktualisierten RustCrypto-Crates.) Die kontinuierliche Integration (CI) sichert dieses Crate für sich allein ab — Tests und cargo deny gegen seine Lockfile. Der Lizenzbaum von rmcp ist unbedenklich (Apache-2.0/MIT/BSD), sodass die Abtrennung, anders als beim Kreuzvalidierungs-Crate xval/anise-frames, dem es sonst gleicht, keine Frage der Lizenzierung ist.

Lizenz: AGPL-3.0-only, die GNU Affero General Public License Version 3 ausschließlich (oder eine kommerzielle Lizenz von Ashforde OÜ; siehe LICENSING.md des Repositorys).