# Poe MCP

> The Poe MCP Server manages your AI chatbot infrastructure directly through API calls. Use this to list, create, update, and delete bots on the Poe platform. You can also monitor conversation history with `list_messages`, track usage stats via `get_bot_stats`, or chain responses between different models using `query_bot`.

## Overview
- **Category:** ai-frontier
- **Price:** Free
- **Tags:** chatbot-development, llm-orchestration, model-chaining, ai-platforms, bot-management, conversational-ai

## Description

You're dealing with Poe—you need your AI agent to talk to it like it's just another service, not something you have to log into via a web dashboard. This server lets you manage and execute against all those bots programmatically. You don't wanna manually mess around on the site; you want your code to handle the whole thing.

**Managing Your Bot Infrastructure**

You can control the entire lifecycle of any Poe API bot using specific functions. Need a new bot? Use `create_bot` and specify all the parameters—the name, the model type, and the base URL—to get it set up right in your code. If you've got an existing bot that needs tweaks, run `update_bot`; it applies those changes immediately for any conversations that follow. When a bot is dead weight or just obsolete, use `delete_bot` to pull it off the platform completely; remember, though, this action wipes out all history and settings, so you gotta be careful.

To check what's already running, run `list_bots`, which gives you a complete list of every bot under your connected Poe account. If you only care about one specific setup, use `get_bot` with the ID to pull up its detailed configuration and metadata for a quick review. You can also peep at all the publicly available bots on the platform that your own systems can connect to using `list_available_bots`. 

**Running Queries and Chaining Models**

This is where the real power is. Forget running queries manually; you'll use `query_bot` to run a specified bot on Poe, allowing you to pull its response directly into your workflow. This lets you chain responses—say, getting GPT-4 to summarize a document, and then feeding that summary right into Claude for refinement or tone adjustment. You can also test connectivity fast by running `send_message`, which simulates a user sending an actual message to the bot endpoint. If you want to just verify if a whole sequence of models works together, this function validates that connection point.

**Monitoring and Debugging Data**

You need hard data on how your bots are doing, right? You can pull usage statistics for any specified Poe bot using `get_bot_stats`. This gives you quantitative metrics like the total message count and the number of unique users who've actually interacted with it. If a bot starts acting weird or misses context, don't guess—use `list_messages` to fetch the recent conversation history. It shows you every message content and the timestamps for serious debugging or if you just wanna analyze usage patterns.

**The Bottom Line**

In short, your agent uses this server to handle everything: it builds bots using `create_bot`, modifies them with `update_bot` or removes 'em with `delete_bot`; it runs complex logic by chaining models through `query_bot`; and you can track the whole performance picture—from message counts via `get_bot_stats` to specific conversation logs using `list_messages`. You've got total programmatic control over your Poe chatbot infrastructure.

## Tools

### create_bot
Creates a new API bot on Poe using specified parameters like name, model, and base URL.

### delete_bot
Permanently removes an existing Poe API bot. Be careful; this action loses all history and settings.

### list_available_bots
Lists all publicly available bots on the Poe platform that your own bots can connect to and query.

### get_bot_stats
Pulls usage statistics—like message counts and unique users—for any specified Poe bot.

### get_bot
Retrieves the detailed configuration and metadata for a single, specific Poe bot ID.

### list_bots
Returns a comprehensive list of every bot you own under your connected Poe account.

### list_messages
Fetches the recent conversation history, showing message content and timestamps for debugging or analysis.

### query_bot
Runs a specified bot on Poe, allowing you to chain its response into your current workflow as input data.

### send_message
Simulates a user sending a message to a Poe bot endpoint for quick connectivity testing and validation.

### update_bot
Changes the configuration settings of an existing Poe bot, applying changes immediately for new conversations.

## Prompt Examples

**Prompt:** 
```
List all my bots and show stats for the first one.
```

**Response:** 
```
🤖 You have 3 bots: SummaryBot, Translator, CodeAssistant. Stats for SummaryBot: 1,247 messages, 89 unique users, avg response 2.3s.
```

**Prompt:** 
```
Create a bot called 'Research Assistant' using GPT-4 that summarizes articles.
```

**Response:** 
```
✅ Bot created! 'Research Assistant' (ID: bot_123) using GPT-4. Configure your endpoint URL in the bot settings.
```

**Prompt:** 
```
Query Claude-3.5-Sonnet from my ResearchBot: 'What are the key trends in AI?'
```

**Response:** 
```
🤖 Claude-3.5-Sonnet responded: 'Key AI trends include multimodal models, agentic workflows, and reasoning capabilities...' Response received successfully.
```

## Capabilities

### Manage Bot Configurations
Create, update, or delete Poe API bots programmatically to control their settings.

