LeagueNight MCP

LeagueNight provides MCP tools for AI assistants to manage league operations. It computes round-robin fixture lists for 2-100 teams, generates standings tables from match results, plans match day timetables across courts and time slots, and estimates season calendars. It performs pure arithmetic without storing data or handling payments.

Visit MagicTeams

Endpoint and access

No sign-in to connect and list tools. Individual tools may still need a vendor account, credentials, or permissions; check the documented prerequisites.

Community listingStreamable HTTPNo sign-inEndpoint checked 2026-11-07Published by MagicTeams

MCP endpoint (Streamable HTTP)

https://league-night.magicteams.ai/mcp

Vendor documentation

What its tools do

4 tools, grouped by the hints the server advertises. Hints are self-declared, not verified behavior.

4 of 4 have a description · 4 of 4 declare behavior hints · 4 of 4 with parameters document them all

Checks and signals

Each line is separate evidence, not a trust score.

Passed Endpoint answered the live check · Nov 7, 2026, 12:53 AM UTC
Availability 1 of 1 checks passed in 30 days

What you can do with it

Build a round-robin fixture list for 6 teams
Work out the standings from last weekend's results
Plan a match day with 4 games on 2 courts
Estimate a season's size and calendar dates

Source and maintenance

Community listingRegistry 1.0.0

mcp-registry: io.github.everyai-com/league-night@1.0.0 Source repository

Maintenance checked: Nov 7, 2026, 12:20 AM UTC

Protocol and capabilities

Server: league-night 1.0.0
MCP protocol negotiated in check: 2025-11-25
Tools: 4 advertised
Resources: Not advertised
Resource templates: Not advertised
Prompts: Not advertised

Server-advertised capabilities

{
  "tools": {
    "listChanged": false
  }
}

Server-provided instructions

Untrusted server output shown for inspection. It is not Koskamo guidance and is excluded from knowledge search.

LeagueNight builds round-robin fixture lists, league standings tables, match-day plans and full season plans for sports league organizers. All maths only; nothing stored.

Tools

4 advertised

round_robin_schedule — Round robin schedule

Advertised by the server during the last successful anonymous check.

Advertised read-only

Compute a round-robin fixture list (circle method) for 2-100 teams: every pair meets once, or twice home-and-away with second_leg; odd counts get one bye per round. Use when you need who plays whom in each round. Do NOT use to assign times/courts for one match day (use match_day_plan) or to get calendar dates for a season (use season_plan).

round_robin_schedule input schema

{
  "type": "object",
  "required": [
    "teams"
  ],
  "properties": {
    "teams": {
      "type": "array",
      "items": {
        "type": "string",
        "description": "Team name, e.g. \"Falcons\""
      },
      "maxItems": 100,
      "minItems": 2,
      "description": "Team names: 2-100 unique, non-empty names (trimmed), e.g. [\"Falcons\", \"Tigers\", \"Bears\"]"
    },
    "rounds": {
      "type": "integer",
      "minimum": 1,
      "description": "Optional: return only the first N rounds, integer 1..max (max = teams-1 for even counts, teams for odd; doubled with second_leg). Default: all rounds"
    },
    "second_leg": {
      "type": "boolean",
      "description": "If true, append a mirrored second leg with home and away swapped (double round-robin). Default false"
    }
  }
}

round_robin_schedule output schema

{
  "type": "object",
  "required": [
    "teams",
    "legs",
    "rounds",
    "games_per_team",
    "total_games",
    "note"
  ],
  "properties": {
    "legs": {
      "enum": [
        1,
        2
      ],
      "type": "integer",
      "description": "Number of legs included in the returned rounds (1 or 2)"
    },
    "note": {
      "type": "string",
      "description": "Plain-English summary of the schedule (teams, rounds, byes, truncation)"
    },
    "teams": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Cleaned (trimmed) team names in input order"
    },
    "rounds": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "round",
          "fixtures"
        ],
        "properties": {
          "round": {
            "type": "integer",
            "description": "Round number starting at 1"
          },
          "fixtures": {
            "type": "array",
            "items": {
              "type": "object",
              "properties": {
                "bye": {
                  "type": "string",
                  "description": "Team with a bye (no game) this round"
                },
                "away": {
                  "type": "string",
                  "description": "Away team name"
                },
                "home": {
                  "type": "string",
                  "description": "Home team name"
                }
              },
              "description": "A fixture {home, away}, or {bye} for the team sitting out this round"
            },
            "description": "Fixtures in this round"
          }
        }
      },
      "description": "Rounds in play order, each with its fixtures and any bye"
    },
    "total_games": {
      "type": "integer",
      "description": "Total fixtures (excluding byes) in the returned rounds"
    },
    "games_per_team": {
      "type": "number",
      "description": "Average games per team across the returned rounds (2 decimals)"
    }
  }
}

