Skip to main content
Glama

jachy-mcp-server

Personal MCP (Model Context Protocol) server for centralized automation tools. Provides a unified interface so nanobot, Qwen, Cursor, Claude Desktop, and other AI agents can invoke the same set of tools through a single server.

Current tools

Tool

Domain

Description

discord_create_forum_post

Discord

Creates a new post in a Discord Forum channel


Quick Start

Prerequisites

  • Node.js ≥ 22

  • pnpm ≥ 9

1 — Install dependencies

pnpm install
# or
make install

2 — Configure environment variables

cp .env.example .env
# Open .env and fill in DISCORD_BOT_TOKEN

See .env.example for descriptions and links to obtain each value.

3 — Run in development mode (hot-reload)

pnpm dev
# or
make dev

4 — Build for production

pnpm build   # compiles src/ → dist/
pnpm start   # runs dist/index.js
# or
make build && make start

Related MCP server: MCP Hub

Project Structure

src/
├── index.ts              Entry point — validates config, creates MCP server, registers tools
├── core/
│   ├── config.ts         Centralised env-var config; call validateConfig() at startup
│   └── httpClient.ts     Shared fetch wrapper with retry, error formatting, request logging
├── tools/
│   ├── index.ts          Single source of truth for allTools[] — only file to edit when adding a domain
│   ├── discord/
│   │   ├── index.ts      Exports discordTools[]
│   │   ├── forum.ts      discord_create_forum_post tool
│   │   └── helpers.ts    Discord REST API helpers (private to this domain)
│   └── _template/
│       ├── index.ts      Template domain index
│       ├── exampleTool.ts Template tool — copy & adapt
│       └── HOWTO.md      Step-by-step guide for adding a new tool domain
└── types/
    └── index.ts          ToolDefinition interface and shared types
tests/
└── tools/
    └── discord/
        └── forum.test.ts Unit tests for discord_create_forum_post

Adding a New Tool Domain

Full walkthrough: src/tools/_template/HOWTO.md

TL;DR — three steps, zero changes to src/index.ts:

Step 1 — Create your domain folder

cp -r src/tools/_template src/tools/github
mv src/tools/github/exampleTool.ts src/tools/github/createIssue.ts

Step 2 — Implement your tool

Edit createIssue.ts:

import { z } from 'zod';
import { type ToolDefinition } from '../../types/index.js';
import { config } from '../../core/config.js';       // ← env vars here
import { httpRequest } from '../../core/httpClient.js'; // ← HTTP here

const Schema = z.object({ repo: z.string(), title: z.string() });

export const githubCreateIssueTool: ToolDefinition = {
  name: 'github_create_issue',
  description: '...',
  inputSchema: { type: 'object', properties: { ... }, required: ['repo', 'title'] },
  handler: async (input) => {
    const { repo, title } = Schema.parse(input);
    // … call GitHub API …
    return `Issue created: ${url}`;
  },
};

Update src/tools/github/index.ts:

import { githubCreateIssueTool } from './createIssue.js';
export const githubTools = [githubCreateIssueTool];

Step 3 — Register in the global registry

Open src/tools/index.ts and add one line:

import { githubTools } from './github/index.js';

export const allTools: ToolDefinition[] = [
  ...discordTools,
  ...githubTools,  // ← add this
];

Done. No other file needs to change.


Architecture Rules

Rule

Why

All env vars through config.*

Single validation point; tests can override process.env safely

All HTTP through httpRequest()

Unified retry, error format, and logging

Input validated with Zod in every handler

Type safety at runtime; descriptive errors for the agent

console.log forbidden; use console.error

MCP uses stdout for JSON-RPC — any extra stdout breaks the protocol


Integrating with AI Agents

Claude Desktop

Add to ~/Library/Application Support/Claude/claude_desktop_config.json:

{
  "mcpServers": {
    "jachy-mcp-server": {
      "command": "node",
      "args": ["/absolute/path/to/jachy-mcp-server/dist/index.js"],
      "env": {
        "DISCORD_BOT_TOKEN": "your-token-here"
      }
    }
  }
}

Cursor

Add to your Cursor MCP settings (~/.cursor/mcp.json or workspace .cursor/mcp.json):

{
  "mcpServers": {
    "jachy-mcp-server": {
      "command": "node",
      "args": ["/absolute/path/to/jachy-mcp-server/dist/index.js"],
      "env": {
        "DISCORD_BOT_TOKEN": "your-token-here"
      }
    }
  }
}

nanobot

In your nanobot config file:

{
  "mcp_servers": {
    "jachy": {
      "command": ["node", "/absolute/path/to/jachy-mcp-server/dist/index.js"],
      "env": {
        "DISCORD_BOT_TOKEN": "your-token-here"
      }
    }
  }
}

Using tsx for development (skip build step)

Replace node dist/index.js with npx tsx src/index.ts in any config above and omit the build step.


Development Commands

pnpm dev          # Run with hot-reload (tsx watch)
pnpm build        # Compile TypeScript → dist/
pnpm start        # Run compiled output
pnpm test         # Run tests once (vitest)
pnpm test:watch   # Run tests in watch mode
pnpm lint         # ESLint
pnpm format       # Prettier (writes in-place)

