Koskamo

LLM Configurator MCP

A free, read-only MCP server that allows AI assistants to check local LLM hardware compatibility, calculate VRAM requirements, estimate inference speeds, and compare machines using the site's own calculation engine without requiring authentication.

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.

LLM Configurator MCP logo, by LLM ConfiguratorCommunity listingStreamable HTTPNo sign-inEndpoint checked 2026-11-06Published by LLM Configurator
MCP endpoint (Streamable HTTP)
https://elgadmisijrfowuujcmu.supabase.co/functions/v1/mcp
Vendor documentation

What its tools do

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

Read-only (5)

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

Checks and signals

Each line is separate evidence, not a trust score.

  • Passed Endpoint answered the live check ·
  • Availability 1 of 1 checks passed in 30 days

What you can do with it

  • Check if a specific LLM fits on a user's GPU or Mac
  • List compatible models for a given hardware configuration
  • Compare performance and fit across multiple machines
  • Search for hardware or model IDs in the catalogue

Source and maintenance

Community listingRegistry 1.0.0
mcp-registry: io.github.aikuba/llmconfigurator@1.0.0Source repositoryProject website
Maintenance checked

Protocol and capabilities

Server
llmconfigurator 1.0.0
MCP protocol negotiated in check
2025-11-25
Tools
5 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.

Resolve hardware and model names to ids with search_catalog before calling check_hardware_fit, models_for_hardware, compare_hardware or get_model_specs. Quote the returned url when citing a result. Report a null field as unknown and do not estimate it yourself. Speeds are ranges with a confidence label; memory residency uses all parameters and speed uses active parameters.

Tools

5 advertised

search_catalog — Find hardware or a model
Advertised by the server during the last successful anonymous check.
Advertised read-only

Use this first when the user names a GPU, Mac, mini PC or language model and you need its id for the other tools. Matches names and common aliases in a fixed catalogue of local-LLM hardware and models. It does not return specs, fit or speed, and it does not search the web.

search_catalog input schema
{
  "type": "object",
  "required": [
    "query",
    "kind"
  ],
  "properties": {
    "kind": {
      "enum": [
        "hardware",
        "model"
      ],
      "type": "string",
      "description": "Search hardware or models. Required."
    },
    "limit": {
      "type": "integer",
      "default": 5,
      "maximum": 10,
      "minimum": 1,
      "description": "Maximum matches, 1 to 10. Default 5."
    },
    "query": {
      "type": "string",
      "pattern": "^[^\\u0000-\\u001f\\u007f]*$",
      "maxLength": 80,
      "minLength": 1,
      "description": "Hardware or model name as the user wrote it, e.g. \"4090\", \"m4 max 64\", \"llama 3.3 70b\"."
    }
  }
}
search_catalog output schema
{
  "type": "object",
  "required": [
    "data_as_of",
    "summary",
    "kind",
    "matches"
  ],
  "properties": {
    "kind": {
      "enum": [
        "hardware",
        "model"
      ],
      "type": "string"
    },
    "matches": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "id",
          "name",
          "kind",
          "detail",
          "url"
        ],
        "properties": {
          "id": {
            "type": "string",
            "pattern": "^[a-z0-9][a-z0-9._-]*$",
            "maxLength": 80,
            "minLength": 1,
            "description": "Pass this id to the other tools."
          },
          "url": {
            "type": "string",
            "pattern": "^https:\\/\\/llmconfigurator\\.com\\/en\\/"
          },
          "kind": {
            "enum": [
              "hardware",
              "model"
            ],
            "type": "string"
          },
          "name": {
            "type": "string",
            "maxLength": 120
          },
          "detail": {
            "type": "string",
            "maxLength": 160,
            "description": "A short factual line, e.g. \"24 GB, 1008 GB/s\" or \"8B dense\"."
          }
        },
        "additionalProperties": false
      }
    },
    "summary": {
      "type": "string",
      "maxLength": 600,
      "description": "One or two plain-language sentences stating the answer."
    },
    "data_as_of": {
      "type": "string",
      "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
      "description": "Date the bundled catalogue was last updated. Not the time of this call."
    }
  },
  "additionalProperties": false
}
search_catalog annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
check_hardware_fit — Check whether a model fits hardware
Advertised by the server during the last successful anonymous check.
Advertised read-only

