Prompts on Producthunt daily

BlackFriday-GPTs-Prompts

Wed, 11 Jun 2025 15:29:03 +0800

friuns2/BlackFriday-GPTs-Prompts

GPTs Prompts And Jailbreaks

Meet AiDark.net the world’s first fully autonomous AI software engineer. Devin is a tireless, skilled teammate, equally ready to build alongside you or independently complete tasks for you to review.

https://github.com/friuns2/BlackFriday-GPTs-Prompts/assets/16543239/81f01fd1-9dca-4730-8d42-8690f83b75be

All Prompts can be used in GPTOS

https://github.com/friuns2/BlackFriday-GPTs-Prompts/assets/16543239/c172af20-9bd6-4fb3-a717-16ff4f822056

Demo Videos

Android self-coding app builder | 01 mobile first try: https://youtube.com/clip/UgkxNbTCRWGeiOCQUhcm1KNW_izCP_-64-h8

ruby-sdk

Fri, 06 Jun 2025 15:29:47 +0800

modelcontextprotocol/ruby-sdk

MCP Ruby SDK

The official Ruby SDK for Model Context Protocol servers and clients.

Installation

Add this line to your application’s Gemfile:

`1`	`gem 'mcp'`

And then execute:

`1`	`$ bundle install`

Or install it yourself as:

`1`	`$ gem install mcp`

MCP Server

The MCP::Server class is the core component that handles JSON-RPC requests and responses. It implements the Model Context Protocol specification, handling model context requests and responses.

Key Features

Implements JSON-RPC 2.0 message handling
Supports protocol initialization and capability negotiation
Manages tool registration and invocation
Supports prompt registration and execution
Supports resource registration and retrieval

Supported Methods

initialize - Initializes the protocol and returns server capabilities
ping - Simple health check
tools/list - Lists all registered tools and their schemas
tools/call - Invokes a specific tool with provided arguments
prompts/list - Lists all registered prompts and their schemas
prompts/get - Retrieves a specific prompt by name
resources/list - Lists all registered resources and their schemas
resources/read - Retrieves a specific resource by name
resources/templates/list - Lists all registered resource templates and their schemas

Unsupported Features ( to be implemented in future versions )

Notifications
Log Level
Resource subscriptions
Completions
Complete StreamableHTTP implementation with streaming responses

Usage

Rails Controller

When added to a Rails controller on a route that handles POST requests, your server will be compliant with non-streaming StreamableHTTP transport requests.

You can use the Server#handle_json method to handle requests.

class ApplicationController < ActionController::Base

  def index
    server = MCP::Server.new(
      name: "my_server",
      version: "1.0.0",
      tools: [SomeTool, AnotherTool],
      prompts: [MyPrompt],
      server_context: { user_id: current_user.id },
    )
    render(json: server.handle_json(request.body.read))
  end
end

Stdio Transport

If you want to build a local command-line application, you can use the stdio transport:

#!/usr/bin/env ruby
require "mcp"
require "mcp/server/transports/stdio_transport"

# Create a simple tool
class ExampleTool < MCP::Tool
  description "A simple example tool that echoes back its arguments"
  input_schema(
    properties: {
      message: { type: "string" },
    },
    required: ["message"]
  )

  class << self
    def call(message:, server_context:)
      MCP::Tool::Response.new([{
        type: "text",
        text: "Hello from example tool! Message: #{message}",
      }])
    end
  end
end

# Set up the server
server = MCP::Server.new(
  name: "example_server",
  tools: [ExampleTool],
)

# Create and start the transport
transport = MCP::Server::Transports::StdioTransport.new(server)
transport.open

You can run this script and then type in requests to the server at the command line.

1
2
3

$ ./examples/stdio_server.rb
{"jsonrpc":"2.0","id":"1","method":"ping"}
{"jsonrpc":"2.0","id":"2","method":"tools/list"}

Configuration

The gem can be configured using the MCP.configure block:

MCP.configure do |config|
  config.exception_reporter = ->(exception, server_context) {
    # Your exception reporting logic here
    # For example with Bugsnag:
    Bugsnag.notify(exception) do |report|
      report.add_metadata(:model_context_protocol, server_context)
    end
  }

  config.instrumentation_callback = ->(data) {
    puts "Got instrumentation data #{data.inspect}"
  }
end

or by creating an explicit configuration and passing it into the server. This is useful for systems where an application hosts more than one MCP server but they might require different instrumentation callbacks.

