update sse configuration

DEPLOYMENT_GUIDE.md

@@ -0,0 +1,146 @@
+# Strava MCP Deployment Guide
+
+This repository contains **two different server implementations** for different use cases:
+
+## 🎯 **Deployment Options**
+
+### 1. 🌐 **Hugging Face Spaces** (Web Interface + MCP SSE)
+**Use this for**: Web-based interface accessible via browser AND MCP Server-Sent Events endpoint
+
+**Entry Point**: `app.py` → `strava_mcp/gradio_server.py`
+
+**Features**:
+- Web-based Gradio interface with tabs
+- Manual OAuth token input
+- Step-by-step authentication guide
+- **MCP SSE endpoint at**: `https://your-space.hf.space/gradio_api/mcp/sse`
+- Perfect for sharing, demonstrations, and LLM integration
+
+**How to Deploy**:
+1. Upload your code to Hugging Face Spaces
+2. Set environment variables in Space settings:
+   ```bash
+   STRAVA_CLIENT_ID=your_client_id
+   STRAVA_CLIENT_SECRET=your_client_secret
+   ```
+3. Use the web interface to authenticate and get activities
+4. **For MCP clients**: Connect to `https://your-space.hf.space/gradio_api/mcp/sse`
+
+### 2. 🖥️ **Claude Desktop** (MCP Integration)
+**Use this for**: Direct integration with Claude Desktop application
+
+**Entry Point**: `run_mcp_server.py` → `strava_mcp/main.py` → `strava_mcp/server.py`
+
+**Features**:
+- Native MCP protocol support
+- Direct integration with Claude Desktop
+- Automatic OAuth flow (when possible)
+- Tools available directly in Claude conversations
+
+**How to Setup**:
+1. Add to your Claude Desktop config (`~/Library/Application Support/Claude/claude_desktop_config.json`):
+   ```json
+   {
+     "mcpServers": {
+       "strava": {
+         "command": "python",
+         "args": ["/path/to/strava-mcp/run_mcp_server.py"],
+         "env": {
+           "STRAVA_CLIENT_ID": "your_client_id",
+           "STRAVA_CLIENT_SECRET": "your_client_secret",
+           "STRAVA_REFRESH_TOKEN": "your_refresh_token"
+         }
+       }
+     }
+   }
+   ```
+
+## 🔧 **Key Differences**
+
+| Feature | Hugging Face Spaces | Claude Desktop |
+|---------|-------------------|----------------|
+| **Interface** | Web browser + SSE endpoint | Claude Desktop app |
+| **Authentication** | Manual token input | Environment variables |
+| **OAuth Flow** | Manual (with helper) | Can be automatic |
+| **Access** | Public/shareable | Local only |
+| **Protocol** | HTTP/Gradio + MCP/SSE | MCP/stdio |
+| **Use Case** | Demos, sharing, LLM integration | Personal use |
+| **MCP Endpoint** | `/gradio_api/mcp/sse` | stdio transport |
+
+## ❌ **Common Issues Fixed**
+
+### ASGI Protocol Errors
+**Problem**: Trying to run both Gradio and MCP server simultaneously caused ASGI conflicts.
+
+**Solution**: Separated the implementations:
+- Hugging Face Spaces: Uses only Gradio (removed `mcp_server=True`)
+- Claude Desktop: Uses only MCP server with stdio transport
+
+### Scope Permission Errors
+**Problem**: Refresh tokens created without `activity:read` scope.
+
+**Solution**: 
+- Updated OAuth URLs to include correct scopes: `read_all,activity:read,activity:read_all,profile:read_all`
+- Added clear error messages and guidance
+- Created OAuth Helper with step-by-step instructions
+
+## 📁 **File Structure**
+
+```
+strava-mcp/
+├── app.py                          # 🌐 HF Spaces entry point
+├── run_mcp_server.py               # 🖥️ Claude Desktop entry point
+├── claude_desktop_config_example.json # Configuration example
+├── strava_mcp/
+│   ├── gradio_server.py            # 🌐 Web interface (Gradio)
+│   ├── server.py                   # 🖥️ MCP server implementation
+│   ├── main.py                     # 🖥️ MCP server runner
+│   ├── api.py                      # Strava API client
+│   ├── auth.py                     # OAuth authentication
+│   ├── service.py                  # Business logic
+│   ├── models.py                   # Data models
+│   └── config.py                   # Settings
+└── check_token_scopes.py           # 🔧 Diagnostic tool
+```
+
+## 🚀 **Quick Start**
+
+### For Hugging Face Spaces:
+```bash
+# Deploy to HF Spaces with app.py as entry point
+# Set STRAVA_CLIENT_ID and STRAVA_CLIENT_SECRET in Space settings
+# Use web interface to authenticate
+```
+
+### For Claude Desktop:
+```bash
+# 1. Get your refresh token
+python check_token_scopes.py CLIENT_ID CLIENT_SECRET REFRESH_TOKEN
+
+# 2. Add to Claude Desktop config
+# 3. Restart Claude Desktop
+# 4. Use Strava tools in conversations
+```
+
+## 🆘 **Troubleshooting**
+
+### "ASGI Protocol Error"
+- **Cause**: Trying to use `mcp_server=True` in Gradio
+- **Fix**: Use separate deployments (this is now fixed)
+
+### "activity:read_permission missing"
+- **Cause**: Refresh token created without correct scopes
+- **Fix**: Get new token using OAuth Helper with correct scopes
+
+### "Service not initialized"
+- **Cause**: Missing environment variables
+- **Fix**: Set `STRAVA_CLIENT_ID`, `STRAVA_CLIENT_SECRET`, and `STRAVA_REFRESH_TOKEN`
+
+## 🎉 **Success!**
+
+After these fixes:
+- ✅ Hugging Face Spaces deployment works without ASGI errors
+- ✅ Claude Desktop integration works with proper MCP protocol
+- ✅ Clear separation between web interface and MCP server
+- ✅ Better error messages and authentication guidance
+- ✅ Comprehensive documentation and examples

