MCP Server

The LogPulse MCP server is a remote Model Context Protocol server. It lets AI assistants and agents, ChatGPT, Claude, Claude Code, Cursor, Codex, or any MCP-capable client, call typed LogPulse tools directly: search and investigate logs, query the risk-based SIEM, check service health, and walk the cross-domain entity graph. The agent reasons over structured results instead of scraping the dashboard or writing raw SQL.

The tools reuse the same in-process registry, LPQL engine, and namespace RBAC the product uses internally, so an agent never gets more access than the token holder. The AI itself never changes your configuration: it reads, and it proposes changes that a person approves in LogPulse. In ChatGPT and Claude, results render as interactive widgets (charts, notables, service maps, proposals) instead of raw JSON.

Note
ChatGPT and Claude connect with OAuth: you sign in to LogPulse and choose the organizations and permissions on a consent screen. Coding agents and automation can also use a Personal Access Token.

Endpoint & transport

The server is exposed at a single endpoint over Streamable HTTP (stateless, JSON responses). All requests are POST and must be authenticated. An unauthenticated request is rejected with 401 before any tool is exposed.

Endpoint
POST https://api.logpulse.io/mcp

The endpoint and an authentication header are everything an MCP client needs; the client discovers the available tools, resources, and prompts automatically after it connects.

Authentication

Two authentication methods resolve to the same identity (organization, user, scopes): a Personal Access Token as a bearer credential, or OAuth 2.1 for interactive sign-in.

Personal access token

Create a token in Settings → Access Tokens, grant it the scopes the agent needs, and send it as a bearer token. A token is tied to you and one organization and never grants more than your own access.

Authorization header
Authorization: Bearer lpat_a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4

OAuth 2.1

Interactive clients can connect with OAuth 2.1 (PKCE, dynamic client registration, and browser consent on the LogPulse scopes), so a user authorizes the agent without handling a token by hand. The agent registers itself, the user signs in and consents, and LogPulse issues a scoped access token bound to the agent and organization. Connected agents are listed, and can be revoked, under Settings → Connections.

Tip
Use a PAT for CI and headless automation; use OAuth for interactive, per-user connections from a developer's editor.

Several organizations

One token or connection can reach several organizations. Pick them when you create the token (Profile → Access Tokens) or on the OAuth consent screen; only organizations you belong to can be chosen, and membership is checked again on every request.

Such a connection has no current organization. list_organizations shows the choices, and every other tool takes a required organization argument (id, slug or exact name). The agent is instructed to ask you when it is not sure which organization you mean. A call without one, or with a name that matches more than one organization, runs nothing and returns the list. Plan, role, data access and the audit trail are those of the organization the call names.

Scopes

Scopes follow a resource:action convention. A token only sees the tools its scopes allow. A tool the token can't reach is invisible in tools/list and cannot be called. Follow least privilege and grant only what the agent needs.

ScopeGrants
logs:readLog search and investigation, plus control-plane reads (alerts, pipelines, dashboards, agents, saved queries) and the onboarding data model
siem:readRisk events, risk summary, notables, detections, UEBA baselines, MITRE coverage, and IOC lookups
services:readService health, KPI anomalies, dependencies, services, and incidents
entities:readEntity 360, blast radius, and entity risk timeline (cross-domain graph)
siem:proposePropose detection rules and alert rules for human review (queued, not applied)
services:proposePropose services, KPIs, dependencies, SLOs and notification routes (Service Intelligence) for human review
pipelines:proposePropose SOAR / automation pipelines and triggers for human review
parsers:proposePropose parser rules (field extraction at ingest), proven on real events first
dashboards:proposePropose dashboards and panels; every panel search runs once first. Never shared on a public link
checks:proposePropose health checks; each check is run once from LogPulse first. Needs a role that may change settings
ops:actWidget actions you click yourself in ChatGPT or Claude: acknowledge or close a notable, mute a rule for a few hours, snooze an anomaly, undo. The AI model cannot call these
proposals:decideApprove or reject a proposal from a widget, confirmed by you in LogPulse each time; never your own proposals and never by the AI. Opt-in on the consent screen
Warning
There are no direct-write scopes. The *:propose scopes let an agent only propose a change. It is queued in LogPulse and a human with the right permission approves it before anything is applied. Approved items are created disabled/inactive, and destructive SOAR actions require owner approval. Grant the narrowest propose scope an agent needs.

Connecting an agent

Any MCP client that supports remote servers over HTTP connects to the same endpoint. ChatGPT and Claude sign in with OAuth; coding agents can use OAuth or a bearer token.

