Plugins Overview

Extend FrontMCP servers with cross-cutting capabilities using plugins

Plugins are powerful components that add cross-cutting functionality to your MCP servers. Instead of implementing features like caching, authentication, or observability in every tool, plugins provide reusable capabilities that work across all your tools and apps.

Why Use Plugins?

Zero Duplication

Add capabilities like caching or code execution once and apply them to all tools automatically.

Composable

Mix and match plugins to build exactly the features you need without coupling.

Cross-App

Plugins work across all apps in your server, providing consistent behavior everywhere.

Production-Ready

Battle-tested implementations for common needs like caching, rate limiting, and monitoring.

Official Plugins

These plugins are maintained by the FrontMCP team and included in @frontmcp/plugins.

Remember Plugin

Encrypted session memory with scoped storage and tool approval system for secure AI agent interactions.

Features:

• Encrypted AES-256-GCM storage with HKDF-SHA256 scope-based key derivation and unique IV per entry
• Multiple scopes: session, user, tool, global
• Tool approval system with audit trails
• Multiple backends: Memory, Redis, Vercel KV, Upstash
• Branded payloads for semantic categorization

Best for: Session memory, user preferences, tool permissions, conversation context

CodeCall Plugin

Hide large toolsets behind a code-first meta-API. Instead of exposing hundreds of tools directly, CodeCall provides search, describe, and execute capabilities that let models write JavaScript plans to orchestrate your tools.

Features:

• Search and discover tools dynamically
• Generate JavaScript execution plans
• Defense-in-depth security with Enclave (AST validation + runtime sandboxing)
• Multi-app tool orchestration
• Direct invocation mode for simple cases

Best for: Large toolsets, OpenAPI-generated tools, multi-app workflows, complex tool orchestration

Cache Plugin

Transparently cache tool responses to reduce redundant computation and improve response times. Works with both in-memory and Redis backends.

Features:

• Deterministic input-based cache keys
• Configurable TTL per tool
• Sliding window for hot data
• Redis support for multi-instance deployments
• Opt-in per-tool caching

Best for: Expensive computations, API rate limiting, multi-tenant data, frequently accessed resources

More official plugins are coming soon! Rate limiting, observability, and validation plugins are in development.

Community Plugins

Community plugins are created and maintained by the FrontMCP community. While not officially supported, they extend FrontMCP’s capabilities with specialized features.

Community plugins are not maintained by the FrontMCP team. Please review the code and security practices before using them in production.

How to Find Community Plugins

1. Search npm

   Search for packages tagged with frontmcp-plugin or mcp-plugin:

   npm search frontmcp-plugin
   
2. Check GitHub Topics

   Browse repositories tagged with frontmcp-plugin on GitHub.

3. Join the Community

   Visit the FrontMCP Discussions to discover and share plugins.

Featured Community Plugins

This section is for community-contributed plugins. If you’ve created a plugin, submit a PR to add it here!

Submit Your Plugin

Created a plugin? Share it with the community! Submit a PR to add your plugin to this page.

Plugin Template

Use the official plugin structure as a template for building your own plugins.

Creating Custom Plugins

You can create custom plugins to add any cross-cutting capability to FrontMCP. Plugins use the @Plugin decorator, extend DynamicPlugin, and hook into the tool execution lifecycle via @ToolHook decorators.

Basic Plugin Structure

import { DynamicPlugin, Plugin, ToolHook, FlowCtxOf } from '@frontmcp/sdk';

@Plugin({
  name: 'my-plugin',
  description: 'My custom plugin',
})
export default class MyCustomPlugin extends DynamicPlugin {
  // Runs BEFORE tool execution
  @ToolHook.Will('execute', { priority: 1000 })
  async beforeExecute(flowCtx: FlowCtxOf<'tools:call-tool'>) {
    const { tool, toolContext } = flowCtx.state;
    if (!tool || !toolContext) return;
    console.log(`About to execute tool: ${tool.fullName}`);
  }

  // Runs AFTER tool execution
  @ToolHook.Did('execute', { priority: 1000 })
  async afterExecute(flowCtx: FlowCtxOf<'tools:call-tool'>) {
    const { tool, toolContext } = flowCtx.state;
    if (!tool || !toolContext) return;
    console.log(`Tool ${tool.fullName} completed`);
  }
}

Plugin Best Practices

1. Minimal Overhead

• Keep plugin logic lightweight
• Avoid blocking operations in hooks
• Use async operations efficiently
• Cache expensive computations
• Consider performance impact on every tool call

2. Error Handling

• Always handle errors gracefully
• Provide clear error messages
• Don’t swallow errors silently
• Log failures appropriately
• Consider fallback strategies

3. Configuration

• Support both plugin-level and tool-level configuration
• Provide sensible defaults
• Make features opt-in when possible
• Document all configuration options
• Validate configuration at initialization

4. Composability

• Don’t assume other plugins are present
• Avoid global state
• Use dependency injection for shared resources
• Document plugin interactions
• Test with common plugin combinations

5. Documentation

• Provide clear usage examples
• Document hooks and lifecycle
• Explain performance characteristics
• Include migration guides
• Show integration with common tools

Publishing Your Plugin

When publishing a community plugin:

1. Package Name: Use the pattern @yourscope/frontmcp-plugin-name or frontmcp-plugin-name
2. Keywords: Include frontmcp, frontmcp-plugin, mcp, plugin
3. README: Include installation, usage, examples, and performance considerations
4. License: Use a permissive license (MIT, Apache 2.0, etc.)
5. Tests: Include comprehensive test coverage including hook behavior
6. TypeScript: Provide TypeScript types and declarations

package.json

{
  "name": "@yourscope/frontmcp-plugin-myfeature",
  "version": "1.0.0",
  "description": "FrontMCP plugin for MyFeature",
  "keywords": ["frontmcp", "frontmcp-plugin", "mcp", "plugin", "myfeature"],
  "peerDependencies": {
    "@frontmcp/sdk": "^0.4.0"
  }
}

Plugin Comparison

Choose the right plugin for your use case:

Plugin	Best For	Overhead	Scope	Complexity
Remember	Session memory, approvals	Low	Per-session	Low
CodeCall	Large toolsets, workflows	Low	Cross-app	Medium
Cache	Expensive operations	Minimal	Per-tool	Low
Custom	Any cross-cutting feature	Varies	Configurable	Medium-High

Next Steps

Remember Plugin

Learn how to use session memory and approvals

CodeCall Plugin

Learn how to use the CodeCall plugin

Cache Plugin

Learn how to use the Cache plugin

Join Community

Get help and share your plugins

Resources

SDK Documentation

Learn about the FrontMCP SDK and plugin interfaces

Source Code

View the official plugins source code

npm Package

Install the official plugins package

Contributing Guide

Contribute to FrontMCP plugins

Related Guides

Enclave

Secure code execution with Enclave (available as a separate repository)

AST Guard

AST validation and security rules (available as a separate repository)