MCP Python Examples

import requests
import base64

API_KEY = "pk_your_api_key_here"
BASE_URL = "https://poe.poesius.com/api/v1/mcp"

def read_document(file_path):
    """Read and encode document as base64"""
    with open(file_path, 'rb') as f:
        return base64.b64encode(f.read()).decode('utf-8')

def call_mcp_tool(tool_name, arguments):
    """Call an MCP tool"""
    response = requests.post(
        f"{BASE_URL}/messages",
        headers={
            "X-API-Key": API_KEY,
            "Content-Type": "application/json"
        },
        json={
            "method": "tools/call",
            "params": {
                "name": tool_name,
                "arguments": arguments
            }
        }
    )
    response.raise_for_status()
    return response.json()

# Step 1: List templates
templates = call_mcp_tool("list_templates", {})
template_id = templates["result"]["templates"][0]["template_id"]
print(f"Using template: {template_id}")

# Step 2: Generate slides
document_base64 = read_document("document.pdf")
result = call_mcp_tool("generate_slides", {
    "topic": "Quarterly Business Review",
    "instructions": "Create a comprehensive presentation with 15 slides",
    "template_id": template_id,
    "num_slides": 15,
    "document_base64": document_base64
})

print(f"Generated {result['result']['total_slides']} slides")
print(f"Download URL: {result['result']['download_url']}")

import requests
import base64

API_KEY = "pk_your_api_key_here"
BASE_URL = "https://poe.poesius.com/api/v1/mcp"

def call_mcp_tool(tool_name, arguments):
    response = requests.post(
        f"{BASE_URL}/messages",
        headers={
            "X-API-Key": API_KEY,
            "Content-Type": "application/json"
        },
        json={
            "method": "tools/call",
            "params": {
                "name": tool_name,
                "arguments": arguments
            }
        }
    )
    response.raise_for_status()
    return response.json()

def read_document(file_path):
    with open(file_path, 'rb') as f:
        return base64.b64encode(f.read()).decode('utf-8')

# Step 1: Generate content
document_base64 = read_document("document.pdf")
content_result = call_mcp_tool("generate_presentation_content", {
    "topic": "AI in Healthcare",
    "instructions": "Generate comprehensive content for 20 slides",
    "num_slides": 20,
    "document_base64": document_base64
})

presentation_id = content_result["result"]["presentation_id"]
markdown_content = content_result["result"]["content"]

print("Content generated. Review and edit if needed.")
print(f"Content preview: {markdown_content[:200]}...")

# Step 2: Create slides from content
slide_result = call_mcp_tool("slide_from_content", {
    "content": markdown_content,
    "instructions": "Create professional slides with consistent styling",
    "template_id": "123e4567-e89b-12d3-a456-426614174000",
    "presentation_id": presentation_id
})

print(f"Created {len(slide_result['result']['slides'])} slides")

import requests

API_KEY = "pk_your_api_key_here"
BASE_URL = "https://poe.poesius.com/api/v1/mcp"

def refine_slide(slide_id, instructions, layout_name=None, conversation_id=None):
    """Refine an existing slide"""
    arguments = {
        "slide_id": slide_id,
        "instructions": instructions
    }
    
    if layout_name:
        arguments["layout_name"] = layout_name
    
    if conversation_id:
        arguments["conversation_id"] = conversation_id
    
    response = requests.post(
        f"{BASE_URL}/messages",
        headers={
            "X-API-Key": API_KEY,
            "Content-Type": "application/json"
        },
        json={
            "method": "tools/call",
            "params": {
                "name": "refine_slide",
                "arguments": arguments
            }
        }
    )
    response.raise_for_status()
    return response.json()

# Refine a slide
result = refine_slide(
    slide_id="uuid",
    instructions="Make the content more concise and add a call-to-action",
    layout_name="Content Slide"
)

print(f"Refined slide: {result['result']['slide']['slide_number']}")
print(f"Download URL: {result['result']['slide']['download_url']}")

import requests
import base64
from typing import Optional, Dict, Any

class PoesiusMCP:
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.base_url = "https://poe.poesius.com/api/v1/mcp"
    
    def _call_tool(self, tool_name: str, arguments: Dict[str, Any]) -> Dict:
        """Internal method to call MCP tools"""
        response = requests.post(
            f"{self.base_url}/messages",
            headers={
                "X-API-Key": self.api_key,
                "Content-Type": "application/json"
            },
            json={
                "method": "tools/call",
                "params": {
                    "name": tool_name,
                    "arguments": arguments
                }
            }
        )
        response.raise_for_status()
        return response.json()
    
    def list_templates(self, limit: int = 50, offset: int = 0) -> Dict:
        """List available templates"""
        return self._call_tool("list_templates", {
            "limit": limit,
            "offset": offset
        })
    
    def generate_slides(
        self,
        topic: Optional[str] = None,
        instructions: str = "",
        template_id: Optional[str] = None,
        num_slides: Optional[int] = None,
        document_path: Optional[str] = None
    ) -> Dict:
        """Generate slides end-to-end"""
        arguments = {"instructions": instructions}
        
        if topic:
            arguments["topic"] = topic
        if template_id:
            arguments["template_id"] = template_id
        if num_slides:
            arguments["num_slides"] = num_slides
        if document_path:
            with open(document_path, 'rb') as f:
                arguments["document_base64"] = base64.b64encode(
                    f.read()
                ).decode('utf-8')
        
        return self._call_tool("generate_slides", arguments)
    
    def refine_slide(
        self,
        slide_id: str,
        instructions: str,
        layout_name: Optional[str] = None
    ) -> Dict:
        """Refine an existing slide"""
        arguments = {
            "slide_id": slide_id,
            "instructions": instructions
        }
        if layout_name:
            arguments["layout_name"] = layout_name
        
        return self._call_tool("refine_slide", arguments)

# Usage
client = PoesiusMCP("pk_your_api_key_here")

# List templates
templates = client.list_templates()
template_id = templates["result"]["templates"][0]["template_id"]

# Generate slides
result = client.generate_slides(
    topic="My Presentation",
    instructions="Create professional slides",
    template_id=template_id,
    num_slides=15,
    document_path="document.pdf"
)

print(f"Generated {result['result']['total_slides']} slides")

import requests
from typing import Optional

class PoesiusMCPError(Exception):
    """Base exception for Poesius MCP errors"""
    pass

class TemplateRequiredError(PoesiusMCPError):
    """Raised when a template is required but not provided"""
    pass

def call_mcp_tool_safe(tool_name: str, arguments: dict, api_key: str) -> dict:
    """Call MCP tool with error handling"""
    try:
        response = requests.post(
            "https://poe.poesius.com/api/v1/mcp/messages",
            headers={
                "X-API-Key": api_key,
                "Content-Type": "application/json"
            },
            json={
                "method": "tools/call",
                "params": {
                    "name": tool_name,
                    "arguments": arguments
                }
            },
            timeout=30
        )
        response.raise_for_status()
        result = response.json()
        
        # Check for template required response
        if result.get("result", {}).get("requires_template"):
            raise TemplateRequiredError(
                "Template required. Available templates: "
                f"{result['result']['available_templates']}"
            )
        
        return result
        
    except requests.exceptions.RequestException as e:
        raise PoesiusMCPError(f"Request failed: {e}") from e