run_mcp_server.py

@@ -0,0 +1,12 @@
+#!/usr/bin/env python3
+"""
+Entry point for running the MCP server locally (for Claude Desktop integration).
+This is separate from the Hugging Face Spaces deployment.
+"""
+
+from strava_mcp.main import main
+
+if __name__ == "__main__":
+    print("🚀 Starting Strava MCP Server for Claude Desktop...")
+    print("💡 For Hugging Face Spaces, use app.py instead")
+    main()

strava_mcp/gradio_server.py

@@ -119,28 +119,35 @@ def get_authorization_url() -> str:
 
 
 async def get_user_activities(
-    before: Optional[int] = None,
-    after: Optional[int] = None,
-    page: int = 1,
-    per_page: int = 30,
-) -> List[Dict]:
+    before: str = "",
+    after: str = "",
+    page: str = "1",
+    per_page: str = "30",
+) -> list[dict]:
     """Get the authenticated user's activities from Strava.
 
     Args:
-        before: An epoch timestamp for filtering activities before a certain time
-        after: An epoch timestamp for filtering activities after a certain time
-        page: Page number (default: 1)
-        per_page: Number of items per page (default: 30, max: 200)
+        before (str): An epoch timestamp for filtering activities before a certain time (leave empty for no filter)
+        after (str): An epoch timestamp for filtering activities after a certain time (leave empty for no filter)
+        page (str): Page number (default: 1)
+        per_page (str): Number of items per page (default: 30, max: 200)
 
     Returns:
         List of activities with details like name, distance, moving time, etc.
     """
+    # Convert string parameters to appropriate types
+    before_int = int(before) if before.strip() else None
+    after_int = int(after) if after.strip() else None
+    page_int = int(page) if page.strip() else 1
+    per_page_int = int(per_page) if per_page.strip() else 30
     try:
         await initialize_service()
         if service is None:
             raise ValueError("Service not initialized")
 
-        activities = await service.get_activities(before, after, page, per_page)
+        activities = await service.get_activities(
+            before_int, after_int, page_int, per_page_int
+        )
         return [activity.model_dump() for activity in activities]
     except Exception as e:
         logger.error(f"Error getting user activities: {str(e)}")