ChatGPT

Add LogPulse as an app in ChatGPT: from the app directory when it is listed for your account, or as a custom app in developer mode (Settings → Apps → Advanced settings) with this URL and OAuth authentication:

MCP server URL
https://api.logpulse.io/mcp

ChatGPT sends you to LogPulse to sign in. On the consent screen you pick the organizations ChatGPT may use and, under Change access, trim the permissions. Results from searches, notables, service health, dashboards and proposals render as interactive widgets in the chat.

Tip
Added LogPulse a while ago and a new tool or widget is missing? ChatGPT keeps the tool list from when the app was added. Refresh the app in its settings, or remove and add it again.

Claude (web, desktop, mobile)

Add LogPulse from the Claude connectors directory when it is listed there (Settings → Connectors → Browse), or as a custom connector with this URL:

Remote MCP server URL
https://api.logpulse.io/mcp

Claude opens LogPulse to sign in and shows the same consent screen. Once connected, LogPulse works in every conversation where the connector is enabled, on the web, in the desktop app and on mobile, with the same interactive widgets.

Claude Code

Add LogPulse with the Claude CLI. Without a header, Claude Code signs in with OAuth the first time you use it (run /mcp to authenticate); with a token it connects directly:

Terminal
claude mcp add logpulse --transport http \
  https://api.logpulse.io/mcp \
  --header "Authorization: Bearer lpat_your_token_here"

The LogPulse tools appear immediately in any Claude Code session. Verify with /mcp or by asking Claude to list its LogPulse tools.

Cursor

Add LogPulse as an HTTP MCP server in Cursor's MCP settings, or edit ~/.cursor/mcp.json directly:

~/.cursor/mcp.json
{
  "mcpServers": {
    "logpulse": {
      "url": "https://api.logpulse.io/mcp",
      "headers": {
        "Authorization": "Bearer lpat_your_token_here"
      }
    }
  }
}

Codex & other clients

Codex, Continue, and custom agents all connect with the same three values. Point your client at the endpoint over Streamable HTTP with a bearer token:

Connection values
Endpoint:  https://api.logpulse.io/mcp
Transport: Streamable HTTP
Auth:      Authorization: Bearer lpat_your_token_here

Example prompts

Ask in your own words; the assistant picks the tools. With several organizations connected, name the one you mean.

AskWhat happens
What happened in production overnight?A briefing: new notables, anomalies, failing health checks and open incidents since your last look.
Show the 5xx rate for the checkout service over the last 24 hours.An LPQL search with a timechart widget; the query is shown so you can reuse it.
Which notables are open, and which ones look like false positives?The notable queue with risk scores; you can acknowledge, close or mark false positives from the widget.
Is the payments service healthy, and what does it depend on?Service health per KPI and the dependency map, with the KPI that is out of bounds.
Propose an alert when login failures for one user exceed 20 in 5 minutes.A proposal tested against your real data (a dry run with the matches it would have produced), queued for a person to approve.

Tool catalog

Tools are grouped by the scope that unlocks them. The catalog mirrors the depth your team uses in the dashboard.

Search & investigate (logs:read)

ToolDescription
search_logsRun an LPQL search and return matching events
count_patternsGroup and count events by a field or pattern
timeline_analysisBucket events over time to spot spikes and gaps
compare_timerangesCompare two time windows for the same query
get_field_valuesList the distinct values of a field
search_similar_historicalFind historical events similar to a reference
system_healthSnapshot of ingest and platform health
lpql_helpLPQL reference for building queries
list_* / get_*Control-plane reads: alerts, pipelines, dashboards, agents, lookups, saved queries, evaluations, maintenance windows
get_data_modelCanonical / OCSF field model for building connectors
estimate_search_costRows a search reads per run and per day, without running it, and how to make it cheaper
find_unparsed_sourcesThe index and sourcetype pairs with the most events without extracted fields, with an example event
check_parsing / test_parser_ruleHow a source is parsed today, and a candidate parser rule tested on real events (with a search that backfills older events)

Security monitoring (siem:read)

ToolDescription
search_risk_eventsSearch the stream of risk events by entity, MITRE tag, score, or time
get_risk_summaryTop-risk-entity leaderboard and risk breakdown
list_notables / get_notableList and inspect notables (with investigation state)
list_detections / get_detectionBrowse and read detection rules
get_ueba_baselinesBehavioral baselines for an entity
mitre_coverageMITRE ATT&CK coverage from enabled content
lookup_iocIOC reputation lookup against threat-intel feeds
get_siem_settingsRead the risk-scoring configuration

