Skip to main content
Build your first MCP server in 5 minutes. This guide walks you through deploying a real-world integration that fetches live ISS position data and makes it conversationally available in Poke.

​
Clone the Examples Repository

  1. Fork the poke-mcp-examples repository on GitHub
  2. Clone your fork and navigate to the ISS tracker example: 
git clone https://github.com/YOUR_USERNAME/poke-mcp-examples.git
cd poke-mcp-examples/iss-tracker
conda create -n iss-tracker python=3.12
conda activate iss-tracker
pip install -r requirements.txt
The ISS tracker example includes:
  • Complete MCP server with streamable HTTP transport
  • Two working tools: get_iss_location and get_server_info
  • Real-time data from a public API
  • Ready to deploy
The repository contains multiple examples: ISS Tracker (no auth), Weather API (API key), WHOOP (OAuth proxy), and Bookmark Manager (full OAuth + DCR). Perfect for learning different patterns.

​
Review the Code

The src/server.py file contains a complete working integration: 
#!/usr/bin/env python3
import os
import httpx
from fastmcp import FastMCP

mcp = FastMCP("ISS Position Tracker")

ISS_API_URL = "https://api.wheretheiss.at/v1/satellites/25544"

@mcp.tool(description="Get formatted location information about the ISS including coordinates and altitude")
async def get_iss_location() -> str:
    """Get a human-readable description of the ISS current location"""
    async with httpx.AsyncClient() as client:
        response = await client.get(ISS_API_URL)
        response.raise_for_status()
        data = response.json()

        lat = data.get("latitude")
        lon = data.get("longitude")
        alt = data.get("altitude")
        vel = data.get("velocity")

        # Determine hemisphere directions
        lat_dir = "N" if lat >= 0 else "S"
        lon_dir = "E" if lon >= 0 else "W"

        return (
            f"The ISS is currently at {abs(lat):.2f}° {lat_dir}, {abs(lon):.2f}° {lon_dir}, "
            f"flying at an altitude of {alt:.2f} km and traveling at {vel:.2f} km/h."
        )

@mcp.tool(description="Get information about the MCP server including name, version, and environment")
def get_server_info() -> dict:
    """Get information about this MCP server"""
    return {
        "server_name": "ISS Position Tracker",
        "version": "1.0.0",
        "environment": os.environ.get("ENVIRONMENT", "development"),
        "python_version": os.sys.version.split()[0],
        "api_source": ISS_API_URL
    }

if __name__ == "__main__":
    port = int(os.environ.get("PORT", 8000))
    host = "0.0.0.0"

    print(f"Starting ISS Position Tracker MCP server on {host}:{port}")

    mcp.run(
        transport="http",
        host=host,
        port=port,
        stateless_http=True
    )
Key features:
  • Two tools: get_iss_location for live tracking and get_server_info for metadata
  • Async HTTP: Fetches real-time data from wheretheiss.at API
  • Human-readable output: Formats coordinates and altitude for conversation
  • No authentication: Perfect first example using public data
Test it locally: 
python src/server.py
You should see: Starting ISS Position Tracker MCP server on 0.0.0.0:8000

​
Test with MCP Inspector

Verify your tools are working using the MCP Inspector:
  1. In another terminal, run: 
    npx @modelcontextprotocol/inspector
    This will automatically open the Inspector in your browser.
  2. In the Inspector, enter http://localhost:8000/mcp as the server URL (note the /mcp path)
  3. Select “Via Proxy” as the connection type and click Connect
  4. Navigate to the Tools tab to see your get_iss_location and get_server_info tools listed
  5. Click on get_iss_location and run it to see live ISS data

​
Deploy Your Server

Deploy to Render:
  1. Connect your GitHub account to Render
  2. Create a new Web Service and select your forked poke-mcp-examples repository
  3. Configure the service:
    • Build Command: pip install -r requirements.txt
    • Start Command: python src/server.py
    • Working Directory: iss-tracker
  4. Deploy
Your server will be available at: 
https://your-service-name.onrender.com/mcp
You can also use FastMCP Cloud or any Python web hosting service that supports HTTPS (Railway, Fly.io, AWS Lambda, Google Cloud Run, etc.). The key requirement is a publicly accessible HTTPS endpoint.

​
Connect to Poke

  1. Go to poke.com/settings/connections/integrations/new
  2. Enter a connection name (e.g., “ISS Position Tracker”)
  3. Paste your server URL including the /mcp path (e.g., https://your-service-name.onrender.com/mcp)
  4. Leave API Key blank (this integration doesn’t need authentication)
  5. Click Connect
Poke calls your server’s endpoints and caches the tool schemas. You should see “ISS Position Tracker” in your connected integrations.

​
Test Your Integration

Go to your conversation with Poke and ask:
Where is the ISS right now?
You should see a formatted response like “The ISS is currently at 45.23° N, 122.45° W, flying at an altitude of 408.5 km and traveling at 27,500 km/h.”
Try asking Poke to “send me the ISS position every morning at 8am.” It will automatically set up a recurring reminder that calls your tool daily.

​
Common Issues

Invalid MCP server URL If connection fails, verify:
  1. Your URL includes the /mcp path (e.g., https://your-service.onrender.com/mcp)
  2. Your server is publicly accessible and live. Test it: 
    curl https://your-service-name.onrender.com/mcp
  3. Render free instances shut down after inactivity. Visit your URL in a browser to wake it up, then try connecting again.
Changes not appearing Poke caches tool schemas when you connect. To update: disconnect your integration in Settings, then reconnect. See Tool Lifecycle for details.

​
Next Steps

You’ve deployed a working integration. Now explore:
All examples in the poke-mcp-examples repository are production-ready and follow best practices. Use them as templates for your own integrations.