Apex Log MCP Server
OfficialAnalyze Salesforce Apex debug logs locally from an AI assistant, and use authenticated org tools to run Apex, fetch logs, and manage trace flags.
Rank slow operations by self time or retained heap, including methods, queries, DML, callouts, flows, and query plans.
Summarize a log's duration, category time, governor limits, namespace usage, truncation, exceptions, and fatal errors.
List governor limits closest to their ceilings.
Search log events in order, including USER_DEBUG, validation rules, statements, and nested events.
List debug logs stored in an org with filters, sorting, and paging.
Download org logs by IDs or newest N and save local paths for analysis.
Execute anonymous Apex against an org and save its debug log.
Create trace flags for users, classes, or triggers with configurable debug levels and duration.
Provides tools to analyze Salesforce Apex debug logs for performance bottlenecks, slow methods, and governor limit usage, and allows executing anonymous Apex against Salesforce orgs.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Apex Log MCP Server Find the top 5 slowest methods in this debug log and their durations"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Apex Log MCP Server
MCP Server to Analyze Salesforce Apex debug logs from your AI assistant. Finds slow methods, governor limit risks, and where a transaction spent its time. In your org, runs anonymous Apex, fetches logs, and sets trace flags.
Instead of scrolling thousands of log lines, ask what's slow and why. Uses the same Apex log parser as the Apex Log Analyzer VS Code extension.
Quick Start
Requires Node.js 22 or later. Add the server to your MCP client as below, then ask your assistant to analyze a log. The org tools - apexlog_execute_anonymous, apexlog_list_org_logs, apexlog_get_org_logs and apexlog_create_trace_flag - also need an org authenticated with the Salesforce CLI.
Claude Code
claude mcp add apex-log-mcp -- npx -y @certinia/apex-log-mcpAdd --scope user to use it in every project, or --scope project to share it with your team through the project's .mcp.json.
VS Code
Add this to .vscode/mcp.json in your project:
{
"servers": {
"apex-log-mcp": {
"command": "npx",
"args": ["-y", "@certinia/apex-log-mcp"]
}
}
}Other clients
Most clients take this in their MCP config, for example claude_desktop_config.json for Claude Desktop:
{
"mcpServers": {
"apex-log-mcp": {
"command": "npx",
"args": ["-y", "@certinia/apex-log-mcp"]
}
}
}Related MCP server: Log Reader MCP
Example Prompts
"Give me a summary of this debug log"
"Show me the 5 slowest methods in the default namespace"
"Are we approaching any governor limits in this transaction?"
"What did my System.debug calls print?"
"Run this Apex against my scratch org and analyze the performance"
"Run it again with database logging at FINEST"
"Find the latest debug log for integration@acme.com and summarize it"
"Why are there no logs for this user?"
Keeping the server connected costs ~2,442 tokens, 1.2% of a 200K context. See Token Cost.
Tools Reference
The org tools use the default org of the project in your client's first root, unless you pass targetOrg. A client that declares no roots gets the default org of the server's working directory, or the global default org. When the server cannot read the roots a client declares, each org tool needs targetOrg, since the project's default org cannot be found. That happens when the client uses MCP protocol version 2026-07-28, when the roots cannot be read - for example, the client does not answer in 5 seconds - or when no root is on this machine.
Each tool returns its result in TOON, and an error as plain text.
A 0 means none, not "not measured". Only what did not happen is left out: fatal errors, lost log content, query plans. Durations are in milliseconds to 3 decimal places, percentages to 1.
An analysis tool that pages gives matchedCount, the rows that matched in all, and, while more remain, nextOffset, the offset of the next page.
A file can hold more than one debug log. Each analysis tool then reads only the first, and every figure, truncated included, is that log's. A warning, first in the response, says how many logs the file holds. Analyze each log as its own file.
The server runs as a local process started by your client over stdio, with no API keys. The analysis tools make no network calls. The server keeps the last parsed log for 5 minutes after its last use, so follow-up questions on that log are faster.
apexlog_list_slow_operations
Ranks what a log spent its time on by self time - code units, methods, queries, searches, DML, flows and workflows in one table.
A default response returns:
capturedAt-{debugCategory, level}operations-{debugCategory, type, name, namespace, callCount, durationTotalMs, durationSelfMs, durationSelfMaxMs, selfPercentage, soqlCount, dmlCount, soslCount, rowCount, thrownCount}queryPlans-{operationRow, leadingOperationType, relativeCost, cardinality, sObjectCardinality}
Each response also gives durationTotalMs for the whole transaction, and returnedSelfPercentage for the share these rows account for.
durationSelfMaxMs is the slowest single call in a grouped row. Read it against durationSelfMs to tell one bad call from many small ones. It is absent when the row is already one call.
Two columns say what a row is, both taken straight from the log:
debugCategory- what Salesforce stamped on the event. It decided whether the event was logged at all, and it is the spellingapexlog_execute_anonymoustakes.type- the event type. The category cannot imply it:SOQL_EXECUTE_BEGIN,SOSL_EXECUTE_BEGINandDML_BEGINall sit underdatabase.
Watch for ENTERING_MANAGED_PKG. It is time a package spent where the log shows nothing, and it is often most of a transaction.
sortBy: "heapSelfNetBytes" ranks by retained heap instead of time, adding that column and returnedHeapPercentage. Both are absent otherwise. The figure is signed, so a row that released more than it took reads below zero. Heap is logged only at apexCode FINER and above, so check the apexCode row of capturedAt before trusting a zero.
capturedAt gives the level each category in the returned rows was logged at.
queryPlans is what the query optimizer decided about the queries behind those rows. A relativeCost above 1 means it will not treat the query as selective. Plans are absent when the log explained none, because explain lines need database FINEST.
operationRow points at a row of operations, counting from 1. Under a namespace, callerNamespace or debugCategory grouping a row is not one query, so the plan carries the query text in name instead.
Parameter | Type | Required | Description |
| string | Yes | Absolute path |
| ( | No | Rank only these debug log categories |
| string[] | No | Rank only these log event types, e.g. SOQL_EXECUTE_BEGIN, DML_BEGIN, METHOD_ENTRY |
| string[] | No | Rank only these namespaces |
| number | No | Drop operations below this self time (default: 0), whichever sortBy is used |
| number ≥ 0 | No | Page size (default: 10); fewer if the page would be too large |
| number ≥ 0 | No | Ranked rows to skip (default: 0): the last page's nextOffset |
|
| No | Fold repeats into one row; default name. callerNamespace attributes platform DML to the package that drove it. debugCategory folds a namespace's event types together and so states no type or name. none ranks each call on its own. A grouped durationTotalMs is what the transaction takes back if the group never runs - never sum it across rows. |
|
| No | Default durationSelfMs. heapSelfNetBytes adds that column. |
apexlog_get_summary
How long the transaction ran, where the time went, what it consumed, and whether the log is complete. Start here.
fatalErrors-{message, frames}governorLimits-{limit, used, max}limitsByNamespace-{namespace, limit, used}categories-{debugCategory, level, operationCount, durationSelfMs, selfPercentage}
All thirteen governor limits are listed.
limitsByNamespace shows what each namespace consumed. This is how you see a managed package spending your CPU time. It has no ceiling column, because a ceiling is per limit for the whole transaction and already sits in governorLimits.
categories covers all eleven, each with the level it was captured at, because the level is what a zero means:
database,NONE,0- the queries were not logged.database,FINEST,0- no queries ran.dataAccess,"",0- the log's header declared no level for it, which most logs do not.
dataAccess, wave and validation are always zero. No timed event carries them.
A last unattributed row holds the time no event spans, such as the time before the transaction starts. With it, the rows add up to the whole log.
truncated says whether the log is complete. In a partial log, every figure is a floor. Where the platform cut it, truncatedBy says how - skipped-lines for a hole, max-size for a missing tail - and skippedBytes says how much went. Both are absent when a log merely stops mid-frame.
thrownCount counts the exceptions thrown.
exceptions appears when something was thrown: {message, thrownIn, lineNumber, thrownCount}, one row per message, most thrown first. The table stops at 20 rows. exceptionGroupCount counts the messages, so a cut table says so. The log does not say whether a throw was caught.
messageis the first line of the exception, cut at 200 characters. Two messages that differ only after that share a row.thrownInandlineNumbersay where the message was first thrown.thrownInis the nearest method, constructor or code unit that the log recorded.Below
APEX_CODE,FINEthe log records no method. ThenthrownIncan be a code unit whilelineNumberis a line in a method that it called.A managed package states its line as
EXTERNAL.
flowErrorCount counts the flow elements that failed. A flow can fail with no exception and no fatal error.
fatalErrors appears once per failure that ended the transaction, with the innermost three frames and a trailing … where there were more. It is the only field that says a transaction did not finish, because a fatal error need not breach any limit.
Parameter | Type | Required | Description |
| string | Yes | Absolute path |
apexlog_list_limit_risks
The governor limits nearest their ceiling, worst first.
capturedAt-{debugCategory, level}atRisk-{limit, used, max, usedPercentage}
threshold is reported beside the rows, so an empty table means nothing reached it rather than that the answer is missing.
capturedAt gives the level that gated each returned limit. Every limit but heap comes from apexProfiling; heapSize comes from apexCode.
Parameter | Type | Required | Description |
| string | Yes | Absolute path |
| number | No | Minimum usedPercentage to report (default: 80) |
apexlog_search_events
Searches a log's events in log order, for what the other tools rank or total: what the code printed (USER_DEBUG), the validation rules, the statements, or every event under one method. Filters combine.
capturedAt-{debugCategory, level}events-{eventId, parentEventId, type, namespace, lineNumber, text}
A row says what an event is and where it sits, not what it cost: rank the time with apexlog_list_slow_operations. eventId names an event and parentEventId the one it sits under, so a row found here can be opened up with parentEventId.
Text past 400 characters is elided. Ask for one event by eventId to read up to 30,000 characters of it. contains searches a row's text before elision, and a long row is cut around the match. For plain text, grep the saved .log: it is cheaper. This tool earns its tokens on event types, nesting, and clients with no shell.
capturedAt comes on the first page, or with one event asked for:
When every
typenamed matched, or you asked for one event, it gives the levels of the categories the matches came from.Otherwise, or when those name no category the header declared, it gives every level the header declared.
No USER_DEBUG on a log at apexCode NONE means the log did not capture debug output, not that the code printed none.
Parameter | Type | Required | Description |
| string | Yes | Absolute path |
| string[] | No | Only these log event types, e.g. USER_DEBUG, VALIDATION_RULE |
| string[] | No | Only these namespaces |
| string | No | Only events whose text holds this, ignoring case |
| number ≥ 0 | No | Only this event, with more of its text |
| number ≥ 0 | No | Only events below this one |
| number ≥ 0 | No | Page size (default: 50) |
| number ≥ 0 | No | Rows to skip (default: 0): the last page's nextOffset |
apexlog_execute_anonymous
Runs anonymous Apex against an authenticated org, saves the debug log locally, and returns the path. Pass that path to any analysis tool. The Apex runs as the targetOrg user, with that user's permissions. Its DML commits when the run succeeds; a compile failure or an uncaught exception rolls it back.
Give exactly one of apex or apexFilePath, as sf apex run --file takes - for example a script under scripts/apex/. A file outside the roots your client declares is refused, as is anything but a regular file. When the server cannot read the roots your client declares, a file is refused: see Tools Reference. A path costs a few tokens, where inline Apex is read and then written out again. A production confirmation shows the Apex the file holds, not its path.
The response gives filePath, fileSizeBytes, org (the username, with its alias if set), orgType, succeeded, exceptionMessage when the Apex threw, durationTotalMs, levelsSource, levelsOverridden, outputDirCreated, and a warning when something needs your attention.
When the targetOrg user has no live USER_DEBUG or DEVELOPER_LOG trace flag, the run adds one and deletes it after the run. The debug level that flag uses, Apex_Log_MCP_Debug_Level, stays in the org for the next run.
Logs go to .apex-log-mcp/ by default - add it to your .gitignore. Production orgs are gated: see Production safety.
Parameter | Type | Required | Description |
| string | No | The anonymous Apex to execute, or use apexFilePath |
| string | No | Absolute path to a file of anonymous Apex |
| string | No | Alias or username of the target Salesforce org. Uses the project default if not specified. |
| string | No | Log directory (default: .apex-log-mcp/ in the first client root, else cwd) |
|
| No | This run's log levels. Omit for the user's trace flag levels, else the defaults; "default" forces the defaults; a bare level sets every category; an object sets the named categories over the defaults. Defaults: apexCode, apexProfiling, visualforce, workflow FINE; callout, system, validation DEBUG; database FINEST; nba, wave INFO. |
An object debugLevel looks like this:
{ "database": "FINEST", "apexCode": "FINE" }Set a USER_DEBUG trace flag on your user - in Setup, for example - and every run you start without debugLevel logs at its levels; your flag is never changed. levelsSource in the response says where a run's levels came from: traceFlag, default or request. A live DEVELOPER_LOG trace flag on your user outranks debugLevel and the defaults, so the run takes its levels and levelsSource is traceFlag. levelsOverridden says when the log carries levels other than the ones levelsSource names.
apexlog_list_org_logs
Lists the debug logs stored in an org - a slow UI action, an integration user's request, a Queueable - so an agent can find one it did not run itself. Filters, sorting and paging all run in the org, so a page costs what limit asks for, however many logs the org holds.
matchedCount is how many logs the filters match. exceptionMessage says why a log failed. A cursor pages past the 2,000 rows SOQL's OFFSET stops at; nextCursor is absent on the last page.
Parameter | Type | Required | Description |
| string | No | Alias or username of the target Salesforce org. Uses the project default if not specified. |
| string | No | Username whose activity was logged |
| string | No | Part of the operation, any case, e.g. "aura" for /aura |
| string | No | e.g. "Api" or "Application" |
| boolean | No | true: succeeded logs only; false: failed logs only |
| string | No | ISO 8601 with a zone, e.g. 2026-10-09T09:00:00Z |
| string | No | |
| number ≥ 0 | No | |
|
| No | Descending (default: startTime) |
| number 1–200 | No | Page size (default: 20) |
| string | No | nextCursor from the previous page |
apexlog_get_org_logs
Downloads logs by ids or the newest latest, as sf apex get log does. Returns each saved path, for the analysis tools.
A log already saved under outputDir is not downloaded again, since a stored log never changes; downloaded says which were. A log that cannot be downloaded is a row in failed, with the cause, and the rest still save. If apexlog_get_summary reports truncated: true with no truncatedBy for a saved log, the file may have been cut off while it was written: delete it and call this tool again. It reports progress as each log saves. Cancelled, it starts no more downloads; those already running finish and are saved. If the org's login stops working, it also starts no more: those ids are rows in failed, and warning says how to log in again.
Parameter | Type | Required | Description |
| string | No | Alias or username of the target Salesforce org. Uses the project default if not specified. |
| string[] (1–25 items) | No | Log ids, from apexlog_list_org_logs |
| number 1–25 | No | The newest N logs, in place of ids (default: 1) |
| string | No | Log directory (default: .apex-log-mcp/ in the first client root, else cwd) |
apexlog_create_trace_flag
Starts logging a user, so an integration user's requests reach the org's logs, for apexlog_list_org_logs to find. A flag on a class or trigger stores no log itself: it sets the levels of that code's work in the logs a user's flag stores. A user is traced as USER_DEBUG; a class or trigger as CLASS_TRACING.
The durationMinutes maximum is a minute short of a day, because Salesforce refuses a flag of a full day. The debug level the flag uses stays in the org after the flag ends, for the next flag at the same levels. An object debugLevel takes the form shown under apexlog_execute_anonymous.
Every transaction a traced user runs while the flag lives is stored, which can fill the org's 1,000 MB of log storage: when it is full, no one can set a flag until logs are deleted in Setup > Debug Logs, or expire after 24 hours. When the entity already has a flag of its type whose time overlaps the new one, the call is refused and names it, with its levels, its expiry and the sf command that deletes it - a flag is never changed here. Against a production org, the call asks first, naming the entity, the levels and the minutes.
Parameter | Type | Required | Description |
| string | No | Alias or username of the target Salesforce org. Uses the project default if not specified. |
| string | Yes | A username or user id, or a class or trigger name (ns.Name if namespaced) |
|
| No | A level for every category, or the named ones over apexlog_execute_anonymous's defaults (default: those) |
| number 1–1439 | No | How long it logs (default: 30) |
Token Cost
Every request carries every tool definition, whether you call them or not. Each figure below is a whole definition: name, title, description, input schema and annotations.
Tool | Tokens |
| ~524 |
| ~424 |
| ~349 |
| ~327 |
| ~313 |
| ~200 |
| ~155 |
| ~150 |
Total | ~2,442 (1.2% of a 200K context), +60% vs 1.x ~1,529 |
No single row compares with 1.x: per tool it would compare different tools, since apexlog_list_slow_operations replaced one that took three selection parameters and ranked methods where this one takes eight and ranks every timed event. The total is above 1.x because of the three org tools, which reach logs and trace flags 1.x could not, and apexlog_search_events, which reaches the events 1.x parsed and dropped.
The 4 tools that replaced 1.x's now cost ~1,253 tokens.
A call itself is a tool name and a log path, so what a call costs is what it returns.
Cost barely grows with the log size. The figures below are measured against a 40 KB slice of the Apex Log Analyzer sample log.
Tool | Response | 1.x | Change |
| ~342 | ~293 | +17% |
| ~400 | ~408 | -2% |
| ~35 | ~84 | -58% |
| ~881 | - | - |
Configuration
The Quick Start config gives you every tool.
Production safety
Every org tool reads the org's type, and a --deny-orgs type: entry can refuse any of them. Only the two tools that change an org - apexlog_execute_anonymous and apexlog_create_trace_flag - use the type to decide whether to ask first:
Org type | Identified by | Behaviour |
|
| Runs |
|
| Runs |
| Not a sandbox, has a trial expiry | Runs |
| Developer Edition | Runs |
| Anything else | Confirmation required |
| The org could not be queried | Confirmation required |
For a production org, --allow-production-orgs skips the confirmation. Otherwise the server asks you to confirm, naming the org and what the call would do - for Apex, all of it with its size. Apex over 10,000 characters is refused rather than cut, so it needs the flag. Confirmation needs a client that supports elicitation; without one the call is refused, and the message names both ways to proceed. Each confirmation authorizes one call, and expires 10 minutes after the server asks.
Deny lists
Org type says nothing about whose data an org holds: a customer sandbox runs with no prompt. --deny-orgs refuses an org outright.
"args": [
"-y",
"@certinia/apex-log-mcp",
"--deny-orgs",
"prod-*-org@mycompany.com,acme--*,type:production"
]An entry matches the org id, username, alias or instance URL. * is a glob, and the match is anchored and ignores case, so prod-*@acme.com denies prod-eu@acme.com and not xprod-eu@acme.com. A deny on any alias of a username holds, whichever name the agent uses. Every value comes from the local sf files, so the server refuses a named org before it connects to it.
An org id matches in its 15- or 18-char form, whatever its case. An instance URL matches by its host, so acme--* denies every sandbox of the acme My Domain.
A type: entry denies a type from the table above, e.g. type:sandbox. type:production also denies an org whose type cannot be read, because the server treats that org as production. The server contacts the org before it refuses on type: it connects, and it queries the org type. No Apex runs and no record is written. A type: entry that names no org type stops the server.
Nothing lifts a deny - not --allow-production-orgs, not a confirmation. The refusal names what matched.
A --deny-orgs entry covers every org tool, since a log holds the org's data. --deny-orgs '*' refuses them all, and the analysis tools keep working.
--deny-org-writes takes the same entries, but refuses only the tools that change an org: apexlog_execute_anonymous and apexlog_create_trace_flag. The org log tools can still read that org. Use it for an org whose logs you need but must not change, such as a shared UAT sandbox. --deny-org-writes type:production refuses every write to production, and the server does not ask for a confirmation.
Only the org id is unspoofable. An alias can be re-pointed, so treat the rest as convenience, not a security boundary.
Server flags
Flag | Description |
| Run against production orgs, and orgs whose type cannot be read, with no confirmation. A |
| Refuse every Apex execution. The tool stays visible, without its parameters, so agents know it exists. Every other tool still works, |
| Refuse every tool that changes an org: |
| Refuse these orgs. See Deny lists. |
| Refuse the tools that change these orgs. The org log tools can still read them. See Deny lists. |
To stop Apex running, add the flag to the Quick Start args:
"args": ["-y", "@certinia/apex-log-mcp", "--no-apex-execution"]Documentation
Contributing
See the Contributing Guide, Developing to set up your environment, and the Code of Conduct.
License
BSD 3-Clause. Copyright © Certinia Inc. All rights reserved.
Available Tools
8 toolsapexlog_create_trace_flagCreate Trace FlagA
Trace a user, class or trigger in a Salesforce org until the trace flag expires. A user's flag stores each transaction they run as a debug log, which can fill log storage; a class or trigger flag only sets that code's levels. Refused if a flag of its log type overlaps the new one. Leaves a debug level in the org.
Inputs: tracedEntity (required), targetOrg, debugLevel, durationMinutes.
apexlog_execute_anonymousExecute Anonymous ApexADestructive
Execute anonymous Apex in a Salesforce org as the targetOrg user; DML commits unless the run fails. Saves the debug log and returns its path for the analysis tools. With no active trace flag, adds one for the run, deleted after, and a debug level, left in the org.
Inputs: apex, outputDir, targetOrg, debugLevel, +1 more.
apexlog_get_org_logsGet Org Debug LogsA
Download debug logs from a Salesforce org, by id or the newest N, and return each saved file's path, which the analysis tools accept.
Inputs: ids, latest, outputDir, targetOrg.
apexlog_get_summaryGet Apex Log SummaryARead-only
Get a high-level summary of an Apex debug log: how long the transaction ran, where the time went by debug log category and the level each was logged at, every governor limit it and each namespace consumed, whether the log is complete, the exceptions and flow errors it raised, and what ended the transaction if it failed. Best for a quick overview.
Inputs: logFilePath (required).
apexlog_list_limit_risksList Apex Log Limit RisksARead-only
List the governor limits an Apex log transaction has nearly used up - CPU time, heap, SOQL queries and rows, SOSL queries, DML statements and rows, callouts and every other limit - worst first, with how much of each was used
Inputs: logFilePath (required), threshold.
apexlog_list_org_logsList Org Debug LogsARead-only
List the debug logs stored in a Salesforce org, with how many match. Pass ids to apexlog_get_org_logs to download them.
Inputs: user, limit, cursor, sortBy, +7 more.
apexlog_list_slow_operationsList Slow Apex Log OperationsARead-only
Rank what an Apex debug log spent its time on by self-execution time, or on the heap it retains - code units, methods, queries, searches, DML, callouts, flows and workflows in one table, each row with its calls, durations, database counts and rows, so the caller can see what to optimize and why, beside the query optimizer's plan for the queries among them.
Inputs: logFilePath (required), type, limit, offset, +5 more.
apexlog_search_eventsSearch Apex Log EventsARead-only
Search the events of an Apex debug log in log order: what the code printed (USER_DEBUG), validation rules, statements, or every event under one method. For plain text in the saved .log, grep is cheaper; use this for event types, nesting, or without a shell. Text past 400 characters is elided; ask for one event by eventId to read up to 30,000.
Inputs: logFilePath (required), type, limit, offset, +4 more.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 8 tools
Most tools have clearly distinct purposes, and the list/get log pair is explicitly linked in the descriptions (list ids, then download with get_org_logs). The only real overlap is between get_summary and list_limit_risks, since the summary already reports consumed governor limits while list_limit_risks reports the same limits worst-first; the boundary is workable but not crisp.
All eight tools use the same apexlog_ prefix followed by a verb_noun snake_case form (create_trace_flag, search_events, list_org_logs, get_summary, list_limit_risks). Verbs (create, search, list, execute, get) are used consistently with their meaning.
Eight tools is well within the ideal 3-15 range for a focused log-analysis server. Each tool maps to a distinct step in the workflow: capture a log, fetch it, then analyze it from four different angles.
The read/analysis side is thorough (list, download, summary, events, limits, slow operations), but the write side is one-directional: there is create_trace_flag with no delete, list, or update counterpart, and the server explicitly leaves debug levels in the org with no tool to manage or remove them. Log deletion is also absent, leaving lifecycle cleanup as a dead end.
Maintenance
Related MCP Connectors
The Polar Signals MCP server enables AI assistants to connect directly with performance profiling data, allowing users to analyze application performance through natural language queries. Key capabilities include querying CPU performance and memory usage, exploring profiling metadata like profile types and labels, and providing AI-driven code optimization suggestions directly within development environments like Claude Code or Cursor.
MCP server for building and testing AI agents with multi-model experimentation and insights.
MCP server that lets your AI assistant build and deploy apps, hosting each one at a live URL.
MCP server for Sentry - error monitoring, issue tracking, and debugging for AI assistants
Related MCP Servers
- AlicenseAqualityDmaintenanceAn MCP server for AI-powered log analysis that enables parsing, searching, and debugging across nine log formats directly within Claude. It features automated error extraction, sensitive data scanning, and streaming support for large log files.1467 PyPI5MIT
- AlicenseNot gradedqualityCmaintenanceAn MCP server that provides AI assistants with direct access to application logs for on-demand searching, filtering, and analysis. It enables tools like Cursor to summarize log entries and identify errors within the development environment to streamline debugging.19 npm6MIT
- AlicenseNot gradedqualityDmaintenanceMCP server that analyzes AI agent session logs to find token waste and optimization opportunities.7 npmMIT

flyto-indexerofficial
AlicenseNot gradedqualityAmaintenanceMCP server that gives AI assistants impact analysis, cross-project reference tracking, and code health scoring.172 PyPI4Apache 2.0