Service intelligence (services:read)

ToolDescription
get_service_healthService status rolled up from its KPIs
list_slosSLOs with target, SLI, error budget left, burn rates and status
list_anomaliesKPI anomalies across services
list_dependenciesUpstream/downstream dependency graph
list_servicesServices in the estate
list_incidentsOpen and recent incidents
get_serviceOne service in full: scope, membership rules, every KPI, dependencies in both directions
list_kpi_templatesGolden-signal KPI templates to start from
suggest_servicesServices discovery finds in your data that do not exist yet, with ready-made rules
suggest_dependenciesDependencies the observed traffic between services suggests
preview_service_scopeWhich entities or sources a set of membership rules matches right now
test_kpiRun a KPI once inside a service scope: the value it would record and its severity (also needs logs:read)

Entity graph (entities:read)

ToolDescription
get_entityEntity 360 across security and observability
get_blast_radiusWhat an entity connects to and could affect
get_entity_risk_timelineAn entity's risk over time

Propose changes (propose-approve)

Agents never write configuration directly. Each propose_* tool queues a change in LogPulse for a human to review and approve; approved items are created disabled/inactive for a person to activate. Destructive SOAR actions (block_ip, disable_user) require owner approval plus the org's destructive-actions flag, and agent-side HTTP nodes are rejected.

ToolScopeDescription
propose_detectionsiem:proposePropose a detection rule (created disabled on approval)
propose_alert_rulesiem:proposePropose a search-based alert rule (notifications added by a human)
propose_serviceservices:proposePropose a Service Intelligence service
propose_kpiservices:proposePropose a KPI on a service
propose_service_setupservices:proposeA whole service in one change: service, KPIs and dependencies, applied all or nothing
propose_service_updateservices:proposeChange a service; the reviewer sees each field before and after
propose_service_deleteservices:proposeDelete a service, listing the KPIs and dependencies that go with it
propose_kpi_updateservices:proposeChange a KPI; a new search runs once against your data first
propose_kpi_deleteservices:proposeDelete a KPI
propose_dependencyservices:proposeAdd, change or remove a dependency between two services
list_my_proposalsservices:proposeWhat this user proposed and where each proposal stands
propose_parser_ruleparsers:proposeCreate, change or delete a parser rule; refused unless it parses the real events it is for
propose_sloservices:proposeCreate, change or delete an SLO; measured over the last 7 days first, refused when that week already spent the whole error budget
list_notification_channelsservices:proposeThe notification channels that exist, with masked targets (never a URL, token or address list)
propose_service_notificationservices:proposeRoute the alerts of a service to an existing channel, change or remove a route. Changes who gets paged; cannot add a recipient
propose_dashboarddashboards:proposeCreate a dashboard with its panels, change its name, visibility or layout, or delete it
propose_dashboard_paneldashboards:proposeAdd, change or remove one panel; its search runs once over the last 15 minutes first
propose_health_check_changechecks:proposeCreate, change or delete a health check; run once from LogPulse first, private and internal addresses refused
propose_pipelinepipelines:proposePropose a SOAR / automation pipeline (created inactive)
propose_automation_triggerpipelines:proposePropose a notable → pipeline trigger (created disabled)

Service Intelligence proposals are checked against your data before they are queued: the membership rules must match entities or sources, every KPI search runs once inside the service scope, and a dependency must point at an existing service. What the check found travels with the proposal, so the reviewer sees the same evidence. An update or delete that was overtaken by a manual edit fails instead of overwriting it.

Changes without a review. By default every proposal waits for a person. An owner or admin can let the agent apply a category by itself under AI → Settings (services, KPIs, dependencies, SLOs, notification routes, dashboards, health checks, parser rules, detections, alert rules, pipelines), each off until switched on. An applied change is still recorded as a proposal with its diff, runs under the rights of the token's owner, and lands in the audit log. Destructive changes always wait for the owner.

Parser rules. check_parsing shows how a source is parsed today, list_grok_templates the building blocks, and test_parser_rule runs a candidate over real events in the same engine ingest uses (all under logs:read). A proposed rule is tested again on the events its source pattern selects and refused when fewer than 80% parse, when the pattern is unsafe or too slow, or when another rule would win for the same events. A rule applies to events that arrive after it is live; for regex and grok rules the result carries a backfillSearch, an LPQL search with | rex that extracts the same fields from events already stored. find_unparsed_sources shows where a rule would help most.

