Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    MCP Server Builder & Tester

    1

    Design, build, and test Model Context Protocol (MCP) servers with a bundled conformance probe and security auditor.

    $20

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    MCP Server Builder & Tester

    MCP Server Builder & Tester

    Example session with this skill installed

    Create a Python MCP server for my local SQLite database at ./data.db. I need to be able to query tables and get schema info. Use stdio.

    • Read your context and instructions
    • Compiled the mcp server builder

    I have designed and built the SQLite MCP server. The protocol conformance probe returned RESULT: PASS with 2 tools detected.

    SQLite MCP Server Implementation

    
# server.py
import sqlite3
import os
from mcp.server.fastmcp import FastMCP

mcp = FastMCP("sqlite-manager")
DB_PATH = os.path.abspath("./data.db")

@mcp.tool()
def list_tables() -> str:
    """List all tables in the database to understand the schema."""
    with sqlite3.connect(DB_PATH) as conn:
        cursor = conn.cursor()
        cursor.execute("SELECT name FROM sqlite_master WHERE type='table';")
        tables = cursor.fetchall()
        return "\n".join([t[0] for t in tables])

@mcp.tool()
def query_db(sql: str) -> str:
    """Execute a read-only SELECT query. Use this for data retrieval."""
    if not sql.lower().strip().startswith("select"):
        return "Error: Only SELECT queries are allowed."
    with sqlite3.connect(DB_PATH) as conn:
        cursor = conn.cursor()
        cursor.execute(sql)
        results = cursor.fetchall()
        return str(results)

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

    Client Configuration (claude_desktop_config.json)

    {
  "mcpServers": {
    "sqlite-manager": {
      "command": "python",
      "args": ["/absolute/path/to/server.py"],
      "env": {
        "PYTHONPATH": "/absolute/path/to/site-packages"
      }
    }
  }
}

    Next steps

    1. Run pip install mcp to install the SDK.
    2. Update the absolute paths in the JSON snippet provided above.
    3. Restart Claude Desktop and verify the list_tables tool appears.
    Client Configuration (claude_desktop_config.json

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

    About this skill

    Building Model Context Protocol (MCP) servers often leads to brittle connections, silent failures, and tools the AI client ignores. This skill provides a specialized workflow to design, build, and verify MCP servers that work on the first try.

    What it does

    • Tool Surface Design creates precise, model-optimized schemas with proper annotations and snake_case naming.
    • Protocol Verification uses a bundled conformance probe to validate the stdio or HTTP transport handshake.
    • Client Configuration generates ready-to-paste snippets for Claude Desktop and Claude Code using absolute paths.
    • Security Auditing enforces path resolution, input sanitization, and credential hygiene.
    • Automated Debugging triages connection timeouts, JSON-RPC errors, and stdout corruption issues.

    How it works

    1. Intake extracts your tech stack (Python/TypeScript), transport method, and the API or database to be wrapped.
    2. Implementation applies tested templates for FastMCP or the TypeScript SDK, ensuring logs go to stderr to prevent protocol corruption.
    3. Verification runs the conformance probe to confirm zero FAIL results before you even open your AI client.

    Frameworks & tools

    Supports Python (FastMCP, MCPServer) and TypeScript/Node.js SDKs. Built-in templates for stdio and Streamable HTTP transports.

    Why this beats prompting it yourself

    Generic prompts often miss wire-level nuances like stderr logging or proper JSON-RPC error codes, leading to "Server disconnected" errors. This skill uses a dedicated conformance probe and protocol checklist to guarantee compatibility.

    Use cases

    • Exposing a local SQL database or legacy CLI as tools for Claude.
    • Debugging an existing MCP server that fails to show tools in the client.
    • Creating a secure bridge to internal APIs with environment-based auth.

    Known limitations

    Requires a Python environment to run the bundled conformance probe. Does not support non-standard transport protocols outside of stdio and Streamable HTTP.

    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 Python to run the mcp_probe.py utility. Designed for official Python/TS SDKs. Client-side manual restart is still required for final integration.

    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

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 1 month ago

    Software
    PythonNode.jsBuilder Tester MCP...@modelcontextprotocol/inspector

    Permissions

    Terminal / Shell
    Environment Variables
    Listed1 month ago

    What's inside

    Frequently Asked Questions

    This skill automates the process of creating Model Context Protocol servers by generating model-optimized schemas and providing a built-in conformance probe to verify connections before deployment, preventing common issues like "Server disconnected" errors.

    The skill provides specific implementation templates for Python (using FastMCP) and TypeScript/Node.js SDKs, supporting both stdio and Streamable HTTP transport methods.

    While the skill helps you build servers for any MCP-compliant client, it includes specific configuration generators for Claude Desktop and Claude Code, including ready-to-paste absolute path snippets.

    Yes, you will need a local Python environment to run the bundled conformance probe, which is essential for triaging JSON-RPC errors and validating the server handshake.

    The skill includes a security auditor that automatically implements path resolution, input sanitization, and credential hygiene to ensure your local databases or APIs aren't exposed to common vulnerabilities.

    You receive the full specialized workflow for design, implementation, and verification, plus the bundled conformance probe and a library of tested templates for both Python and TypeScript.

    New in LLM Ops