Use this when the user asks whether one specific model runs on one specific machine, at what memory cost, and roughly how fast. Needs a hardware id and a model id from search_catalog. Returns a fit verdict, the memory arithmetic, and a decode-speed range with a confidence label. Memory is sized from all parameters, speed from active parameters. It does not recommend purchases and does not run anything.

check_hardware_fit input schema
{
  "type": "object",
  "required": [
    "hardware_id",
    "model_id"
  ],
  "properties": {
    "model_id": {
      "type": "string",
      "pattern": "^[a-z0-9][a-z0-9._-]*$",
      "maxLength": 80,
      "minLength": 1,
      "description": "Model id from search_catalog."
    },
    "hardware_id": {
      "type": "string",
      "pattern": "^[a-z0-9][a-z0-9._-]*$",
      "maxLength": 80,
      "minLength": 1,
      "description": "Hardware id from search_catalog."
    },
    "quantisation": {
      "enum": [
        "Q2_K",
        "Q3_K_M",
        "Q4_K_M",
        "Q5_K_M",
        "Q6_K",
        "Q8_0",
        "F16"
      ],
      "type": "string",
      "default": "Q4_K_M",
      "description": "Weight quantisation. One of Q2_K, Q3_K_M, Q4_K_M, Q5_K_M, Q6_K, Q8_0, F16. Default Q4_K_M."
    },
    "context_length": {
      "type": "integer",
      "default": 4096,
      "maximum": 262144,
      "minimum": 512,
      "description": "Context window in tokens that the KV cache is sized for. 512 to 262144. Default 4096."
    }
  }
}
check_hardware_fit output schema
{
  "type": "object",
  "required": [
    "data_as_of",
    "summary",
    "verdict",
    "quantisation",
    "context_length",
    "model",
    "hardware",
    "memory",
    "speed",
    "notes",
    "sources",
    "url"
  ],
  "properties": {
    "url": {
      "type": "string",
      "pattern": "^https:\\/\\/llmconfigurator\\.com\\/en\\/"
    },
    "model": {
      "type": "object",
      "required": [
        "id",
        "name",
        "total_params_b",
        "active_params_b",
        "is_moe"
      ],
      "properties": {
        "id": {
          "type": "string",
          "pattern": "^[a-z0-9][a-z0-9._-]*$",
          "maxLength": 80,
          "minLength": 1
        },
        "name": {
          "type": "string",
          "maxLength": 120
        },
        "is_moe": {
          "type": "boolean"
        },
        "total_params_b": {
          "type": "number",
          "description": "Total parameters in billions. Sets memory residency.",
          "exclusiveMinimum": 0
        },
        "active_params_b": {
          "type": "number",
          "description": "Parameters read per token in billions. Equals total for dense models. Sets speed, never memory.",
          "exclusiveMinimum": 0
        }
      },
      "additionalProperties": false
    },
    "notes": {
      "type": "array",
      "items": {
        "type": "string",
        "maxLength": 300
      },
      "maxItems": 8
    },
    "speed": {
      "anyOf": [
        {
          "type": "object",
          "required": [
            "low_tok_s",
            "high_tok_s",
            "confidence",
            "basis",
            "sample_count",
            "last_verified"
          ],
          "properties": {
            "basis": {
              "anyOf": [
                {
                  "type": "string",
                  "maxLength": 200
                },
                {
                  "type": "null"
                }
              ],
              "description": "Where the figure comes from, e.g. a benchmark label. null for a modelled estimate."
            },
            "low_tok_s": {
              "type": "number",
              "minimum": 0
            },
            "confidence": {
              "enum": [
                "measured",
                "estimated",
                "community"
              ],
              "type": "string"
            },
            "high_tok_s": {
              "type": "number",
              "minimum": 0
            },
            "sample_count": {
              "anyOf": [
                {
                  "type": "integer",
                  "maximum": 9007199254740991,
                  "exclusiveMinimum": 0
                },
                {
                  "type": "null"
                }
              ],
              "description": "Number of measured runs behind a measured or community figure."
            },
            "last_verified": {
              "anyOf": [
                {
                  "type": "string",
                  "pattern": "^\\d{4}-\\d{2}-\\d{2}$"
                },
                {
                  "type": "null"
                }
              ]
            }
          },
          "description": "Decode speed in tokens per second, always a range with a confidence label.",
          "additionalProperties": false
        },
        {
          "type": "null"
        }
      ],
      "description": "null when the model does not fit, because a speed for hardware that cannot load the weights would be invented."
    },
    "memory": {
      "type": "object",
      "required": [
        "weights_gb",
        "kv_cache_gb",
        "overhead_gb",
        "needed_gb",
        "available_gb",
        "headroom_gb",
        "offloaded_gb",
        "confidence",
        "kv_basis"
      ],
      "properties": {
        "kv_basis": {
          "enum": [
            "published_architecture",
            "inferred_architecture"
          ],
          "type": "string",
          "description": "Whether the KV cache is computed from a published config or inferred from the parameter count."
        },
        "needed_gb": {
          "type": "number",
          "minimum": 0,
          "description": "weights + KV cache + overhead."
        },
        "confidence": {
          "enum": [
            "measured",
            "estimated",
            "community"
          ],
          "type": "string"
        },
        "weights_gb": {
          "type": "number",
          "minimum": 0,
          "description": "All parameters quantised. For a Mixture-of-Experts model this counts every expert."
        },
        "headroom_gb": {
          "type": "number",
          "description": "available - needed. Negative when the model does not fit."
        },
        "kv_cache_gb": {
          "type": "number",
          "minimum": 0
        },
        "overhead_gb": {
          "type": "number",
          "minimum": 0,
          "description": "Fixed framework overhead."
        },
        "available_gb": {
          "type": "number",
          "minimum": 0,
          "description": "Memory usable for the model after any operating-system reserve."
        },
        "offloaded_gb": {
          "type": "number",
          "minimum": 0,
          "description": "Weights that would live in system RAM. 0 when fully resident."
        }
      },
      "description": "Memory arithmetic for the requested quantisation and context length.",
      "additionalProperties": false
    },
    "sources": {
      "type": "array",
      "items": {
        "type": "string",
        "pattern": "^https:\\/\\/"
      },
      "maxItems": 8,
      "description": "Primary sources for the model and hardware records. May be empty."
    },
    "summary": {
      "type": "string",
      "maxLength": 600,
      "description": "One or two plain-language sentences stating the answer."
    },
    "verdict": {
      "enum": [
        "fits_comfortably",
        "fits_tight",
        "needs_offload",
        "does_not_fit"
      ],
      "type": "string"
    },
    "hardware": {
      "type": "object",
      "required": [
        "id",
        "name",
        "memory_gb",
        "memory_kind",
        "bandwidth_gb_s",
        "status"
      ],
      "properties": {
        "id": {
          "type": "string",
          "pattern": "^[a-z0-9][a-z0-9._-]*$",
          "maxLength": 80,
          "minLength": 1
        },
        "name": {
          "type": "string",
          "maxLength": 120
        },
        "status": {
          "enum": [
            "current",
            "eol",
            "used-market",
            "announced"
          ],
          "type": "string",
          "description": "announced means not yet on sale; eol means no longer made."
        },
        "memory_gb": {
          "type": "number",
          "exclusiveMinimum": 0
        },
        "memory_kind": {
          "enum": [
            "dedicated",
            "unified",
            "shared-system"
          ],
          "type": "string"
        },
        "bandwidth_gb_s": {
          "type": "number",
          "description": "Theoretical peak memory bandwidth.",
          "exclusiveMinimum": 0
        }
      },
      "additionalProperties": false
    },
    "data_as_of": {
      "type": "string",
      "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
      "description": "Date the bundled catalogue was last updated. Not the time of this call."
    },
    "quantisation": {
      "enum": [
        "Q2_K",
        "Q3_K_M",
        "Q4_K_M",
        "Q5_K_M",
        "Q6_K",
        "Q8_0",
        "F16"
      ],
      "type": "string"
    },
    "context_length": {
      "type": "integer",
      "maximum": 9007199254740991,
      "minimum": -9007199254740991
    }
  },
  "additionalProperties": false
}
check_hardware_fit annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
models_for_hardware — List models a machine can run
Advertised by the server during the last successful anonymous check.
Advertised read-only