Or use make <command> for any of the above.


Setting Up a Discord Bot

  1. Go to https://discord.com/developers/applications and create a New Application.

  2. Under Bot, click Reset Token and copy it to DISCORD_BOT_TOKEN in .env.

  3. Under OAuth2 → URL Generator, select scope bot and permission Send Messages + Create Public Threads.

  4. Use the generated URL to invite the bot to your server.

  5. The bot must have View Channel + Send Messages in Threads permissions on the Forum channel.

  6. Enable Developer Mode in Discord (Settings → Advanced) to right-click channels and copy their IDs.


License

ISC

Available Tools

1 tool
discord_create_forum_postA

Creates a new post (thread) inside a Discord Forum channel.

Parameters:

  • channel_id (string, required) : Snowflake ID of the Forum channel. Right-click the channel in Discord → Copy Channel ID.

  • title (string, required) : Post subject line. Max 100 characters.

  • content (string, required) : Body of the first message. Max 2000 characters. Supports Discord markdown (bold, italic, code blocks, etc.)

  • tag_ids (string[], optional): Array of Forum tag snowflake IDs to label the post.

Returns: A confirmation string with the post title and a direct URL, e.g.: "Forum post created successfully.\nTitle: My Post\nURL: https://discord.com/channels/GUILD/THREAD"

Errors:

  • "Invalid input …" — Input failed validation (wrong types, values out of range).

  • HTTP 401 Unauthorized — DISCORD_BOT_TOKEN is missing or invalid.

  • HTTP 403 Forbidden — The bot does not have permission to post in this channel.

  • HTTP 404 Not Found — channel_id does not exist or is not a Forum channel.

  • HTTP 400 Bad Request — Malformed payload (e.g. tag IDs that do not exist in the forum).

ParametersJSON Schema
NameRequiredDescriptionDefault
channel_idYesDiscord Forum channel ID (right-click channel → Copy Channel ID)
titleYesPost subject / thread title (max 100 characters)
contentYesFirst message body — supports Discord markdown (max 2000 characters)
tag_idsNoOptional array of Forum tag snowflake IDs to apply to the post

TDQS

A3.7/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries full burden and does an excellent job disclosing behavioral traits. It explains authentication requirements (DISCORD_BOT_TOKEN), permission needs (403 Forbidden), error conditions, return format, and character limits. The only minor gap is lack of rate limit information.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Well-structured with clear sections (Parameters, Returns, Errors) and front-loaded purpose statement. Some redundancy exists between description and schema, but overall the information is organized efficiently with no wasted sentences.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a mutation tool with no annotations and no output schema, the description provides excellent coverage of behavior, errors, and return format. The only gaps are rate limits and more detailed usage context, but it's substantially complete for the tool's complexity.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description repeats parameter information but doesn't add meaningful semantic context beyond what's in the schema descriptions. The baseline of 3 is appropriate when the schema does the heavy lifting.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the specific action ('Creates a new post (thread)') and resource ('inside a Discord Forum channel'), with no sibling tools to differentiate from. It uses precise terminology like 'post (thread)' to clarify the Discord-specific concept.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is provided on when to use this tool versus alternatives, prerequisites, or best practices. The description only states what the tool does without context about when it's appropriate or what other tools might exist for related tasks.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

TDQS

A3.6/5.0
Disambiguation5/5

With only one tool, there is no possibility of confusion or overlap with other tools. The tool's purpose is singular and clearly defined as creating forum posts in Discord.

Naming Consistency5/5

Since there is only one tool, naming consistency is inherently perfect. The tool name 'discord_create_forum_post' follows a clear verb_noun pattern with a domain prefix.

Tool Count2/5

A single tool is too few for a server named 'Jachy MCP Server' which implies broader functionality, likely in the Discord domain. This minimal set feels thin and incomplete for typical Discord operations.

Completeness2/5

Inferred domain is Discord forum management, but the toolset is severely incomplete—it only allows creating posts with no ability to read, update, delete, or list existing posts. This will cause agent failures for common workflows.

Maintenance

ActivityInactive
ResponsivenessNo issues

Resources

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

Related MCP Servers

  • F
    license
    Not graded
    quality
    D
    maintenance
    A unified AI and automation command center that allows users to interact with multiple AI providers (OpenAI, Anthropic, Gemini) and services (GitHub, Google) through natural language commands and multi-step workflows.
  • -
    license
    Not graded
    quality
    Not graded
    maintenance
    An open source toolkit that converts 280+ integrations into MCP servers for use with Claude Desktop, Cursor, or Windsurf, enabling AI automation through a type-safe pieces framework written in TypeScript.
  • A
    license
    Not graded
    quality
    A
    maintenance
    MCP Hub is a self-hosted AI operations platform that provides a unified MCP gateway with semantic tool routing, persistent vector memory, automation, and multi-agent flows. It enables connecting any MCP client to 130+ tools across 12 integrations through just 3 hub endpoints.
    4
    MIT

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/jachy-h/jachy-mcp-server'

If you have feedback or need assistance with the MCP directory API, please join our Discord server