Scheduled searches show their cost. A detection, alert rule or KPI runs forever, so before it is queued the server estimates the rows it reads per day (the store's own estimate, or the hourly counts) and shows that number to the reviewer, with advice on how to narrow it. Nothing is refused on cost.

SLOs, notification routes, dashboards and health checks. A proposed SLO is measured over the last 7 days with the computation the SLO editor's preview uses, and the reviewer sees its SLI, error budget and burn rate. A notification route names a channel that already exists by its id: an agent cannot add a recipient, an email address or a webhook URL, and it only ever sees masked targets. Every panel search of a proposed dashboard runs once and must be narrowed. A proposed health check is run once from LogPulse behind the same protection against private and internal addresses as the Test button; a check that runs on an agent needs an online agent.

Searches must be narrowed. The log store is sorted by index, so a proposed detection or alert rule without index=, sourcetype=, source= or host= before its first pipe is refused; a KPI runs inside its service scope and is advised to add index=. platform_help teaches the agent how to build an efficient search and what can and cannot be done over MCP, and get_agent_permissions tells it, per kind of change, whether a proposal is applied at once or waits for a person. Both need no scope.

Note
detection_help (under logs:read) explains how detections and KPIs map onto the data model, so an agent can draft a correct rule before calling propose_detection.

Resources & prompts

Beyond callable tools, the server exposes MCP resources for read-grounding and prompts that steer the agent through a workflow.

Resources include an LPQL cheat sheet and a detection guide (available with any valid token), plus your data models and saved queries (gated by logs:read). A resource the token can't reach is hidden from resources/list.

Prompts include triage_notable, is_ip_malicious, onboard_connector,service_health_check and set_up_service, each guides the agent through the right sequence of read-only tools for that task.

Security model

The MCP surface is governed by design:

The AI never writes directly. Every configuration change goes through propose-approve: a propose_* tool (behind a *:propose scope) queues a change that a human approves in LogPulse before anything is applied, unless an owner has chosen to let the AI apply proposals in AI → Settings. The few direct actions (acknowledge a notable, mute a rule, undo) are hidden from the model and only run when you click them in a widget.

Scoped & RBAC-aware. A token holds only the scopes you grant, and the token holder's namespace RBAC is applied to every query. An agent can never read across tenants or beyond what the user's roles grant.

Audited & rate-limited. Every tool call is written to the audit log (denied calls included) and rate-limited per token.

Usage is a detection. Each call is also emitted to an internal log stream and watched by built-in detections. Abnormal call volume or an agent write raises a notable on your own engine.

Untrusted data stays data. Tool output is treated as data, not instructions, as a guard against prompt injection through your own logs. There is no auto-execute and no write without a human in the loop. Data stays EU-hosted and AI evaluation runs in the EU.

Data & privacy

The MCP server only returns data from the organizations you selected on the consent screen, within your role and the scopes you granted. LogPulse does not read your conversations with ChatGPT or Claude: it receives the tool calls the assistant makes and records each one (tool, organization, user, time) in the audit log. What the assistant does with a result is governed by the assistant's own terms. LogPulse data is hosted in the EU. See the privacy policy for retention, processors and your rights. Revoke a connection at any time under Settings → Connections; its tokens stop working immediately.

Rate limits & auditing

The endpoint is rate-limited to 120 requests/min per token. Exceeding it returns 429; back off and retry. Each successful call updates the token's "last used" timestamp in Settings, and every call is recorded in the organization's audit log with the user, scope, and whether it was a write.

On top of the rate limit, an owner or admin can give each connection (an access token or an OAuth client) a daily limit per organization on tool calls and on rows read, under AI → Usage. There is none by default. Over a limit, a tool call returns an error that says which limit was reached and when it resets: 00:00 UTC. The same page shows calls and rows read per day and per connection.

Note
MCP access is part of your LogPulse plan and governed by the per-token rate limit. Pricing stays flat, billed per plan, not per query or per agent.

Troubleshooting

SymptomCause & fix
401 on connectMissing or invalid token. Confirm the Authorization header is Bearer lpat_… and the token is not revoked or expired.
A tool is missing from the listThe token lacks that tool’s scope. Create a token with the right scope (for example siem:read for notables).
403 calling a toolThe token is valid but missing the required scope for that specific tool.
429 responsesPer-token rate limit (120/min) exceeded. Reduce call volume or back off and retry.
"Daily limit reached"An admin set a daily limit for connections in this organization and this one reached it. It resets at 00:00 UTC; the limit is changed under AI → Usage.
A proposed change is not live yetExpected: propose_* tools queue a change for human approval. Approve it in LogPulse; approved items are created disabled/inactive, then a person enables them.

Still stuck? See Personal Access Tokens for token errors, or contact us.