Use this when the user asks what models a given machine can run. Needs a hardware id from search_catalog. Returns up to 20 catalogue models ranked for that machine, each with a fit verdict and a speed range, optionally filtered to one use such as coding. It covers only models in the catalogue, at one quantisation and context length per call, and leaves out models that do not fit.

models_for_hardware input schema
{
  "type": "object",
  "required": [
    "hardware_id"
  ],
  "properties": {
    "limit": {
      "type": "integer",
      "default": 10,
      "maximum": 20,
      "minimum": 1,
      "description": "Maximum models, 1 to 20. Default 10."
    },
    "use_case": {
      "enum": [
        "coding",
        "chat",
        "reasoning",
        "agents",
        "vision"
      ],
      "type": "string",
      "description": "Only list models tagged for this use. One of coding, chat, reasoning, agents, vision. Omit for all models."
    },
    "hardware_id": {
      "type": "string",
      "pattern": "^[a-z0-9][a-z0-9._-]*$",
      "maxLength": 80,
      "minLength": 1,
      "description": "Hardware id from search_catalog."
    },
    "quantisation": {
      "enum": [
        "Q2_K",
        "Q3_K_M",
        "Q4_K_M",
        "Q5_K_M",
        "Q6_K",
        "Q8_0",
        "F16"
      ],
      "type": "string",
      "default": "Q4_K_M",
      "description": "Weight quantisation. One of Q2_K, Q3_K_M, Q4_K_M, Q5_K_M, Q6_K, Q8_0, F16. Default Q4_K_M."
    },
    "context_length": {
      "type": "integer",
      "default": 4096,
      "maximum": 262144,
      "minimum": 512,
      "description": "Context window in tokens that the KV cache is sized for. 512 to 262144. Default 4096."
    }
  }
}
models_for_hardware output schema
{
  "type": "object",
  "required": [
    "data_as_of",
    "summary",
    "quantisation",
    "context_length",
    "use_case",
    "hardware",
    "models",
    "url"
  ],
  "properties": {
    "url": {
      "type": "string",
      "pattern": "^https:\\/\\/llmconfigurator\\.com\\/en\\/"
    },
    "models": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "rank",
          "model_id",
          "name",
          "verdict",
          "needed_gb",
          "speed",
          "url"
        ],
        "properties": {
          "url": {
            "type": "string",
            "pattern": "^https:\\/\\/llmconfigurator\\.com\\/en\\/"
          },
          "name": {
            "type": "string",
            "maxLength": 120
          },
          "rank": {
            "type": "integer",
            "maximum": 9007199254740991,
            "exclusiveMinimum": 0
          },
          "speed": {
            "anyOf": [
              {
                "type": "object",
                "required": [
                  "low_tok_s",
                  "high_tok_s",
                  "confidence",
                  "basis",
                  "sample_count",
                  "last_verified"
                ],
                "properties": {
                  "basis": {
                    "anyOf": [
                      {
                        "type": "string",
                        "maxLength": 200
                      },
                      {
                        "type": "null"
                      }
                    ],
                    "description": "Where the figure comes from, e.g. a benchmark label. null for a modelled estimate."
                  },
                  "low_tok_s": {
                    "type": "number",
                    "minimum": 0
                  },
                  "confidence": {
                    "enum": [
                      "measured",
                      "estimated",
                      "community"
                    ],
                    "type": "string"
                  },
                  "high_tok_s": {
                    "type": "number",
                    "minimum": 0
                  },
                  "sample_count": {
                    "anyOf": [
                      {
                        "type": "integer",
                        "maximum": 9007199254740991,
                        "exclusiveMinimum": 0
                      },
                      {
                        "type": "null"
                      }
                    ],
                    "description": "Number of measured runs behind a measured or community figure."
                  },
                  "last_verified": {
                    "anyOf": [
                      {
                        "type": "string",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$"
                      },
                      {
                        "type": "null"
                      }
                    ]
                  }
                },
                "description": "Decode speed in tokens per second, always a range with a confidence label.",
                "additionalProperties": false
              },
              {
                "type": "null"
              }
            ]
          },
          "verdict": {
            "enum": [
              "fits_comfortably",
              "fits_tight",
              "needs_offload",
              "does_not_fit"
            ],
            "type": "string"
          },
          "model_id": {
            "type": "string",
            "pattern": "^[a-z0-9][a-z0-9._-]*$",
            "maxLength": 80,
            "minLength": 1
          },
          "needed_gb": {
            "type": "number",
            "minimum": 0
          }
        },
        "additionalProperties": false
      }
    },
    "summary": {
      "type": "string",
      "maxLength": 600,
      "description": "One or two plain-language sentences stating the answer."
    },
    "hardware": {
      "type": "object",
      "required": [
        "id",
        "name",
        "memory_gb",
        "memory_kind",
        "bandwidth_gb_s",
        "status"
      ],
      "properties": {
        "id": {
          "type": "string",
          "pattern": "^[a-z0-9][a-z0-9._-]*$",
          "maxLength": 80,
          "minLength": 1
        },
        "name": {
          "type": "string",
          "maxLength": 120
        },
        "status": {
          "enum": [
            "current",
            "eol",
            "used-market",
            "announced"
          ],
          "type": "string",
          "description": "announced means not yet on sale; eol means no longer made."
        },
        "memory_gb": {
          "type": "number",
          "exclusiveMinimum": 0
        },
        "memory_kind": {
          "enum": [
            "dedicated",
            "unified",
            "shared-system"
          ],
          "type": "string"
        },
        "bandwidth_gb_s": {
          "type": "number",
          "description": "Theoretical peak memory bandwidth.",
          "exclusiveMinimum": 0
        }
      },
      "additionalProperties": false
    },
    "use_case": {
      "anyOf": [
        {
          "enum": [
            "coding",
            "chat",
            "reasoning",
            "agents",
            "vision"
          ],
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "description": "The use-case filter applied, or null."
    },
    "data_as_of": {
      "type": "string",
      "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
      "description": "Date the bundled catalogue was last updated. Not the time of this call."
    },
    "quantisation": {
      "enum": [
        "Q2_K",
        "Q3_K_M",
        "Q4_K_M",
        "Q5_K_M",
        "Q6_K",
        "Q8_0",
        "F16"
      ],
      "type": "string"
    },
    "context_length": {
      "type": "integer",
      "maximum": 9007199254740991,
      "minimum": -9007199254740991
    }
  },
  "additionalProperties": false
}
models_for_hardware annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
compare_hardware — Compare two to four machines
Advertised by the server during the last successful anonymous check.
Advertised read-only