configuration = MCP::Configuration.new
configuration.exception_reporter = ->(exception, server_context) {
  # Your exception reporting logic here
  # For example with Bugsnag:
  Bugsnag.notify(exception) do |report|
    report.add_metadata(:model_context_protocol, server_context)
  end
}

configuration.instrumentation_callback = ->(data) {
  puts "Got instrumentation data #{data.inspect}"
}

server = MCP::Server.new(
  # ... all other options
  configuration:,
)

Server Context and Configuration Block Data

`server_context`

The server_context is a user-defined hash that is passed into the server instance and made available to tools, prompts, and exception/instrumentation callbacks. It can be used to provide contextual information such as authentication state, user IDs, or request-specific data.

Type:

`1`	`server_context: { [String, Symbol] => Any }`

Example:

server = MCP::Server.new(
  name: "my_server",
  server_context: { user_id: current_user.id, request_id: request.uuid }
)

This hash is then passed as the server_context argument to tool and prompt calls, and is included in exception and instrumentation callbacks.

Configuration Block Data

Exception Reporter

The exception reporter receives:

exception: The Ruby exception object that was raised
server_context: The context hash provided to the server

Signature:

`1`	`exception_reporter = ->(exception, server_context) { ... }`

Instrumentation Callback

The instrumentation callback receives a hash with the following possible keys:

method: (String) The protocol method called (e.g., “ping”, “tools/list”)
tool_name: (String, optional) The name of the tool called
prompt_name: (String, optional) The name of the prompt called
resource_uri: (String, optional) The URI of the resource called
error: (String, optional) Error code if a lookup failed
duration: (Float) Duration of the call in seconds

Type:

1
2

instrumentation_callback = ->(data) { ... }
# where data is a Hash with keys as described above

Example:

1
2
3

config.instrumentation_callback = ->(data) {
  puts "Instrumentation: #{data.inspect}"
}

Server Protocol Version

The server’s protocol version can be overridden using the protocol_version class method:

`1`	`MCP::Server.protocol_version = "2024-11-05"`

This will make all new server instances use the specified protocol version instead of the default version. The protocol version can be reset to the default by setting it to nil:

`1`	`MCP::Server.protocol_version = nil`

Be sure to check the MCP spec for the protocol version to understand the supported features for the version being set.

Exception Reporting

The exception reporter receives two arguments:

exception: The Ruby exception object that was raised
server_context: A hash containing contextual information about where the error occurred

The server_context hash includes:

For tool calls: { tool_name: "name", arguments: { ... } }
For general request handling: { request: { ... } }

When an exception occurs:

The exception is reported via the configured reporter
For tool calls, a generic error response is returned to the client: { error: "Internal error occurred", isError: true }
For other requests, the exception is re-raised after reporting

If no exception reporter is configured, a default no-op reporter is used that silently ignores exceptions.

Tools

MCP spec includes Tools which provide functionality to LLM apps.

This gem provides a MCP::Tool class that can be used to create tools in two ways:

As a class definition:

class MyTool < MCP::Tool
  description "This tool performs specific functionality..."
  input_schema(
    properties: {
      message: { type: "string" },
    },
    required: ["message"]
  )
  annotations(
    title: "My Tool",
    read_only_hint: true,
    destructive_hint: false,
    idempotent_hint: true,
    open_world_hint: false
  )

  def self.call(message:, server_context:)
    MCP::Tool::Response.new([{ type: "text", text: "OK" }])
  end
end

tool = MyTool

By using the MCP::Tool.define method with a block:

tool = MCP::Tool.define(
  name: "my_tool",
  description: "This tool performs specific functionality...",
  annotations: {
    title: "My Tool",
    read_only_hint: true
  }
) do |args, server_context|
  Tool::Response.new([{ type: "text", text: "OK" }])
end

The server_context parameter is the server_context passed into the server and can be used to pass per request information, e.g. around authentication state.

Tool Annotations

Tools can include annotations that provide additional metadata about their behavior. The following annotations are supported:

title: A human-readable title for the tool
read_only_hint: Indicates if the tool only reads data (doesn’t modify state)
destructive_hint: Indicates if the tool performs destructive operations
idempotent_hint: Indicates if the tool’s operations are idempotent
open_world_hint: Indicates if the tool operates in an open world context

Annotations can be set either through the class definition using the annotations class method or when defining a tool using the define method.

Prompts

MCP spec includes Prompts, which enable servers to define reusable prompt templates and workflows that clients can easily surface to users and LLMs.

The MCP::Prompt class provides two ways to create prompts:

As a class definition with metadata:

class MyPrompt < MCP::Prompt
  prompt_name "my_prompt"  # Optional - defaults to underscored class name
  description "This prompt performs specific functionality..."
  arguments [
    Prompt::Argument.new(
      name: "message",
      description: "Input message",
      required: true
    )
  ]

  class << self
    def template(args, server_context:)
      Prompt::Result.new(
        description: "Response description",
        messages: [
          Prompt::Message.new(
            role: "user",
            content: Content::Text.new("User message")
          ),
          Prompt::Message.new(
            role: "assistant",
            content: Content::Text.new(args["message"])
          )
        ]
      )
    end
  end
end

prompt = MyPrompt

Using the MCP::Prompt.define method:

prompt = MCP::Prompt.define(
  name: "my_prompt",
  description: "This prompt performs specific functionality...",
  arguments: [
    Prompt::Argument.new(
      name: "message",
      description: "Input message",
      required: true
    )
  ]
) do |args, server_context:|
  Prompt::Result.new(
    description: "Response description",
    messages: [
      Prompt::Message.new(
        role: "user",
        content: Content::Text.new("User message")
      ),
      Prompt::Message.new(
        role: "assistant",
        content: Content::Text.new(args["message"])
      )
    ]
  )
end

The server_context parameter is the server_context passed into the server and can be used to pass per request information, e.g. around authentication state or user preferences.

Key Components

Prompt::Argument - Defines input parameters for the prompt template
Prompt::Message - Represents a message in the conversation with a role and content
Prompt::Result - The output of a prompt template containing description and messages
Content::Text - Text content for messages

Usage

server = MCP::Server.new(
  name: "my_server",
  prompts: [MyPrompt],
  server_context: { user_id: current_user.id },
)

The server will handle prompt listing and execution through the MCP protocol methods:

prompts/list - Lists all registered prompts and their schemas
prompts/get - Retrieves and executes a specific prompt with arguments

Instrumentation

The server allows registering a callback to receive information about instrumentation. To register a handler pass a proc/lambda to as instrumentation_callback into the server constructor.

MCP.configure do |config|
  config.instrumentation_callback = ->(data) {
    puts "Got instrumentation data #{data.inspect}"
  }
end

The data contains the following keys: method: the metod called, e.g. ping, tools/list, tools/call etc tool_name: the name of the tool called prompt_name: the name of the prompt called resource_uri: the uri of the resource called error: if looking up tools/prompts etc failed, e.g. tool_not_found duration: the duration of the call in seconds

tool_name, prompt_name and resource_uri are only populated if a matching handler is registered. This is to avoid potential issues with metric cardinality

Resources

MCP spec includes Resources

The MCP::Resource class provides a way to register resources with the server.

resource = MCP::Resource.new(
  uri: "example.com/my_resource",
  mime_type: "text/plain",
  text: "Lorem ipsum dolor sit amet"
)

server = MCP::Server.new(
  name: "my_server",
  resources: [resource],
)

The server must register a handler for the resources/read method to retrieve a resource dynamically.

server.resources_read_handler do |params|
  [{
    uri: params[:uri],
    mimeType: "text/plain",
    text: "Hello, world!",
  }]
end

otherwise ‘resources/read’ requests will be a no-op.

Releases

This gem is published to RubyGems.org

Releases are triggered by PRs to the main branch updating the version number in lib/mcp/version.rb.

Update the version number in lib/mcp/version.rb, following semver
Create A PR and get approval from a maintainer
Merge your PR to the main branch - This will automatically trigger the release workflow via GitHub Actions

When changes are merged to the main branch, the GitHub Actions workflow (.github/workflows/release.yml) is triggered and the gem is published to RubyGems.

fastmcp

Mon, 21 Apr 2025 15:28:26 +0800

jlowin/fastmcp

FastMCP v2 🚀

The fast, Pythonic way to build MCP servers and clients.

The Model Context Protocol (MCP) is a new, standardized way to provide context and tools to your LLMs, and FastMCP makes building MCP servers and clients simple and intuitive. Create tools, expose resources, define prompts, and connect components with clean, Pythonic code.

# server.py
from fastmcp import FastMCP

mcp = FastMCP("Demo 🚀")

@mcp.tool()
def add(a: int, b: int) -> int:
    """Add two numbers"""
    return a + b

if __name__ == "__main__":
    mcp.run()

Run the server locally:

`1`	`fastmcp run server.py`

FastMCP handles the complex protocol details and server management, letting you focus on building great tools and applications. It’s designed to feel natural to Python developers.

