Polar Signals MCP

@polar-signals show me CPU profiling data for the checkout service over the last hour

Based on recent profiling data, the checkout service spent 42% of CPU time in database query execution, 28% in JSON serialization, and 18% in authentication middleware. The top function by self-time was `validatePaymentToken()` at 8.3% CPU. Peak usage occurred at 14:23 UTC with 89% utilization across 4 cores. This is illustrative output reflecting typical continuous profiling metrics.

This example shows how the MCP surfaces performance bottlenecks from continuous profiling. Requires API key with read access to profiling data. The granularity and retention window depend on your Polar Signals plan — free tiers may have limited historical data.

@polar-signals compare memory allocation patterns between version 2.1.4 and 2.1.5 of the API gateway

Version 2.1.5 shows a 34% increase in heap allocations in the request routing layer compared to 2.1.4. The `parseHeaders()` function now allocates 2.1 MB per 1000 requests versus 1.6 MB previously. Garbage collection frequency increased from every 8.2 seconds to every 5.7 seconds under equivalent load. This comparison reflects how profiling data would highlight regression patterns between deployments.

Demonstrates version-to-version analysis for performance regression detection. Requires both versions to have been profiled during their runtime. The MCP can only compare data that exists in your Polar Signals account — ensure continuous profiling was active during both deployments.

@polar-signals identify which microservices are causing the most lock contention in production right now

Current lock contention analysis shows the inventory-service leads with 127 ms average wait time on `stockMutex`, affecting 23% of requests. The order-processor follows at 89 ms on database connection pooling locks. The user-session service shows minimal contention at 4 ms. These figures illustrate how real-time profiling data would surface concurrency bottlenecks across your service mesh.

This synthesis example pairs profiling metrics with AI reasoning to prioritize optimization work. Accuracy depends on profiling agent coverage — services without instrumentation won't appear. Lock contention visibility requires profilers that capture synchronization primitives, which may need specific configuration.

When continuous profiling beats ad-hoc debugging for small teams

A 3-engineer backend team ships a new feature and latency spikes 40% in production. Without profiling data, they're guessing which service is the bottleneck. Polar Signals MCP gives them CPU and memory profiles across their entire stack without redeploying or adding instrumentation. The team can ask Switchy to compare profiles before and after the deploy, identify the hot path, and link it to the commit that introduced the regression. This works best when you're already running Polar Signals' agent in production—if you're not collecting profiles yet, the MCP has nothing to query. For teams under 10 engineers who treat performance as a first-class concern, this turns profiling from a specialist skill into a standup conversation.

Profiling data surfaces compute waste faster than dashboards alone

A 15-person SaaS team is burning $8k/month on cloud compute and needs to cut 30% before next quarter. Their observability stack shows which services are expensive, but not why. Polar Signals MCP lets them query flame graphs and CPU profiles directly from Switchy, asking questions like 'which functions are using the most CPU in our billing service' or 'where are we allocating memory we don't need'. The MCP requires API key auth, so any team member with Polar Signals access can run these queries without SSHing into servers or learning pprof syntax. This scenario assumes you're already profiling continuously—if you only profile on-demand, the MCP's value drops to near zero. Best fit: teams with steady production load who want profiling to be a shared capability, not a DevOps bottleneck.

Live profiling queries during outages when every second counts

A 6-person on-call rotation is managing a customer-facing API that serves 2 million requests per day. When an incident fires at 2am, the engineer on duty needs to know if the problem is a code regression, a dependency, or infrastructure. Polar Signals MCP lets them pull live profiling data into Switchy and ask 'what changed in the last hour' or 'which goroutines are blocked right now' without switching tools or waiting for a senior engineer to interpret flame graphs. The trade-off: this only helps if your profiling agent is already deployed and collecting data in real time. If you're profiling manually or only in staging, the MCP won't have the data you need when the pager goes off. For teams running continuous profiling in production, this turns incident response from a specialist task into a shared capability across the rotation.