yominpost-mcp
Supports generating and publishing posts to Bluesky.
Enables generating and publishing posts to Discord channels.
Supports creating posts for Facebook Pages, including format selection and pre-publish risk checks, with real publishing.
Allows generating Instagram posts, including carousels and image posts, with real publishing support.
Supports posting to Mastodon with zero-config app registration and real publishing.
Enables generating platform-native Pinterest posts and risk-checking them; publishing is currently simulated.
Enables generating and risk-checking Reddit posts, with real publishing support via Reddit's API.
Allows generating and publishing posts to Telegram.
Enables generating platform-native Threads posts and risk-checking them; publishing is currently simulated.
Enables generating platform-native TikTok posts and risk-checking them; publishing is currently simulated.
Enables generating platform-native Xiaohongshu posts and risk-checking them; publishing is currently simulated.
Provides short-video storyboard and SRT generation for YouTube Shorts, with real publishing support.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@yominpost-mcpturn this launch announcement into posts for x, linkedin, and tiktok"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
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-mcpCursor: 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.mdInstructions 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 |
|
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 |
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] --> SVCData 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 |
|
|
| Enables the |
| Real image generation (gpt-image, any OpenAI-compatible endpoint) |
| OAuth apps for one-click Connect (or paste them once on the Settings page) |
| Data root, default |
| 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.shCode 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/codexCLI 或 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 toolscheck_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.
| Name | Required | Description | Default |
|---|---|---|---|
| text | Yes | ||
| hashtags | No | ||
| platform | No | x |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
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.
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.
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.
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.
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.
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.
| Name | Required | Description | Default |
|---|---|---|---|
| brand | Yes | ||
| trends | No | ||
| language | No | auto | |
| material | No | ||
| platforms | No | ||
| num_topics | No |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
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.
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.
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.
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.
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.
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).
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
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.
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.
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.
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.
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.
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).
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | ||
| status | No |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
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.
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.
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.
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.
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.
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.
| Name | Required | Description | Default |
|---|---|---|---|
| cta | No | ||
| hook | No | ||
| text | Yes | ||
| title | No | ||
| hashtags | No | ||
| platforms | No |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
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.
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.
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.
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.
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.
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.
5 tool updates
v0.1.0- First observed
check_post - First observed
generate_posts - First observed
list_platforms - First observed
list_posts - First observed
save_draft
TDQS
Scored across 5 tools
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.
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.
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.
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
Related MCP Connectors
Draft, validate, publish, schedule, and manage social posts across connected accounts.
Draft, schedule and publish social posts to nine platforms from any AI agent.
World-class creative social media content studio, powered by AI.
Draft, schedule and publish social media posts from any AI agent.
Related MCP Servers
- FlicenseNot gradedqualityDmaintenanceEnables AI agents to create, schedule, and manage social media posts across 10 platforms via a unified API.-
- AlicenseNot gradedqualityBmaintenanceEnables 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
- AlicenseNot gradedqualityBmaintenanceEnables MCP-compatible assistants to manage social publishing workflows, including creating drafts, uploading media, scheduling, publishing, and monitoring delivery.205 npmApache 2.0
- AlicenseNot gradedqualityBmaintenanceEnables AI assistants to draft, schedule, and publish social media content, generate AI text and image variations, analyze performance, and automate social workflows.MIT