@@ -159,24 +166,27 @@ async def get_user_activities(
 
 
 async def get_activity_details(
-    activity_id: int,
-    include_all_efforts: bool = False,
-) -> Dict:
+    activity_id: str,
+    include_all_efforts: str = "false",
+) -> dict:
     """Get detailed information about a specific activity.
 
     Args:
-        activity_id: The unique ID of the activity
-        include_all_efforts: Whether to include all segment efforts (default: False)
+        activity_id (str): The unique ID of the activity
+        include_all_efforts (str): Whether to include all segment efforts (true/false, default: false)
 
     Returns:
         Detailed activity information including stats, segments, and metadata
     """
+    # Convert string parameters to appropriate types
+    activity_id_int = int(activity_id)
+    include_efforts_bool = include_all_efforts.lower().strip() == "true"
     try:
         await initialize_service()
         if service is None:
             raise ValueError("Service not initialized")
 
-        activity = await service.get_activity(activity_id, include_all_efforts)
+        activity = await service.get_activity(activity_id_int, include_efforts_bool)
         return activity.model_dump()
     except Exception as e:
         logger.error(f"Error getting activity details: {str(e)}")
@@ -192,21 +202,23 @@ async def get_activity_details(
             raise gr.Error(f"Failed to get activity details: {error_msg}")
 
 
-async def get_activity_segments(activity_id: int) -> List[Dict]:
+async def get_activity_segments(activity_id: str) -> list[dict]:
     """Get segment efforts for a specific activity.
 
     Args:
-        activity_id: The unique ID of the activity
+        activity_id (str): The unique ID of the activity
 
     Returns:
         List of segment efforts with performance data and rankings
     """
+    # Convert string parameter to appropriate type
+    activity_id_int = int(activity_id)
     try:
         await initialize_service()
         if service is None:
             raise ValueError("Service not initialized")
 
-        segments = await service.get_activity_segments(activity_id)
+        segments = await service.get_activity_segments(activity_id_int)
         return [segment.model_dump() for segment in segments]
     except Exception as e:
         logger.error(f"Error getting activity segments: {str(e)}")
@@ -254,10 +266,18 @@ def create_interface():
     activities_interface = gr.Interface(
         fn=get_user_activities,
         inputs=[
-            gr.Number(label="Before (epoch timestamp)", value=None, precision=0),
-            gr.Number(label="After (epoch timestamp)", value=None, precision=0),
-            gr.Number(label="Page", value=1, precision=0),
-            gr.Number(label="Per Page", value=30, precision=0),
+            gr.Textbox(
+                label="Before (epoch timestamp)",
+                value="",
+                placeholder="Leave empty for no filter",
+            ),
+            gr.Textbox(
+                label="After (epoch timestamp)",
+                value="",
+                placeholder="Leave empty for no filter",
+            ),
+            gr.Textbox(label="Page", value="1", placeholder="1"),
+            gr.Textbox(label="Per Page", value="30", placeholder="30"),
         ],
         outputs=gr.JSON(label="Activities"),
         title="📊 Get User Activities",
@@ -268,8 +288,10 @@ def create_interface():
     details_interface = gr.Interface(
         fn=get_activity_details,
         inputs=[
-            gr.Number(label="Activity ID", precision=0),
-            gr.Checkbox(label="Include All Efforts", value=False),
+            gr.Textbox(label="Activity ID", placeholder="Enter activity ID"),
+            gr.Textbox(
+                label="Include All Efforts", value="false", placeholder="true or false"
+            ),
         ],
         outputs=gr.JSON(label="Activity Details"),
         title="🔍 Get Activity Details",
@@ -280,7 +302,7 @@ def create_interface():
     segments_interface = gr.Interface(
         fn=get_activity_segments,
         inputs=[
-            gr.Number(label="Activity ID", precision=0),
+            gr.Textbox(label="Activity ID", placeholder="Enter activity ID"),
         ],
         outputs=gr.JSON(label="Activity Segments"),
         title="🏃 Get Activity Segments",
@@ -315,12 +337,14 @@ def main():
 
     demo = create_interface()
 
-    # Launch with MCP server enabled for Hugging Face Spaces
+    # Launch for Hugging Face Spaces with MCP server enabled via SSE
     demo.launch(
         mcp_server=True,
         server_name="0.0.0.0",
         server_port=7860,  # Standard port for HF Spaces
         share=False,
+        max_request_size=50 * 1024 * 1024,  # 50MB max request size
+        max_header_size=32768,  # 32KB max header size
     )
 
 

test_mcp_connection.py

@@ -0,0 +1,111 @@
+#!/usr/bin/env python3
+"""
+Test script to verify MCP SSE endpoint connectivity.
+This helps debug connection issues with the Strava MCP server.
+"""
+
+import asyncio
+import json
+import sys
+from typing import Optional
+
+import httpx
+
+
+async def test_mcp_sse_connection(base_url: str) -> bool:
+    """Test connection to the MCP SSE endpoint.
+    
+    Args:
+        base_url: The base URL of the Hugging Face Space (e.g., https://your-space.hf.space)
+        
+    Returns:
+        True if connection successful, False otherwise
+    """
+    mcp_url = f"{base_url.rstrip('/')}/gradio_api/mcp/sse"
+    schema_url = f"{base_url.rstrip('/')}/gradio_api/mcp/schema"
+    
+    print(f"🔍 Testing MCP connection to: {mcp_url}")
+    
+    # Test 1: Check if schema endpoint is accessible
+    print("\n1️⃣ Testing schema endpoint...")
+    try:
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            response = await client.get(schema_url)
+            
+            if response.status_code == 200:
+                print(f"✅ Schema endpoint accessible: {response.status_code}")
+                try:
+                    schema = response.json()
+                    tools = schema.get("tools", [])
+                    print(f"✅ Found {len(tools)} MCP tools:")
+                    for tool in tools:
+                        name = tool.get("name", "unknown")
+                        description = tool.get("description", "no description")
+                        print(f"   - {name}: {description}")
+                except Exception as e:
+                    print(f"⚠️  Schema response not JSON: {e}")
+            else:
+                print(f"❌ Schema endpoint failed: {response.status_code} - {response.text}")
+                return False
+                
+    except Exception as e:
+        print(f"❌ Schema endpoint error: {e}")
+        return False
+    
+    # Test 2: Check if SSE endpoint is accessible
+    print(f"\n2️⃣ Testing SSE endpoint...")
+    try:
+        headers = {
+            "Accept": "text/event-stream",
+            "Cache-Control": "no-cache",
+        }
+        
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            # Try a simple connection test
+            response = await client.get(mcp_url, headers=headers)
+            
+            if response.status_code == 200:
+                print(f"✅ SSE endpoint accessible: {response.status_code}")
+                print(f"✅ Content-Type: {response.headers.get('content-type', 'unknown')}")
+                return True
+            else:
+                print(f"❌ SSE endpoint failed: {response.status_code}")
+                print(f"❌ Response: {response.text}")
+                return False
+                
+    except Exception as e:
+        print(f"❌ SSE endpoint error: {e}")
+        return False
+
+
+def main():
+    """Main function to test MCP connection."""
+    if len(sys.argv) != 2:
+        print("Usage: python test_mcp_connection.py <hugging_face_space_url>")
+        print("Example: python test_mcp_connection.py https://burtenshaw-strava-mcp.hf.space")
+        sys.exit(1)
+    
+    base_url = sys.argv[1]
+    
+    print("🧪 MCP SSE Connection Test")
+    print(f"🎯 Target: {base_url}")
+    
+    success = asyncio.run(test_mcp_sse_connection(base_url))
+    
+    if success:
+        print(f"\n🎉 SUCCESS: MCP server is accessible!")
+        print(f"🔗 Your LLM can connect to: {base_url}/gradio_api/mcp/sse")
+        print(f"📋 Schema available at: {base_url}/gradio_api/mcp/schema")
+    else:
+        print(f"\n❌ FAILED: MCP server connection failed")
+        print("💡 Possible issues:")
+        print("   - Server not running or still starting up")
+        print("   - Authentication/credentials not configured")
+        print("   - Network connectivity issues")
+        print("   - Header size limitations")
+        
+    sys.exit(0 if success else 1)
+
+
+if __name__ == "__main__":
+    main()