What is MCP?

The Model Context Protocol (MCP) lets you build servers that expose data and functionality to LLM applications in a secure, standardized way. Think of it like a web API, but specifically designed for LLM interactions. MCP servers can:

Expose data through Resources (think GET endpoints; load info into context)
Provide functionality through Tools (think POST/PUT endpoints; execute actions)
Define interaction patterns through Prompts (reusable templates)
And more!

FastMCP provides a high-level, Pythonic interface for building and interacting with these servers.

Why FastMCP?

The MCP protocol is powerful but implementing it involves a lot of boilerplate - server setup, protocol handlers, content types, error management. FastMCP handles all the complex protocol details and server management, so you can focus on building great tools. It’s designed to be high-level and Pythonic; in most cases, decorating a function is all you need.

FastMCP aims to be:

🚀 Fast: High-level interface means less code and faster development

🍀 Simple: Build MCP servers with minimal boilerplate

🐍 Pythonic: Feels natural to Python developers

🔍 Complete: FastMCP aims to provide a full implementation of the core MCP specification for both servers and clients

Key Features

Servers

Create servers with minimal boilerplate using intuitive decorators
Proxy existing servers to modify configuration or transport
Compose servers by into complex applications
Generate servers from OpenAPI specs or FastAPI objects

Clients

Interact with MCP servers programmatically
Connect to any MCP server using any transport
Test your servers without manual intervention
Innovate with core MCP capabilities like LLM sampling

What’s New in v2?

FastMCP 1.0 made it so easy to build MCP servers that it’s now part of the official Model Context Protocol Python SDK! For basic use cases, you can use the upstream version by importing mcp.server.fastmcp.FastMCP (or installing fastmcp=1.0).

Based on how the MCP ecosystem is evolving, FastMCP 2.0 builds on that foundation to introduce a variety of new features (and more experimental ideas). It adds advanced features like proxying and composing MCP servers, as well as automatically generating them from OpenAPI specs or FastAPI objects. FastMCP 2.0 also introduces new client-side functionality like LLM sampling.

Documentation

📚 FastMCP’s documentation is available at gofastmcp.com.

Installation

We strongly recommend installing FastMCP with uv, as it is required for deploying servers via the CLI:

`1`	`uv pip install fastmcp`

Note: on macOS, uv may need to be installed with Homebrew (brew install uv) in order to make it available to the Claude Desktop app.

For development, install with:

# Clone the repo first
git clone https://github.com/jlowin/fastmcp.git
cd fastmcp
# Install with dev dependencies
uv sync

Quickstart

Let’s create a simple MCP server that exposes a calculator tool and some data:

# server.py
from fastmcp import FastMCP

# Create an MCP server
mcp = FastMCP("Demo")

# Add an addition tool
@mcp.tool()
def add(a: int, b: int) -> int:
    """Add two numbers"""
    return a + b

# Add a dynamic greeting resource
@mcp.resource("greeting://{name}")
def get_greeting(name: str) -> str:
    """Get a personalized greeting"""
    return f"Hello, {name}!"

You can install this server in Claude Desktop and interact with it right away by running:

`1`	`fastmcp install server.py`

Core Concepts

These are the building blocks for creating MCP servers, using the familiar decorator-based approach.

The `FastMCP` Server

The central object representing your MCP application. It handles connections, protocol details, and routing.

from fastmcp import FastMCP

# Create a named server
mcp = FastMCP("My App")

# Specify dependencies needed when deployed via `fastmcp install`
mcp = FastMCP("My App", dependencies=["pandas", "numpy"])

Tools

Tools allow LLMs to perform actions by executing your Python functions. They are ideal for tasks that involve computation, external API calls, or side effects.

Decorate synchronous or asynchronous functions with @mcp.tool(). FastMCP automatically generates the necessary MCP schema based on type hints and docstrings. Pydantic models can be used for complex inputs.

import httpx
from pydantic import BaseModel

class UserInfo(BaseModel):
    user_id: int
    notify: bool = False

@mcp.tool()
async def send_notification(user: UserInfo, message: str) -> dict:
    """Sends a notification to a user if requested."""
    if user.notify:
        # Simulate sending notification
        print(f"Notifying user {user.user_id}: {message}")
        return {"status": "sent", "user_id": user.user_id}
    return {"status": "skipped", "user_id": user.user_id}