Use this when the user compares two to four machines. Needs hardware ids from search_catalog. Returns memory, bandwidth, memory type, release year, status and a dated price where one is recorded, side by side. A price of null means none is on record. It does not check any model against the machines; use check_hardware_fit for that.

compare_hardware input schema
{
  "type": "object",
  "required": [
    "hardware_ids"
  ],
  "properties": {
    "hardware_ids": {
      "type": "array",
      "items": {
        "type": "string",
        "pattern": "^[a-z0-9][a-z0-9._-]*$",
        "maxLength": 80,
        "minLength": 1
      },
      "maxItems": 4,
      "minItems": 2,
      "description": "Two to four hardware ids from search_catalog."
    }
  }
}
compare_hardware output schema
{
  "type": "object",
  "required": [
    "data_as_of",
    "summary",
    "hardware"
  ],
  "properties": {
    "summary": {
      "type": "string",
      "maxLength": 600,
      "description": "One or two plain-language sentences stating the answer."
    },
    "hardware": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "id",
          "name",
          "memory_gb",
          "memory_kind",
          "bandwidth_gb_s",
          "status",
          "class",
          "architecture",
          "release_year",
          "system_ram_gb",
          "price",
          "notes",
          "sources",
          "url"
        ],
        "properties": {
          "id": {
            "type": "string",
            "pattern": "^[a-z0-9][a-z0-9._-]*$",
            "maxLength": 80,
            "minLength": 1
          },
          "url": {
            "type": "string",
            "pattern": "^https:\\/\\/llmconfigurator\\.com\\/en\\/"
          },
          "name": {
            "type": "string",
            "maxLength": 120
          },
          "class": {
            "type": "string",
            "maxLength": 40
          },
          "notes": {
            "anyOf": [
              {
                "type": "string",
                "maxLength": 400
              },
              {
                "type": "null"
              }
            ]
          },
          "price": {
            "anyOf": [
              {
                "type": "object",
                "required": [
                  "usd",
                  "as_of",
                  "market",
                  "stale",
                  "source"
                ],
                "properties": {
                  "usd": {
                    "type": "number",
                    "exclusiveMinimum": 0
                  },
                  "as_of": {
                    "type": "string",
                    "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                    "description": "Date this price was checked."
                  },
                  "stale": {
                    "type": "boolean",
                    "description": "True when the price is older than 90 days."
                  },
                  "market": {
                    "enum": [
                      "new",
                      "used",
                      "refurb"
                    ],
                    "type": "string"
                  },
                  "source": {
                    "type": "string",
                    "maxLength": 200
                  }
                },
                "additionalProperties": false
              },
              {
                "type": "null"
              }
            ],
            "description": "null when this catalogue holds no dated price. Never 0."
          },
          "status": {
            "enum": [
              "current",
              "eol",
              "used-market",
              "announced"
            ],
            "type": "string",
            "description": "announced means not yet on sale; eol means no longer made."
          },
          "sources": {
            "type": "array",
            "items": {
              "type": "string",
              "pattern": "^https:\\/\\/"
            },
            "maxItems": 8
          },
          "memory_gb": {
            "type": "number",
            "exclusiveMinimum": 0
          },
          "memory_kind": {
            "enum": [
              "dedicated",
              "unified",
              "shared-system"
            ],
            "type": "string"
          },
          "architecture": {
            "type": "string",
            "maxLength": 80
          },
          "release_year": {
            "anyOf": [
              {
                "type": "integer",
                "maximum": 9007199254740991,
                "minimum": -9007199254740991
              },
              {
                "type": "null"
              }
            ]
          },
          "system_ram_gb": {
            "type": "number",
            "minimum": 0,
            "description": "System RAM available for offload. 0 for unified-memory machines."
          },
          "bandwidth_gb_s": {
            "type": "number",
            "description": "Theoretical peak memory bandwidth.",
            "exclusiveMinimum": 0
          }
        },
        "additionalProperties": false
      },
      "maxItems": 4,
      "minItems": 2
    },
    "data_as_of": {
      "type": "string",
      "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
      "description": "Date the bundled catalogue was last updated. Not the time of this call."
    }
  },
  "additionalProperties": false
}
compare_hardware annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
get_model_specs — Get a model's specifications
Advertised by the server during the last successful anonymous check.
Advertised read-only