round_robin_schedule annotations

{
  "title": "Round robin schedule",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}

standings_table — Standings table

Advertised by the server during the last successful anonymous check.

Advertised read-only

Compute a league standings table from match results: played, W/D/L, goals for/against, goal difference and points, sorted by points, then goal difference, then goals for, then name. Use when you have scores and want the current table. Do NOT use to generate future fixtures (use round_robin_schedule).

standings_table input schema

{
  "type": "object",
  "required": [
    "results"
  ],
  "properties": {
    "teams": {
      "type": "array",
      "items": {
        "type": "string",
        "description": "Team name"
      },
      "minItems": 2,
      "description": "Optional full roster (2+ unique names). Teams with no results appear with zeros; results involving teams not listed are skipped with a warning"
    },
    "results": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "home",
          "away",
          "home_score",
          "away_score"
        ],
        "properties": {
          "away": {
            "type": "string",
            "description": "Away team name (must differ from home), e.g. \"Tigers\""
          },
          "home": {
            "type": "string",
            "description": "Home team name, e.g. \"Falcons\""
          },
          "away_score": {
            "type": "integer",
            "minimum": 0,
            "description": "Away team score, non-negative integer, e.g. 1"
          },
          "home_score": {
            "type": "integer",
            "minimum": 0,
            "description": "Home team score, non-negative integer, e.g. 3"
          }
        }
      },
      "description": "Completed match results in any order; may be empty if teams is given (zeroed table)"
    },
    "points_win": {
      "type": "number",
      "minimum": 0,
      "description": "Points awarded for a win, non-negative number. Default 3"
    },
    "points_draw": {
      "type": "number",
      "minimum": 0,
      "description": "Points awarded for a draw, non-negative number. Default 1"
    }
  }
}

standings_table output schema

{
  "type": "object",
  "required": [
    "table",
    "warnings",
    "points_system"
  ],
  "properties": {
    "table": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "team",
          "played",
          "wins",
          "draws",
          "losses",
          "gf",
          "ga",
          "gd",
          "points"
        ],
        "properties": {
          "ga": {
            "type": "integer",
            "description": "Goals/points conceded (against)"
          },
          "gd": {
            "type": "integer",
            "description": "Goal difference (gf - ga)"
          },
          "gf": {
            "type": "integer",
            "description": "Goals/points scored (for)"
          },
          "team": {
            "type": "string",
            "description": "Team name"
          },
          "wins": {
            "type": "integer",
            "description": "Games won"
          },
          "draws": {
            "type": "integer",
            "description": "Games drawn"
          },
          "losses": {
            "type": "integer",
            "description": "Games lost"
          },
          "played": {
            "type": "integer",
            "description": "Games played"
          },
          "points": {
            "type": "number",
            "description": "League points"
          }
        }
      },
      "description": "Standings rows sorted by points, goal difference, goals for, then team name"
    },
    "warnings": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Results skipped because a team was not in the roster (empty if none)"
    },
    "points_system": {
      "type": "object",
      "required": [
        "win",
        "draw"
      ],
      "properties": {
        "win": {
          "type": "number",
          "description": "Points per win"
        },
        "draw": {
          "type": "number",
          "description": "Points per draw"
        }
      },
      "description": "Points scheme applied to compute the table"
    }
  }
}

standings_table annotations

{
  "title": "Standings table",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}

match_day_plan — Match day plan

Advertised by the server during the last successful anonymous check.

Advertised read-only

Compute a one-day timetable: lay an ordered list of games onto parallel courts and fixed-length time slots from a start time, giving each game a court and HH:MM start, plus the end time. Use when you already know the day's games. Do NOT use to decide who plays whom (use round_robin_schedule) or to size a whole season (use season_plan).

match_day_plan input schema