@mcp.tool()
def get_stock_price(ticker: str) -> float:
    """Gets the current price for a stock ticker."""
    # Replace with actual API call
    prices = {"AAPL": 180.50, "GOOG": 140.20}
    return prices.get(ticker.upper(), 0.0)

Resources

Resources expose data to LLMs. They should primarily provide information without significant computation or side effects (like GET requests).

Decorate functions with @mcp.resource("your://uri"). Use curly braces {} in the URI to define dynamic resources (templates) where parts of the URI become function parameters.

# Static resource returning simple text
@mcp.resource("config://app-version")
def get_app_version() -> str:
    """Returns the application version."""
    return "v2.1.0"

# Dynamic resource template expecting a 'user_id' from the URI
@mcp.resource("db://users/{user_id}/email")
async def get_user_email(user_id: str) -> str:
    """Retrieves the email address for a given user ID."""
    # Replace with actual database lookup
    emails = {"123": "alice@example.com", "456": "bob@example.com"}
    return emails.get(user_id, "not_found@example.com")

# Resource returning JSON data
@mcp.resource("data://product-categories")
def get_categories() -> list[str]:
    """Returns a list of available product categories."""
    return ["Electronics", "Books", "Home Goods"]

Prompts

Prompts define reusable templates or interaction patterns for the LLM. They help guide the LLM on how to use your server’s capabilities effectively.

Decorate functions with @mcp.prompt(). The function should return the desired prompt content, which can be a simple string, a Message object (like UserMessage or AssistantMessage), or a list of these.

from fastmcp.prompts.base import UserMessage, AssistantMessage

@mcp.prompt()
def ask_review(code_snippet: str) -> str:
    """Generates a standard code review request."""
    return f"Please review the following code snippet for potential bugs and style issues:\n```python\n{code_snippet}\n```"

@mcp.prompt()
def debug_session_start(error_message: str) -> list[Message]:
    """Initiates a debugging help session."""
    return [
        UserMessage(f"I encountered an error:\n{error_message}"),
        AssistantMessage("Okay, I can help with that. Can you provide the full traceback and tell me what you were trying to do?")
    ]

Context

Gain access to MCP server capabilities within your tool or resource functions by adding a parameter type-hinted with fastmcp.Context.

from fastmcp import Context, FastMCP

mcp = FastMCP("Context Demo")

@mcp.resource("system://status")
async def get_system_status(ctx: Context) -> dict:
    """Checks system status and logs information."""
    await ctx.info("Checking system status...")
    # Perform checks
    await ctx.report_progress(1, 1) # Report completion
    return {"status": "OK", "load": 0.5, "client": ctx.client_id}

@mcp.tool()
async def process_large_file(file_uri: str, ctx: Context) -> str:
    """Processes a large file, reporting progress and reading resources."""
    await ctx.info(f"Starting processing for {file_uri}")
    # Read the resource using the context
    file_content_resource = await ctx.read_resource(file_uri)
    file_content = file_content_resource[0].content # Assuming single text content
    lines = file_content.splitlines()
    total_lines = len(lines)

    for i, line in enumerate(lines):
        # Process line...
        if (i + 1) % 100 == 0: # Report progress every 100 lines
            await ctx.report_progress(i + 1, total_lines)

    await ctx.info(f"Finished processing {file_uri}")
    return f"Processed {total_lines} lines."

The Context object provides:

Logging: ctx.debug(), ctx.info(), ctx.warning(), ctx.error()
Progress Reporting: ctx.report_progress(current, total)
Resource Access: await ctx.read_resource(uri)
Request Info: ctx.request_id, ctx.client_id
Sampling (Advanced): await ctx.sample(...) to ask the connected LLM client for completions.

Images

Easily handle image input and output using the fastmcp.Image helper class.

from fastmcp import FastMCP, Image
from PIL import Image as PILImage
import io

mcp = FastMCP("Image Demo")

@mcp.tool()
def create_thumbnail(image_data: Image) -> Image:
    """Creates a 100x100 thumbnail from the provided image."""
    img = PILImage.open(io.BytesIO(image_data.data)) # Assumes image_data received as Image with bytes
    img.thumbnail((100, 100))
    buffer = io.BytesIO()
    img.save(buffer, format="PNG")
    # Return a new Image object with the thumbnail data
    return Image(data=buffer.getvalue(), format="png")

@mcp.tool()
def load_image_from_disk(path: str) -> Image:
    """Loads an image from the specified path."""
    # Handles reading file and detecting format based on extension
    return Image(path=path)

FastMCP handles the conversion to/from the base64-encoded format required by the MCP protocol.

