Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    Freebies — Basic Mcp Server Manifest

    1

    Generate standards-compliant MCP server manifests, tool schemas, and client configurations for AI agents.

    Free

    Security scanned
    Freebies — Basic Mcp Server Manifest

    Freebies — Basic Mcp Server Manifest

    Example session with this skill installed

    Scaffold a new TypeScript MCP server for a tool called 'weather_checker' that takes a 'city' string and 'units' enum. Add Claude Desktop config.

    • Read your context and instructions
    • Compiled the freebies

    I have scaffolded a new TypeScript MCP server and the corresponding client configuration. The server includes the weather_checker tool with full JSON Schema validation for the city and units parameters.

    MCP Server Manifest

    import { Server } from "@modelcontextprotocol/sdk/server/index.js";
    import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
    import {
      CallToolRequestSchema,
      ListToolsRequestSchema,
    } from "@modelcontextprotocol/sdk/types.js";
    
    const server = new Server(
      {
        name: "weather-server",
        version: "1.0.0",
      },
      {
        capabilities: {
          tools: {},
        },
      }
    );
    
    server.setRequestHandler(ListToolsRequestSchema, async () => ({
      tools: [
        {
          name: "weather_checker",
          description: "Get current weather for a specific city",
          inputSchema: {
            type: "object",
            properties: {
              city: { type: "string", description: "The city name" },
              units: { type: "string", enum: ["celsius", "fahrenheit"] },
            },
            required: ["city"],
          },
        },
      ],
    }));
    
    server.setRequestHandler(CallToolRequestSchema, async (request) => {
      if (request.params.name === "weather_checker") {
        // Logic for weather checking goes here
        return {
          content: [{ type: "text", text: "Weather data for " + request.params.arguments?.city }],
        };
      }
      throw new Error("Tool not found");
    });
    
    const transport = new StdioServerTransport();
    await server.connect(transport);
    

    Claude Desktop Configuration

    {
      "mcpServers": {
        "weather-server": {
          "command": "npx",
          "args": ["-y", "weather-server-path/index.js"],
          "env": {
            "API_KEY": "your_api_key_here"
          }
        }
      }
    }
    

    Next steps

    1. Run npm install @modelcontextprotocol/sdk to install dependencies.
    2. Replace the placeholder logic in the CallToolRequestSchema handler with your API call.
    3. Add your server path to the claude_desktop_config.json file.

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

    About this skill

    Building custom tools for AI agents often involves tedious boilerplate and schema validation errors. This skill automates the creation of Model Context Protocol (MCP) server manifests, package configurations, and JSON-RPC tool skeletons. It eliminates the manual overhead of scaffolding standards-compliant transport layers and input validation schemas.

    What it does

    • Server Scaffolding: Generates MCP server entry points using official TypeScript or Python SDKs.
    • Schema Generation: Produces JSON Schema validation for tool inputs to ensure type safety.
    • Transport Configuration: Sets up standard stdio transport server listeners for agent communication.
    • Client Integration: Creates configuration snippets for Claude Desktop, Cursor, and other IDEs.
    • Dependency Management: Drafts package.json or requirements.txt files with necessary protocol libraries.

    How it works

    1. Structure Server: The skill generates the core server entry point using the @modelcontextprotocol/sdk.
    2. Define Tools: It builds out the tool registration skeletons with precise inputSchema definitions.
    3. Configure Transport: It implements the stdio transport layer for reliable message passing.
    4. Export Config: The skill provides the final JSON configuration required for client-side discovery.

    Frameworks & tools

    This skill supports TypeScript via the official MCP SDK and Python using the mcp library. It produces configurations compatible with Claude Code, Cursor, Windsurf, and the Google Antigravity IDE.

    Why this beats prompting it yourself

    Writing MCP manifests manually often leads to silent failures due to incorrect JSON-RPC nesting or malformed tool schemas. This skill uses deterministic patterns to ensure the resulting code follows the Oct 2026 Linux Foundation standards, saving you hours of debugging transport issues.

    Use cases

    • Scaffolding a new MCP server for local file system tools.
    • Generating a database connector manifest with secure environment variable placeholders.
    • Creating a tool registration skeleton for a custom internal API.
    • Updating legacy agent tools to the latest Model Context Protocol standard.

    Known limitations

    Restricted to stdio transport only. Workspace-confined execution prevents access to system-level configuration paths or parent directories.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Agents & Orchestration.

    Supports stdio transport only. Limited to TypeScript and Python implementations. Workspace-confined to current project directory.

    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

    Free to use

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed today

    • Free with an Agensi account

    Linux only

    Software
    Freebies Basic Manifest MCPDatabase Connector Secure MCPContext Compression Engine MCP
    Zero global installation
    orelevated privileges required.

    File System Read/Write (strictly scoped to current project workspace `./`).

    Permissions

    Read Files
    Network Access

    Target Use Cases: - Scaffold an MCP server in TypeScript with stdio transport. - Create a Model Context Protocol tool schema. - Generate an MCP server skeleton for Claude Desktop.

    Listedtoday

    What's inside

    Frequently Asked Questions

    This skill automates the creation of Model Context Protocol (MCP) server manifests, tool schemas, and transport configurations, eliminating the manual boilerplate and schema validation errors often associated with building custom agent tools.

    The skill generates configuration and boilerplate code compatible with any agent or IDE that supports the Model Context Protocol, including Claude Desktop, Cursor, Windsurf, and Claude Code.

    The skill produces code and configurations in TypeScript (via the official SDK) and Python (using the mcp library), ensuring you can work in the language that best fits your project.

    You will receive standards-compliant server entry points, precise JSON Schema definitions for tool inputs, transport layer listeners, and the necessary dependency files like package.json or requirements.txt.

    The skill is currently optimized for stdio transport, which is the standard for local agent-to-tool communication; it does not currently support SSE (Server-Sent Events) or other remote transport layers.

    The skill follows the latest Model Context Protocol standards as defined by the Linux Foundation, ensuring your manifests are valid and future-proofed against protocol version mismatches.

    New in Agents & Orchestration

    Free