# BlogIn MCP MCP

> BlogIn helps you manage your company's knowledge base through natural conversation. Use this MCP to write new posts, find specific policies in the wiki, track team updates, and check who works where—all without clicking through dozens of internal links.

## Overview
- **Category:** collaboration
- **Price:** Free
- **Tags:** internal-blog, team-communication, knowledge-sharing, company-updates, wiki-management, content-creation

## Description

Stop losing valuable information buried in old drives or forgotten SharePoint folders. This connection lets you treat your company's entire knowledge base like a searchable conversation. You can ask your agent to find the details for a specific post, pull up current HR policies from static pages, and even draft an announcement using titles and categories. It’s about making sure everyone knows where to look and what was last said. Since it connects directly through Vinkius, you get one point of access to manage posts, track discussions, and see who's on the team—all integrated into your regular workflow.

## Tools

### create_internal_post
Writes and publishes an entirely new blog post into the system.

### get_post_details
Pulls all the content, metadata, and HTML for one specific blog entry.

### list_categories
Provides a list of available topics or categories to help you narrow down searches.

### list_recent_comments
Gathers a feed of the newest discussion comments from various posts.

### list_internal_pages
Shows a list of static wiki pages that contain company policies and handbooks.

### list_posts
Retrieves a summary listing of all posts in the internal blog system.

### list_team_members
Fetches a directory list of all accounts and users within your organization.

## Prompt Examples

**Prompt:** 
```
List the most recent internal blog posts.
```

**Response:** 
```
I've retrieved your latest posts. You have: 'New Office Policies', 'Team Lunch Recap', and 'Quarterly Roadmap Update'. Which one would you like to read the details for?
```

**Prompt:** 
```
Show me the comments for the post 'Quarterly Roadmap Update'.
```

**Response:** 
```
I've fetched the comments. There are 3 recent discussions including positive feedback from Sarah and a question from Mike about the timeline. Shall I retrieve the full text of the comments?
```

**Prompt:** 
```
Create an internal post: 'New Benefits Guide' in the 'HR' category.
```

**Response:** 
```
Success! The post 'New Benefits Guide' has been created in the 'HR' category (ID: cat_10293). It is now published and visible to your team members in BlogIn.
```

## Capabilities

### Drafting new content
Create a brand new blog post with full text, title, and category directly through conversation.

### Retrieving specific posts
Get all the metadata and HTML for an existing post using its identifier.

### Mapping company policies
Query static internal wiki pages to find company handbooks or guidelines.

### Identifying team members
List all users and account members, giving you a quick overview of the organizational structure.

### Monitoring feedback
See recent comments across multiple posts to keep track of internal discussion threads.

## Use Cases

### Need to draft an urgent announcement about new PTO rules.
The HR manager asks their agent: 'Draft a post on updated PTO guidelines.' The agent uses `create_internal_post` and publishes the content, notifying everyone in the system.

### A new team member needs to know the current vacation policy.
Instead of searching multiple tabs, they ask: 'What are the company policies on PTO?' The agent queries `list_internal_pages` and gives them a direct answer from the handbook.

### A project post is getting confusing; I need to know who contributed.
The Project Manager asks: 'Who were the key contributors on the Q2 Roadmap update?' The agent uses `list_team_members` to retrieve and summarize the relevant user profiles.

### I want to see if there's any buzz or feedback on the new benefits guide.
The Comm team member asks: 'What are the latest comments on the Benefits Guide?' The agent runs `list_recent_comments` and presents a summarized feed of discussion points.

## Benefits

- You can instantly create new announcements using the `create_internal_post` tool. Just give your agent a title and text, and it publishes the post immediately.
- Instead of navigating through complex folder structures to find policy info, you ask the system to list internal pages or get specific details on company handbooks.
- Need context on who worked on this? Use `list_team_members` to quickly see contributor profiles without leaving your chat window.
- Stay in the loop by monitoring recent discussion comments. This lets you track team feedback and know if a post needs an update, all using `list_recent_comments`.
- When you need to find content by topic, first run `list_categories`. Then, let the agent pull relevant posts for you, making discovery simple.
- The system summarizes everything. You can get a full list of available blog entries via `list_posts`, giving your agent enough data to answer complex questions.

## How It Works

The bottom line is you use your AI client to ask questions that query and synthesize information from all parts of your internal blog system.

1. Subscribe to this MCP and input your BlogIn API Key and Subdomain credentials.
2. Connect your preferred AI client (Claude, Cursor, etc.) via Vinkius.
3. Start by simply asking your agent a question like: 'What are the latest updates regarding remote work policies?'

## Frequently Asked Questions

**How do I use the list_team_members tool with BlogIn MCP?**
You simply ask your agent to 'list all team members.' The agent executes `list_team_members` and gives you a directory of names, roles, and accounts.

**Can I use create_internal_post for drafting announcements?**
Yes. You tell the agent what you want to announce, specify the category, and it uses `create_internal_post` to publish the content directly into your blog system.

**If I need an official policy, should I use list_posts or list_internal_pages?**
Always start by asking about policies. The agent will query `list_internal_pages`, which is designed for static documents like handbooks, keeping them separate from regular announcements.

**What if I want to see all the comments on a post?**
You ask your agent to check recent discussions. It uses `list_recent_comments` to pull in the latest feedback and helps you keep track of internal conversations.

**How can I use the list_categories tool to find relevant content groupings?**
The `list_categories` tool provides a full rundown of all available post topics. This is useful for seeing what kinds of knowledge your company already tracks, letting you filter by topic rather than searching through titles.

**What specific information do I get when using the get_post_details tool?**
It returns both detailed metadata and the full HTML content for one specific blog post. You use this tool when you need to read the entire article, not just see its title or summary.

**Should I use list_posts if I only want a quick overview of everything published?**
Yes, `list_posts` gives you a fast rundown of all existing entries. It lists the posts without pulling their full content, making it perfect for auditing or checking titles across your entire knowledge base.

**How does list_internal_pages differ from listing regular blog posts?**
Internal pages handle static documentation like handbooks and formal company policies. You use `list_internal_pages` when you need structured reference material, while `list_posts` pulls content that was published as a traditional article.

**Can I see the HTML content of a specific internal post via AI?**
Yes! Use the `get_post_details` tool and provide the Post ID. Your agent will retrieve the complete metadata and HTML body for that specific blog entry.

**How do I list all the static wiki pages in my account?**
Run the `list_internal_pages` query. The agent will retrieve a complete list of all static, wiki-style pages currently configured in your BlogIn account.

**Is it possible to create a new internal post via AI?**
Absolutely. Use the `create_internal_post` action. Provide a title, the content, and an optional category ID to publish a new update instantly to your team.