- 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
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
- Run
npm install @modelcontextprotocol/sdkto install dependencies. - Replace the placeholder logic in the
CallToolRequestSchemahandler with your API call. - Add your server path to the
claude_desktop_config.jsonfile.
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
- Structure Server: The skill generates the core server entry point using the
@modelcontextprotocol/sdk. - Define Tools: It builds out the tool registration skeletons with precise
inputSchemadefinitions. - Configure Transport: It implements the stdio transport layer for reliable message passing.
- 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
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 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 MCPZero global installationorelevated privileges required.
File System Read/Write (strictly scoped to current project workspace `./`).
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.