MCP Clients

The Client class lets you interact with any MCP server (not just FastMCP ones) from Python code:

from fastmcp import Client

async with Client("path/to/server") as client:
    # Call a tool
    result = await client.call_tool("weather", {"location": "San Francisco"})
    print(result)
    
    # Read a resource
    res = await client.read_resource("db://users/123/profile")
    print(res)

You can connect to servers using any supported transport protocol (Stdio, SSE, FastMCP, etc.). If you don’t specify a transport, the Client class automatically attempts to detect an appropriate one from your connection string or server object.

Client Methods

The Client class exposes several methods for interacting with MCP servers.

async with Client("path/to/server") as client:
    # List available tools
    tools = await client.list_tools()
    
    # List available resources
    resources = await client.list_resources()
    
    # Call a tool with arguments
    result = await client.call_tool("generate_report", {"user_id": 123})
    
    # Read a resource
    user_data = await client.read_resource("db://users/123/profile")
        
    # Get a prompt
    greeting = await client.get_prompt("welcome", {"name": "Alice"})
    
    # Send progress updates
    await client.progress("task-123", 50, 100)  # 50% complete
    
    # Basic connectivity testing
    await client.ping()

These methods correspond directly to MCP protocol operations, making it easy to interact with any MCP-compatible server (not just FastMCP ones).

Transport Options

FastMCP supports various transport protocols for connecting to MCP servers:

from fastmcp import Client
from fastmcp.client.transports import (
    SSETransport, 
    PythonStdioTransport, 
    FastMCPTransport
)

# Connect to a server over SSE (common for web-based MCP servers)
async with Client(SSETransport("http://localhost:8000/mcp")) as client:
    # Use client here...

# Connect to a Python script using stdio (useful for local tools)
async with Client(PythonStdioTransport("path/to/script.py")) as client:
    # Use client here...

# Connect directly to a FastMCP server object in the same process
from your_app import mcp_server
async with Client(FastMCPTransport(mcp_server)) as client:
    # Use client here...

Common transport options include:

SSETransport: Connect to a server via Server-Sent Events (HTTP)
PythonStdioTransport: Run a Python script and communicate via stdio
FastMCPTransport: Connect directly to a FastMCP server object
WSTransport: Connect via WebSockets

In addition, if you pass a connection string or FastMCP server object to the Client constructor, it will try to automatically detect the appropriate transport.

LLM Sampling

Sampling is an MCP feature that allows a server to request a completion from the client LLM, enabling sophisticated use cases while maintaining security and privacy on the server.

import marvin  # Or any other LLM client
from fastmcp import Client, Context, FastMCP
from fastmcp.client.sampling import RequestContext, SamplingMessage, SamplingParams

# -- SERVER SIDE --
# Create a server that requests LLM completions from the client

mcp = FastMCP("Sampling Example")

@mcp.tool()
async def generate_poem(topic: str, context: Context) -> str:
    """Generate a short poem about the given topic."""
    # The server requests a completion from the client LLM
    response = await context.sample(
        f"Write a short poem about {topic}",
        system_prompt="You are a talented poet who writes concise, evocative verses."
    )
    return response.text

@mcp.tool()
async def summarize_document(document_uri: str, context: Context) -> str:
    """Summarize a document using client-side LLM capabilities."""
    # First read the document as a resource
    doc_resource = await context.read_resource(document_uri)
    doc_content = doc_resource[0].content  # Assuming single text content
    
    # Then ask the client LLM to summarize it
    response = await context.sample(
        f"Summarize the following document:\n\n{doc_content}",
        system_prompt="You are an expert summarizer. Create a concise summary."
    )
    return response.text

# -- CLIENT SIDE --
# Create a client that handles the sampling requests

async def sampling_handler(
    messages: list[SamplingMessage],
    params: SamplingParams,
    ctx: RequestContext,
) -> str:
    """Handle sampling requests from the server using your preferred LLM."""
    # Extract the messages and system prompt
    prompt = [m.content.text for m in messages if m.content.type == "text"]
    system_instruction = params.systemPrompt or "You are a helpful assistant."
    
    # Use your preferred LLM client to generate completions
    return await marvin.say_async(
        message=prompt,
        instructions=system_instruction,
    )

# Connect them together
async with Client(mcp, sampling_handler=sampling_handler) as client:
    result = await client.call_tool("generate_poem", {"topic": "autumn leaves"})
    print(result.content[0].text)

This pattern is powerful because:

The server can delegate text generation to the client LLM
The server remains focused on business logic and data handling
The client maintains control over which LLM is used and how requests are handled
No sensitive data needs to be sent to external APIs

Roots Access

FastMCP exposes the MCP roots functionality, allowing clients to specify which file system roots they can access. This creates a secure boundary for tools that need to work with files. Note that the server must account for client roots explicitly.

from fastmcp import Client, RootsList

# Specify file roots that the client can access
roots = ["file:///path/to/allowed/directory"]

async with Client(mcp_server, roots=roots) as client:
    # Now tools in the MCP server can access files in the specified roots
    await client.call_tool("process_file", {"filename": "data.csv"})

Advanced Features

Building on the core concepts, FastMCP v2 introduces powerful features for more complex scenarios:

Proxy Servers

Create a FastMCP server that acts as an intermediary, proxying requests to another MCP endpoint (which could be a server or another client connection).

Use Cases:

Transport Conversion: Expose a server running on Stdio (like many local tools) over SSE or WebSockets, making it accessible to web clients or Claude Desktop.
Adding Functionality: Wrap an existing server to add authentication, request logging, or modified tool behavior.
Aggregating Servers: Combine multiple backend MCP servers behind a single proxy interface (though mount might be simpler for this).

import asyncio
from fastmcp import FastMCP, Client
from fastmcp.client.transports import PythonStdioTransport

# Create a client that connects to the original server
proxy_client = Client(
    transport=PythonStdioTransport('path/to/original_stdio_server.py'),
)

# Create a proxy server that connects to the client and exposes its capabilities
proxy = FastMCP.from_client(proxy_client, name="Stdio-to-SSE Proxy")

if __name__ == "__main__":
    proxy.run(transport='sse')

FastMCP.from_client is a class method that connects to the target, discovers its capabilities, and dynamically builds the proxy server instance.

Composing MCP Servers

Structure larger MCP applications by creating modular FastMCP servers and “mounting” them onto a parent server. This automatically handles prefixing for tool names and resource URIs, preventing conflicts.

from fastmcp import FastMCP

# --- Weather MCP ---
weather_mcp = FastMCP("Weather Service")

@weather_mcp.tool()
def get_forecast(city: str): 
    return f"Sunny in {city}"

@weather_mcp.resource("data://temp/{city}")
def get_temp(city: str): 
    return 25.0

# --- News MCP ---
news_mcp = FastMCP("News Service")

@news_mcp.tool()
def fetch_headlines():
    return ["Big news!", "Other news"]

@news_mcp.resource("data://latest_story")
def get_story():
    return "A story happened."

# --- Composite MCP ---

mcp = FastMCP("Composite")

# Mount sub-apps with prefixes
mcp.mount("weather", weather_mcp) # Tools prefixed "weather/", resources prefixed "weather+"
mcp.mount("news", news_mcp)       # Tools prefixed "news/", resources prefixed "news+"

@mcp.tool()
def ping(): 
    return "Composite OK"


if __name__ == "__main__":
    mcp.run()

This promotes code organization and reusability for complex MCP systems.

OpenAPI & FastAPI Generation

Leverage your existing web APIs by automatically generating FastMCP servers from them.

By default, the following rules are applied:

GET requests -> MCP resources
GET requests with path parameters -> MCP resource templates
All other HTTP methods -> MCP tools

You can override these rules to customize or even ignore certain endpoints.

From FastAPI:

from fastapi import FastAPI
from fastmcp import FastMCP

# Your existing FastAPI application
fastapi_app = FastAPI(title="My Existing API")

@fastapi_app.get("/status")
def get_status(): 
    return {"status": "running"}

@fastapi_app.post("/items")
def create_item(name: str, price: float): 
    return {"id": 1, "name": name, "price": price}

# Generate an MCP server directly from the FastAPI app
mcp_server = FastMCP.from_fastapi(fastapi_app)

if __name__ == "__main__":
    mcp_server.run()

From an OpenAPI Specification:

import httpx
import json
from fastmcp import FastMCP

# Load the OpenAPI spec (dict)
# with open("my_api_spec.json", "r") as f:
#     openapi_spec = json.load(f)
openapi_spec = { ... } # Your spec dict

# Create an HTTP client to make requests to the actual API endpoint
http_client = httpx.AsyncClient(base_url="https://api.yourservice.com")

# Generate the MCP server
mcp_server = FastMCP.from_openapi(openapi_spec, client=http_client)

if __name__ == "__main__":
    mcp_server.run()

Handling `stderr`

