- Home
- Skills
- Agents & Orchestration
- Freebies — Basic Mcp Server Manifest
Works with the AI Agents you already use
Freebies — Basic Mcp Server Manifest
Generate standards-compliant MCP server manifests, tool schemas, and client configurations for AI agents.
Free
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 ```typescript 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 ```json { "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.
Supports stdio transport only. Limited to TypeScript and Python implementations. Workspace-confined to current project directory.
How to use
- 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
Sign in to Agensi
Your agent shows a sign-in link. Sign in and click Allow.
- 3
Ask for what you need
Your agent loads this skill and uses it on your task. It always asks before any payment.
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 forever
No account required to browse
Trust & safety
Security scan
Security scan passed today
- Free with an Agensi account
Requires
Permissions
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.