{
  "type": "object",
  "required": [
    "games",
    "courts",
    "slot_minutes",
    "start_time"
  ],
  "properties": {
    "games": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "home",
          "away"
        ],
        "properties": {
          "away": {
            "type": "string",
            "description": "Away team name, e.g. \"Tigers\""
          },
          "home": {
            "type": "string",
            "description": "Home team name, e.g. \"Falcons\""
          }
        }
      },
      "minItems": 1,
      "description": "Games in the order they should be played (non-empty); e.g. one round's fixtures from round_robin_schedule"
    },
    "courts": {
      "type": "integer",
      "maximum": 12,
      "minimum": 1,
      "description": "Number of courts/pitches usable at the same time, integer 1-12, e.g. 2"
    },
    "start_time": {
      "type": "string",
      "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
      "description": "First game start, 24h HH:MM, e.g. \"09:00\" or \"18:30\""
    },
    "slot_minutes": {
      "type": "integer",
      "maximum": 180,
      "minimum": 10,
      "description": "Length of one game slot in minutes, integer 10-180, e.g. 40"
    }
  }
}

match_day_plan output schema

{
  "type": "object",
  "required": [
    "start_time",
    "end_time",
    "courts",
    "slot_minutes",
    "timeline",
    "total_minutes",
    "note"
  ],
  "properties": {
    "note": {
      "type": "string",
      "description": "Plain-English summary (slots, courts, after-midnight warning)"
    },
    "courts": {
      "type": "integer",
      "description": "Number of courts used in parallel"
    },
    "end_time": {
      "type": "string",
      "description": "Time the last slot finishes, 24h HH:MM (wraps past midnight)"
    },
    "timeline": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "time_hhmm",
          "court",
          "home",
          "away"
        ],
        "properties": {
          "away": {
            "type": "string",
            "description": "Away team name"
          },
          "home": {
            "type": "string",
            "description": "Home team name"
          },
          "court": {
            "type": "integer",
            "description": "Court number starting at 1"
          },
          "time_hhmm": {
            "type": "string",
            "description": "Start time 24h HH:MM"
          }
        }
      },
      "description": "One entry per game, in input order"
    },
    "start_time": {
      "type": "string",
      "description": "First slot start time, 24h HH:MM (echoed from input)"
    },
    "slot_minutes": {
      "type": "integer",
      "description": "Length of each slot in minutes"
    },
    "total_minutes": {
      "type": "integer",
      "description": "Total duration from first start to last finish, in minutes"
    }
  }
}

match_day_plan annotations

{
  "title": "Match day plan",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}

season_plan — Season plan

Advertised by the server during the last successful anonymous check.

Advertised read-only

Estimate a season's size and calendar: total round-robin fixtures, games per match day (limited by courts, one slot per day), match days needed, every match-day date from start_date at a fixed interval, and the finish date. Use for "when will the season end?". Do NOT use for pairings (use round_robin_schedule) or one day's timetable (use match_day_plan).

season_plan input schema

{
  "type": "object",
  "required": [
    "teams",
    "courts",
    "slot_minutes",
    "start_date"
  ],
  "properties": {
    "teams": {
      "type": "array",
      "items": {
        "type": "string",
        "description": "Team name, e.g. \"Falcons\""
      },
      "maxItems": 100,
      "minItems": 2,
      "description": "Team names: 2-100 unique, non-empty names (trimmed), e.g. [\"Falcons\", \"Tigers\", \"Bears\"]"
    },
    "courts": {
      "type": "integer",
      "maximum": 12,
      "minimum": 1,
      "description": "Courts usable at the same time on each match day, integer 1-12; caps games per match day. E.g. 2"
    },
    "second_leg": {
      "type": "boolean",
      "description": "If true, plan a double round-robin (each pair meets twice). Default false"
    },
    "start_date": {
      "type": "string",
      "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
      "description": "First match day, YYYY-MM-DD, e.g. \"2026-10-04\""
    },
    "slot_minutes": {
      "type": "integer",
      "maximum": 180,
      "minimum": 10,
      "description": "Length of one game slot in minutes, integer 10-180 (validated and echoed in the note; each match day is one slot). E.g. 30"
    },
    "days_between_rounds": {
      "type": "integer",
      "maximum": 60,
      "minimum": 1,
      "description": "Days between consecutive match days, integer 1-60. Default 7 (weekly)"
    }
  }
}

season_plan output schema