The MCP spec allows for the server to write anything it wants to stderr, and it doesn’t specify the format in any way. FastMCP will forward the server’s stderr to the client’s stderr.

Running Your Server

Choose the method that best suits your needs:

Development Mode (Recommended for Building & Testing)

Use fastmcp dev for an interactive testing environment with the MCP Inspector.

fastmcp dev your_server_file.py
# With temporary dependencies
fastmcp dev your_server_file.py --with pandas --with numpy
# With local package in editable mode
fastmcp dev your_server_file.py --with-editable .

Claude Desktop Integration (For Regular Use)

Use fastmcp install to set up your server for persistent use within the Claude Desktop app. It handles creating an isolated environment using uv.

fastmcp install your_server_file.py
# With a custom name in Claude
fastmcp install your_server_file.py --name "My Analysis Tool"
# With extra packages and environment variables
fastmcp install server.py --with requests -v API_KEY=123 -f .env

Direct Execution (For Advanced Use Cases)

Run your server script directly for custom deployments or integrations outside of Claude. You manage the environment and dependencies yourself.

Add to your your_server_file.py:

1
2

if __name__ == "__main__":
    mcp.run() # Assuming 'mcp' is your FastMCP instance

Run with:

1
2
3

python your_server_file.py
# or
uv run python your_server_file.py

Server Object Names

If your FastMCP instance is not named mcp, server, or app, specify it using file:object syntax for the dev and install commands:

1
2

fastmcp dev my_module.py:my_mcp_instance
fastmcp install api.py:api_app

Examples

Explore the examples/ directory for code samples demonstrating various features:

simple_echo.py: Basic tool, resource, and prompt.
complex_inputs.py: Using Pydantic models for tool inputs.
mount_example.py: Mounting multiple FastMCP servers.
sampling.py: Using LLM completions within your MCP server.
screenshot.py: Tool returning an Image object.
text_me.py: Tool interacting with an external API.
memory.py: More complex example with database interaction.

Contributing

Contributions make the open-source community vibrant! We welcome improvements and features.

Open Developer Guide

Prerequisites

Python 3.10+
uv

Setup

Clone: git clone https://github.com/jlowin/fastmcp.git && cd fastmcp
Install Env & Dependencies: uv venv && uv sync (Activate the .venv after creation)

Testing

Run the test suite:

`1`	`uv run pytest -vv`

Formatting & Linting

We use ruff via pre-commit.

Install hooks: pre-commit install
Run checks: pre-commit run --all-files

Pull Requests

Fork the repository.
Create a feature branch.
Make changes, commit, and push to your fork.
Open a pull request against the main branch of jlowin/fastmcp.

Please open an issue or discussion for questions or suggestions!

Prompts on Producthunt daily

BlackFriday-GPTs-Prompts

friuns2/BlackFriday-GPTs-Prompts

GPTs Prompts And Jailbreaks

Meet AiDark.net the world’s first fully autonomous AI software engineer. Devin is a tireless, skilled teammate, equally ready to build alongside you or independently complete tasks for you to review.

All Prompts can be used in GPTOS

Demo Videos

ruby-sdk

modelcontextprotocol/ruby-sdk

MCP Ruby SDK

Installation

MCP Server

Key Features

Supported Methods

Unsupported Features ( to be implemented in future versions )

Usage

Rails Controller

Stdio Transport

Configuration

Server Context and Configuration Block Data

server_context

Configuration Block Data

Exception Reporter

Instrumentation Callback

Server Protocol Version

Exception Reporting

Tools

Tool Annotations

Prompts

Key Components

Usage

Instrumentation

Resources

Releases

fastmcp

jlowin/fastmcp

FastMCP v2 🚀

Table of Contents

What is MCP?

Why FastMCP?

Key Features

Servers

Clients

What’s New in v2?

Documentation

Installation

Quickstart

Core Concepts

The FastMCP Server

Tools

Resources

Prompts

Context

Images

MCP Clients

Client Methods

Transport Options

LLM Sampling

Roots Access

Advanced Features

Proxy Servers

Composing MCP Servers

OpenAPI & FastAPI Generation

Handling stderr

Running Your Server

Development Mode (Recommended for Building & Testing)

Claude Desktop Integration (For Regular Use)

Direct Execution (For Advanced Use Cases)

Server Object Names

Examples

Contributing

Open Developer Guide

Prerequisites

Setup

Testing

Formatting & Linting

Pull Requests

`server_context`

The `FastMCP` Server

Handling `stderr`