### Chain AI Model Responses
Run a bot query through multiple different models (GPT-4, Claude, etc.) and use the output from one model as input for the next.

### Monitor Conversations
View detailed message logs and timestamps using `list_messages` to debug user interactions or analyze patterns.

### Track Usage Metrics
Get quantitative data on bot performance, including total messages sent and unique users engaged with the bot (`get_bot_stats`).

### Test Endpoints
Send simulated test messages using `send_message` to validate that a bot is correctly connected and responding.

## Use Cases

### Analyzing Support Ticket Responses
The Community Manager needs to audit if their 'SupportBot' is keeping up. They use `list_messages` to pull the last 50 conversations, then run `get_bot_stats` to see if message volume spiked this week, identifying potential resource bottlenecks.

### Building a Research Pipeline
An AI Researcher wants to compare how GPT-4 and Claude summarize the same text. The agent first uses `list_available_bots` to identify both models, then runs `query_bot` twice—once for each model—to get comparable outputs in a single workflow.

### Automated Bot Deployment
A Bot Developer finishes a new bot concept. They use `create_bot` to spin up the initial version, then immediately use `update_bot` to set the final system prompt and test it with `send_message` before going live.

### Auditing Account Status
A DevOps Engineer needs a quick inventory. They run `list_bots` to see everything owned, then use `get_bot` on the most critical bot to verify its current model settings and endpoint URL.

## Benefits

- **Full Bot Lifecycle Control:** You gain the ability to programmatically manage every bot. Instead of logging in to create a new service, use `create_bot` or `update_bot` directly through your agent's API call.
- **Cross-Model Logic (Chaining):** Stop running models in silos. Use `query_bot` to build complex logic where Model A generates data and passes that result for refinement by Model B.
- **Immediate Debugging:** When a bot fails, you don't have to guess why. Run `list_messages` to pull the full conversation history, see timestamps, and debug exactly where the interaction broke down.
- **Performance Benchmarking:** Need to know if your bot is underutilized? Use `get_bot_stats`. It gives metrics like message counts and unique users—hard numbers you need for product reporting.
- **Zero-Friction Testing:** Before deploying a new workflow, use `send_message` to fire off a test payload. This validates the endpoint connection instantly without simulating an actual user interaction.

## How It Works

The bottom line is that you treat Poe as a managed API service, allowing your agent to perform all necessary bot administrative tasks without manual web interaction.

1. First, subscribe to the server and give your AI client the Poe API access token.
2. Then, use an agent command (e.g., 'List all my bots') to call the `list_bots` tool.
3. Finally, you get a structured list of every bot ID, name, and status configured under your account.

## Frequently Asked Questions

**How do I list all my bots using the Poe MCP Server?**
You call `list_bots`. This tool returns an array containing the name, handle, and status of every single bot configured under your Poe account.

**What is `query_bot` used for in a workflow?**
`query_bot` allows you to run one specific bot (e.g., Claude) from another part of your code, using that bot's output as direct input data for the next step.

**Can I test my bot without a real user?**
Yes. Use `send_message`. This tool simulates a user sending a message to the specified bot endpoint, letting you verify connectivity and response quality without generating actual history.

**What if I need to change my bot's settings?**
Use `update_bot`. You provide the new configuration parameters (like a revised system prompt or model type) and the changes take effect immediately for all future conversations.

**What API token do I need to use the `list_bots` tool?**
You must provide your Poe API access token from creator.poe.com. This token authenticates your connection and allows the agent to list all bots associated with your account.

**How do I debug a bot that is giving unexpected responses using `list_messages`?**
Use `list_messages` to view recent conversations. This returns message content, timestamps, and user IDs, letting you analyze the exact input or response data for debugging.

**Does `get_bot_stats` help me monitor performance bottlenecks?**
Yes, `get_bot_stats` provides usage statistics. You can track message counts, unique users, and average response times to spot where your bot needs optimization.

**What is the risk of using the `delete_bot` tool?**
Be careful; this action removes a bot permanently. The API call deletes all associated conversation history and settings, so double-check before running it.

**How do I get a Poe API access token?**
Go to [creator.poe.com](https://creator.poe.com/), navigate to Settings > API, and generate an access token. This token authenticates all API requests for bot management.

**What AI models can I query through Poe?**
Poe has GPT-4, GPT-4o, Claude 3.5 Sonnet, Claude 3 Opus, Llama 3, and dozens of specialized bots. Use query_bot to chain responses from multiple models in your workflows.

**How does bot chaining work?**
Using Poe API v2, your bot can query any other bot on Poe for free. The response becomes input for your bot's processing. Costs are covered by the user's free message limit or subscription.