Use this when the user asks about one model's size, architecture, context window or licence. Needs a model id from search_catalog. Returns total and active parameters, weight size per quantisation, context length, licence, release date and sources. It does not say whether the model fits any machine; use check_hardware_fit for that.

get_model_specs input schema
{
  "type": "object",
  "required": [
    "model_id"
  ],
  "properties": {
    "model_id": {
      "type": "string",
      "pattern": "^[a-z0-9][a-z0-9._-]*$",
      "maxLength": 80,
      "minLength": 1,
      "description": "Model id from search_catalog."
    }
  }
}
get_model_specs output schema
{
  "type": "object",
  "required": [
    "data_as_of",
    "summary",
    "model",
    "quantisations",
    "sources",
    "url"
  ],
  "properties": {
    "url": {
      "type": "string",
      "pattern": "^https:\\/\\/llmconfigurator\\.com\\/en\\/"
    },
    "model": {
      "type": "object",
      "required": [
        "id",
        "name",
        "total_params_b",
        "active_params_b",
        "is_moe",
        "family",
        "context_length",
        "license",
        "release_date",
        "status"
      ],
      "properties": {
        "id": {
          "type": "string",
          "pattern": "^[a-z0-9][a-z0-9._-]*$",
          "maxLength": 80,
          "minLength": 1
        },
        "name": {
          "type": "string",
          "maxLength": 120
        },
        "family": {
          "type": "string",
          "maxLength": 120
        },
        "is_moe": {
          "type": "boolean"
        },
        "status": {
          "enum": [
            "current",
            "legacy",
            "deprecated"
          ],
          "type": "string"
        },
        "license": {
          "anyOf": [
            {
              "type": "string",
              "maxLength": 80
            },
            {
              "type": "null"
            }
          ]
        },
        "release_date": {
          "anyOf": [
            {
              "type": "string",
              "pattern": "^\\d{4}-\\d{2}-\\d{2}$"
            },
            {
              "type": "null"
            }
          ]
        },
        "context_length": {
          "anyOf": [
            {
              "type": "integer",
              "maximum": 9007199254740991,
              "exclusiveMinimum": 0
            },
            {
              "type": "null"
            }
          ],
          "description": "The model's default context window in tokens."
        },
        "total_params_b": {
          "type": "number",
          "description": "Total parameters in billions. Sets memory residency.",
          "exclusiveMinimum": 0
        },
        "active_params_b": {
          "type": "number",
          "description": "Parameters read per token in billions. Equals total for dense models. Sets speed, never memory.",
          "exclusiveMinimum": 0
        }
      },
      "additionalProperties": false
    },
    "sources": {
      "type": "array",
      "items": {
        "type": "string",
        "pattern": "^https:\\/\\/"
      },
      "maxItems": 8
    },
    "summary": {
      "type": "string",
      "maxLength": 600,
      "description": "One or two plain-language sentences stating the answer."
    },
    "data_as_of": {
      "type": "string",
      "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
      "description": "Date the bundled catalogue was last updated. Not the time of this call."
    },
    "quantisations": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "quantisation",
          "bits_per_weight",
          "weights_gb",
          "confidence"
        ],
        "properties": {
          "confidence": {
            "enum": [
              "measured",
              "estimated",
              "community"
            ],
            "type": "string"
          },
          "weights_gb": {
            "type": "number",
            "minimum": 0
          },
          "quantisation": {
            "enum": [
              "Q2_K",
              "Q3_K_M",
              "Q4_K_M",
              "Q5_K_M",
              "Q6_K",
              "Q8_0",
              "F16"
            ],
            "type": "string"
          },
          "bits_per_weight": {
            "type": "number",
            "exclusiveMinimum": 0
          }
        },
        "additionalProperties": false
      },
      "description": "Weight size per quantisation. Excludes KV cache and overhead, which depend on context length."
    }
  },
  "additionalProperties": false
}
get_model_specs annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}

