Serveur MCP LastPing
Commit 12 nov. 2026Permet à un agent IA de configurer, gérer et lire son propre monitoring afin de signaler l'échec, le blocage ou la nécessité d'une approbation humaine pour ses tâches.
Aussi connu sous lastping-dev/lastping-app, lastping-app
- Étoiles
- 3
- Outils
- —
- Téléchargements, 30 jours
- —
- Dernière version
- 0.2.2
- Dernier commit
- 12 nov. 2026
- Licence
- MIT
Qu'est-ce que LastPing MCP ?
Permet à un agent IA de configurer, gérer et lire son propre monitoring afin de signaler l'échec, le blocage ou la nécessité d'une approbation humaine pour ses tâches.
Résumé généré à partir du README du projet
À propos du MCP server LastPing
LastPing fournit un système de monitoring conçu pour les agents IA, les tâches cron et les pipelines CI/CD. Contrairement au monitoring traditionnel qui recherche des erreurs, ce service utilise une approche inversée : il vous alerte lorsqu'un processus ne parvient pas à envoyer son signal de présence. Cela garantit que si une tâche se bloque, plante ou ne démarre jamais, vous êtes averti par l'absence de signal. Le système est gratuit pour les particuliers et se connecte à un service hébergé sur lastping.dev.
Les développeurs peuvent utiliser le MCP server pour permettre aux agents IA de gérer leur propre cycle de vie de monitoring. Un agent peut utiliser des outils tels que create_monitor et get_ping_instructions pour configurer ses propres alertes sans intervention humaine. Le serveur prend en charge diverses configurations clients, notamment Claude Desktop via une extension ou le bridge mcp-remote, ainsi que des connexions directes pour Claude Code. Il fournit également un wrapper CLI pour rapporter automatiquement le cycle de vie des processus, les codes de sortie et les traces OpenTelemetry.
Ce que vous pouvez faire avec
- 1Configuration automatisée du monitoring d'agentUn agent IA peut créer de manière autonome ses propres moniteurs et récupérer les commandes nécessaires pour rapporter son statut.
- 2Détection de défaillances de processus silencieusesLe système identifie lorsqu'une tâche ne parvient pas à envoyer de signal, ce qui est utile pour les processus défectueux incapables de rapporter des erreurs.
- 3Observation des traces d'exécution d'agentsLes développeurs peuvent utiliser le CLI pour encapsuler des commandes et exporter automatiquement les traces OpenTelemetry afin de suivre les performances de l'agent.
- 4Gestion des destinations d'alerteLes utilisateurs peuvent configurer par programmation les destinations d'envoi des alertes à l'aide des outils de gestion disponibles.
Extrait du README du projet. Chaque cas d'utilisation est vérifié par rapport à une citation du document.
Comment installer LastPing MCP
Formats vérifiés le 10 nov. 2026Ajouter à CursorAjouter à GooseInstaller LastPing MCP dans Claude Code
$ claude mcp add --transport http lastping-app https://mcp.lastping.dev/mcpInstaller LastPing MCP dans Cursor
~/.cursor/mcp.json
{
"mcpServers": {
"lastping-app": {
"url": "https://mcp.lastping.dev/mcp"
}
}
}Installer LastPing MCP dans VS Code
.vscode/mcp.json
{
"servers": {
"lastping-app": {
"type": "http",
"url": "https://mcp.lastping.dev/mcp"
}
}
}Installer LastPing MCP dans VS Code CLI
$ code --add-mcp '{"name":"lastping-app","type":"http","url":"https://mcp.lastping.dev/mcp"}'Installer LastPing MCP dans Codex
$ codex mcp add lastping-app --url https://mcp.lastping.dev/mcpInstaller LastPing MCP dans Codex config.toml
~/.codex/config.toml
[mcp_servers.lastping-app] url = "https://mcp.lastping.dev/mcp"
Installer LastPing MCP dans Gemini CLI
$ gemini mcp add -s user --transport http lastping-app https://mcp.lastping.dev/mcpInstaller LastPing MCP dans Gemini settings.json
~/.gemini/settings.json
{
"mcpServers": {
"lastping-app": {
"url": "https://mcp.lastping.dev/mcp",
"type": "http"
}
}
}Configuration
LASTPING_AUTH
| Nom | Description | Type |
|---|---|---|
| LASTPING_AUTH | — |
Vérifications automatisées
Exécuté le 14 nov. 2026Rapport complet →Pas encore vérifié. Un serveur nécessite un score de 80, aucune faille sérieuse et suffisamment de données pour que nous puissions effectuer les vérifications. Fonctionnement des vérifications · Ce qu'il faut corriger pour gagner des points
- Dépôt source lié et accessiblelastping-dev/lastping-app is public and reachablegithub.com/lastping-dev/lastping-app ↗Réussi
- Le nom du package correspond au dépôt sourceNon vérifié
- Provenance du build (attestation Sigstore)Non vérifié
- Licence open source (OSI)MITspdx.org/licenses/MIT.html ↗Réussi
- Commit ou version publiée au cours de l'année écouléeLast commit or release 2026-11-12github.com/lastping-dev/lastping-app ↗Réussi
- OpenSSF ScorecardNon vérifié
- Nom du package non proche d'un package populaireNon vérifié
- Aucun avis critique dans le package ou ses dépendancesNon vérifié
- Aucune instruction cachée destinée au modèle0 tool descriptions and the README read; no override phrases, credential paths or hidden charactersRéussi
- Les outils destructifs sont étiquetésNon vérifié
- Le point de terminaison distant répond à la poignée de main MCPHTTPS endpoint answered 401 (sign-in required)Réussi
README
Voir sur GitHubLastPing alerts you when your AI agents fail, stall, wait for your approval or never start, and watches the cron jobs and CI/CD pipelines around them. Free for individuals.
Most monitoring watches a thing and tells you when it looks wrong. LastPing waits for a thing to check in and tells you when it doesn't. That inversion is the whole product: a job that breaks can't send you an error, but it can fail to send you anything, and absence is the one signal a broken process can still produce.
This repository holds the client pieces: the lastping CLI, which wraps
any command and reports its start, exit code and traces, and the MCP server,
which lets an AI agent set up and read its own monitoring. The hosted service
they talk to is at lastping.dev, free for
individuals.
Quick start
# 1. Install the CLI (macOS and Linux, amd64 and arm64)
curl -fsSL https://raw.githubusercontent.com/lastping-dev/lastping-app/main/install.sh | sh
# 2. Wrap a job: a start ping, your command untouched, then its exit code
lastping run --monitor <monitor-id> -- ./backup.sh
# 3. Or give your AI assistant the hosted MCP server, and sign in
https://mcp.lastping.dev/mcp
Create the monitor, and get its id, at app.lastping.dev, or let your assistant do it over MCP. Connect steps for each client are at lastping.dev/mcp/.
Install
curl -fsSL https://raw.githubusercontent.com/lastping-dev/lastping-app/main/install.sh | sh
No Go toolchain needed — that pulls a prebuilt binary for macOS and Linux, on amd64 and arm64, and verifies its checksum. Windows builds are on the releases page.
If you do have Go:
go install github.com/lastping-dev/lastping-app/cmd/lastping@latest
lastping run — reporting you can't forget
Put it in front of whatever you already run:
lastping run --monitor <monitor-id> -- python nightly_etl.py
lastping run --monitor <monitor-id> -- ./backup.sh
lastping run --monitor <monitor-id> -- claude
It sends a start ping, runs your command untouched, and reports the exit code when it finishes — success on 0, failure on anything else, with the tail of stderr attached so the alert says why.
Three properties worth knowing, because they are the difference between a monitoring wrapper you can trust in production and one you remove after a bad night:
- Your exit code always propagates. The wrapper exits with whatever your command exited with, so CI behaves exactly as it did before you added it.
- A failed ping never touches your command. If LastPing is unreachable, your job still runs, still writes its output, still exits normally.
- Interactive stays interactive. stdin and stdout are handed over as file descriptors, so wrapping a REPL or an agent session works.
Why a wrapper rather than an instruction? Because anything advisory decays. An
AI agent told to report on every task will stop doing it, and a cron line you
meant to add a curl to never gets it. A wrapper reports from the process
lifecycle, so nothing depends on anybody remembering.
Traces
lastping run always configures your wrapped command's OpenTelemetry
exporter, in its environment only, so an auto-instrumented agent can export
its own trace spans with no code change:
OTEL_EXPORTER_OTLP_TRACES_ENDPOINT— the header-free monitor-URL form (<ping url>/v1/traces) whenLASTPING_API_KEYis not set, so a headerless exporter can still authenticate; the ping host's/v1/traces(the Bearer form) when it is set.OTEL_RESOURCE_ATTRIBUTES—lastping.monitor_id=<id>,lastping.run_id=<rid>appended to whatever you already set, so a trace's spans join the same run the surrounding pings report.OTEL_EXPORTER_OTLP_HEADERS—Authorization=Bearer <your key>, only whenLASTPING_API_KEYis set and you have not already set that variable yourself.
Any of the three you already set is left alone. The key is never used to authenticate a ping; the ping URL stays unauthenticated by design, as above.
MCP server — let an agent set up its own monitoring
Claude Desktop extension
A one-click install for Claude Desktop on macOS and Windows that keeps your key in the system keychain. It needs no Node.js.
- Download lastping.mcpb.
- Double-click it; Claude Desktop opens its install dialog.
- Paste a write-scope key from Settings, API keys at app.lastping.dev.
The extension runs this repository's stdio binary (below) on your computer.
It is built by mcpb/build.sh when a version is tagged, and every release is
signed; the release build fails rather than ship an unsigned bundle. The
certificate is self-signed, so Claude Desktop shows the extension as
unverified. The signature still proves the bundle came from this repository's
release pipeline and was not altered after it was signed. A local build of
mcpb/build.sh without the signing secrets is unsigned and says so.
MCPB_CERT_CA_ISSUED is kept for a future certificate from a public CA.
Claude Desktop through the mcp-remote bridge
Claude Desktop's config file runs local programs only, so LastPing connects
through the mcp-remote bridge. Add this to claude_desktop_config.json
(macOS: ~/Library/Application Support/Claude/, Windows: %APPDATA%\Claude\):
{
"mcpServers": {
"lastping": {
"command": "/ABSOLUTE/PATH/TO/npx",
"args": [
"-y", "mcp-remote",
"https://mcp.lastping.dev/mcp",
"--header", "Authorization:${LASTPING_AUTH}"
],
"env": {
"PATH": "/FOLDER/THAT/HOLDS/npx:/usr/bin:/bin",
"LASTPING_AUTH": "Bearer lp_your_key"
}
}
}
}
- Needs Node.js. Claude Desktop does not read your shell's PATH, so give it
the full path: run
which npxin a terminal and put the result incommand(with nvm it looks like/Users/you/.nvm/versions/node/v22.11.0/bin/npx), and its folder at the front ofPATHinenv. - Quit and reopen Claude Desktop; it reads the file only at start-up. Settings, Connectors then lists lastping.
- Without a key, add LastPing as a custom connector instead (Customize,
Connectors, Add custom connector, then paste
https://mcp.lastping.dev/mcp) and sign in to LastPing in the browser. The same connector covers claude.ai, the Claude mobile apps and Cowork.
Other clients
Claude Code connects directly, no bridge:
claude mcp add --transport http --scope user lastping https://mcp.lastping.dev/mcp --header "Authorization: Bearer <key>".
Cursor, Windsurf, Codex CLI, Gemini CLI and other clients:
lastping.dev/mcp/#connect.
The hosted server is the recommended path, and it always carries the current tool set. Most clients connect by adding the URL and signing in to LastPing, with nothing to install; Cursor and Windsurf use the URL and an API key. With a key, Claude Desktop connects through the extension or the mcp-remote bridge above.
A stdio binary is also here if you would rather run it yourself:
go install github.com/lastping-dev/lastping-app/cmd/lastping-mcp@latest
Monitors: create_monitor · get_monitor · list_monitors ·
update_monitor · delete_monitor · pause_monitor · resume_monitor ·
snooze_monitor
Discovery: discover_monitors_reconcile
Reporting: get_ping_instructions · declare_run_expectations
Incidents & runs: list_incidents · get_run_history · get_run
(one run's full timeline, assertion verdicts and spans) · list_runs
(runs across every monitor, traced runs included, with filters) ·
get_incident (one incident's recorded timeline)
Tracing: get_trace_setup (the set-up steps for one tool, from the server) ·
create_ingest_key (a tracing key bound to one monitor; a write key is
enough) · get_trace_diagnostics (why a sent span was refused)
Agent observability: get_agent_dependencies · get_agent_usage ·
list_dependencies · list_discovered_agents · adopt_discovered_agent
The failure loop: list_open_incidents · add_incident_note
Alert routing: set_route · delete_route
Delivery log: list_deliveries, recent alert deliveries across every
monitor, no paging
Destinations: list_destinations · create_destination ·
update_destination · test_destination · delete_destination
Alert templates: get_alert_templates · set_alert_template
Agent registry: register_agent · list_agents · get_agent ·
update_agent · delete_agent
Status pages: list_status_pages · create_status_page ·
update_status_page · delete_status_page
API keys: create_api_key (optional scope: read / write / admin / ingest) ·
list_api_keys · regenerate_api_key (new secret, same key; does not
cascade) · revoke_api_key (cascades to every key it created)
Terraform: export_terraform
This binary carries the same tool set as the hosted server at
mcp.lastping.dev. It is a thin REST client throughout: every tool is a
direct HTTP call to the management API, so it stays free to run yourself with
no lag behind the hosted surface beyond a new release.
The one that matters most is get_ping_instructions: an agent calls
create_monitor, then asks for its own ping commands, and wires them into its
own work — in one conversation, without a human opening a dashboard.
Ping API
Every monitor gets a URL. There is nothing to install and no library to keep current; anything that can make an HTTP request can report.
| What happened | Request |
|---|---|
| finished successfully | POST <ping-url> |
| started a run | POST <ping-url>/start |
| failed | POST <ping-url>/fail with the error as the body |
| exited with a code | POST <ping-url>/<exit-code> |
| waiting on a human | POST <ping-url>/blocked |
| progress worth recording | POST <ping-url>/note |
Add ?rid=<id> to pair a run's start with its result, so LastPing can group a
run's pings and time it.
# The classic one-liner, at the end of a cron job:
curl -fsS -m 10 --retry 3 https://ping.lastping.dev/<monitor-id>
Traces
POST https://ping.lastping.dev/v1/traces accepts an OTLP/HTTP export
(application/x-protobuf or application/json, gzip accepted) with a
Bearer key (an ingest key bound to the monitor, from create_ingest_key;
a write or admin key also works), or POST <ping-url>/v1/traces for exporters that
cannot set headers. Spans need the resource attribute lastping.monitor_id;
with lastping.run_id they join that run, and without it each trace becomes a
run of its own. A payload is capped at 1 MiB decompressed,
500 spans per request and 2,000 spans per run. lastping run sets all of
this up for you — see Traces above.
Monitoring as code
resource "lastping_monitor" "nightly_etl" {
name = "nightly-etl"
slug = "nightly-etl"
schedule_kind = "cron"
cron_expr = "0 3 * * *"
tz = "Europe/Berlin"
grace_s = 900
}
The provider is on the
Terraform Registry
as lastping-dev/lastping, with source at
lastping-dev/terraform-provider-lastping.
Links
- lastping.dev — the hosted service, free for individuals
- AI agent monitoring — the agent-first guide
- MCP server — connect configs per client
- Terraform provider — monitoring as code
- Integration guides — cron, Kubernetes, systemd, GitHub Actions, Python, Node
License
MIT. See LICENSE.
Questions sur LastPing MCP
Comment ajouter LastPing MCP à Claude Code ?
Exécutez claude mcp add --transport http lastping-app https://mcp.lastping.dev/mcp dans votre terminal. Ajoutez --scope user pour le rendre disponible dans tous les projets.
Comment ajouter LastPing MCP à Cursor ?
Ouvrez ~/.cursor/mcp.json et ajoutez le serveur sous mcpServers, avec la configuration Cursor indiquée dans la section d'installation ci-dessus.
Que surveille LastPing ?
Il surveille les agents IA pour détecter les échecs, les blocages ou les demandes d'approbation, ainsi que les tâches cron et les pipelines CI/CD.
En quoi LastPing diffère-t-il du monitoring traditionnel ?
Au lieu de surveiller une ressource et de signaler une anomalie, LastPing attend un signal de présence (check-in) et alerte lorsqu'il ne le reçoit pas.
L'utilisation de LastPing est-elle payante pour les particuliers ?
Non, le service est gratuit pour les particuliers.
Puis-je utiliser LastPing avec mes commandes existantes ?
Oui, vous pouvez utiliser le CLI LastPing pour encapsuler n'importe quelle commande afin de rapporter son démarrage, son code de sortie et ses traces.