Skill UI

This comprehensive workflow manages the entire lifecycle of notes within Evernote. It provides structured methods for creating new notes (supporting plain text, checklists, and ENML formatting), retrieving existing content, updating notes, and organizing both notes and notebooks/stacks. Essential for building full-featured note-taking applications and content management systems.

This bundle collects comprehensive diagnostic evidence for Langfuse support tickets and troubleshooting. It gathers system environment details (Node.js, Python, OS), installed SDK versions, API connectivity status, and redacted application logs. Use this when encountering persistent or complex Langfuse issues to provide full context to support teams.

Used for building, debugging, and extending MCP servers and clients. This skill implements robust connections between AI systems and external tools/data sources using structured protocols like JSON-RPC 2.0. Expertise includes defining tool schemas (Zod/Pydantic), configuring transport layers (HTTP/SSE/stdio), and scaffolding full-stack projects in TypeScript or Python.

This skill provides a comprehensive walkthrough for setting up and testing Sentry error monitoring using both Node.js and Python SDKs. It demonstrates how to capture various event types, including simple messages and full exceptions, and crucially, how to enrich these events with user context, searchable tags, and detailed breadcrumbs. This is essential for verifying robust error logging and monitoring in a production environment.

This skill guides you through advanced integration patterns to connect Sentry with your full observability stack. Learn how to correlate error events from structured loggers (like Winston/Pino) using Event IDs, track business metrics (counters, gauges) within Sentry, and link performance data across multiple tools (Grafana, Datadog). Achieve end-to-end visibility, ensuring every error is tied back to its root cause and business context.

A lightweight integration providing full read/write access to Google Slides presentations. This tool allows users to programmatically create, inspect, modify, and extract content (including text and tables) from Google Workspace documents. Perfect for local automation tasks requiring full control over presentation structure and content without needing a dedicated server.

Allows users to resume an interrupted or paused autoresearch experiment. It automatically loads the full context, including configuration, strategy files, complete results history, and recent code changes. The system then summarizes the current best metrics and patterns, prompting the user to continue with a single iteration, set up an automated loop, or manually review the results.

This skill provides a robust system for tracking all code modifications using structured JSON records and enforcing a defined state machine (e.g., planned -> deployed). It is critical for AI coding workflows, ensuring that if a session expires or is abandoned, the next session receives the full context, progress summary, and blockers to resume seamlessly. Ideal for complex, multi-stage development projects and onboarding new codebases.

samber/oops is a robust library that transforms standard Go error handling by adding crucial structured context. Instead of generic error messages, it allows developers to attach key-value attributes, stack traces, error codes, and user-facing messages directly to the error object. This is essential for modern microservices, allowing APM tools (Datadog, Sentry) and on-call engineers to diagnose failures accurately by understanding the full context of the failure, such as the domain, user ID, and specific query that failed.

This tool generates a comprehensive context map of a codebase before making any modifications. It guides developers to systematically analyze all relevant files, dependencies, existing tests, and common patterns. Use it to assess the full scope of a task, identify potential breaking changes, and ensure a robust and stable development cycle.

This generator provides a comprehensive, production-ready template for building a Model Context Protocol (MCP) server using Kotlin. It sets up the full Gradle structure, integrates essential dependencies (MCP SDK, Ktor, Coroutines), and includes robust placeholders for custom tools, error handling, and testing, accelerating the development of context-aware backend services.

This tool scaffolds a complete, production-ready Model Context Protocol (MCP) server project written in Rust. It utilizes the official `rmcp` SDK to ensure full compatibility. The generated structure includes modules for handling logic, defining tools, managing prompts, and providing resources. Users can configure different transports (stdio, SSE, HTTP) and immediately run the server for integration testing or production use.