Skip to main content
Glama

YominPost

One piece of material in, platform-native posts out. Reviewed, risk-checked, scheduled and published from a studio you host yourself.

一份素材 → 每个渠道一版地道的帖子 → 发布前风控检查 → 排期 / 发布。自托管,默认零配置、无需任何 API Key。

Web app · CLI (yominpost) · MCP server (yominpost-mcp) · Agent Skill (skill/SKILL.md) · MIT

By Yomin Ma · GitHub @mrlong0129 · Sister projects: wechat-article-fetcher, agent-web-fetch · 中文说明

Quick start

No install and no config. All you need is uv (curl -LsSf https://astral.sh/uv/install.sh | sh):

# 1) Start the studio (web UI on http://127.0.0.1:8300, data in ~/.yominpost/)
uvx --from git+https://github.com/mrlong0129/yominpost yominpost --open

# 2) Or generate posts straight from the terminal
uvx --from git+https://github.com/mrlong0129/yominpost yominpost run \
  --brand "Acme" --source "Acme turns one long-form idea into ten platform-native posts." \
  --platform x --platform linkedin --platform tiktok --topics 3

# 3) Claude Code: register the MCP server in one line
claude mcp add yominpost -- uvx --from git+https://github.com/mrlong0129/yominpost yominpost-mcp

Cursor: add this to ~/.cursor/mcp.json (global) or .cursor/mcp.json (project):

{
  "mcpServers": {
    "yominpost": {
      "command": "uvx",
      "args": ["--from", "git+https://github.com/mrlong0129/yominpost", "yominpost-mcp"]
    }
  }
}

Agent Skill (teaches Claude Code / Cursor how to write, check and hand off social posts with YominPost):

# Claude Code
mkdir -p ~/.claude/skills/yominpost && curl -fsSL https://raw.githubusercontent.com/mrlong0129/yominpost/main/skill/SKILL.md -o ~/.claude/skills/yominpost/SKILL.md
# Cursor
mkdir -p ~/.cursor/skills/yominpost && curl -fsSL https://raw.githubusercontent.com/mrlong0129/yominpost/main/skill/SKILL.md -o ~/.cursor/skills/yominpost/SKILL.md

Instructions for coding agents live in AGENTS.md.

Related MCP server: omnipost-social-engine

Why

Posting the same idea to X, LinkedIn, Instagram, TikTok and Telegram means rewriting it five times, guessing which format each platform wants, and hoping the AI-written version doesn't get the account flagged. Hosted schedulers lock your tokens and drafts in someone else's cloud, and most AI writers stop at "here is a caption".

YominPost does the whole loop on your own machine:

  • It decides the format, not just the words. A rule-based router picks text, thread, image post, carousel or short video per platform and explains why.

  • It critiques its own drafts. Every draft is scored and rewritten once if it misses the bar.

  • It protects the account. A pre-publish risk gate catches leaked prompts, engagement bait, hashtag stuffing, duplicate posts and unsafe posting cadence. These are the signals that get AI-assisted accounts restricted.

  • It actually publishes. Real OAuth2 + PKCE connectors, encrypted tokens, a scheduler that fires on time and never double-posts.

Features

8-slot content engine

Brand DNA → trends → ideation & calendar → format router → copy → visual (SVG/JPG poster) → short-video storyboard + SRT → QA self-critique

Post Creating Loop

Paste text, a URL or image links → analysis → research → strategy → one draft per channel, shown on an infinite canvas with chat-style refinement

Swappable drivers

template (offline, deterministic, default) · claude_code (local claude CLI) · codex (local codex CLI) · agy · anthropic (API). Automatic fallback chain, so a failing driver never breaks a run

Real publishing

X, LinkedIn, Reddit, Facebook Page, Instagram, YouTube Shorts, Discord, Mastodon (zero-config app registration), Telegram, Bluesky, Webhook. TikTok, Xiaohongshu, Threads and Pinterest are simulated for now

Pre-publish risk gate

Prompt-leak and engagement-bait lint, hashtag/link limits, duplicate detection, per-platform cadence caps, auto-freeze after a platform block

Operations

Calendar (week/list), scheduled queue with retry, asset library, topic bank, per-channel health (native signals such as karma, strikes and account status), daily channel sync

Self-hosted and safe by default

FastAPI + SQLite, no build step. Fernet-encrypted tokens, operator access key (required for public deploys), SSRF-guarded URL fetching, daily backups

Agent-native

MCP tools generate_posts, check_post, save_draft, list_posts, list_platforms. There is deliberately no publish tool: a human approves in the UI

Architecture

flowchart LR
    subgraph Inputs
      U[Operator in browser]
      A[AI agent via MCP]
      C[CLI]
    end
    U --> WEB[FastAPI app<br/>web/app.py + vanilla JS SPA]
    A --> MCP[MCP server<br/>mcp_server.py]
    C --> CLI[cli.py]
    WEB --> SVC[services.py<br/>compose · posts · publish]
    MCP --> SVC
    CLI --> ORCH
    SVC --> ORCH[orchestrator.py<br/>8-slot pipeline]
    ORCH --> DRV{{Driver chain<br/>template · claude · codex · anthropic}}
    SVC --> RISK[platform_risk.py<br/>pre-publish gate]
    RISK --> CONN[connectors/<br/>OAuth2 + PKCE · token · webhook]
    CONN --> P[(X · LinkedIn · Reddit · IG · FB · YT<br/>Telegram · Discord · Mastodon · Bluesky)]
    SVC --> DB[(SQLite<br/>~/.yominpost/data)]
    SCHED[scheduler.py<br/>due posts · health · backups] --> SVC

Data model, storage and security details: ARCHITECTURE.md (Chinese). Platform risk research: docs/PLATFORM_RISK.md. Registering OAuth apps: docs/REGISTER_APPS.md. Public deployment through Cloudflare Tunnel: deploy/DEPLOY.md.

Configuration

Defaults need nothing. Everything is optional and set through environment variables (see .env.example):

Variable

What it does

YOMINPOST_PROVIDER

template (default) · claude_code · codex · agy · anthropic

ANTHROPIC_API_KEY

Enables the anthropic driver

OPENAI_API_KEY / YOMINPOST_IMAGE_BASE_URL

Real image generation (gpt-image, any OpenAI-compatible endpoint)

X_CLIENT_ID, LINKEDIN_CLIENT_ID, …

OAuth apps for one-click Connect (or paste them once on the Settings page)

YOMINPOST_HOME

Data root, default ~/.yominpost

YOMINPOST_PUBLIC_URL + YOMINPOST_ACCESS_KEY

Public deployment. The app refuses to start publicly without an access key

FAQ

Do I need an API key? No. The default template driver runs offline and deterministically, so you can try the whole flow and run the test suite with zero keys. For production-quality copy, switch to claude_code or codex (uses the CLI you are already logged into) or anthropic.

Is the offline output good enough to post? It is a solid scaffold that follows your material's language, not a replacement for a real model. Use it to try the workflow, then plug in a driver.

Can the MCP server publish for me? No, and that's on purpose. Agents can generate, check and save drafts; you review and press Publish in the UI. Publishing goes out under your real accounts and can't be undone.

Where is my data? In ~/.yominpost/ (SQLite DB, encryption key, generated posters). Back up data/.secret.key together with the DB, or stored OAuth tokens can't be decrypted.

Which platforms really publish? X, LinkedIn, Reddit, Facebook Page, Instagram, YouTube Shorts, Discord, Mastodon, Telegram, Bluesky and Webhook. TikTok, Xiaohongshu, Threads and Pinterest use a simulated connector until their APIs are wired in.

What language is the UI? The web UI is currently in Chinese. Generated copy follows your material (English in, English out) or --language en|zh. An English UI is on the roadmap; PRs welcome.

How is this different from Postiz / Buffer? Same "connect → compose → schedule → publish" backbone, plus an AI content engine that picks formats and critiques itself, a platform-risk gate built for AI-assisted posting, and an MCP server so coding agents can draft for you. It is a single-user, self-hosted Python app, not a SaaS.

Development

git clone https://github.com/mrlong0129/yominpost && cd yominpost
uv venv && uv pip install -e ".[dev]"
.venv/bin/pytest -q            # offline, no keys needed
.venv/bin/yominpost serve      # or ./run.sh

Code map: yominpost/stages/ (8 slots), orchestrator.py (pipeline), services.py (compose / posts / publish), connectors/ + oauth_specs.py + oauth_flow.py (platforms), platform_risk.py (risk gate), scheduler.py, web/ (FastAPI + SPA), mcp_server.py, cli.py.

中文说明

YominPost 是一个自托管的 AI 社媒工作台:把一份素材(文字、链接、图片)交给它,它会为每个渠道判断合适的形式(文本 / thread / 图文 / 轮播 / 短视频),写出地道的文案,自己打分、不达标就重写一次,发布前再过一遍平台风控(prompt 残留、诱导互动、堆标签、重复内容、发帖频率),最后通过真实 OAuth 连接器排期或发布。

  • 零配置:uvx --from git+https://github.com/mrlong0129/yominpost yominpost --open,不用装、不用 Key,默认离线模板驱动;想要更好的文案就切到本机已登录的 claude / codex CLI 或 Anthropic API。

  • 给 Agent 用:claude mcp add yominpost -- uvx --from git+https://github.com/mrlong0129/yominpost yominpost-mcp,提供生成、风控检查、存草稿等工具;刻意不提供发布工具,发布由人在界面里确认。

  • 真实发布:X、LinkedIn、Reddit、Facebook 主页、Instagram、YouTube Shorts、Discord、Mastodon、Telegram、Bluesky、Webhook;抖音/TikTok、小红书、Threads、Pinterest 目前为模拟连接器。

  • 数据都在本机 ~/.yominpost/,令牌 Fernet 加密;公网部署必须设置访问密钥。界面目前是中文。

License

MIT © 2026 Yomin Ma

Available Tools

5 tools
check_postA

Pre-publish risk check for one post: prompt leaks, engagement bait, hashtag stuffing, link stacking and platform length limits. ok=false means do not publish as-is.

ParametersJSON Schema
NameRequiredDescriptionDefault
textYes
hashtagsNo
platformNox

Output Schema

ParametersJSON Schema
NameRequiredDescription

No output parameters

TDQS

A4/5.0
Behavior4/5

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

With no annotations, the description carries the full burden and largely succeeds: it discloses what the check inspects and, crucially, the verdict contract (ok=false means do not publish as-is). It does not state permission/auth needs or whether the check is purely read-only, but the output semantics are a meaningful behavioral disclosure.

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

Conciseness5/5

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

Two sentences, front-loaded with the purpose and followed by the actionable verdict rule. No filler or repetition.

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

Completeness3/5

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

An output schema exists, so return values need not be explained, and the description usefully clarifies the ok=false semantics. However, the near-total absence of parameter guidance for a 3-param tool with 0% schema coverage leaves a real gap for correct invocation.

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

Parameters2/5

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

Schema description coverage is 0% for three parameters (text, hashtags, platform), and the description never defines them. It only indirectly hints that hashtags and platform matter via the phrases "hashtag stuffing" and "platform length limits"; it does not explain the platform default of "x" or how hashtags relate to the text field.

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 names a specific verb+resource (risk check for a post) and enumerates exactly what is inspected: prompt leaks, engagement bait, hashtag stuffing, link stacking, platform length limits. This clearly separates it from the sibling generate_posts/save_draft/list_posts tools.

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

Usage Guidelines4/5

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

"Pre-publish" gives a clear trigger context for when to call it, and "one post" scopes it to a single item. It does not name an alternative tool or state when not to use it, so it stops short of full routing guidance.

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

generate_postsA

Generate platform-specific social posts from brand material.

Runs YominPost's 8-slot pipeline (brand DNA → trends → ideation → format router → copy → visual → short-video storyboard → QA self-critique). Works offline with no API key; uses a real model if the server was configured with one (YOMINPOST_PROVIDER / ANTHROPIC_API_KEY).

Args: brand: brand or product name. material: what the brand does / the announcement / notes to write from. platforms: any of x, linkedin, instagram, tiktok, youtube, xiaohongshu, wechat. Default ["x"]. num_topics: number of post ideas (1-10). trends: optional trend signals to weave in. language: auto (follow the material), en or zh.

ParametersJSON Schema
NameRequiredDescriptionDefault
brandYes
trendsNo
languageNoauto
materialNo
platformsNo
num_topicsNo

Output Schema

ParametersJSON Schema
NameRequiredDescription

No output parameters

TDQS

A4/5.0
Behavior4/5

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

With no annotations, the description carries the full behavioral burden and does reasonably well: it discloses the 8-stage pipeline, a QA self-critique step, offline vs model-backed execution, and the 1-10 bounds on num_topics. It omits cost, latency, and failure modes, but the environment-dependent execution behavior is an uncommon and valuable disclosure.

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?

Front-loaded with the purpose sentence, then a compact pipeline line and an Args block; each element earns its place. The em-dash/arrow formatting is slightly dense but not wasteful, and nothing is buried.

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?

An output schema exists, so return values need no explanation, and the description fully covers execution model and parameters. The remaining gap is the absence of any routing guidance relative to check_post and save_draft, which prevents a 5 for a tool with four siblings.

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

Parameters5/5

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

Schema description coverage is 0%, so the description must compensate and it does: all six parameters are explained, including the allowed platform values (x, linkedin, instagram, tiktok, youtube, xiaohongshu, wechat), the num_topics range 1-10, the language auto/en/zh options, and the semantics of trends and material. This adds meaning well beyond the bare schema.

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

Purpose4/5

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

The first line gives a precise verb and resource: generate platform-specific social posts from brand material, and the pipeline enumeration (brand DNA → trends → ideation → copy → visual → storyboard → QA) makes the scope concrete. It never references the siblings (check_post, save_draft, list_posts), so differentiation from alternatives is left to inference, which keeps it at 4 rather than 5.

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

Usage Guidelines3/5

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

The description supplies useful operational context — works offline without an API key, uses a real model when configured via YOMINPOST_PROVIDER/ANTHROPIC_API_KEY — but it never says when to reach for this tool versus check_post or save_draft, nor any prerequisite or exclusion. Usage is implied by the pipeline framing rather than stated.

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

list_platformsA

List generation targets and publishing channels (which ones publish for real and how they authenticate).

ParametersJSON Schema
NameRequiredDescriptionDefault

No parameters

Output Schema

ParametersJSON Schema
NameRequiredDescription

No output parameters

TDQS

A3.7/5.0
Behavior3/5

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

No annotations are provided, so the description carries the disclosure burden. 'List' implies a safe read operation, and the parenthetical adds that results indicate which channels publish for real and how they authenticate, but there is no statement of auth requirements, rate limits, or side effects (and no output schema caveat beyond the fact one exists).

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

Conciseness5/5

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

A single front-loaded sentence with zero filler; the parenthetical adds genuine information about the returned fields rather than restating the name.

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?

An output schema exists, so return values need not be spelled out, and the description is essentially complete for a zero-argument list tool. The only gap is the absence of any when-to-use routing against its four siblings.

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

Parameters4/5

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

The tool takes zero parameters, so the baseline of 4 applies. Schema coverage is 100% and there is nothing for the description to compensate for.

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

Purpose4/5

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

The description states a specific verb ('List') and a concrete resource ('generation targets and publishing channels'), which is clearly distinct from siblings like list_posts or generate_posts. It could sharpen the distinction further by naming when this differs from list_posts, but the resource is unambiguous.

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

Usage Guidelines3/5

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

There is no explicit when-to-use statement or named alternative. Usage is only implied by the phrasing 'generation targets' (i.e., consult this to discover where posts can go), leaving the agent to infer the ordering relative to generate_posts and check_post.

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

list_postsB

List posts in the local workspace. status: draft | scheduled | posted | failed (empty = all).

ParametersJSON Schema
NameRequiredDescriptionDefault
limitNo
statusNo

Output Schema

ParametersJSON Schema
NameRequiredDescription

No output parameters

TDQS

B3.2/5.0
Behavior3/5

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

No annotations are provided, so the description carries the burden; 'List' reasonably implies a read-only operation, and the status-filter semantics are genuinely added context beyond the structured fields. However, it says nothing about pagination behavior, ordering, or what happens when limit exceeds available posts.

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?

Two compact sentences, front-loaded with the core purpose and then the status filter semantics. Nothing is padding, though the terse format leaves gaps rather than being excessive.

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

Completeness3/5

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

An output schema exists, so return-value documentation is not required. The main remaining gap is the undocumented limit parameter and absence of any pagination or ordering note, which matters for a listing tool defaulting to 20 results.

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 0%, so the description must compensate. It documents the status parameter's allowed values ('draft | scheduled | posted | failed') and the empty-string default meaning ('empty = all'), which is real added value, but the limit parameter is left completely unexplained.

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

Purpose4/5

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

States a specific verb ('List') and resource ('posts') with a scope qualifier ('in the local workspace'), so the agent knows exactly what it returns. It doesn't differentiate from the sibling listing tool list_platforms or explain its relationship to generate_posts/check_post, but the action is unambiguous.

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 when-to-use guidance, no conditions, no mention of alternatives like check_post for a single post. The purpose is implied by the verb but the agent gets no routing help among the five siblings.

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

save_draftA

Save a post as a DRAFT in the local YominPost workspace, targeting the connected channels for the given platforms. It is not published; the user reviews and publishes it in the web UI.

ParametersJSON Schema
NameRequiredDescriptionDefault
ctaNo
hookNo
textYes
titleNo
hashtagsNo
platformsNo

Output Schema

ParametersJSON Schema
NameRequiredDescription

No output parameters

TDQS

A3.8/5.0
Behavior3/5

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

No annotations are provided, so the description carries the full disclosure burden. It usefully discloses the key side-effect profile (saved locally, not published) and that channels must already be connected, but says nothing about overwrite/duplicate behavior, what happens with unconnected platforms, or failure modes.

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

Conciseness5/5

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

Two sentences, front-loaded with the core action and scope, and the second sentence adds the essential non-publishing clarification. No filler or restatement of the tool name.

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

Completeness3/5

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

An output schema exists so return values need not be explained, and the purpose/side-effect profile is adequately covered. However, with 6 undocumented parameters and no annotations, the definition leaves meaningful gaps for an agent assembling a call.

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

Parameters2/5

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

Schema description coverage is 0% across 6 parameters, so the description must compensate and largely does not: only 'platforms' is implied by 'targeting the connected channels for the given platforms.' The hook, cta, hashtags, and title fields are never mentioned, and the only required parameter (text) is not explained.

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?

States a specific verb (save) and resource (post as a DRAFT) with an explicit scope: the local YominPost workspace, targeting connected channels for the given platforms. This is clearly distinguishable from siblings like generate_posts, check_post, and list_posts without opening a schema.

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

Usage Guidelines4/5

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

Makes the usage context explicit: the result is not published and the user must review and publish it in the web UI, which tells the agent this is the pre-publish path rather than a publish action. It stops short of naming a sibling alternative (e.g., a publish tool), so it is clear but not fully routing.

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

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

  1. 5 tool updatesv0.1.0
    • First observedcheck_post
    • First observedgenerate_posts
    • First observedlist_platforms
    • First observedlist_posts
    • First observedsave_draft

TDQS

A3.9/5.0

Scored across 5 tools

Disambiguation5/5

Each tool targets a clearly distinct action on the post lifecycle: generation, risk-checking, platform discovery, draft persistence, and listing. There is a slight question of whether generate_posts persists output, but save_draft explicitly owns persistence, so the boundary is legible.

Naming Consistency5/5

All five names follow a consistent verb_noun snake_case pattern (generate_posts, check_post, list_platforms, save_draft, list_posts). The only trivial deviation is singular 'check_post' vs plural 'list_posts', which is still readable and predictable.

Tool Count5/5

Five tools is well-scoped for a focused social-post generation and drafting server, with no redundant or filler tools. Each tool covers a distinct stage of the pipeline rather than duplicating capability.

Completeness4/5

Core lifecycle coverage is present: generate, validate, save draft, list posts, and discover platforms. Publishing is deliberately delegated to the web UI, but there is no get-single-post, update/edit, or delete tool, which leaves minor lifecycle gaps an agent must work around.

Maintenance

ActivityMaintained
ResponsivenessNo issues

Related MCP Connectors

Related MCP Servers

  • A
    license
    Not graded
    quality
    B
    maintenance
    Enables AI agents to manage social media posts across multiple platforms by scoring virality, generating threads, converting formats, optimizing hooks, scheduling campaigns, and validating platform limits.
    MIT
  • A
    license
    Not graded
    quality
    B
    maintenance
    Enables MCP-compatible assistants to manage social publishing workflows, including creating drafts, uploading media, scheduling, publishing, and monitoring delivery.
    205 npm
    Apache 2.0