Backend Builder 🔧

# FastAPI REST API
/agent backend-builder "Create a REST API for sports leagues with CRUD operations" --runtime python --framework fastapi
 
# Express GraphQL API
/agent backend-builder "Build a GraphQL API for user management" --runtime node --framework express --type graphql
 
# Hono MCP Server
/agent backend-builder "Create an MCP server for document processing" --runtime bun --framework hono --type mcp-server

/agent backend-builder "Create an MCP server for sports data with tools:
 
Tools:
- get_league_info(league_id: str) -> League
- search_players(query: str, limit: int) -> List[Player]
- get_game_stats(game_id: str) -> GameStats
- predict_winner(team1_id: str, team2_id: str) -> Prediction
 
Database: Supabase
Authentication: API key
Deployment: Cloud Run" --runtime python --framework fastapi --type mcp-server

#!/usr/bin/env python3
"""
Sports Data MCP Server
 
Provides Claude Code with sports league data access.
"""
from fastmcp import FastMCP
from typing import List, Optional
import os
 
from .services import LeagueService, PlayerService, GameService
 
# Initialize MCP server
mcp = FastMCP("sports-data")
 
# Initialize services
league_service = LeagueService(supabase_url=os.getenv("SUPABASE_URL"))
player_service = PlayerService(supabase_url=os.getenv("SUPABASE_URL"))
game_service = GameService(supabase_url=os.getenv("SUPABASE_URL"))
 
@mcp.tool()
async def get_league_info(league_id: str) -> dict:
    """
    Get detailed information about a sports league.
 
    Args:
        league_id: Unique league identifier
 
    Returns:
        League details including teams, standings, and statistics
    """
    league = await league_service.get_by_id(league_id)
    if not league:
        raise ValueError(f"League {league_id} not found")
 
    return {
        "id": league.id,
        "name": league.name,
        "sport": league.sport,
        "teams_count": len(league.teams),
        "season": league.current_season,
        "standings": await league_service.get_standings(league_id)
    }
 
@mcp.tool()
async def search_players(
    query: str,
    limit: int = 10
) -> List[dict]:
    """
    Search for players across all leagues.
 
    Args:
        query: Search query (name, team, position)
        limit: Maximum results to return
 
    Returns:
        List of matching players
    """
    players = await player_service.search(query, limit=limit)
 
    return [
        {
            "id": p.id,
            "name": p.name,
            "team": p.team.name,
            "position": p.position,
            "stats": p.season_stats
        }
        for p in players
    ]
 
@mcp.tool()
async def get_game_stats(game_id: str) -> dict:
    """
    Get detailed statistics for a game.
 
    Args:
        game_id: Unique game identifier
 
    Returns:
        Game statistics including scores, player stats, and events
    """
    game = await game_service.get_with_stats(game_id)
    if not game:
        raise ValueError(f"Game {game_id} not found")
 
    return {
        "id": game.id,
        "home_team": game.home_team.name,
        "away_team": game.away_team.name,
        "score": f"{game.home_score} - {game.away_score}",
        "status": game.status,
        "player_stats": game.player_stats,
        "key_events": game.key_events
    }
 
@mcp.tool()
async def predict_winner(
    team1_id: str,
    team2_id: str
) -> dict:
    """
    Predict the winner of a matchup between two teams.
 
    Args:
        team1_id: First team identifier
        team2_id: Second team identifier
 
    Returns:
        Prediction with probability and reasoning
    """
    prediction = await game_service.predict_matchup(team1_id, team2_id)
 
    return {
        "predicted_winner": prediction.winner.name,
        "confidence": prediction.confidence,
        "win_probability": prediction.win_probability,
        "reasoning": prediction.reasoning,
        "key_factors": prediction.key_factors
    }
 
if __name__ == "__main__":
    mcp.run()

// .cursor/mcp.json
{
  "mcpServers": {
    "sports-data": {
      "command": "python",
      "args": ["-m", "sports_data_mcp"],
      "env": {
        "SUPABASE_URL": "https://your-project.supabase.co",
        "SUPABASE_KEY": "your-api-key"
      }
    }
  }
}

/agent backend-builder "Create a GraphQL API for user management:
 