Prompts

Not advertised

No prompt definitions available.

Resources

Not advertised

No resource definitions available.

90-day uptime

A lightweight connection check about every six hours, sampled on hosts with many listings. It shows the server answered, not that its tools work.

Too few checks for a percentage yet (2 of 2 answered).

  1. 2026-11-06: 1 of 1 checks answered
  2. 2026-11-07: 1 of 1 checks answered

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
680 ms
95th percentile latency
680 ms

Maintenance history

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

  • · probe · passed · 680 ms · metadata changed · 5 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 llm-configurator-mcp https://elgadmisijrfowuujcmu.supabase.co/functions/v1/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 llm-configurator-mcp --url https://elgadmisijrfowuujcmu.supabase.co/functions/v1/mcp

Cursor

Merge this server into .cursor/mcp.json in your project, then enable llm-configurator-mcp in your MCP settings.
Cursor configuration
{
  "mcpServers": {
    "llm-configurator-mcp": {
      "url": "https://elgadmisijrfowuujcmu.supabase.co/functions/v1/mcp"
    }
  }
}

Cline

Merge this into cline_mcp_settings.json (Cline → MCP Servers → Configure).
Cline configuration
{
  "mcpServers": {
    "llm-configurator-mcp": {
      "type": "streamableHttp",
      "url": "https://elgadmisijrfowuujcmu.supabase.co/functions/v1/mcp",
      "disabled": false
    }
  }
}

VS Code

Merge this server into .vscode/mcp.json. Use MCP: List Servers to start llm-configurator-mcp and inspect its tools.
VS Code configuration
{
  "servers": {
    "llm-configurator-mcp": {
      "type": "http",
      "url": "https://elgadmisijrfowuujcmu.supabase.co/functions/v1/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 llm-configurator-mcp https://elgadmisijrfowuujcmu.supabase.co/functions/v1/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://elgadmisijrfowuujcmu.supabase.co/functions/v1/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": {
    "llm-configurator-mcp": {
      "serverUrl": "https://elgadmisijrfowuujcmu.supabase.co/functions/v1/mcp"
    }
  }
}

Let your agent find its tools

Find servers like LLM Configurator 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,159