More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    fluxometer

    1

    Find and fix JS/TS performance bottlenecks and AI cost spikes using local Postgres metrics and MCP.

    Free

    Security scanned
    fluxometer

    fluxometer

    Example session with this skill installed

    What should I look at today in terms of performance and bottlenecks?

    • Read your context and instructions
    • Compiled the fluxometer

    I queried the fluxometer metrics for the last 24 hours. I found

    2 issues requiring attention, mainly AI processing latency and a recent regression in the project module.

    (Example output: routes and numbers are illustrative.)

    Performance analysis

    ruleIdSubjectSummarySuggestion
    slow_routePOST /tasks/ai-parseRoute is slow (p95 3800ms)Heavy work inside the request; move it to a background queue.
    regressionGET /projects/:idp95 up 35% vs last weekCheck the git log for recent changes in the project controller.

    The slow_route on /tasks/ai-parse is the top priority: it is far above the 800 ms threshold, most likely because of a synchronous AI call inside the request. slow_query did not fire. That usually means no query averaged over 200 ms, but it also stays silent if pg_stat_statements isn't available on your Postgres, so it's worth confirming the extension is enabled.

    Next steps

    1. Review src/routes/tasks.ts to find where the AI parsing can be deferred to a worker.
    2. Compare src/controllers/projectController.ts with the version from 7 days ago to find the regression cause.
    3. Note today's p95 of 3800 ms for /tasks/ai-parse so you can verify the fix after the next deploy.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Identifying performance regressions and cost spikes in Node.js applications usually requires expensive SaaS subscriptions and complex dashboards. This skill lets you diagnose bottlenecks directly from your terminal or editor, using a local MCP server that queries your own database. No data leaves your infrastructure.

    Free and open source (MIT), built and maintained by Allan Monteiro at DesenvBR Group (https://desenvbr.com). Source, issues and docs: https://github.com/allanaramont/fluxometer · npm: https://www.npmjs.com/package/fluxometer

    What it does

    • Diagnose bottlenecks by running 12 deterministic rules over request, query and AI-call metrics.
    • Detect regressions by comparing p95 latency with the same window last week, and the 2 hours after a deploy with the 2 hours before.
    • Audit AI costs to spot spend spikes and high failure rates in LLM integrations.
    • Find slow queries using pg_stat_statements to suggest missing indexes or N+1 fixes.
    • Pinpoint error spikes, timeouts, platform-specific failures and peak-hour issues.

    How it works

    1. Install with npm install fluxometer, then run npx fluxometer init to set up a dedicated Postgres schema and a read-only role.
    2. Instrument the app by adding the middleware for Express, Fastify or Next.js (or the generic track API) to record requests and AI calls.
    3. Connect the MCP server (npx fluxometer mcp) using the generated read-only database URL.
    4. Ask your agent what to look at today: it calls whatShouldILookAtToday and this skill tells it what each rule means and where to look in your code.

    Frameworks & tools

    Node.js 18+, TypeScript/JavaScript and PostgreSQL. Native support for Express, Fastify and Next.js. Works with MCP clients like Claude Code and Cursor.

    Why this beats prompting it yourself

    Generic AI agents can't see your application's internal metrics or database statistics. This skill gives them a secure, read-only interface to deterministic performance data, so suggestions are based on actual traffic rather than guesses.

    Use cases

    • Find which database queries need an index after a traffic surge.
    • Check whether a recent deployment caused a latency regression in specific API routes.
    • Find out why AI provider costs went up without opening external dashboards.
    • Debug why one mobile platform has a higher 5xx rate than web.

    Data and network

    Metrics stay in a fluxometer schema in your own Postgres: route templates (never real IDs), status, duration, platform, a hashed user ID and AI call metadata. No names, e-mails, request bodies or prompts. The only outbound call is the optional daily Slack webhook you configure. No telemetry.

    Known limitations

    Doesn't support non-Postgres databases or frontend-only metrics like Lighthouse scores. Rules run over 24-hour and 7-day windows, so it isn't meant for real-time alerting; week-over-week rules need about 8 days of data. slow_query needs pg_stat_statements, which some managed Postgres plans don't expose.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for LLM Ops.

    Requires Postgres with pg_stat_statements for query analysis. Week-over-week rules require 8 days of data. Not for real-time alerts; rules run over 24h/7d windows. No frontend-only metrics.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before buying a skill.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Free to use

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 12 days ago

    • Free with an Agensi account

    Software
    Node.jsGitPostgreSQLfluxometer (npm package and MCP server)

    Permissions

    Terminal / Shell
    Network Access
    Read Files
    Write Files
    Environment Variables

    Terminal: runs npx fluxometer init / mcp / rotate. Read and write files: adds the middleware to the app and merges variables into .env. Environment variables: reads DATABASE_URL and FLUXOMETER_READONLY_URL. Network: connects to the user's own Postgres; the only outbound HTTP call is the optional Slack webhook the user configures, from the daily report route. No telemetry.

    Listed12 days ago
    Updated10 days ago

    What's inside

    Frequently Asked Questions

    Fluxometer analyzes your application's actual request and AI-call metrics stored in your local Postgres database to identify p95 latency regressions, N+1 query patterns, and LLM cost spikes. Unlike generic prompts, it uses deterministic rules to provide evidence-based fixes for your specific codebase.

    Fluxometer is a Model Context Protocol (MCP) server that works with any MCP-compatible environment, including Claude Code, Cursor, and Windsurf. It requires a Node.js 18+ environment and a PostgreSQL database.

    Setup involves three steps: running a simple initialization command to create a read-only database schema, adding a middleware package to your Node.js app (Express, Fastify, or Next.js), and connecting the MCP server to your editor using a database URL.

    No, Fluxometer is designed for privacy and security. It queries your metrics locally via a read-only database role and does not send your raw database records to external SaaS platforms or cloud dashboards.

    Fluxometer specializes in server-side Node.js metrics and PostgreSQL database performance. It does not currently track frontend-specific metrics like Core Web Vitals or Lighthouse scores, nor does it support non-Postgres databases like MongoDB or MySQL.

    It's free. This listing is the SKILL.md that teaches your agent when and how to use fluxometer. The tool itself (MCP server, Express/Fastify/Next.js middleware and setup CLI) is the free, MIT-licensed npm package fluxometer: install it with npm install fluxometer and update it like any other npm dependency. Releases and changelog: https://github.com/allanaramont/fluxometer

    New in LLM Ops

    Free