Types:
- User (id, email, name, role, created_at)
- Post (id, title, content, author, published)
- Comment (id, content, author, post, created_at)
 
Queries:
- users(filter, pagination)
- user(id)
- posts(author_id, published, pagination)
- post(id)
 
Mutations:
- createUser(input)
- updateUser(id, input)
- deleteUser(id)
- createPost(input)
- publishPost(id)
- addComment(post_id, content)
 
Features:
- JWT authentication
- DataLoader for N+1 prevention
- Subscriptions for real-time updates
- MongoDB database" --runtime node --framework express --type graphql --database mongodb

# Python + FastAPI (default)
--runtime python --framework fastapi
 
# Node.js + Express
--runtime node --framework express
 
# Node.js + Fastify
--runtime node --framework fastify
 
# Bun + Hono
--runtime bun --framework hono
 
# Go + Gin
--runtime go --framework gin

# REST API (default)
--type rest-api
 
# GraphQL API
--type graphql-api
 
# WebSocket server
--type websocket
 
# MCP server
--type mcp-server
 
# gRPC service
--type grpc

# PostgreSQL
--database postgres
 
# MongoDB
--database mongo
 
# Redis
--database redis
 
# Firestore
--database firestore
 
# Supabase
--database supabase
 
# Multiple databases
--database postgres,redis

# Docker
--deployment docker
 
# Google Cloud Run
--deployment cloud-run
 
# AWS Lambda
--deployment lambda
 
# Kubernetes
--deployment kubernetes
 
# Vercel Functions
--deployment vercel

Controller (API) → Service (Business Logic) → Repository (Data Access)

# Unit tests
pytest tests/unit/
 
# Integration tests
pytest tests/integration/
 
# E2E tests
pytest tests/e2e/
 
# Coverage report
pytest --cov=src --cov-report=html

http://localhost:8080/docs      # Swagger UI
http://localhost:8080/redoc     # ReDoc
http://localhost:8080/openapi.json  # OpenAPI spec

# Generated caching layer
from redis import Redis
from functools import wraps
 
redis_client = Redis.from_url(os.getenv("REDIS_URL"))
 
def cache(ttl: int = 300):
    def decorator(func):
        @wraps(func)
        async def wrapper(*args, **kwargs):
            cache_key = f"{func.__name__}:{args}:{kwargs}"
 
            # Check cache
            cached = redis_client.get(cache_key)
            if cached:
                return json.loads(cached)
 
            # Compute result
            result = await func(*args, **kwargs)
 
            # Store in cache
            redis_client.setex(cache_key, ttl, json.dumps(result))
 
            return result
        return wrapper
    return decorator

# Generated background task system
from celery import Celery
 
celery = Celery('tasks', broker=os.getenv("REDIS_URL"))
 
@celery.task
def send_email(user_id: str, subject: str, body: str):
    """Send email in background"""
    # Email sending logic
    pass
 
# Trigger from API
@router.post("/users/{user_id}/welcome-email")
async def send_welcome_email(user_id: int):
    send_email.delay(user_id, "Welcome!", "Welcome message...")
    return {"status": "queued"}

# Generated monitoring
from prometheus_client import Counter, Histogram, generate_latest
from opentelemetry import trace
 
# Metrics
request_count = Counter('http_requests_total', 'Total requests')
request_duration = Histogram('http_request_duration_seconds', 'Request duration')
 
# Tracing
tracer = trace.get_tracer(__name__)
 
@app.get("/metrics")
async def metrics():
    return Response(content=generate_latest(), media_type="text/plain")

# Check database connection
python -c "from src.utils.database import db; db.health_check()"
 
# Run migrations
alembic upgrade head
 
# Reset database (development only)
docker-compose down -v && docker-compose up -d

# Verify JWT secret is set
echo $JWT_SECRET
 
# Test auth endpoint
curl -X POST http://localhost:8080/auth/login \
  -H "Content-Type: application/json" \
  -d '{"email":"user@example.com","password":"password"}'

# Enable query logging
DATABASE_LOG_LEVEL=DEBUG uvicorn src.main:app
 
# Profile requests
python -m cProfile -o profile.stats src/main.py
 
# Analyze profile
python -m pstats profile.stats