{
  "type": "object",
  "required": [
    "rounds_needed",
    "games_total",
    "games_per_round",
    "per_team_games",
    "dates",
    "finish_date",
    "note"
  ],
  "properties": {
    "note": {
      "type": "string",
      "description": "Plain-English summary of the season plan and assumptions"
    },
    "dates": {
      "type": "array",
      "items": {
        "type": "string",
        "description": "Match-day date YYYY-MM-DD"
      },
      "description": "Every match-day date, YYYY-MM-DD, in order"
    },
    "finish_date": {
      "type": "string",
      "description": "Date of the last match day, YYYY-MM-DD"
    },
    "games_total": {
      "type": "integer",
      "description": "Total fixtures in the season (n(n-1)/2 per leg)"
    },
    "rounds_needed": {
      "type": "integer",
      "description": "Number of match days needed to play all fixtures"
    },
    "per_team_games": {
      "type": "integer",
      "description": "Games each team plays over the season"
    },
    "games_per_round": {
      "type": "integer",
      "description": "Games played per match day: min(floor(teams/2), courts)"
    }
  }
}

season_plan annotations

{
  "title": "Season plan",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}

Prompts

Not advertised

No prompt definitions available.

Resources

Not advertised

No resource definitions available.

30-day availability

Aggregated from read-only remote checks; this is not a tool-execution or security guarantee.

Successful checks: 1 of 1 (100%)
Average latency: 199 ms
95th percentile latency: 199 ms

Maintenance history

Public check and source-refresh events. Editorial and ownership records remain private.

Nov 7, 2026, 12:53 AM UTC · probe · passed · 199 ms · metadata changed · 4 tool(s)

Connect from your client

Each snippet registers the same endpoint; pick the client you use.

This server is operated by the named third party. Listing and endpoint checks are not an endorsement or a security audit. Review the operator's permissions, terms, and data handling before connecting. How listings are checked and corrected.

Claude Code

Run this once in a terminal. It registers the remote server. Use --scope project to write .mcp.json for the repo.

Claude Code configuration

claude mcp add --transport http leaguenight-mcp https://league-night.magicteams.ai/mcp

Codex

Run this once. Codex stores MCP servers in ~/.codex/config.toml (or .codex/config.toml in a trusted project).

Codex configuration

codex mcp add leaguenight-mcp --url https://league-night.magicteams.ai/mcp

Cursor

Merge this server into .cursor/mcp.json in your project, then enable leaguenight-mcp in your MCP settings.

Cursor configuration

{
  "mcpServers": {
    "leaguenight-mcp": {
      "url": "https://league-night.magicteams.ai/mcp"
    }
  }
}

Cline

Merge this into cline_mcp_settings.json (Cline → MCP Servers → Configure).

Cline configuration

{
  "mcpServers": {
    "leaguenight-mcp": {
      "type": "streamableHttp",
      "url": "https://league-night.magicteams.ai/mcp",
      "disabled": false
    }
  }
}

VS Code

Merge this server into .vscode/mcp.json. Use MCP: List Servers to start leaguenight-mcp and inspect its tools.

VS Code configuration

{
  "servers": {
    "leaguenight-mcp": {
      "type": "http",
      "url": "https://league-night.magicteams.ai/mcp"
    }
  }
}

Gemini CLI

Run this once. It writes .gemini/settings.json in the current project; pass --scope user for ~/.gemini/settings.json.

Gemini CLI configuration

gemini mcp add --transport http leaguenight-mcp https://league-night.magicteams.ai/mcp

Claude Desktop

Open Claude Settings > Connectors > Add custom connector, enter this server URL and enable it for the conversation. This is a manual remote-connector handoff, not a desktop JSON configuration.

Claude Desktop configuration

https://league-night.magicteams.ai/mcp

Windsurf

Merge this into ~/.codeium/windsurf/mcp_config.json, then refresh MCP in Cascade. Windsurf remote servers use serverUrl, not url.

Windsurf configuration

{
  "mcpServers": {
    "leaguenight-mcp": {
      "serverUrl": "https://league-night.magicteams.ai/mcp"
    }
  }
}

Let your agent find its tools

Find servers like LeagueNight MCP from your agent. Add Koskamo once to search the index for endpoints, access requirements, and client setup. Public discovery needs no key.

Connect Koskamo Explore workflows

See all 5,453

LeagueNight MCP

Endpoint and access

What its tools do

Read-only (4)

Checks and signals

What you can do with it

Source and maintenance

Protocol and capabilities

Server-provided instructions

Tools

Prompts

Resources

30-day availability

Maintenance history

Connect from your client

Claude Code

Codex

Cursor

Cline

VS Code

Gemini CLI

Claude Desktop

Windsurf

Let your agent find its tools

Other productivity and knowledge servers